← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Brian Aker
  • Date: 2009-01-07 09:27:07 UTC
  • Revision ID: brian@tangent.org-20090107092707-bn67qpdllfcyh3j9
Removing dead field translator code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/include/data0data.h
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (C) 1994, 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/data0data.h
 
1
/************************************************************************
21
2
SQL data field and tuple
22
3
 
 
4
(c) 1994-1996 Innobase Oy
 
5
 
23
6
Created 5/30/1994 Heikki Tuuri
24
7
*************************************************************************/
25
8
 
33
16
#include "mem0mem.h"
34
17
#include "dict0types.h"
35
18
 
36
 
/** Storage for overflow data in a big record, that is, a clustered
37
 
index record which needs external storage of data fields */
38
19
typedef struct big_rec_struct           big_rec_t;
39
20
 
40
21
#ifdef UNIV_DEBUG
41
 
/*********************************************************************//**
42
 
Gets pointer to the type struct of SQL data field.
43
 
@return pointer to the type struct */
 
22
/*************************************************************************
 
23
Gets pointer to the type struct of SQL data field. */
44
24
UNIV_INLINE
45
25
dtype_t*
46
26
dfield_get_type(
47
27
/*============*/
48
 
        const dfield_t* field); /*!< in: SQL data field */
49
 
/*********************************************************************//**
50
 
Gets pointer to the data in a field.
51
 
@return pointer to data */
 
28
                                /* out: pointer to the type struct */
 
29
        const dfield_t* field); /* in: SQL data field */
 
30
/*************************************************************************
 
31
Gets pointer to the data in a field. */
52
32
UNIV_INLINE
53
33
void*
54
34
dfield_get_data(
55
35
/*============*/
56
 
        const dfield_t* field); /*!< in: field */
 
36
                                /* out: pointer to data */
 
37
        const dfield_t* field); /* in: field */
57
38
#else /* UNIV_DEBUG */
58
39
# define dfield_get_type(field) (&(field)->type)
59
40
# define dfield_get_data(field) ((field)->data)
60
41
#endif /* UNIV_DEBUG */
61
 
/*********************************************************************//**
 
42
/*************************************************************************
62
43
Sets the type struct of SQL data field. */
63
44
UNIV_INLINE
64
45
void
65
46
dfield_set_type(
66
47
/*============*/
67
 
        dfield_t*       field,  /*!< in: SQL data field */
68
 
        dtype_t*        type);  /*!< in: pointer to data type struct */
69
 
/*********************************************************************//**
70
 
Gets length of field data.
71
 
@return length of data; UNIV_SQL_NULL if SQL null data */
 
48
        dfield_t*       field,  /* in: SQL data field */
 
49
        dtype_t*        type);  /* in: pointer to data type struct */
 
50
/*************************************************************************
 
51
Gets length of field data. */
72
52
UNIV_INLINE
73
53
ulint
74
54
dfield_get_len(
75
55
/*===========*/
76
 
        const dfield_t* field); /*!< in: field */
77
 
/*********************************************************************//**
 
56
                                /* out: length of data; UNIV_SQL_NULL if
 
57
                                SQL null data */
 
58
        const dfield_t* field); /* in: field */
 
59
/*************************************************************************
78
60
Sets length in a field. */
79
61
UNIV_INLINE
80
62
void
81
63
dfield_set_len(
82
64
/*===========*/
83
 
        dfield_t*       field,  /*!< in: field */
84
 
        ulint           len);   /*!< in: length or UNIV_SQL_NULL */
85
 
/*********************************************************************//**
86
 
Determines if a field is SQL NULL
87
 
@return nonzero if SQL null data */
 
65
        dfield_t*       field,  /* in: field */
 
66
        ulint           len);   /* in: length or UNIV_SQL_NULL */
 
67
/*************************************************************************
 
68
Determines if a field is SQL NULL */
88
69
UNIV_INLINE
89
70
ulint
90
71
dfield_is_null(
91
72
/*===========*/
92
 
        const dfield_t* field); /*!< in: field */
93
 
/*********************************************************************//**
94
 
Determines if a field is externally stored
95
 
@return nonzero if externally stored */
 
73
                                /* out: nonzero if SQL null data */
 
74
        const dfield_t* field); /* in: field */
 
75
/*************************************************************************
 
76
Determines if a field is externally stored */
96
77
UNIV_INLINE
97
78
ulint
98
79
dfield_is_ext(
99
80
/*==========*/
100
 
        const dfield_t* field); /*!< in: field */
101
 
/*********************************************************************//**
 
81
                                /* out: nonzero if externally stored */
 
82
        const dfield_t* field); /* in: field */
 
83
/*************************************************************************
102
84
Sets the "external storage" flag */
103
85
UNIV_INLINE
104
86
void
105
87
dfield_set_ext(
106
88
/*===========*/
107
 
        dfield_t*       field); /*!< in/out: field */
108
 
/*********************************************************************//**
 
89
        dfield_t*       field); /* in/out: field */
 
90
/*************************************************************************
109
91
Sets pointer to the data and length in a field. */
110
92
UNIV_INLINE
111
93
void
112
94
dfield_set_data(
113
95
/*============*/
114
 
        dfield_t*       field,  /*!< in: field */
115
 
        const void*     data,   /*!< in: data */
116
 
        ulint           len);   /*!< in: length or UNIV_SQL_NULL */
117
 
/*********************************************************************//**
 
96
        dfield_t*       field,  /* in: field */
 
97
        const void*     data,   /* in: data */
 
98
        ulint           len);   /* in: length or UNIV_SQL_NULL */
 
99
/*************************************************************************
118
100
Sets a data field to SQL NULL. */
119
101
UNIV_INLINE
120
102
void
121
103
dfield_set_null(
122
104
/*============*/
123
 
        dfield_t*       field); /*!< in/out: field */
124
 
/**********************************************************************//**
 
105
        dfield_t*       field); /* in/out: field */
 
106
/**************************************************************************
125
107
Writes an SQL null field full of zeros. */
126
108
UNIV_INLINE
127
109
void
128
110
data_write_sql_null(
129
111
/*================*/
130
 
        byte*   data,   /*!< in: pointer to a buffer of size len */
131
 
        ulint   len);   /*!< in: SQL null size in bytes */
132
 
/*********************************************************************//**
 
112
        byte*   data,   /* in: pointer to a buffer of size len */
 
113
        ulint   len);   /* in: SQL null size in bytes */
 
114
/*************************************************************************
133
115
Copies the data and len fields. */
134
116
UNIV_INLINE
135
117
void
136
118
dfield_copy_data(
137
119
/*=============*/
138
 
        dfield_t*       field1, /*!< out: field to copy to */
139
 
        const dfield_t* field2);/*!< in: field to copy from */
140
 
/*********************************************************************//**
 
120
        dfield_t*       field1, /* out: field to copy to */
 
121
        const dfield_t* field2);/* in: field to copy from */
 
122
/*************************************************************************
141
123
Copies a data field to another. */
142
124
UNIV_INLINE
143
125
void
144
126
dfield_copy(
145
127
/*========*/
146
 
        dfield_t*       field1, /*!< out: field to copy to */
147
 
        const dfield_t* field2);/*!< in: field to copy from */
148
 
/*********************************************************************//**
 
128
        dfield_t*       field1, /* out: field to copy to */
 
129
        const dfield_t* field2);/* in: field to copy from */
 
130
/*************************************************************************
149
131
Copies the data pointed to by a data field. */
150
132
UNIV_INLINE
151
133
void
152
134
dfield_dup(
153
135
/*=======*/
154
 
        dfield_t*       field,  /*!< in/out: data field */
155
 
        mem_heap_t*     heap);  /*!< in: memory heap where allocated */
156
 
/*********************************************************************//**
157
 
Tests if data length and content is equal for two dfields.
158
 
@return TRUE if equal */
 
136
        dfield_t*       field,  /* in/out: data field */
 
137
        mem_heap_t*     heap);  /* in: memory heap where allocated */
 
138
/*************************************************************************
 
139
Tests if data length and content is equal for two dfields. */
159
140
UNIV_INLINE
160
141
ibool
161
142
dfield_datas_are_binary_equal(
162
143
/*==========================*/
163
 
        const dfield_t* field1, /*!< in: field */
164
 
        const dfield_t* field2);/*!< in: field */
165
 
/*********************************************************************//**
166
 
Tests if dfield data length and content is equal to the given.
167
 
@return TRUE if equal */
 
144
                                /* out: TRUE if equal */
 
145
        const dfield_t* field1, /* in: field */
 
146
        const dfield_t* field2);/* in: field */
 
147
/*************************************************************************
 
148
Tests if dfield data length and content is equal to the given. */
168
149
UNIV_INTERN
169
150
ibool
170
151
dfield_data_is_binary_equal(
171
152
/*========================*/
172
 
        const dfield_t* field,  /*!< in: field */
173
 
        ulint           len,    /*!< in: data length or UNIV_SQL_NULL */
174
 
        const byte*     data);  /*!< in: data */
175
 
/*********************************************************************//**
176
 
Gets number of fields in a data tuple.
177
 
@return number of fields */
 
153
                                /* out: TRUE if equal */
 
154
        const dfield_t* field,  /* in: field */
 
155
        ulint           len,    /* in: data length or UNIV_SQL_NULL */
 
156
        const byte*     data);  /* in: data */
 
157
/*************************************************************************
 
158
Gets number of fields in a data tuple. */
178
159
UNIV_INLINE
179
160
ulint
180
161
dtuple_get_n_fields(
181
162
/*================*/
182
 
        const dtuple_t* tuple); /*!< in: tuple */
 
163
                                /* out: number of fields */
 
164
        const dtuple_t* tuple); /* in: tuple */
183
165
#ifdef UNIV_DEBUG
184
 
/*********************************************************************//**
185
 
Gets nth field of a tuple.
186
 
@return nth field */
 
166
/*************************************************************************
 
167
Gets nth field of a tuple. */
187
168
UNIV_INLINE
188
169
dfield_t*
189
170
dtuple_get_nth_field(
190
171
/*=================*/
191
 
        const dtuple_t* tuple,  /*!< in: tuple */
192
 
        ulint           n);     /*!< in: index of field */
 
172
                                /* out: nth field */
 
173
        const dtuple_t* tuple,  /* in: tuple */
 
174
        ulint           n);     /* in: index of field */
193
175
#else /* UNIV_DEBUG */
194
176
# define dtuple_get_nth_field(tuple, n) ((tuple)->fields + (n))
195
177
#endif /* UNIV_DEBUG */
196
 
/*********************************************************************//**
197
 
Gets info bits in a data tuple.
198
 
@return info bits */
 
178
/*************************************************************************
 
179
Gets info bits in a data tuple. */
199
180
UNIV_INLINE
200
181
ulint
201
182
dtuple_get_info_bits(
202
183
/*=================*/
203
 
        const dtuple_t* tuple); /*!< in: tuple */
204
 
/*********************************************************************//**
 
184
                                /* out: info bits */
 
185
        const dtuple_t* tuple); /* in: tuple */
 
186
/*************************************************************************
205
187
Sets info bits in a data tuple. */
206
188
UNIV_INLINE
207
189
void
208
190
dtuple_set_info_bits(
209
191
/*=================*/
210
 
        dtuple_t*       tuple,          /*!< in: tuple */
211
 
        ulint           info_bits);     /*!< in: info bits */
212
 
/*********************************************************************//**
213
 
Gets number of fields used in record comparisons.
214
 
@return number of fields used in comparisons in rem0cmp.* */
 
192
        dtuple_t*       tuple,          /* in: tuple */
 
193
        ulint           info_bits);     /* in: info bits */
 
194
/*************************************************************************
 
195
Gets number of fields used in record comparisons. */
215
196
UNIV_INLINE
216
197
ulint
217
198
dtuple_get_n_fields_cmp(
218
199
/*====================*/
219
 
        const dtuple_t* tuple); /*!< in: tuple */
220
 
/*********************************************************************//**
 
200
                                /* out: number of fields used in comparisons
 
201
                                in rem0cmp.* */
 
202
        const dtuple_t* tuple); /* in: tuple */
 
203
/*************************************************************************
221
204
Gets number of fields used in record comparisons. */
222
205
UNIV_INLINE
223
206
void
224
207
dtuple_set_n_fields_cmp(
225
208
/*====================*/
226
 
        dtuple_t*       tuple,          /*!< in: tuple */
227
 
        ulint           n_fields_cmp);  /*!< in: number of fields used in
 
209
        dtuple_t*       tuple,          /* in: tuple */
 
210
        ulint           n_fields_cmp);  /* in: number of fields used in
228
211
                                        comparisons in rem0cmp.* */
229
 
/**********************************************************//**
 
212
/**************************************************************
230
213
Creates a data tuple to a memory heap. The default value for number
231
 
of fields used in record comparisons for this tuple is n_fields.
232
 
@return own: created tuple */
 
214
of fields used in record comparisons for this tuple is n_fields. */
233
215
UNIV_INLINE
234
216
dtuple_t*
235
217
dtuple_create(
236
218
/*==========*/
237
 
        mem_heap_t*     heap,   /*!< in: memory heap where the tuple
 
219
                                /* out, own: created tuple */
 
220
        mem_heap_t*     heap,   /* in: memory heap where the tuple
238
221
                                is created */
239
 
        ulint           n_fields); /*!< in: number of fields */
 
222
        ulint           n_fields); /* in: number of fields */
240
223
 
241
 
/**********************************************************//**
 
224
/**************************************************************
242
225
Wrap data fields in a tuple. The default value for number
243
 
of fields used in record comparisons for this tuple is n_fields.
244
 
@return data tuple */
 
226
of fields used in record comparisons for this tuple is n_fields. */
245
227
UNIV_INLINE
246
228
const dtuple_t*
247
229
dtuple_from_fields(
248
230
/*===============*/
249
 
        dtuple_t*       tuple,          /*!< in: storage for data tuple */
250
 
        const dfield_t* fields,         /*!< in: fields */
251
 
        ulint           n_fields);      /*!< in: number of fields */
 
231
                                        /* out: data tuple */
 
232
        dtuple_t*       tuple,          /* in: storage for data tuple */
 
233
        const dfield_t* fields,         /* in: fields */
 
234
        ulint           n_fields);      /* in: number of fields */
252
235
 
253
 
/*********************************************************************//**
 
236
/*************************************************************************
254
237
Sets number of fields used in a tuple. Normally this is set in
255
238
dtuple_create, but if you want later to set it smaller, you can use this. */
256
239
UNIV_INTERN
257
240
void
258
241
dtuple_set_n_fields(
259
242
/*================*/
260
 
        dtuple_t*       tuple,          /*!< in: tuple */
261
 
        ulint           n_fields);      /*!< in: number of fields */
262
 
/*********************************************************************//**
 
243
        dtuple_t*       tuple,          /* in: tuple */
 
244
        ulint           n_fields);      /* in: number of fields */
 
245
/*************************************************************************
263
246
Copies a data tuple to another.  This is a shallow copy; if a deep copy
264
 
is desired, dfield_dup() will have to be invoked on each field.
265
 
@return own: copy of tuple */
 
247
is desired, dfield_dup() will have to be invoked on each field. */
266
248
UNIV_INLINE
267
249
dtuple_t*
268
250
dtuple_copy(
269
251
/*========*/
270
 
        const dtuple_t* tuple,  /*!< in: tuple to copy from */
271
 
        mem_heap_t*     heap);  /*!< in: memory heap
 
252
                                /* out, own: copy of tuple */
 
253
        const dtuple_t* tuple,  /* in: tuple to copy from */
 
254
        mem_heap_t*     heap);  /* in: memory heap
272
255
                                where the tuple is created */
273
 
/**********************************************************//**
 
256
/**************************************************************
274
257
The following function returns the sum of data lengths of a tuple. The space
275
 
occupied by the field structs or the tuple struct is not counted.
276
 
@return sum of data lens */
 
258
occupied by the field structs or the tuple struct is not counted. */
277
259
UNIV_INLINE
278
260
ulint
279
261
dtuple_get_data_size(
280
262
/*=================*/
281
 
        const dtuple_t* tuple,  /*!< in: typed data tuple */
282
 
        ulint           comp);  /*!< in: nonzero=ROW_FORMAT=COMPACT  */
283
 
/*********************************************************************//**
284
 
Computes the number of externally stored fields in a data tuple.
285
 
@return number of fields */
 
263
                                /* out: sum of data lens */
 
264
        const dtuple_t* tuple); /* in: typed data tuple */
 
265
/*************************************************************************
 
266
Computes the number of externally stored fields in a data tuple. */
286
267
UNIV_INLINE
287
268
ulint
288
269
dtuple_get_n_ext(
289
270
/*=============*/
290
 
        const dtuple_t* tuple); /*!< in: tuple */
291
 
/************************************************************//**
292
 
Compare two data tuples, respecting the collation of character fields.
293
 
@return 1, 0 , -1 if tuple1 is greater, equal, less, respectively,
294
 
than tuple2 */
 
271
                                /* out: number of fields */
 
272
        const dtuple_t* tuple); /* in: tuple */
 
273
/****************************************************************
 
274
Compare two data tuples, respecting the collation of character fields. */
295
275
UNIV_INTERN
296
276
int
297
277
dtuple_coll_cmp(
298
278
/*============*/
299
 
        const dtuple_t* tuple1, /*!< in: tuple 1 */
300
 
        const dtuple_t* tuple2);/*!< in: tuple 2 */
301
 
/************************************************************//**
302
 
Folds a prefix given as the number of fields of a tuple.
303
 
@return the folded value */
 
279
                                /* out: 1, 0 , -1 if tuple1 is greater, equal,
 
280
                                less, respectively, than tuple2 */
 
281
        const dtuple_t* tuple1, /* in: tuple 1 */
 
282
        const dtuple_t* tuple2);/* in: tuple 2 */
 
283
/****************************************************************
 
284
Folds a prefix given as the number of fields of a tuple. */
304
285
UNIV_INLINE
305
286
ulint
306
287
dtuple_fold(
307
288
/*========*/
308
 
        const dtuple_t* tuple,  /*!< in: the tuple */
309
 
        ulint           n_fields,/*!< in: number of complete fields to fold */
310
 
        ulint           n_bytes,/*!< in: number of bytes to fold in an
 
289
                                /* out: the folded value */
 
290
        const dtuple_t* tuple,  /* in: the tuple */
 
291
        ulint           n_fields,/* in: number of complete fields to fold */
 
292
        ulint           n_bytes,/* in: number of bytes to fold in an
311
293
                                incomplete last field */
312
 
        index_id_t      tree_id)/*!< in: index tree id */
 
294
        dulint          tree_id)/* in: index tree id */
313
295
        __attribute__((pure));
314
 
/*******************************************************************//**
 
296
/***********************************************************************
315
297
Sets types of fields binary in a tuple. */
316
298
UNIV_INLINE
317
299
void
318
300
dtuple_set_types_binary(
319
301
/*====================*/
320
 
        dtuple_t*       tuple,  /*!< in: data tuple */
321
 
        ulint           n);     /*!< in: number of fields to set */
322
 
/**********************************************************************//**
323
 
Checks if a dtuple contains an SQL null value.
324
 
@return TRUE if some field is SQL null */
 
302
        dtuple_t*       tuple,  /* in: data tuple */
 
303
        ulint           n);     /* in: number of fields to set */
 
304
/**************************************************************************
 
305
Checks if a dtuple contains an SQL null value. */
325
306
UNIV_INLINE
326
307
ibool
327
308
dtuple_contains_null(
328
309
/*=================*/
329
 
        const dtuple_t* tuple); /*!< in: dtuple */
330
 
/**********************************************************//**
331
 
Checks that a data field is typed. Asserts an error if not.
332
 
@return TRUE if ok */
 
310
                                /* out: TRUE if some field is SQL null */
 
311
        const dtuple_t* tuple); /* in: dtuple */
 
312
/**************************************************************
 
313
Checks that a data field is typed. Asserts an error if not. */
333
314
UNIV_INTERN
334
315
ibool
335
316
dfield_check_typed(
336
317
/*===============*/
337
 
        const dfield_t* field); /*!< in: data field */
338
 
/**********************************************************//**
339
 
Checks that a data tuple is typed. Asserts an error if not.
340
 
@return TRUE if ok */
 
318
                                /* out: TRUE if ok */
 
319
        const dfield_t* field); /* in: data field */
 
320
/**************************************************************
 
321
Checks that a data tuple is typed. Asserts an error if not. */
341
322
UNIV_INTERN
342
323
ibool
343
324
dtuple_check_typed(
344
325
/*===============*/
345
 
        const dtuple_t* tuple); /*!< in: tuple */
346
 
/**********************************************************//**
347
 
Checks that a data tuple is typed.
348
 
@return TRUE if ok */
 
326
                                /* out: TRUE if ok */
 
327
        const dtuple_t* tuple); /* in: tuple */
 
328
/**************************************************************
 
329
Checks that a data tuple is typed. */
349
330
UNIV_INTERN
350
331
ibool
351
332
dtuple_check_typed_no_assert(
352
333
/*=========================*/
353
 
        const dtuple_t* tuple); /*!< in: tuple */
 
334
                                /* out: TRUE if ok */
 
335
        const dtuple_t* tuple); /* in: tuple */
354
336
#ifdef UNIV_DEBUG
355
 
/**********************************************************//**
 
337
/**************************************************************
356
338
Validates the consistency of a tuple which must be complete, i.e,
357
 
all fields must have been set.
358
 
@return TRUE if ok */
 
339
all fields must have been set. */
359
340
UNIV_INTERN
360
341
ibool
361
342
dtuple_validate(
362
343
/*============*/
363
 
        const dtuple_t* tuple); /*!< in: tuple */
 
344
                                /* out: TRUE if ok */
 
345
        const dtuple_t* tuple); /* in: tuple */
364
346
#endif /* UNIV_DEBUG */
365
 
/*************************************************************//**
 
347
/*****************************************************************
366
348
Pretty prints a dfield value according to its data type. */
367
349
UNIV_INTERN
368
350
void
369
351
dfield_print(
370
352
/*=========*/
371
 
        const dfield_t* dfield);/*!< in: dfield */
372
 
/*************************************************************//**
 
353
        const dfield_t* dfield);/* in: dfield */
 
354
/*****************************************************************
373
355
Pretty prints a dfield value according to its data type. Also the hex string
374
356
is printed if a string contains non-printable characters. */
375
357
UNIV_INTERN
376
358
void
377
359
dfield_print_also_hex(
378
360
/*==================*/
379
 
        const dfield_t* dfield);         /*!< in: dfield */
380
 
/**********************************************************//**
 
361
        const dfield_t* dfield);         /* in: dfield */
 
362
/**************************************************************
381
363
The following function prints the contents of a tuple. */
382
364
UNIV_INTERN
383
365
void
384
366
dtuple_print(
385
367
/*=========*/
386
 
        FILE*           f,      /*!< in: output stream */
387
 
        const dtuple_t* tuple); /*!< in: tuple */
388
 
/**************************************************************//**
 
368
        FILE*           f,      /* in: output stream */
 
369
        const dtuple_t* tuple); /* in: tuple */
 
370
/******************************************************************
389
371
Moves parts of long fields in entry to the big record vector so that
390
372
the size of tuple drops below the maximum record size allowed in the
391
373
database. Moves data only from those fields which are not necessary
392
 
to determine uniquely the insertion place of the tuple in the index.
393
 
@return own: created big record vector, NULL if we are not able to
394
 
shorten the entry enough, i.e., if there are too many fixed-length or
395
 
short fields in entry or the index is clustered */
 
374
to determine uniquely the insertion place of the tuple in the index. */
396
375
UNIV_INTERN
397
376
big_rec_t*
398
377
dtuple_convert_big_rec(
399
378
/*===================*/
400
 
        dict_index_t*   index,  /*!< in: index */
401
 
        dtuple_t*       entry,  /*!< in/out: index entry */
402
 
        ulint*          n_ext); /*!< in/out: number of
 
379
                                /* out, own: created big record vector,
 
380
                                NULL if we are not able to shorten
 
381
                                the entry enough, i.e., if there are
 
382
                                too many fixed-length or short fields
 
383
                                in entry or the index is clustered */
 
384
        dict_index_t*   index,  /* in: index */
 
385
        dtuple_t*       entry,  /* in/out: index entry */
 
386
        ulint*          n_ext); /* in/out: number of
403
387
                                externally stored columns */
404
 
/**************************************************************//**
 
388
/******************************************************************
405
389
Puts back to entry the data stored in vector. Note that to ensure the
406
390
fields in entry can accommodate the data, vector must have been created
407
391
from entry with dtuple_convert_big_rec. */
409
393
void
410
394
dtuple_convert_back_big_rec(
411
395
/*========================*/
412
 
        dict_index_t*   index,  /*!< in: index */
413
 
        dtuple_t*       entry,  /*!< in: entry whose data was put to vector */
414
 
        big_rec_t*      vector);/*!< in, own: big rec vector; it is
 
396
        dict_index_t*   index,  /* in: index */
 
397
        dtuple_t*       entry,  /* in: entry whose data was put to vector */
 
398
        big_rec_t*      vector);/* in, own: big rec vector; it is
415
399
                                freed in this function */
416
 
/**************************************************************//**
 
400
/******************************************************************
417
401
Frees the memory in a big rec vector. */
418
402
UNIV_INLINE
419
403
void
420
404
dtuple_big_rec_free(
421
405
/*================*/
422
 
        big_rec_t*      vector);        /*!< in, own: big rec vector; it is
 
406
        big_rec_t*      vector);        /* in, own: big rec vector; it is
423
407
                                freed in this function */
424
408
 
425
409
/*######################################################################*/
426
410
 
427
 
/** Structure for an SQL data field */
 
411
/* Structure for an SQL data field */
428
412
struct dfield_struct{
429
 
        void*           data;   /*!< pointer to data */
430
 
        unsigned        ext:1;  /*!< TRUE=externally stored, FALSE=local */
431
 
        unsigned        len:32; /*!< data length; UNIV_SQL_NULL if SQL null */
432
 
        dtype_t         type;   /*!< type of data */
 
413
        void*           data;   /* pointer to data */
 
414
        unsigned        ext:1;  /* TRUE=externally stored, FALSE=local */
 
415
        unsigned        len:32; /* data length; UNIV_SQL_NULL if SQL null */
 
416
        dtype_t         type;   /* type of data */
433
417
};
434
418
 
435
 
/** Structure for an SQL data tuple of fields (logical record) */
436
419
struct dtuple_struct {
437
 
        ulint           info_bits;      /*!< info bits of an index record:
 
420
        ulint           info_bits;      /* info bits of an index record:
438
421
                                        the default is 0; this field is used
439
422
                                        if an index record is built from
440
423
                                        a data tuple */
441
 
        ulint           n_fields;       /*!< number of fields in dtuple */
442
 
        ulint           n_fields_cmp;   /*!< number of fields which should
 
424
        ulint           n_fields;       /* number of fields in dtuple */
 
425
        ulint           n_fields_cmp;   /* number of fields which should
443
426
                                        be used in comparison services
444
427
                                        of rem0cmp.*; the index search
445
428
                                        is performed by comparing only these
446
429
                                        fields, others are ignored; the
447
430
                                        default value in dtuple creation is
448
431
                                        the same value as n_fields */
449
 
        dfield_t*       fields;         /*!< fields */
 
432
        dfield_t*       fields;         /* fields */
450
433
        UT_LIST_NODE_T(dtuple_t) tuple_list;
451
 
                                        /*!< data tuples can be linked into a
 
434
                                        /* data tuples can be linked into a
452
435
                                        list using this field */
453
436
#ifdef UNIV_DEBUG
454
 
        ulint           magic_n;        /*!< magic number, used in
455
 
                                        debug assertions */
456
 
/** Value of dtuple_struct::magic_n */
 
437
        ulint           magic_n;
457
438
# define                DATA_TUPLE_MAGIC_N      65478679
458
439
#endif /* UNIV_DEBUG */
459
440
};
460
441
 
461
 
/** A slot for a field in a big rec vector */
 
442
/* A slot for a field in a big rec vector */
 
443
 
462
444
typedef struct big_rec_field_struct     big_rec_field_t;
463
 
/** A slot for a field in a big rec vector */
464
445
struct big_rec_field_struct {
465
 
        ulint           field_no;       /*!< field number in record */
466
 
        ulint           len;            /*!< stored data length, in bytes */
467
 
        const void*     data;           /*!< stored data */
 
446
        ulint           field_no;       /* field number in record */
 
447
        ulint           len;            /* stored data len */
 
448
        const void*     data;           /* stored data */
468
449
};
469
450
 
470
 
/** Storage format for overflow data in a big record, that is, a
471
 
clustered index record which needs external storage of data fields */
 
451
/* Storage format for overflow data in a big record, that is, a record
 
452
which needs external storage of data fields */
 
453
 
472
454
struct big_rec_struct {
473
 
        mem_heap_t*     heap;           /*!< memory heap from which
474
 
                                        allocated */
475
 
        ulint           n_fields;       /*!< number of stored fields */
476
 
        big_rec_field_t*fields;         /*!< stored fields */
 
455
        mem_heap_t*     heap;           /* memory heap from which allocated */
 
456
        ulint           n_fields;       /* number of stored fields */
 
457
        big_rec_field_t* fields;        /* stored fields */
477
458
};
478
459
 
479
460
#ifndef UNIV_NONINL