← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/include/row0vers.h

  • Committer: brian
  • Date: 2008-06-25 05:29:13 UTC
  • Revision ID: brian@localhost.localdomain-20080625052913-6upwo0jsrl4lnapl
clean slate

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/row0vers.h
 
1
/******************************************************
 
2
Row versions
 
3
 
 
4
(c) 1997 Innobase Oy
 
5
 
 
6
Created 2/6/1997 Heikki Tuuri
 
7
*******************************************************/
 
8
 
 
9
#ifndef row0vers_h
 
10
#define row0vers_h
 
11
 
 
12
#include "univ.i"
 
13
#include "data0data.h"
 
14
#include "dict0types.h"
 
15
#include "trx0types.h"
 
16
#include "que0types.h"
 
17
#include "rem0types.h"
 
18
#include "mtr0mtr.h"
 
19
#include "read0types.h"
 
20
 
 
21
/*********************************************************************
 
22
Finds out if an active transaction has inserted or modified a secondary
 
23
index record. NOTE: the kernel mutex is temporarily released in this
 
24
function! */
 
25
 
 
26
trx_t*
 
27
row_vers_impl_x_locked_off_kernel(
 
28
/*==============================*/
 
29
                                /* out: NULL if committed, else the active
 
30
                                transaction; NOTE that the kernel mutex is
 
31
                                temporarily released! */
 
32
        rec_t*          rec,    /* in: record in a secondary index */
 
33
        dict_index_t*   index,  /* in: the secondary index */
 
34
        const ulint*    offsets);/* in: rec_get_offsets(rec, index) */
 
35
/*********************************************************************
 
36
Finds out if we must preserve a delete marked earlier version of a clustered
 
37
index record, because it is >= the purge view. */
 
38
 
 
39
ibool
 
40
row_vers_must_preserve_del_marked(
 
41
/*==============================*/
 
42
                        /* out: TRUE if earlier version should be preserved */
 
43
        dulint  trx_id, /* in: transaction id in the version */
 
44
        mtr_t*  mtr);   /* in: mtr holding the latch on the clustered index
 
45
                        record; it will also hold the latch on purge_view */
 
46
/*********************************************************************
 
47
Finds out if a version of the record, where the version >= the current
 
48
purge view, should have ientry as its secondary index entry. We check
 
49
if there is any not delete marked version of the record where the trx
 
50
id >= purge view, and the secondary index entry == ientry; exactly in
 
51
this case we return TRUE. */
 
52
 
 
53
ibool
 
54
row_vers_old_has_index_entry(
 
55
/*=========================*/
 
56
                                /* out: TRUE if earlier version should have */
 
57
        ibool           also_curr,/* in: TRUE if also rec is included in the
 
58
                                versions to search; otherwise only versions
 
59
                                prior to it are searched */
 
60
        rec_t*          rec,    /* in: record in the clustered index; the
 
61
                                caller must have a latch on the page */
 
62
        mtr_t*          mtr,    /* in: mtr holding the latch on rec; it will
 
63
                                also hold the latch on purge_view */
 
64
        dict_index_t*   index,  /* in: the secondary index */
 
65
        dtuple_t*       ientry);        /* in: the secondary index entry */
 
66
/*********************************************************************
 
67
Constructs the version of a clustered index record which a consistent
 
68
read should see. We assume that the trx id stored in rec is such that
 
69
the consistent read should not see rec in its present version. */
 
70
 
 
71
ulint
 
72
row_vers_build_for_consistent_read(
 
73
/*===============================*/
 
74
                                /* out: DB_SUCCESS or DB_MISSING_HISTORY */
 
75
        rec_t*          rec,    /* in: record in a clustered index; the
 
76
                                caller must have a latch on the page; this
 
77
                                latch locks the top of the stack of versions
 
78
                                of this records */
 
79
        mtr_t*          mtr,    /* in: mtr holding the latch on rec; it will
 
80
                                also hold the latch on purge_view */
 
81
        dict_index_t*   index,  /* in: the clustered index */
 
82
        ulint**         offsets,/* in/out: offsets returned by
 
83
                                rec_get_offsets(rec, index) */
 
84
        read_view_t*    view,   /* in: the consistent read view */
 
85
        mem_heap_t**    offset_heap,/* in/out: memory heap from which
 
86
                                the offsets are allocated */
 
87
        mem_heap_t*     in_heap,/* in: memory heap from which the memory for
 
88
                                old_vers is allocated; memory for possible
 
89
                                intermediate versions is allocated and freed
 
90
                                locally within the function */
 
91
        rec_t**         old_vers);/* out, own: old version, or NULL if the
 
92
                                record does not exist in the view, that is,
 
93
                                it was freshly inserted afterwards */
 
94
 
 
95
/*********************************************************************
 
96
Constructs the last committed version of a clustered index record,
 
97
which should be seen by a semi-consistent read. */
 
98
 
 
99
ulint
 
100
row_vers_build_for_semi_consistent_read(
 
101
/*====================================*/
 
102
                                /* out: DB_SUCCESS or DB_MISSING_HISTORY */
 
103
        rec_t*          rec,    /* in: record in a clustered index; the
 
104
                                caller must have a latch on the page; this
 
105
                                latch locks the top of the stack of versions
 
106
                                of this records */
 
107
        mtr_t*          mtr,    /* in: mtr holding the latch on rec */
 
108
        dict_index_t*   index,  /* in: the clustered index */
 
109
        ulint**         offsets,/* in/out: offsets returned by
 
110
                                rec_get_offsets(rec, index) */
 
111
        mem_heap_t**    offset_heap,/* in/out: memory heap from which
 
112
                                the offsets are allocated */
 
113
        mem_heap_t*     in_heap,/* in: memory heap from which the memory for
 
114
                                old_vers is allocated; memory for possible
 
115
                                intermediate versions is allocated and freed
 
116
                                locally within the function */
 
117
        rec_t**         old_vers);/* out, own: rec, old version, or NULL if the
 
118
                                record does not exist in the view, that is,
 
119
                                it was freshly inserted afterwards */
 
120
 
 
121
 
 
122
#ifndef UNIV_NONINL
 
123
#include "row0vers.ic"
 
124
#endif
 
125
 
 
126
#endif