36
48
row_get_rec_roll_ptr(
37
49
/*=================*/
38
50
/* out: value of the field */
39
rec_t* rec, /* in: record */
51
const rec_t* rec, /* in: record */
40
52
dict_index_t* index, /* in: clustered index */
41
53
const ulint* offsets);/* in: rec_get_offsets(rec, index) */
42
/*************************************************************************
43
Writes the trx id field to a clustered index record. */
48
rec_t* rec, /* in: record */
49
dict_index_t* index, /* in: clustered index */
50
const ulint* offsets,/* in: rec_get_offsets(rec, index) */
51
dulint trx_id);/* in: value of the field */
52
/*************************************************************************
53
Sets the roll pointer field in a clustered index record. */
58
rec_t* rec, /* in: record */
59
dict_index_t* index, /* in: clustered index */
60
const ulint* offsets,/* in: rec_get_offsets(rec, index) */
61
dulint roll_ptr);/* in: value of the field */
62
54
/*********************************************************************
63
When an insert to a table is performed, this function builds the entry which
64
has to be inserted to an index on the table. */
55
When an insert or purge to a table is performed, this function builds
56
the entry to be inserted into or purged from an index on the table. */
67
59
row_build_index_entry(
68
60
/*==================*/
69
/* out: index entry which should be inserted */
70
dtuple_t* row, /* in: row which should be inserted to the
61
/* out: index entry which should be
62
inserted or purged, or NULL if the
63
externally stored columns in the
64
clustered index record are unavailable
66
const dtuple_t* row, /* in: row which should be
68
row_ext_t* ext, /* in: externally stored column prefixes,
72
70
dict_index_t* index, /* in: index on the table */
73
71
mem_heap_t* heap); /* in: memory heap from which the memory for
74
72
the index entry is allocated */
75
73
/***********************************************************************
76
An inverse function to dict_row_build_index_entry. Builds a row from a
74
An inverse function to row_build_index_entry. Builds a row from a
77
75
record in a clustered index. */
82
/* out, own: row built; see the NOTE below! */
83
ulint type, /* in: ROW_COPY_POINTERS or ROW_COPY_DATA;
84
the latter copies also the data fields to
85
heap while the first only places pointers to
86
data fields on the index page, and thus is
88
dict_index_t* index, /* in: clustered index */
89
rec_t* rec, /* in: record in the clustered index;
90
NOTE: in the case ROW_COPY_POINTERS
91
the data fields in the row will point
92
directly into this record, therefore,
93
the buffer page of this record must be
94
at least s-latched and the latch held
95
as long as the row dtuple is used! */
96
const ulint* offsets,/* in: rec_get_offsets(rec, index)
97
or NULL, in which case this function
98
will invoke rec_get_offsets() */
99
mem_heap_t* heap); /* in: memory heap from which the memory
100
needed is allocated */
80
/* out, own: row built;
81
see the NOTE below! */
82
ulint type, /* in: ROW_COPY_POINTERS or
83
ROW_COPY_DATA; the latter
84
copies also the data fields to
85
heap while the first only
86
places pointers to data fields
87
on the index page, and thus is
89
const dict_index_t* index, /* in: clustered index */
90
const rec_t* rec, /* in: record in the clustered
91
index; NOTE: in the case
92
ROW_COPY_POINTERS the data
93
fields in the row will point
94
directly into this record,
95
therefore, the buffer page of
96
this record must be at least
97
s-latched and the latch held
98
as long as the row dtuple is used! */
99
const ulint* offsets,/* in: rec_get_offsets(rec,index)
100
or NULL, in which case this function
101
will invoke rec_get_offsets() */
102
const dict_table_t* col_table,
103
/* in: table, to check which
104
externally stored columns
105
occur in the ordering columns
106
of an index, or NULL if
107
index->table should be
108
consulted instead; the user
109
columns in this table should be
110
the same columns as in index->table */
111
row_ext_t** ext, /* out, own: cache of
112
externally stored column
114
mem_heap_t* heap); /* in: memory heap from which
115
the memory needed is allocated */
101
116
/***********************************************************************
102
117
Converts an index record to a typed data tuple. */
120
row_rec_to_index_entry_low(
121
/*=======================*/
122
/* out: index entry built; does not
123
set info_bits, and the data fields in
124
the entry will point directly to rec */
125
const rec_t* rec, /* in: record in the index */
126
const dict_index_t* index, /* in: index */
127
const ulint* offsets,/* in: rec_get_offsets(rec, index) */
128
ulint* n_ext, /* out: number of externally
130
mem_heap_t* heap); /* in: memory heap from which
131
the memory needed is allocated */
132
/***********************************************************************
133
Converts an index record to a typed data tuple. NOTE that externally
134
stored (often big) fields are NOT copied to heap. */
105
137
row_rec_to_index_entry(
106
138
/*===================*/
107
/* out, own: index entry built; see the
109
ulint type, /* in: ROW_COPY_DATA, or ROW_COPY_POINTERS:
110
the former copies also the data fields to
111
heap as the latter only places pointers to
112
data fields on the index page */
113
dict_index_t* index, /* in: index */
114
rec_t* rec, /* in: record in the index;
115
NOTE: in the case ROW_COPY_POINTERS
116
the data fields in the row will point
117
directly into this record, therefore,
118
the buffer page of this record must be
119
at least s-latched and the latch held
120
as long as the dtuple is used! */
121
mem_heap_t* heap); /* in: memory heap from which the memory
122
needed is allocated */
139
/* out, own: index entry
140
built; see the NOTE below! */
141
ulint type, /* in: ROW_COPY_DATA, or
142
ROW_COPY_POINTERS: the former
143
copies also the data fields to
144
heap as the latter only places
145
pointers to data fields on the
147
const rec_t* rec, /* in: record in the index;
149
ROW_COPY_POINTERS the data
150
fields in the row will point
151
directly into this record,
152
therefore, the buffer page of
153
this record must be at least
154
s-latched and the latch held
155
as long as the dtuple is used! */
156
const dict_index_t* index, /* in: index */
157
ulint* offsets,/* in/out: rec_get_offsets(rec) */
158
ulint* n_ext, /* out: number of externally
160
mem_heap_t* heap); /* in: memory heap from which
161
the memory needed is allocated */
123
162
/***********************************************************************
124
163
Builds from a secondary index record a row reference with which we can
125
164
search the clustered index record. */
128
167
row_build_row_ref(
129
168
/*==============*/
146
185
/***********************************************************************
147
186
Builds from a secondary index record a row reference with which we can
148
187
search the clustered index record. */
151
190
row_build_row_ref_in_tuple(
152
191
/*=======================*/
153
dtuple_t* ref, /* in/out: row reference built; see the
155
dict_index_t* index, /* in: index */
156
rec_t* rec, /* in: record in the index;
157
NOTE: the data fields in ref will point
158
directly into this record, therefore,
159
the buffer page of this record must be
160
at least s-latched and the latch held
161
as long as the row reference is used! */
162
trx_t* trx); /* in: transaction */
192
dtuple_t* ref, /* in/out: row reference built;
193
see the NOTE below! */
194
const rec_t* rec, /* in: record in the index;
195
NOTE: the data fields in ref
196
will point directly into this
197
record, therefore, the buffer
198
page of this record must be at
199
least s-latched and the latch
200
held as long as the row
201
reference is used! */
202
const dict_index_t* index, /* in: secondary index */
203
ulint* offsets,/* in: rec_get_offsets(rec, index)
205
trx_t* trx); /* in: transaction */
163
206
/***********************************************************************
164
207
From a row build a row reference with which we can search the clustered
168
211
row_build_row_ref_from_row(
169
212
/*=======================*/
170
dtuple_t* ref, /* in/out: row reference built; see the
171
NOTE below! ref must have the right number
173
dict_table_t* table, /* in: table */
174
dtuple_t* row); /* in: row
175
NOTE: the data fields in ref will point
176
directly into data of this row */
213
dtuple_t* ref, /* in/out: row reference built;
215
ref must have the right number
217
const dict_table_t* table, /* in: table */
218
const dtuple_t* row); /* in: row
219
NOTE: the data fields in ref will point
220
directly into data of this row */
177
221
/***********************************************************************
178
222
Builds from a secondary index record a row reference with which we can
179
223
search the clustered index record. */
182
226
row_build_row_ref_fast(
183
227
/*===================*/
184
dtuple_t* ref, /* in: typed data tuple where the
228
dtuple_t* ref, /* in/out: typed data tuple where the
185
229
reference is built */
186
230
const ulint* map, /* in: array of field numbers in rec
187
231
telling how ref should be built from
188
232
the fields of rec */
189
rec_t* rec, /* in: record in the index; must be
233
const rec_t* rec, /* in: record in the index; must be
190
234
preserved while ref is used, as we do
191
235
not copy field values to heap */
192
236
const ulint* offsets);/* in: array returned by rec_get_offsets() */
193
237
/*******************************************************************
194
238
Searches the clustered index record for a row, if we have the row
198
242
row_search_on_row_ref(
199
243
/*==================*/
200
/* out: TRUE if found */
201
btr_pcur_t* pcur, /* in/out: persistent cursor, which must
202
be closed by the caller */
203
ulint mode, /* in: BTR_MODIFY_LEAF, ... */
204
dict_table_t* table, /* in: table */
205
dtuple_t* ref, /* in: row reference */
206
mtr_t* mtr); /* in: mtr */
244
/* out: TRUE if found */
245
btr_pcur_t* pcur, /* out: persistent cursor, which must
246
be closed by the caller */
247
ulint mode, /* in: BTR_MODIFY_LEAF, ... */
248
const dict_table_t* table, /* in: table */
249
const dtuple_t* ref, /* in: row reference */
250
mtr_t* mtr); /* in/out: mtr */
207
251
/*************************************************************************
208
252
Fetches the clustered index record for a secondary index record. The latches
209
253
on the secondary index record are preserved. */
212
256
row_get_clust_rec(
213
257
/*==============*/
214
258
/* out: record or NULL, if no record found */
215
259
ulint mode, /* in: BTR_MODIFY_LEAF, ... */
216
rec_t* rec, /* in: record in a secondary index */
260
const rec_t* rec, /* in: record in a secondary index */
217
261
dict_index_t* index, /* in: secondary index */
218
262
dict_index_t** clust_index,/* out: clustered index */
219
263
mtr_t* mtr); /* in: mtr */
220
264
/*******************************************************************
221
265
Searches an index record. */
224
268
row_search_index_entry(
225
269
/*===================*/
226
270
/* out: TRUE if found */
227
271
dict_index_t* index, /* in: index */
228
dtuple_t* entry, /* in: index entry */
272
const dtuple_t* entry, /* in: index entry */
229
273
ulint mode, /* in: BTR_MODIFY_LEAF, ... */
230
274
btr_pcur_t* pcur, /* in/out: persistent cursor, which must
231
275
be closed by the caller */
added
removed
storage/innobase/include/row0row.h
