← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Monty Taylor
  • Date: 2010-08-12 20:27:32 UTC
  • mto: (1720.1.5 build)
  • mto: This revision was merged to the branch mainline in revision 1722.
  • Revision ID: mordred@inaugust.com-20100812202732-9kzchbkvkyki4n3u
Merged libdrizzle directly into tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/row0row.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1996, 2010, 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/row0row.h
21
 
General row routines
22
 
 
23
 
Created 4/20/1996 Heikki Tuuri
24
 
*******************************************************/
25
 
 
26
 
#ifndef row0row_h
27
 
#define row0row_h
28
 
 
29
 
#include "univ.i"
30
 
#include "data0data.h"
31
 
#include "dict0types.h"
32
 
#include "trx0types.h"
33
 
#include "que0types.h"
34
 
#include "mtr0mtr.h"
35
 
#include "rem0types.h"
36
 
#include "read0types.h"
37
 
#include "row0types.h"
38
 
#include "btr0types.h"
39
 
 
40
 
/*********************************************************************//**
41
 
Gets the offset of the trx id field, in bytes relative to the origin of
42
 
a clustered index record.
43
 
@return offset of DATA_TRX_ID */
44
 
UNIV_INTERN
45
 
ulint
46
 
row_get_trx_id_offset(
47
 
/*==================*/
48
 
        const rec_t*    rec,    /*!< in: record */
49
 
        dict_index_t*   index,  /*!< in: clustered index */
50
 
        const ulint*    offsets);/*!< in: rec_get_offsets(rec, index) */
51
 
/*********************************************************************//**
52
 
Reads the trx id field from a clustered index record.
53
 
@return value of the field */
54
 
UNIV_INLINE
55
 
trx_id_t
56
 
row_get_rec_trx_id(
57
 
/*===============*/
58
 
        const rec_t*    rec,    /*!< in: record */
59
 
        dict_index_t*   index,  /*!< in: clustered index */
60
 
        const ulint*    offsets);/*!< in: rec_get_offsets(rec, index) */
61
 
/*********************************************************************//**
62
 
Reads the roll pointer field from a clustered index record.
63
 
@return value of the field */
64
 
UNIV_INLINE
65
 
roll_ptr_t
66
 
row_get_rec_roll_ptr(
67
 
/*=================*/
68
 
        const rec_t*    rec,    /*!< in: record */
69
 
        dict_index_t*   index,  /*!< in: clustered index */
70
 
        const ulint*    offsets);/*!< in: rec_get_offsets(rec, index) */
71
 
/*****************************************************************//**
72
 
When an insert or purge to a table is performed, this function builds
73
 
the entry to be inserted into or purged from an index on the table.
74
 
@return index entry which should be inserted or purged, or NULL if the
75
 
externally stored columns in the clustered index record are
76
 
unavailable and ext != NULL */
77
 
UNIV_INTERN
78
 
dtuple_t*
79
 
row_build_index_entry(
80
 
/*==================*/
81
 
        const dtuple_t* row,    /*!< in: row which should be
82
 
                                inserted or purged */
83
 
        row_ext_t*      ext,    /*!< in: externally stored column prefixes,
84
 
                                or NULL */
85
 
        dict_index_t*   index,  /*!< in: index on the table */
86
 
        mem_heap_t*     heap);  /*!< in: memory heap from which the memory for
87
 
                                the index entry is allocated */
88
 
/*******************************************************************//**
89
 
An inverse function to row_build_index_entry. Builds a row from a
90
 
record in a clustered index.
91
 
@return own: row built; see the NOTE below! */
92
 
UNIV_INTERN
93
 
dtuple_t*
94
 
row_build(
95
 
/*======*/
96
 
        ulint                   type,   /*!< in: ROW_COPY_POINTERS or
97
 
                                        ROW_COPY_DATA; the latter
98
 
                                        copies also the data fields to
99
 
                                        heap while the first only
100
 
                                        places pointers to data fields
101
 
                                        on the index page, and thus is
102
 
                                        more efficient */
103
 
        const dict_index_t*     index,  /*!< in: clustered index */
104
 
        const rec_t*            rec,    /*!< in: record in the clustered
105
 
                                        index; NOTE: in the case
106
 
                                        ROW_COPY_POINTERS the data
107
 
                                        fields in the row will point
108
 
                                        directly into this record,
109
 
                                        therefore, the buffer page of
110
 
                                        this record must be at least
111
 
                                        s-latched and the latch held
112
 
                                        as long as the row dtuple is used! */
113
 
        const ulint*            offsets,/*!< in: rec_get_offsets(rec,index)
114
 
                                        or NULL, in which case this function
115
 
                                        will invoke rec_get_offsets() */
116
 
        const dict_table_t*     col_table,
117
 
                                        /*!< in: table, to check which
118
 
                                        externally stored columns
119
 
                                        occur in the ordering columns
120
 
                                        of an index, or NULL if
121
 
                                        index->table should be
122
 
                                        consulted instead; the user
123
 
                                        columns in this table should be
124
 
                                        the same columns as in index->table */
125
 
        row_ext_t**             ext,    /*!< out, own: cache of
126
 
                                        externally stored column
127
 
                                        prefixes, or NULL */
128
 
        mem_heap_t*             heap);  /*!< in: memory heap from which
129
 
                                        the memory needed is allocated */
130
 
/*******************************************************************//**
131
 
Converts an index record to a typed data tuple.
132
 
@return index entry built; does not set info_bits, and the data fields
133
 
in the entry will point directly to rec */
134
 
UNIV_INTERN
135
 
dtuple_t*
136
 
row_rec_to_index_entry_low(
137
 
/*=======================*/
138
 
        const rec_t*            rec,    /*!< in: record in the index */
139
 
        const dict_index_t*     index,  /*!< in: index */
140
 
        const ulint*            offsets,/*!< in: rec_get_offsets(rec, index) */
141
 
        ulint*                  n_ext,  /*!< out: number of externally
142
 
                                        stored columns */
143
 
        mem_heap_t*             heap);  /*!< in: memory heap from which
144
 
                                        the memory needed is allocated */
145
 
/*******************************************************************//**
146
 
Converts an index record to a typed data tuple. NOTE that externally
147
 
stored (often big) fields are NOT copied to heap.
148
 
@return own: index entry built; see the NOTE below! */
149
 
UNIV_INTERN
150
 
dtuple_t*
151
 
row_rec_to_index_entry(
152
 
/*===================*/
153
 
        ulint                   type,   /*!< in: ROW_COPY_DATA, or
154
 
                                        ROW_COPY_POINTERS: the former
155
 
                                        copies also the data fields to
156
 
                                        heap as the latter only places
157
 
                                        pointers to data fields on the
158
 
                                        index page */
159
 
        const rec_t*            rec,    /*!< in: record in the index;
160
 
                                        NOTE: in the case
161
 
                                        ROW_COPY_POINTERS the data
162
 
                                        fields in the row will point
163
 
                                        directly into this record,
164
 
                                        therefore, the buffer page of
165
 
                                        this record must be at least
166
 
                                        s-latched and the latch held
167
 
                                        as long as the dtuple is used! */
168
 
        const dict_index_t*     index,  /*!< in: index */
169
 
        ulint*                  offsets,/*!< in/out: rec_get_offsets(rec) */
170
 
        ulint*                  n_ext,  /*!< out: number of externally
171
 
                                        stored columns */
172
 
        mem_heap_t*             heap);  /*!< in: memory heap from which
173
 
                                        the memory needed is allocated */
174
 
/*******************************************************************//**
175
 
Builds from a secondary index record a row reference with which we can
176
 
search the clustered index record.
177
 
@return own: row reference built; see the NOTE below! */
178
 
UNIV_INTERN
179
 
dtuple_t*
180
 
row_build_row_ref(
181
 
/*==============*/
182
 
        ulint           type,   /*!< in: ROW_COPY_DATA, or ROW_COPY_POINTERS:
183
 
                                the former copies also the data fields to
184
 
                                heap, whereas the latter only places pointers
185
 
                                to data fields on the index page */
186
 
        dict_index_t*   index,  /*!< in: secondary index */
187
 
        const rec_t*    rec,    /*!< in: record in the index;
188
 
                                NOTE: in the case ROW_COPY_POINTERS
189
 
                                the data fields in the row will point
190
 
                                directly into this record, therefore,
191
 
                                the buffer page of this record must be
192
 
                                at least s-latched and the latch held
193
 
                                as long as the row reference is used! */
194
 
        mem_heap_t*     heap);  /*!< in: memory heap from which the memory
195
 
                                needed is allocated */
196
 
/*******************************************************************//**
197
 
Builds from a secondary index record a row reference with which we can
198
 
search the clustered index record. */
199
 
UNIV_INTERN
200
 
void
201
 
row_build_row_ref_in_tuple(
202
 
/*=======================*/
203
 
        dtuple_t*               ref,    /*!< in/out: row reference built;
204
 
                                        see the NOTE below! */
205
 
        const rec_t*            rec,    /*!< in: record in the index;
206
 
                                        NOTE: the data fields in ref
207
 
                                        will point directly into this
208
 
                                        record, therefore, the buffer
209
 
                                        page of this record must be at
210
 
                                        least s-latched and the latch
211
 
                                        held as long as the row
212
 
                                        reference is used! */
213
 
        const dict_index_t*     index,  /*!< in: secondary index */
214
 
        ulint*                  offsets,/*!< in: rec_get_offsets(rec, index)
215
 
                                        or NULL */
216
 
        trx_t*                  trx);   /*!< in: transaction */
217
 
/*******************************************************************//**
218
 
Builds from a secondary index record a row reference with which we can
219
 
search the clustered index record. */
220
 
UNIV_INLINE
221
 
void
222
 
row_build_row_ref_fast(
223
 
/*===================*/
224
 
        dtuple_t*       ref,    /*!< in/out: typed data tuple where the
225
 
                                reference is built */
226
 
        const ulint*    map,    /*!< in: array of field numbers in rec
227
 
                                telling how ref should be built from
228
 
                                the fields of rec */
229
 
        const rec_t*    rec,    /*!< in: record in the index; must be
230
 
                                preserved while ref is used, as we do
231
 
                                not copy field values to heap */
232
 
        const ulint*    offsets);/*!< in: array returned by rec_get_offsets() */
233
 
/***************************************************************//**
234
 
Searches the clustered index record for a row, if we have the row
235
 
reference.
236
 
@return TRUE if found */
237
 
UNIV_INTERN
238
 
ibool
239
 
row_search_on_row_ref(
240
 
/*==================*/
241
 
        btr_pcur_t*             pcur,   /*!< out: persistent cursor, which must
242
 
                                        be closed by the caller */
243
 
        ulint                   mode,   /*!< in: BTR_MODIFY_LEAF, ... */
244
 
        const dict_table_t*     table,  /*!< in: table */
245
 
        const dtuple_t*         ref,    /*!< in: row reference */
246
 
        mtr_t*                  mtr);   /*!< in/out: mtr */
247
 
/*********************************************************************//**
248
 
Fetches the clustered index record for a secondary index record. The latches
249
 
on the secondary index record are preserved.
250
 
@return record or NULL, if no record found */
251
 
UNIV_INTERN
252
 
rec_t*
253
 
row_get_clust_rec(
254
 
/*==============*/
255
 
        ulint           mode,   /*!< in: BTR_MODIFY_LEAF, ... */
256
 
        const rec_t*    rec,    /*!< in: record in a secondary index */
257
 
        dict_index_t*   index,  /*!< in: secondary index */
258
 
        dict_index_t**  clust_index,/*!< out: clustered index */
259
 
        mtr_t*          mtr);   /*!< in: mtr */
260
 
 
261
 
/** Result of row_search_index_entry */
262
 
enum row_search_result {
263
 
        ROW_FOUND = 0,          /*!< the record was found */
264
 
        ROW_NOT_FOUND,          /*!< record not found */
265
 
        ROW_BUFFERED,           /*!< one of BTR_INSERT, BTR_DELETE, or
266
 
                                BTR_DELETE_MARK was specified, the
267
 
                                secondary index leaf page was not in
268
 
                                the buffer pool, and the operation was
269
 
                                enqueued in the insert/delete buffer */
270
 
        ROW_NOT_DELETED_REF     /*!< BTR_DELETE was specified, and
271
 
                                row_purge_poss_sec() failed */
272
 
};
273
 
 
274
 
/***************************************************************//**
275
 
Searches an index record.
276
 
@return whether the record was found or buffered */
277
 
UNIV_INTERN
278
 
enum row_search_result
279
 
row_search_index_entry(
280
 
/*===================*/
281
 
        dict_index_t*   index,  /*!< in: index */
282
 
        const dtuple_t* entry,  /*!< in: index entry */
283
 
        ulint           mode,   /*!< in: BTR_MODIFY_LEAF, ... */
284
 
        btr_pcur_t*     pcur,   /*!< in/out: persistent cursor, which must
285
 
                                be closed by the caller */
286
 
        mtr_t*          mtr);   /*!< in: mtr */
287
 
 
288
 
 
289
 
#define ROW_COPY_DATA           1
290
 
#define ROW_COPY_POINTERS       2
291
 
 
292
 
/* The allowed latching order of index records is the following:
293
 
(1) a secondary index record ->
294
 
(2) the clustered index record ->
295
 
(3) rollback segment data for the clustered index record.
296
 
 
297
 
No new latches may be obtained while the kernel mutex is reserved.
298
 
However, the kernel mutex can be reserved while latches are owned. */
299
 
 
300
 
/*******************************************************************//**
301
 
Formats the raw data in "data" (in InnoDB on-disk format) using
302
 
"dict_field" and writes the result to "buf".
303
 
Not more than "buf_size" bytes are written to "buf".
304
 
The result is always NUL-terminated (provided buf_size is positive) and the
305
 
number of bytes that were written to "buf" is returned (including the
306
 
terminating NUL).
307
 
@return number of bytes that were written */
308
 
UNIV_INTERN
309
 
ulint
310
 
row_raw_format(
311
 
/*===========*/
312
 
        const char*             data,           /*!< in: raw data */
313
 
        ulint                   data_len,       /*!< in: raw data length
314
 
                                                in bytes */
315
 
        const dict_field_t*     dict_field,     /*!< in: index field */
316
 
        char*                   buf,            /*!< out: output buffer */
317
 
        ulint                   buf_size);      /*!< in: output buffer size
318
 
                                                in bytes */
319
 
 
320
 
#ifndef UNIV_NONINL
321
 
#include "row0row.ic"
322
 
#endif
323
 
 
324
 
#endif