← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2009-02-21 00:18:15 UTC
  • Revision ID: brian@tangent.org-20090221001815-x20e8h71e984lvs1
Completion (?) of uint conversion.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/read0read.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1997, 2009, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
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
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file include/read0read.h
 
1
/******************************************************
21
2
Cursor read
22
3
 
 
4
(c) 1997 Innobase Oy
 
5
 
23
6
Created 2/16/1997 Heikki Tuuri
24
7
*******************************************************/
25
8
 
34
17
#include "trx0trx.h"
35
18
#include "read0types.h"
36
19
 
37
 
/*********************************************************************//**
 
20
/*************************************************************************
38
21
Opens a read view where exactly the transactions serialized before this
39
 
point in time are seen in the view.
40
 
@return own: read view struct */
 
22
point in time are seen in the view. */
41
23
UNIV_INTERN
42
24
read_view_t*
43
25
read_view_open_now(
44
26
/*===============*/
45
 
        trx_id_t        cr_trx_id,      /*!< in: trx_id of creating
46
 
                                        transaction, or 0 used in purge */
47
 
        mem_heap_t*     heap);          /*!< in: memory heap from which
 
27
                                        /* out, own: read view struct */
 
28
        dulint          cr_trx_id,      /* in: trx_id of creating
 
29
                                        transaction, or (0, 0) used in
 
30
                                        purge */
 
31
        mem_heap_t*     heap);          /* in: memory heap from which
48
32
                                        allocated */
49
 
/*********************************************************************//**
 
33
/*************************************************************************
50
34
Makes a copy of the oldest existing read view, or opens a new. The view
51
 
must be closed with ..._close.
52
 
@return own: read view struct */
 
35
must be closed with ..._close. */
53
36
UNIV_INTERN
54
37
read_view_t*
55
38
read_view_oldest_copy_or_open_new(
56
39
/*==============================*/
57
 
        trx_id_t        cr_trx_id,      /*!< in: trx_id of creating
58
 
                                        transaction, or 0 used in purge */
59
 
        mem_heap_t*     heap);          /*!< in: memory heap from which
 
40
                                        /* out, own: read view struct */
 
41
        dulint          cr_trx_id,      /* in: trx_id of creating
 
42
                                        transaction, or (0, 0) used in
 
43
                                        purge */
 
44
        mem_heap_t*     heap);          /* in: memory heap from which
60
45
                                        allocated */
61
 
/*********************************************************************//**
 
46
/*************************************************************************
62
47
Closes a read view. */
63
48
UNIV_INTERN
64
49
void
65
50
read_view_close(
66
51
/*============*/
67
 
        read_view_t*    view);  /*!< in: read view */
68
 
/*********************************************************************//**
 
52
        read_view_t*    view);  /* in: read view */
 
53
/*************************************************************************
69
54
Closes a consistent read view for MySQL. This function is called at an SQL
70
55
statement end if the trx isolation level is <= TRX_ISO_READ_COMMITTED. */
71
56
UNIV_INTERN
72
57
void
73
58
read_view_close_for_mysql(
74
59
/*======================*/
75
 
        trx_t*  trx);   /*!< in: trx which has a read view */
76
 
/*********************************************************************//**
77
 
Checks if a read view sees the specified transaction.
78
 
@return TRUE if sees */
 
60
        trx_t*  trx);   /* in: trx which has a read view */
 
61
/*************************************************************************
 
62
Checks if a read view sees the specified transaction. */
79
63
UNIV_INLINE
80
64
ibool
81
65
read_view_sees_trx_id(
82
66
/*==================*/
83
 
        const read_view_t*      view,   /*!< in: read view */
84
 
        trx_id_t                trx_id);/*!< in: trx id */
85
 
/*********************************************************************//**
 
67
                                /* out: TRUE if sees */
 
68
        read_view_t*    view,   /* in: read view */
 
69
        dulint          trx_id);/* in: trx id */
 
70
/*************************************************************************
86
71
Prints a read view to stderr. */
87
72
UNIV_INTERN
88
73
void
89
74
read_view_print(
90
75
/*============*/
91
 
        const read_view_t*      view);  /*!< in: read view */
92
 
/*********************************************************************//**
 
76
        read_view_t*    view);  /* in: read view */
 
77
/*************************************************************************
93
78
Create a consistent cursor view for mysql to be used in cursors. In this
94
79
consistent read view modifications done by the creating transaction or future
95
80
transactions are not visible. */
97
82
cursor_view_t*
98
83
read_cursor_view_create_for_mysql(
99
84
/*==============================*/
100
 
        trx_t*          cr_trx);/*!< in: trx where cursor view is created */
101
 
/*********************************************************************//**
 
85
        trx_t*          cr_trx);/* in: trx where cursor view is created */
 
86
/*************************************************************************
102
87
Close a given consistent cursor view for mysql and restore global read view
103
88
back to a transaction read view. */
104
89
UNIV_INTERN
105
90
void
106
91
read_cursor_view_close_for_mysql(
107
92
/*=============================*/
108
 
        trx_t*          trx,            /*!< in: trx */
109
 
        cursor_view_t*  curview);       /*!< in: cursor view to be closed */
110
 
/*********************************************************************//**
 
93
        trx_t*          trx,            /* in: trx */
 
94
        cursor_view_t*  curview);       /* in: cursor view to be closed */
 
95
/*************************************************************************
111
96
This function sets a given consistent cursor view to a transaction
112
97
read view if given consistent cursor view is not NULL. Otherwise, function
113
98
restores a global read view to a transaction read view. */
115
100
void
116
101
read_cursor_set_for_mysql(
117
102
/*======================*/
118
 
        trx_t*          trx,    /*!< in: transaction where cursor is set */
119
 
        cursor_view_t*  curview);/*!< in: consistent cursor view to be set */
 
103
        trx_t*          trx,    /* in: transaction where cursor is set */
 
104
        cursor_view_t*  curview);/* in: consistent cursor view to be set */
120
105
 
121
 
/** Read view lists the trx ids of those transactions for which a consistent
 
106
/* Read view lists the trx ids of those transactions for which a consistent
122
107
read should not see the modifications to the database. */
123
108
 
124
109
struct read_view_struct{
125
 
        ulint           type;   /*!< VIEW_NORMAL, VIEW_HIGH_GRANULARITY */
126
 
        undo_no_t       undo_no;/*!< 0 or if type is
127
 
                                VIEW_HIGH_GRANULARITY
 
110
        ulint   type;           /* VIEW_NORMAL, VIEW_HIGH_GRANULARITY */
 
111
        dulint  undo_no;        /* (0, 0) or if type is VIEW_HIGH_GRANULARITY
128
112
                                transaction undo_no when this high-granularity
129
113
                                consistent read view was created */
130
 
        trx_id_t        low_limit_no;
131
 
                                /*!< The view does not need to see the undo
 
114
        dulint  low_limit_no;   /* The view does not need to see the undo
132
115
                                logs for transactions whose transaction number
133
116
                                is strictly smaller (<) than this value: they
134
117
                                can be removed in purge if not needed by other
135
118
                                views */
136
 
        trx_id_t        low_limit_id;
137
 
                                /*!< The read should not see any transaction
138
 
                                with trx id >= this value. In other words,
139
 
                                this is the "high water mark". */
140
 
        trx_id_t        up_limit_id;
141
 
                                /*!< The read should see all trx ids which
142
 
                                are strictly smaller (<) than this value.
143
 
                                In other words,
144
 
                                this is the "low water mark". */
145
 
        ulint           n_trx_ids;
146
 
                                /*!< Number of cells in the trx_ids array */
147
 
        trx_id_t*       trx_ids;/*!< Additional trx ids which the read should
 
119
        dulint  low_limit_id;   /* The read should not see any transaction
 
120
                                with trx id >= this value */
 
121
        dulint  up_limit_id;    /* The read should see all trx ids which
 
122
                                are strictly smaller (<) than this value */
 
123
        ulint   n_trx_ids;      /* Number of cells in the trx_ids array */
 
124
        dulint* trx_ids;        /* Additional trx ids which the read should
148
125
                                not see: typically, these are the active
149
126
                                transactions at the time when the read is
150
127
                                serialized, except the reading transaction
151
128
                                itself; the trx ids in this array are in a
152
 
                                descending order. These trx_ids should be
153
 
                                between the "low" and "high" water marks,
154
 
                                that is, up_limit_id and low_limit_id. */
155
 
        trx_id_t        creator_trx_id;
156
 
                                /*!< trx id of creating transaction, or
157
 
                                0 used in purge */
 
129
                                descending order */
 
130
        dulint  creator_trx_id; /* trx id of creating transaction, or
 
131
                                (0, 0) used in purge */
158
132
        UT_LIST_NODE_T(read_view_t) view_list;
159
 
                                /*!< List of read views in trx_sys */
 
133
                                /* List of read views in trx_sys */
160
134
};
161
135
 
162
 
/** Read view types @{ */
163
 
#define VIEW_NORMAL             1       /*!< Normal consistent read view
 
136
/* Read view types */
 
137
#define VIEW_NORMAL             1       /* Normal consistent read view
164
138
                                        where transaction does not see changes
165
139
                                        made by active transactions except
166
140
                                        creating transaction. */
167
 
#define VIEW_HIGH_GRANULARITY   2       /*!< High-granularity read view where
 
141
#define VIEW_HIGH_GRANULARITY   2       /* High-granularity read view where
168
142
                                        transaction does not see changes
169
143
                                        made by active transactions and own
170
144
                                        changes after a point in time when this
171
145
                                        read view was created. */
172
 
/* @} */
173
146
 
174
 
/** Implement InnoDB framework to support consistent read views in
 
147
/* Implement InnoDB framework to support consistent read views in
175
148
cursors. This struct holds both heap where consistent read view
176
149
is allocated and pointer to a read view. */
177
150
 
178
151
struct cursor_view_struct{
179
152
        mem_heap_t*     heap;
180
 
                                /*!< Memory heap for the cursor view */
 
153
                                /* Memory heap for the cursor view */
181
154
        read_view_t*    read_view;
182
 
                                /*!< Consistent read view of the cursor*/
 
155
                                /* Consistent read view of the cursor*/
 
156
        ulint           n_mysql_tables_in_use;
 
157
                                /* number of Innobase tables used in the
 
158
                                processing of this cursor */
183
159
};
184
160
 
185
161
#ifndef UNIV_NONINL