← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

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