← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/rem/rem0rec.c

  • Committer: Brian Aker
  • Date: 2009-07-11 19:23:04 UTC
  • mfrom: (1089.1.14 merge)
  • Revision ID: brian@gaz-20090711192304-ootijyl5yf9jq9kd
Merge Brian

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/rem/rem0rec.c
1
 
/************************************************************************
2
 
Record manager
3
 
 
4
 
(c) 1994-2001 Innobase Oy
5
 
 
6
 
Created 5/30/1994 Heikki Tuuri
7
 
*************************************************************************/
8
 
 
9
 
#include "rem0rec.h"
10
 
 
11
 
#ifdef UNIV_NONINL
12
 
#include "rem0rec.ic"
13
 
#endif
14
 
 
15
 
#include "mtr0mtr.h"
16
 
#include "mtr0log.h"
17
 
 
18
 
/*                      PHYSICAL RECORD (OLD STYLE)
19
 
                        ===========================
20
 
 
21
 
The physical record, which is the data type of all the records
22
 
found in index pages of the database, has the following format
23
 
(lower addresses and more significant bits inside a byte are below
24
 
represented on a higher text line):
25
 
 
26
 
| offset of the end of the last field of data, the most significant
27
 
  bit is set to 1 if and only if the field is SQL-null,
28
 
  if the offset is 2-byte, then the second most significant
29
 
  bit is set to 1 if the field is stored on another page:
30
 
  mostly this will occur in the case of big BLOB fields |
31
 
...
32
 
| offset of the end of the first field of data + the SQL-null bit |
33
 
| 4 bits used to delete mark a record, and mark a predefined
34
 
  minimum record in alphabetical order |
35
 
| 4 bits giving the number of records owned by this record
36
 
  (this term is explained in page0page.h) |
37
 
| 13 bits giving the order number of this record in the
38
 
  heap of the index page |
39
 
| 10 bits giving the number of fields in this record |
40
 
| 1 bit which is set to 1 if the offsets above are given in
41
 
  one byte format, 0 if in two byte format |
42
 
| two bytes giving an absolute pointer to the next record in the page |
43
 
ORIGIN of the record
44
 
| first field of data |
45
 
...
46
 
| last field of data |
47
 
 
48
 
The origin of the record is the start address of the first field
49
 
of data. The offsets are given relative to the origin.
50
 
The offsets of the data fields are stored in an inverted
51
 
order because then the offset of the first fields are near the
52
 
origin, giving maybe a better processor cache hit rate in searches.
53
 
 
54
 
The offsets of the data fields are given as one-byte
55
 
(if there are less than 127 bytes of data in the record)
56
 
or two-byte unsigned integers. The most significant bit
57
 
is not part of the offset, instead it indicates the SQL-null
58
 
if the bit is set to 1. */
59
 
 
60
 
/*                      PHYSICAL RECORD (NEW STYLE)
61
 
                        ===========================
62
 
 
63
 
The physical record, which is the data type of all the records
64
 
found in index pages of the database, has the following format
65
 
(lower addresses and more significant bits inside a byte are below
66
 
represented on a higher text line):
67
 
 
68
 
| length of the last non-null variable-length field of data:
69
 
  if the maximum length is 255, one byte; otherwise,
70
 
  0xxxxxxx (one byte, length=0..127), or 1exxxxxxxxxxxxxx (two bytes,
71
 
  length=128..16383, extern storage flag) |
72
 
...
73
 
| length of first variable-length field of data |
74
 
| SQL-null flags (1 bit per nullable field), padded to full bytes |
75
 
| 4 bits used to delete mark a record, and mark a predefined
76
 
  minimum record in alphabetical order |
77
 
| 4 bits giving the number of records owned by this record
78
 
  (this term is explained in page0page.h) |
79
 
| 13 bits giving the order number of this record in the
80
 
  heap of the index page |
81
 
| 3 bits record type: 000=conventional, 001=node pointer (inside B-tree),
82
 
  010=infimum, 011=supremum, 1xx=reserved |
83
 
| two bytes giving a relative pointer to the next record in the page |
84
 
ORIGIN of the record
85
 
| first field of data |
86
 
...
87
 
| last field of data |
88
 
 
89
 
The origin of the record is the start address of the first field
90
 
of data. The offsets are given relative to the origin.
91
 
The offsets of the data fields are stored in an inverted
92
 
order because then the offset of the first fields are near the
93
 
origin, giving maybe a better processor cache hit rate in searches.
94
 
 
95
 
The offsets of the data fields are given as one-byte
96
 
(if there are less than 127 bytes of data in the record)
97
 
or two-byte unsigned integers. The most significant bit
98
 
is not part of the offset, instead it indicates the SQL-null
99
 
if the bit is set to 1. */
100
 
 
101
 
/* CANONICAL COORDINATES. A record can be seen as a single
102
 
string of 'characters' in the following way: catenate the bytes
103
 
in each field, in the order of fields. An SQL-null field
104
 
is taken to be an empty sequence of bytes. Then after
105
 
the position of each field insert in the string
106
 
the 'character' <FIELD-END>, except that after an SQL-null field
107
 
insert <NULL-FIELD-END>. Now the ordinal position of each
108
 
byte in this canonical string is its canonical coordinate.
109
 
So, for the record ("AA", SQL-NULL, "BB", ""), the canonical
110
 
string is "AA<FIELD_END><NULL-FIELD-END>BB<FIELD-END><FIELD-END>".
111
 
We identify prefixes (= initial segments) of a record
112
 
with prefixes of the canonical string. The canonical
113
 
length of the prefix is the length of the corresponding
114
 
prefix of the canonical string. The canonical length of
115
 
a record is the length of its canonical string.
116
 
 
117
 
For example, the maximal common prefix of records
118
 
("AA", SQL-NULL, "BB", "C") and ("AA", SQL-NULL, "B", "C")
119
 
is "AA<FIELD-END><NULL-FIELD-END>B", and its canonical
120
 
length is 5.
121
 
 
122
 
A complete-field prefix of a record is a prefix which ends at the
123
 
end of some field (containing also <FIELD-END>).
124
 
A record is a complete-field prefix of another record, if
125
 
the corresponding canonical strings have the same property. */
126
 
 
127
 
ulint   rec_dummy;      /* this is used to fool compiler in
128
 
                        rec_validate */
129
 
 
130
 
/*******************************************************************
131
 
Validates the consistency of an old-style physical record. */
132
 
static
133
 
ibool
134
 
rec_validate_old(
135
 
/*=============*/
136
 
                        /* out: TRUE if ok */
137
 
        rec_t*  rec);   /* in: physical record */
138
 
 
139
 
/**********************************************************
140
 
The following function determines the offsets to each field in the
141
 
record.  The offsets are written to a previously allocated array of
142
 
ulint, where rec_offs_n_fields(offsets) has been initialized to the
143
 
number of fields in the record.  The rest of the array will be
144
 
initialized by this function.  rec_offs_base(offsets)[0] will be set
145
 
to the extra size (if REC_OFFS_COMPACT is set, the record is in the
146
 
new format), and rec_offs_base(offsets)[1..n_fields] will be set to
147
 
offsets past the end of fields 0..n_fields, or to the beginning of
148
 
fields 1..n_fields+1.  When the high-order bit of the offset at [i+1]
149
 
is set (REC_OFFS_SQL_NULL), the field i is NULL.  When the second
150
 
high-order bit of the offset at [i+1] is set (REC_OFFS_EXTERNAL), the
151
 
field i is being stored externally. */
152
 
static
153
 
void
154
 
rec_init_offsets(
155
 
/*=============*/
156
 
        rec_t*          rec,    /* in: physical record */
157
 
        dict_index_t*   index,  /* in: record descriptor */
158
 
        ulint*          offsets)/* in/out: array of offsets;
159
 
                                in: n=rec_offs_n_fields(offsets) */
160
 
{
161
 
        ulint   i       = 0;
162
 
        ulint   offs;
163
 
 
164
 
        rec_offs_make_valid(rec, index, offsets);
165
 
 
166
 
        if (dict_table_is_comp(index->table)) {
167
 
                const byte*     nulls;
168
 
                const byte*     lens;
169
 
                dict_field_t*   field;
170
 
                ulint           null_mask;
171
 
                ulint           status = rec_get_status(rec);
172
 
                ulint           n_node_ptr_field = ULINT_UNDEFINED;
173
 
 
174
 
                switch (UNIV_EXPECT(status, REC_STATUS_ORDINARY)) {
175
 
                case REC_STATUS_INFIMUM:
176
 
                case REC_STATUS_SUPREMUM:
177
 
                        /* the field is 8 bytes long */
178
 
                        rec_offs_base(offsets)[0]
179
 
                                = REC_N_NEW_EXTRA_BYTES | REC_OFFS_COMPACT;
180
 
                        rec_offs_base(offsets)[1] = 8;
181
 
                        return;
182
 
                case REC_STATUS_NODE_PTR:
183
 
                        n_node_ptr_field
184
 
                                = dict_index_get_n_unique_in_tree(index);
185
 
                        break;
186
 
                case REC_STATUS_ORDINARY:
187
 
                        break;
188
 
                }
189
 
 
190
 
                nulls = rec - (REC_N_NEW_EXTRA_BYTES + 1);
191
 
                lens = nulls - UT_BITS_IN_BYTES(index->n_nullable);
192
 
                offs = 0;
193
 
                null_mask = 1;
194
 
 
195
 
                /* read the lengths of fields 0..n */
196
 
                do {
197
 
                        ulint   len;
198
 
                        if (UNIV_UNLIKELY(i == n_node_ptr_field)) {
199
 
                                len = offs += 4;
200
 
                                goto resolved;
201
 
                        }
202
 
 
203
 
                        field = dict_index_get_nth_field(index, i);
204
 
                        if (!(dict_field_get_col(field)->prtype
205
 
                              & DATA_NOT_NULL)) {
206
 
                                /* nullable field => read the null flag */
207
 
 
208
 
                                if (UNIV_UNLIKELY(!(byte) null_mask)) {
209
 
                                        nulls--;
210
 
                                        null_mask = 1;
211
 
                                }
212
 
 
213
 
                                if (*nulls & null_mask) {
214
 
                                        null_mask <<= 1;
215
 
                                        /* No length is stored for NULL fields.
216
 
                                        We do not advance offs, and we set
217
 
                                        the length to zero and enable the
218
 
                                        SQL NULL flag in offsets[]. */
219
 
                                        len = offs | REC_OFFS_SQL_NULL;
220
 
                                        goto resolved;
221
 
                                }
222
 
                                null_mask <<= 1;
223
 
                        }
224
 
 
225
 
                        if (UNIV_UNLIKELY(!field->fixed_len)) {
226
 
                                /* Variable-length field: read the length */
227
 
                                const dict_col_t*       col
228
 
                                        = dict_field_get_col(field);
229
 
                                len = *lens--;
230
 
                                if (UNIV_UNLIKELY(col->len > 255)
231
 
                                    || UNIV_UNLIKELY(col->mtype
232
 
                                                     == DATA_BLOB)) {
233
 
                                        if (len & 0x80) {
234
 
                                                /* 1exxxxxxx xxxxxxxx */
235
 
                                                len <<= 8;
236
 
                                                len |= *lens--;
237
 
 
238
 
                                                offs += len & 0x3fff;
239
 
                                                if (UNIV_UNLIKELY(len
240
 
                                                                  & 0x4000)) {
241
 
                                                        len = offs
242
 
                                                                | REC_OFFS_EXTERNAL;
243
 
                                                } else {
244
 
                                                        len = offs;
245
 
                                                }
246
 
 
247
 
                                                goto resolved;
248
 
                                        }
249
 
                                }
250
 
 
251
 
                                len = offs += len;
252
 
                        } else {
253
 
                                len = offs += field->fixed_len;
254
 
                        }
255
 
resolved:
256
 
                        rec_offs_base(offsets)[i + 1] = len;
257
 
                } while (++i < rec_offs_n_fields(offsets));
258
 
 
259
 
                *rec_offs_base(offsets)
260
 
                        = (rec - (lens + 1)) | REC_OFFS_COMPACT;
261
 
        } else {
262
 
                /* Old-style record: determine extra size and end offsets */
263
 
                offs = REC_N_OLD_EXTRA_BYTES;
264
 
                if (rec_get_1byte_offs_flag(rec)) {
265
 
                        offs += rec_offs_n_fields(offsets);
266
 
                        *rec_offs_base(offsets) = offs;
267
 
                        /* Determine offsets to fields */
268
 
                        do {
269
 
                                offs = rec_1_get_field_end_info(rec, i);
270
 
                                if (offs & REC_1BYTE_SQL_NULL_MASK) {
271
 
                                        offs &= ~REC_1BYTE_SQL_NULL_MASK;
272
 
                                        offs |= REC_OFFS_SQL_NULL;
273
 
                                }
274
 
                                rec_offs_base(offsets)[1 + i] = offs;
275
 
                        } while (++i < rec_offs_n_fields(offsets));
276
 
                } else {
277
 
                        offs += 2 * rec_offs_n_fields(offsets);
278
 
                        *rec_offs_base(offsets) = offs;
279
 
                        /* Determine offsets to fields */
280
 
                        do {
281
 
                                offs = rec_2_get_field_end_info(rec, i);
282
 
                                if (offs & REC_2BYTE_SQL_NULL_MASK) {
283
 
                                        offs &= ~REC_2BYTE_SQL_NULL_MASK;
284
 
                                        offs |= REC_OFFS_SQL_NULL;
285
 
                                }
286
 
                                if (offs & REC_2BYTE_EXTERN_MASK) {
287
 
                                        offs &= ~REC_2BYTE_EXTERN_MASK;
288
 
                                        offs |= REC_OFFS_EXTERNAL;
289
 
                                }
290
 
                                rec_offs_base(offsets)[1 + i] = offs;
291
 
                        } while (++i < rec_offs_n_fields(offsets));
292
 
                }
293
 
        }
294
 
}
295
 
 
296
 
/**********************************************************
297
 
The following function determines the offsets to each field
298
 
in the record.  It can reuse a previously returned array. */
299
 
 
300
 
ulint*
301
 
rec_get_offsets_func(
302
 
/*=================*/
303
 
                                /* out: the new offsets */
304
 
        rec_t*          rec,    /* in: physical record */
305
 
        dict_index_t*   index,  /* in: record descriptor */
306
 
        ulint*          offsets,/* in/out: array consisting of offsets[0]
307
 
                                allocated elements, or an array from
308
 
                                rec_get_offsets(), or NULL */
309
 
        ulint           n_fields,/* in: maximum number of initialized fields
310
 
                                (ULINT_UNDEFINED if all fields) */
311
 
        mem_heap_t**    heap,   /* in/out: memory heap */
312
 
        const char*     file,   /* in: file name where called */
313
 
        ulint           line)   /* in: line number where called */
314
 
{
315
 
        ulint   n;
316
 
        ulint   size;
317
 
 
318
 
        ut_ad(rec);
319
 
        ut_ad(index);
320
 
        ut_ad(heap);
321
 
 
322
 
        if (dict_table_is_comp(index->table)) {
323
 
                switch (UNIV_EXPECT(rec_get_status(rec),
324
 
                                    REC_STATUS_ORDINARY)) {
325
 
                case REC_STATUS_ORDINARY:
326
 
                        n = dict_index_get_n_fields(index);
327
 
                        break;
328
 
                case REC_STATUS_NODE_PTR:
329
 
                        n = dict_index_get_n_unique_in_tree(index) + 1;
330
 
                        break;
331
 
                case REC_STATUS_INFIMUM:
332
 
                case REC_STATUS_SUPREMUM:
333
 
                        /* infimum or supremum record */
334
 
                        n = 1;
335
 
                        break;
336
 
                default:
337
 
                        ut_error;
338
 
                        return(NULL);
339
 
                }
340
 
        } else {
341
 
                n = rec_get_n_fields_old(rec);
342
 
        }
343
 
 
344
 
        if (UNIV_UNLIKELY(n_fields < n)) {
345
 
                n = n_fields;
346
 
        }
347
 
 
348
 
        size = n + (1 + REC_OFFS_HEADER_SIZE);
349
 
 
350
 
        if (UNIV_UNLIKELY(!offsets)
351
 
            || UNIV_UNLIKELY(rec_offs_get_n_alloc(offsets) < size)) {
352
 
                if (!*heap) {
353
 
                        *heap = mem_heap_create_func(size * sizeof(ulint),
354
 
                                                     NULL, MEM_HEAP_DYNAMIC,
355
 
                                                     file, line);
356
 
                }
357
 
                offsets = mem_heap_alloc(*heap, size * sizeof(ulint));
358
 
                rec_offs_set_n_alloc(offsets, size);
359
 
        }
360
 
 
361
 
        rec_offs_set_n_fields(offsets, n);
362
 
        rec_init_offsets(rec, index, offsets);
363
 
        return(offsets);
364
 
}
365
 
 
366
 
/****************************************************************
367
 
The following function is used to get a pointer to the nth
368
 
data field in an old-style record. */
369
 
 
370
 
byte*
371
 
rec_get_nth_field_old(
372
 
/*==================*/
373
 
                        /* out: pointer to the field */
374
 
        rec_t*  rec,    /* in: record */
375
 
        ulint   n,      /* in: index of the field */
376
 
        ulint*  len)    /* out: length of the field; UNIV_SQL_NULL if SQL
377
 
                        null */
378
 
{
379
 
        ulint   os;
380
 
        ulint   next_os;
381
 
 
382
 
        ut_ad(rec && len);
383
 
        ut_ad(n < rec_get_n_fields_old(rec));
384
 
 
385
 
        if (n > REC_MAX_N_FIELDS) {
386
 
                fprintf(stderr, "Error: trying to access field %lu in rec\n",
387
 
                        (ulong) n);
388
 
                ut_error;
389
 
        }
390
 
 
391
 
        if (rec == NULL) {
392
 
                fputs("Error: rec is NULL pointer\n", stderr);
393
 
                ut_error;
394
 
        }
395
 
 
396
 
        if (rec_get_1byte_offs_flag(rec)) {
397
 
                os = rec_1_get_field_start_offs(rec, n);
398
 
 
399
 
                next_os = rec_1_get_field_end_info(rec, n);
400
 
 
401
 
                if (next_os & REC_1BYTE_SQL_NULL_MASK) {
402
 
                        *len = UNIV_SQL_NULL;
403
 
 
404
 
                        return(rec + os);
405
 
                }
406
 
 
407
 
                next_os = next_os & ~REC_1BYTE_SQL_NULL_MASK;
408
 
        } else {
409
 
                os = rec_2_get_field_start_offs(rec, n);
410
 
 
411
 
                next_os = rec_2_get_field_end_info(rec, n);
412
 
 
413
 
                if (next_os & REC_2BYTE_SQL_NULL_MASK) {
414
 
                        *len = UNIV_SQL_NULL;
415
 
 
416
 
                        return(rec + os);
417
 
                }
418
 
 
419
 
                next_os = next_os & ~(REC_2BYTE_SQL_NULL_MASK
420
 
                                      | REC_2BYTE_EXTERN_MASK);
421
 
        }
422
 
 
423
 
        *len = next_os - os;
424
 
 
425
 
        ut_ad(*len < UNIV_PAGE_SIZE);
426
 
 
427
 
        return(rec + os);
428
 
}
429
 
 
430
 
/**************************************************************
431
 
The following function returns the size of a data tuple when converted to
432
 
a new-style physical record. */
433
 
 
434
 
ulint
435
 
rec_get_converted_size_new(
436
 
/*=======================*/
437
 
                                /* out: size */
438
 
        dict_index_t*   index,  /* in: record descriptor */
439
 
        dtuple_t*       dtuple) /* in: data tuple */
440
 
{
441
 
        ulint           size            = REC_N_NEW_EXTRA_BYTES
442
 
                + UT_BITS_IN_BYTES(index->n_nullable);
443
 
        ulint           i;
444
 
        ulint           n_fields;
445
 
        ut_ad(index && dtuple);
446
 
        ut_ad(dict_table_is_comp(index->table));
447
 
 
448
 
        switch (dtuple_get_info_bits(dtuple) & REC_NEW_STATUS_MASK) {
449
 
        case REC_STATUS_ORDINARY:
450
 
                n_fields = dict_index_get_n_fields(index);
451
 
                ut_ad(n_fields == dtuple_get_n_fields(dtuple));
452
 
                break;
453
 
        case REC_STATUS_NODE_PTR:
454
 
                n_fields = dict_index_get_n_unique_in_tree(index);
455
 
                ut_ad(n_fields + 1 == dtuple_get_n_fields(dtuple));
456
 
                ut_ad(dtuple_get_nth_field(dtuple, n_fields)->len == 4);
457
 
                size += 4; /* child page number */
458
 
                break;
459
 
        case REC_STATUS_INFIMUM:
460
 
        case REC_STATUS_SUPREMUM:
461
 
                /* infimum or supremum record, 8 data bytes */
462
 
                return(REC_N_NEW_EXTRA_BYTES + 8);
463
 
        default:
464
 
                ut_error;
465
 
                return(ULINT_UNDEFINED);
466
 
        }
467
 
 
468
 
        /* read the lengths of fields 0..n */
469
 
        for (i = 0; i < n_fields; i++) {
470
 
                dict_field_t*           field;
471
 
                ulint                   len;
472
 
                const dict_col_t*       col;
473
 
 
474
 
                field = dict_index_get_nth_field(index, i);
475
 
                len = dtuple_get_nth_field(dtuple, i)->len;
476
 
                col = dict_field_get_col(field);
477
 
 
478
 
                ut_ad(dict_col_type_assert_equal(
479
 
                              col, dfield_get_type(dtuple_get_nth_field(
480
 
                                                           dtuple, i))));
481
 
 
482
 
                if (len == UNIV_SQL_NULL) {
483
 
                        /* No length is stored for NULL fields. */
484
 
                        ut_ad(!(col->prtype & DATA_NOT_NULL));
485
 
                        continue;
486
 
                }
487
 
 
488
 
                ut_ad(len <= col->len || col->mtype == DATA_BLOB);
489
 
 
490
 
                if (field->fixed_len) {
491
 
                        ut_ad(len == field->fixed_len);
492
 
                        /* dict_index_add_col() should guarantee this */
493
 
                        ut_ad(!field->prefix_len
494
 
                              || field->fixed_len == field->prefix_len);
495
 
                } else if (len < 128
496
 
                           || (col->len < 256 && col->mtype != DATA_BLOB)) {
497
 
                        size++;
498
 
                } else {
499
 
                        /* For variable-length columns, we look up the
500
 
                        maximum length from the column itself.  If this
501
 
                        is a prefix index column shorter than 256 bytes,
502
 
                        this will waste one byte. */
503
 
                        size += 2;
504
 
                }
505
 
                size += len;
506
 
        }
507
 
 
508
 
        return(size);
509
 
}
510
 
 
511
 
/***************************************************************
512
 
Sets the value of the ith field SQL null bit of an old-style record. */
513
 
 
514
 
void
515
 
rec_set_nth_field_null_bit(
516
 
/*=======================*/
517
 
        rec_t*  rec,    /* in: record */
518
 
        ulint   i,      /* in: ith field */
519
 
        ibool   val)    /* in: value to set */
520
 
{
521
 
        ulint   info;
522
 
 
523
 
        if (rec_get_1byte_offs_flag(rec)) {
524
 
 
525
 
                info = rec_1_get_field_end_info(rec, i);
526
 
 
527
 
                if (val) {
528
 
                        info = info | REC_1BYTE_SQL_NULL_MASK;
529
 
                } else {
530
 
                        info = info & ~REC_1BYTE_SQL_NULL_MASK;
531
 
                }
532
 
 
533
 
                rec_1_set_field_end_info(rec, i, info);
534
 
 
535
 
                return;
536
 
        }
537
 
 
538
 
        info = rec_2_get_field_end_info(rec, i);
539
 
 
540
 
        if (val) {
541
 
                info = info | REC_2BYTE_SQL_NULL_MASK;
542
 
        } else {
543
 
                info = info & ~REC_2BYTE_SQL_NULL_MASK;
544
 
        }
545
 
 
546
 
        rec_2_set_field_end_info(rec, i, info);
547
 
}
548
 
 
549
 
/***************************************************************
550
 
Sets the value of the ith field extern storage bit of an old-style record. */
551
 
 
552
 
void
553
 
rec_set_nth_field_extern_bit_old(
554
 
/*=============================*/
555
 
        rec_t*  rec,    /* in: old-style record */
556
 
        ulint   i,      /* in: ith field */
557
 
        ibool   val,    /* in: value to set */
558
 
        mtr_t*  mtr)    /* in: mtr holding an X-latch to the page where
559
 
                        rec is, or NULL; in the NULL case we do not
560
 
                        write to log about the change */
561
 
{
562
 
        ulint   info;
563
 
 
564
 
        ut_a(!rec_get_1byte_offs_flag(rec));
565
 
        ut_a(i < rec_get_n_fields_old(rec));
566
 
 
567
 
        info = rec_2_get_field_end_info(rec, i);
568
 
 
569
 
        if (val) {
570
 
                info = info | REC_2BYTE_EXTERN_MASK;
571
 
        } else {
572
 
                info = info & ~REC_2BYTE_EXTERN_MASK;
573
 
        }
574
 
 
575
 
        if (mtr) {
576
 
                mlog_write_ulint(rec - REC_N_OLD_EXTRA_BYTES - 2 * (i + 1),
577
 
                                 info, MLOG_2BYTES, mtr);
578
 
        } else {
579
 
                rec_2_set_field_end_info(rec, i, info);
580
 
        }
581
 
}
582
 
 
583
 
/***************************************************************
584
 
Sets the value of the ith field extern storage bit of a new-style record. */
585
 
 
586
 
void
587
 
rec_set_nth_field_extern_bit_new(
588
 
/*=============================*/
589
 
        rec_t*          rec,    /* in: record */
590
 
        dict_index_t*   index,  /* in: record descriptor */
591
 
        ulint           ith,    /* in: ith field */
592
 
        ibool           val,    /* in: value to set */
593
 
        mtr_t*          mtr)    /* in: mtr holding an X-latch to the page
594
 
                                where rec is, or NULL; in the NULL case
595
 
                                we do not write to log about the change */
596
 
{
597
 
        byte*           nulls   = rec - (REC_N_NEW_EXTRA_BYTES + 1);
598
 
        byte*           lens    = nulls - UT_BITS_IN_BYTES(index->n_nullable);
599
 
        ulint           i;
600
 
        ulint           n_fields;
601
 
        ulint           null_mask       = 1;
602
 
        ut_ad(rec && index);
603
 
        ut_ad(dict_table_is_comp(index->table));
604
 
        ut_ad(rec_get_status(rec) == REC_STATUS_ORDINARY);
605
 
 
606
 
        n_fields = dict_index_get_n_fields(index);
607
 
 
608
 
        ut_ad(ith < n_fields);
609
 
 
610
 
        /* read the lengths of fields 0..n */
611
 
        for (i = 0; i < n_fields; i++) {
612
 
                const dict_field_t*     field;
613
 
                const dict_col_t*       col;
614
 
 
615
 
                field = dict_index_get_nth_field(index, i);
616
 
                col = dict_field_get_col(field);
617
 
 
618
 
                if (!(col->prtype & DATA_NOT_NULL)) {
619
 
                        if (UNIV_UNLIKELY(!(byte) null_mask)) {
620
 
                                nulls--;
621
 
                                null_mask = 1;
622
 
                        }
623
 
 
624
 
                        if (*nulls & null_mask) {
625
 
                                null_mask <<= 1;
626
 
                                /* NULL fields cannot be external. */
627
 
                                ut_ad(i != ith);
628
 
                                continue;
629
 
                        }
630
 
 
631
 
                        null_mask <<= 1;
632
 
                }
633
 
                if (field->fixed_len) {
634
 
                        /* fixed-length fields cannot be external
635
 
                        (Fixed-length fields longer than
636
 
                        DICT_MAX_INDEX_COL_LEN will be treated as
637
 
                        variable-length ones in dict_index_add_col().) */
638
 
                        ut_ad(i != ith);
639
 
                        continue;
640
 
                }
641
 
                lens--;
642
 
                if (col->len > 255 || col->mtype == DATA_BLOB) {
643
 
                        ulint   len = lens[1];
644
 
                        if (len & 0x80) { /* 1exxxxxx: 2-byte length */
645
 
                                if (i == ith) {
646
 
                                        if (!val == !(len & 0x40)) {
647
 
                                                return; /* no change */
648
 
                                        }
649
 
                                        /* toggle the extern bit */
650
 
                                        len ^= 0x40;
651
 
                                        if (mtr) {
652
 
                                                mlog_write_ulint(lens + 1,
653
 
                                                                 len,
654
 
                                                                 MLOG_1BYTE,
655
 
                                                                 mtr);
656
 
                                        } else {
657
 
                                                lens[1] = (byte) len;
658
 
                                        }
659
 
                                        return;
660
 
                                }
661
 
                                lens--;
662
 
                        } else {
663
 
                                /* short fields cannot be external */
664
 
                                ut_ad(i != ith);
665
 
                        }
666
 
                } else {
667
 
                        /* short fields cannot be external */
668
 
                        ut_ad(i != ith);
669
 
                }
670
 
        }
671
 
}
672
 
 
673
 
/***************************************************************
674
 
Sets TRUE the extern storage bits of fields mentioned in an array. */
675
 
 
676
 
void
677
 
rec_set_field_extern_bits(
678
 
/*======================*/
679
 
        rec_t*          rec,    /* in: record */
680
 
        dict_index_t*   index,  /* in: record descriptor */
681
 
        const ulint*    vec,    /* in: array of field numbers */
682
 
        ulint           n_fields,/* in: number of fields numbers */
683
 
        mtr_t*          mtr)    /* in: mtr holding an X-latch to the
684
 
                                page where rec is, or NULL;
685
 
                                in the NULL case we do not write
686
 
                                to log about the change */
687
 
{
688
 
        ulint   i;
689
 
 
690
 
        if (dict_table_is_comp(index->table)) {
691
 
                for (i = 0; i < n_fields; i++) {
692
 
                        rec_set_nth_field_extern_bit_new(rec, index, vec[i],
693
 
                                                         TRUE, mtr);
694
 
                }
695
 
        } else {
696
 
                for (i = 0; i < n_fields; i++) {
697
 
                        rec_set_nth_field_extern_bit_old(rec, vec[i],
698
 
                                                         TRUE, mtr);
699
 
                }
700
 
        }
701
 
}
702
 
 
703
 
/***************************************************************
704
 
Sets an old-style record field to SQL null.
705
 
The physical size of the field is not changed. */
706
 
 
707
 
void
708
 
rec_set_nth_field_sql_null(
709
 
/*=======================*/
710
 
        rec_t*  rec,    /* in: record */
711
 
        ulint   n)      /* in: index of the field */
712
 
{
713
 
        ulint   offset;
714
 
 
715
 
        offset = rec_get_field_start_offs(rec, n);
716
 
 
717
 
        data_write_sql_null(rec + offset, rec_get_nth_field_size(rec, n));
718
 
 
719
 
        rec_set_nth_field_null_bit(rec, n, TRUE);
720
 
}
721
 
 
722
 
/*************************************************************
723
 
Builds an old-style physical record out of a data tuple and
724
 
stores it beginning from the start of the given buffer. */
725
 
static
726
 
rec_t*
727
 
rec_convert_dtuple_to_rec_old(
728
 
/*==========================*/
729
 
                        /* out: pointer to the origin of
730
 
                        physical record */
731
 
        byte*   buf,    /* in: start address of the physical record */
732
 
        dtuple_t* dtuple)/* in: data tuple */
733
 
{
734
 
        dfield_t*       field;
735
 
        ulint           n_fields;
736
 
        ulint           data_size;
737
 
        rec_t*          rec;
738
 
        ulint           end_offset;
739
 
        ulint           ored_offset;
740
 
        byte*           data;
741
 
        ulint           len;
742
 
        ulint           i;
743
 
 
744
 
        ut_ad(buf && dtuple);
745
 
        ut_ad(dtuple_validate(dtuple));
746
 
        ut_ad(dtuple_check_typed(dtuple));
747
 
 
748
 
        n_fields = dtuple_get_n_fields(dtuple);
749
 
        data_size = dtuple_get_data_size(dtuple);
750
 
 
751
 
        ut_ad(n_fields > 0);
752
 
 
753
 
        /* Calculate the offset of the origin in the physical record */
754
 
 
755
 
        rec = buf + rec_get_converted_extra_size(data_size, n_fields);
756
 
#ifdef UNIV_DEBUG
757
 
        /* Suppress Valgrind warnings of ut_ad()
758
 
        in mach_write_to_1(), mach_write_to_2() et al. */
759
 
        memset(buf, 0xff, rec - buf + data_size);
760
 
#endif /* UNIV_DEBUG */
761
 
        /* Store the number of fields */
762
 
        rec_set_n_fields_old(rec, n_fields);
763
 
 
764
 
        /* Set the info bits of the record */
765
 
        rec_set_info_bits(rec, FALSE,
766
 
                          dtuple_get_info_bits(dtuple) & REC_INFO_BITS_MASK);
767
 
 
768
 
        /* Store the data and the offsets */
769
 
 
770
 
        end_offset = 0;
771
 
 
772
 
        if (data_size <= REC_1BYTE_OFFS_LIMIT) {
773
 
 
774
 
                rec_set_1byte_offs_flag(rec, TRUE);
775
 
 
776
 
                for (i = 0; i < n_fields; i++) {
777
 
 
778
 
                        field = dtuple_get_nth_field(dtuple, i);
779
 
 
780
 
                        data = dfield_get_data(field);
781
 
                        len = dfield_get_len(field);
782
 
 
783
 
                        if (len == UNIV_SQL_NULL) {
784
 
                                len = dtype_get_sql_null_size(
785
 
                                        dfield_get_type(field));
786
 
                                data_write_sql_null(rec + end_offset, len);
787
 
 
788
 
                                end_offset += len;
789
 
                                ored_offset = end_offset
790
 
                                        | REC_1BYTE_SQL_NULL_MASK;
791
 
                        } else {
792
 
                                /* If the data is not SQL null, store it */
793
 
                                ut_memcpy(rec + end_offset, data, len);
794
 
 
795
 
                                end_offset += len;
796
 
                                ored_offset = end_offset;
797
 
                        }
798
 
 
799
 
                        rec_1_set_field_end_info(rec, i, ored_offset);
800
 
                }
801
 
        } else {
802
 
                rec_set_1byte_offs_flag(rec, FALSE);
803
 
 
804
 
                for (i = 0; i < n_fields; i++) {
805
 
 
806
 
                        field = dtuple_get_nth_field(dtuple, i);
807
 
 
808
 
                        data = dfield_get_data(field);
809
 
                        len = dfield_get_len(field);
810
 
 
811
 
                        if (len == UNIV_SQL_NULL) {
812
 
                                len = dtype_get_sql_null_size(
813
 
                                        dfield_get_type(field));
814
 
                                data_write_sql_null(rec + end_offset, len);
815
 
 
816
 
                                end_offset += len;
817
 
                                ored_offset = end_offset
818
 
                                        | REC_2BYTE_SQL_NULL_MASK;
819
 
                        } else {
820
 
                                /* If the data is not SQL null, store it */
821
 
                                ut_memcpy(rec + end_offset, data, len);
822
 
 
823
 
                                end_offset += len;
824
 
                                ored_offset = end_offset;
825
 
                        }
826
 
 
827
 
                        rec_2_set_field_end_info(rec, i, ored_offset);
828
 
                }
829
 
        }
830
 
 
831
 
        return(rec);
832
 
}
833
 
 
834
 
/*************************************************************
835
 
Builds a new-style physical record out of a data tuple and
836
 
stores it beginning from the start of the given buffer. */
837
 
static
838
 
rec_t*
839
 
rec_convert_dtuple_to_rec_new(
840
 
/*==========================*/
841
 
                                /* out: pointer to the origin
842
 
                                of physical record */
843
 
        byte*           buf,    /* in: start address of the physical record */
844
 
        dict_index_t*   index,  /* in: record descriptor */
845
 
        dtuple_t*       dtuple) /* in: data tuple */
846
 
{
847
 
        dfield_t*       field;
848
 
        dtype_t*        type;
849
 
        rec_t*          rec             = buf + REC_N_NEW_EXTRA_BYTES;
850
 
        byte*           end;
851
 
        byte*           nulls;
852
 
        byte*           lens;
853
 
        ulint           len;
854
 
        ulint           i;
855
 
        ulint           n_node_ptr_field;
856
 
        ulint           fixed_len;
857
 
        ulint           null_mask       = 1;
858
 
        const ulint     n_fields        = dtuple_get_n_fields(dtuple);
859
 
        const ulint     status          = dtuple_get_info_bits(dtuple)
860
 
                & REC_NEW_STATUS_MASK;
861
 
        ut_ad(dict_table_is_comp(index->table));
862
 
        ut_ad(n_fields > 0);
863
 
 
864
 
        /* Try to ensure that the memset() between the for() loops
865
 
        completes fast.  The address is not exact, but UNIV_PREFETCH
866
 
        should never generate a memory fault. */
867
 
        UNIV_PREFETCH_RW(rec - REC_N_NEW_EXTRA_BYTES - n_fields);
868
 
        UNIV_PREFETCH_RW(rec);
869
 
 
870
 
        switch (UNIV_EXPECT(status, REC_STATUS_ORDINARY)) {
871
 
        case REC_STATUS_ORDINARY:
872
 
                ut_ad(n_fields <= dict_index_get_n_fields(index));
873
 
                n_node_ptr_field = ULINT_UNDEFINED;
874
 
                break;
875
 
        case REC_STATUS_NODE_PTR:
876
 
                ut_ad(n_fields == dict_index_get_n_unique_in_tree(index) + 1);
877
 
                n_node_ptr_field = n_fields - 1;
878
 
                break;
879
 
        case REC_STATUS_INFIMUM:
880
 
        case REC_STATUS_SUPREMUM:
881
 
                ut_ad(n_fields == 1);
882
 
                n_node_ptr_field = ULINT_UNDEFINED;
883
 
                goto init;
884
 
        default:
885
 
                ut_a(0);
886
 
                return(0);
887
 
        }
888
 
 
889
 
        /* Calculate the offset of the origin in the physical record.
890
 
        We must loop over all fields to do this. */
891
 
        rec += UT_BITS_IN_BYTES(index->n_nullable);
892
 
 
893
 
        for (i = 0; i < n_fields; i++) {
894
 
                if (UNIV_UNLIKELY(i == n_node_ptr_field)) {
895
 
#ifdef UNIV_DEBUG
896
 
                        field = dtuple_get_nth_field(dtuple, i);
897
 
                        type = dfield_get_type(field);
898
 
                        ut_ad(dtype_get_prtype(type) & DATA_NOT_NULL);
899
 
                        ut_ad(dfield_get_len(field) == 4);
900
 
#endif /* UNIV_DEBUG */
901
 
                        goto init;
902
 
                }
903
 
                field = dtuple_get_nth_field(dtuple, i);
904
 
                type = dfield_get_type(field);
905
 
                len = dfield_get_len(field);
906
 
                fixed_len = dict_index_get_nth_field(index, i)->fixed_len;
907
 
 
908
 
                ut_ad(dict_col_type_assert_equal(
909
 
                              dict_field_get_col(dict_index_get_nth_field(
910
 
                                                         index, i)),
911
 
                              dfield_get_type(field)));
912
 
 
913
 
                if (!(dtype_get_prtype(type) & DATA_NOT_NULL)) {
914
 
                        if (len == UNIV_SQL_NULL)
915
 
                                continue;
916
 
                }
917
 
                /* only nullable fields can be null */
918
 
                ut_ad(len != UNIV_SQL_NULL);
919
 
                if (fixed_len) {
920
 
                        ut_ad(len == fixed_len);
921
 
                } else {
922
 
                        ut_ad(len <= dtype_get_len(type)
923
 
                              || dtype_get_mtype(type) == DATA_BLOB);
924
 
                        rec++;
925
 
                        if (len >= 128
926
 
                            && (dtype_get_len(type) >= 256
927
 
                                || dtype_get_mtype(type) == DATA_BLOB)) {
928
 
                                rec++;
929
 
                        }
930
 
                }
931
 
        }
932
 
 
933
 
init:
934
 
        end = rec;
935
 
        nulls = rec - (REC_N_NEW_EXTRA_BYTES + 1);
936
 
        lens = nulls - UT_BITS_IN_BYTES(index->n_nullable);
937
 
        /* clear the SQL-null flags */
938
 
        memset (lens + 1, 0, nulls - lens);
939
 
 
940
 
        /* Set the info bits of the record */
941
 
        rec_set_status(rec, status);
942
 
 
943
 
        rec_set_info_bits(rec, TRUE,
944
 
                          dtuple_get_info_bits(dtuple) & REC_INFO_BITS_MASK);
945
 
 
946
 
        /* Store the data and the offsets */
947
 
 
948
 
        for (i = 0; i < n_fields; i++) {
949
 
                field = dtuple_get_nth_field(dtuple, i);
950
 
                type = dfield_get_type(field);
951
 
                len = dfield_get_len(field);
952
 
 
953
 
                if (UNIV_UNLIKELY(i == n_node_ptr_field)) {
954
 
                        ut_ad(dtype_get_prtype(type) & DATA_NOT_NULL);
955
 
                        ut_ad(len == 4);
956
 
                        memcpy(end, dfield_get_data(field), len);
957
 
                        break;
958
 
                }
959
 
                fixed_len = dict_index_get_nth_field(index, i)->fixed_len;
960
 
 
961
 
                if (!(dtype_get_prtype(type) & DATA_NOT_NULL)) {
962
 
                        /* nullable field */
963
 
                        ut_ad(index->n_nullable > 0);
964
 
 
965
 
                        if (UNIV_UNLIKELY(!(byte) null_mask)) {
966
 
                                nulls--;
967
 
                                null_mask = 1;
968
 
                        }
969
 
 
970
 
                        ut_ad(*nulls < null_mask);
971
 
 
972
 
                        /* set the null flag if necessary */
973
 
                        if (len == UNIV_SQL_NULL) {
974
 
                                *nulls |= null_mask;
975
 
                                null_mask <<= 1;
976
 
                                continue;
977
 
                        }
978
 
 
979
 
                        null_mask <<= 1;
980
 
                }
981
 
                /* only nullable fields can be null */
982
 
                ut_ad(len != UNIV_SQL_NULL);
983
 
                if (fixed_len) {
984
 
                        ut_ad(len == fixed_len);
985
 
                } else {
986
 
                        ut_ad(len <= dtype_get_len(type)
987
 
                              || dtype_get_mtype(type) == DATA_BLOB);
988
 
                        if (len < 128
989
 
                            || (dtype_get_len(type) < 256
990
 
                                && dtype_get_mtype(type) != DATA_BLOB)) {
991
 
 
992
 
                                *lens-- = (byte) len;
993
 
                        } else {
994
 
                                /* the extern bits will be set later */
995
 
                                ut_ad(len < 16384);
996
 
                                *lens-- = (byte) (len >> 8) | 0x80;
997
 
                                *lens-- = (byte) len;
998
 
                        }
999
 
                }
1000
 
 
1001
 
                memcpy(end, dfield_get_data(field), len);
1002
 
                end += len;
1003
 
        }
1004
 
 
1005
 
        return(rec);
1006
 
}
1007
 
 
1008
 
/*************************************************************
1009
 
Builds a physical record out of a data tuple and
1010
 
stores it beginning from the start of the given buffer. */
1011
 
 
1012
 
rec_t*
1013
 
rec_convert_dtuple_to_rec(
1014
 
/*======================*/
1015
 
                                        /* out: pointer to the origin
1016
 
                                        of physical record */
1017
 
        byte*           buf,            /* in: start address of the
1018
 
                                        physical record */
1019
 
        dict_index_t*   index,          /* in: record descriptor */
1020
 
        dtuple_t*       dtuple)         /* in: data tuple */
1021
 
{
1022
 
        rec_t*  rec;
1023
 
 
1024
 
        ut_ad(buf && index && dtuple);
1025
 
        ut_ad(dtuple_validate(dtuple));
1026
 
        ut_ad(dtuple_check_typed(dtuple));
1027
 
 
1028
 
        if (dict_table_is_comp(index->table)) {
1029
 
                rec = rec_convert_dtuple_to_rec_new(buf, index, dtuple);
1030
 
        } else {
1031
 
                rec = rec_convert_dtuple_to_rec_old(buf, dtuple);
1032
 
        }
1033
 
 
1034
 
#ifdef UNIV_DEBUG
1035
 
        {
1036
 
                mem_heap_t*     heap    = NULL;
1037
 
                ulint           offsets_[REC_OFFS_NORMAL_SIZE];
1038
 
                const ulint*    offsets;
1039
 
                *offsets_ = (sizeof offsets_) / sizeof *offsets_;
1040
 
 
1041
 
                offsets = rec_get_offsets(rec, index,
1042
 
                                          offsets_, ULINT_UNDEFINED, &heap);
1043
 
                ut_ad(rec_validate(rec, offsets));
1044
 
                if (UNIV_LIKELY_NULL(heap)) {
1045
 
                        mem_heap_free(heap);
1046
 
                }
1047
 
        }
1048
 
#endif /* UNIV_DEBUG */
1049
 
        return(rec);
1050
 
}
1051
 
 
1052
 
/******************************************************************
1053
 
Copies the first n fields of a physical record to a data tuple. The fields
1054
 
are copied to the memory heap. */
1055
 
 
1056
 
void
1057
 
rec_copy_prefix_to_dtuple(
1058
 
/*======================*/
1059
 
        dtuple_t*       tuple,          /* in: data tuple */
1060
 
        rec_t*          rec,            /* in: physical record */
1061
 
        dict_index_t*   index,          /* in: record descriptor */
1062
 
        ulint           n_fields,       /* in: number of fields to copy */
1063
 
        mem_heap_t*     heap)           /* in: memory heap */
1064
 
{
1065
 
        dfield_t*       field;
1066
 
        byte*           data;
1067
 
        ulint           len;
1068
 
        byte*           buf = NULL;
1069
 
        ulint           i;
1070
 
        ulint           offsets_[REC_OFFS_NORMAL_SIZE];
1071
 
        ulint*          offsets = offsets_;
1072
 
        *offsets_ = (sizeof offsets_) / sizeof *offsets_;
1073
 
 
1074
 
        offsets = rec_get_offsets(rec, index, offsets, n_fields, &heap);
1075
 
 
1076
 
        ut_ad(rec_validate(rec, offsets));
1077
 
        ut_ad(dtuple_check_typed(tuple));
1078
 
 
1079
 
        dtuple_set_info_bits(tuple, rec_get_info_bits(
1080
 
                                     rec, dict_table_is_comp(index->table)));
1081
 
 
1082
 
        for (i = 0; i < n_fields; i++) {
1083
 
 
1084
 
                field = dtuple_get_nth_field(tuple, i);
1085
 
                data = rec_get_nth_field(rec, offsets, i, &len);
1086
 
 
1087
 
                if (len != UNIV_SQL_NULL) {
1088
 
                        buf = mem_heap_alloc(heap, len);
1089
 
 
1090
 
                        ut_memcpy(buf, data, len);
1091
 
                }
1092
 
 
1093
 
                dfield_set_data(field, buf, len);
1094
 
        }
1095
 
}
1096
 
 
1097
 
/******************************************************************
1098
 
Copies the first n fields of an old-style physical record
1099
 
to a new physical record in a buffer. */
1100
 
static
1101
 
rec_t*
1102
 
rec_copy_prefix_to_buf_old(
1103
 
/*=======================*/
1104
 
                                /* out, own: copied record */
1105
 
        rec_t*  rec,            /* in: physical record */
1106
 
        ulint   n_fields,       /* in: number of fields to copy */
1107
 
        ulint   area_end,       /* in: end of the prefix data */
1108
 
        byte**  buf,            /* in/out: memory buffer for the copied prefix,
1109
 
                                or NULL */
1110
 
        ulint*  buf_size)       /* in/out: buffer size */
1111
 
{
1112
 
        rec_t*  copy_rec;
1113
 
        ulint   area_start;
1114
 
        ulint   prefix_len;
1115
 
 
1116
 
        if (rec_get_1byte_offs_flag(rec)) {
1117
 
                area_start = REC_N_OLD_EXTRA_BYTES + n_fields;
1118
 
        } else {
1119
 
                area_start = REC_N_OLD_EXTRA_BYTES + 2 * n_fields;
1120
 
        }
1121
 
 
1122
 
        prefix_len = area_start + area_end;
1123
 
 
1124
 
        if ((*buf == NULL) || (*buf_size < prefix_len)) {
1125
 
                if (*buf != NULL) {
1126
 
                        mem_free(*buf);
1127
 
                }
1128
 
 
1129
 
                *buf = mem_alloc(prefix_len);
1130
 
                *buf_size = prefix_len;
1131
 
        }
1132
 
 
1133
 
        ut_memcpy(*buf, rec - area_start, prefix_len);
1134
 
 
1135
 
        copy_rec = *buf + area_start;
1136
 
 
1137
 
        rec_set_n_fields_old(copy_rec, n_fields);
1138
 
 
1139
 
        return(copy_rec);
1140
 
}
1141
 
 
1142
 
/******************************************************************
1143
 
Copies the first n fields of a physical record to a new physical record in
1144
 
a buffer. */
1145
 
 
1146
 
rec_t*
1147
 
rec_copy_prefix_to_buf(
1148
 
/*===================*/
1149
 
                                        /* out, own: copied record */
1150
 
        rec_t*          rec,            /* in: physical record */
1151
 
        dict_index_t*   index,          /* in: record descriptor */
1152
 
        ulint           n_fields,       /* in: number of fields to copy */
1153
 
        byte**          buf,            /* in/out: memory buffer
1154
 
                                        for the copied prefix, or NULL */
1155
 
        ulint*          buf_size)       /* in/out: buffer size */
1156
 
{
1157
 
        byte*           nulls;
1158
 
        byte*           lens;
1159
 
        ulint           i;
1160
 
        ulint           prefix_len;
1161
 
        ulint           null_mask;
1162
 
        ulint           status;
1163
 
 
1164
 
        UNIV_PREFETCH_RW(*buf);
1165
 
 
1166
 
        if (!dict_table_is_comp(index->table)) {
1167
 
                ut_ad(rec_validate_old(rec));
1168
 
                return(rec_copy_prefix_to_buf_old(
1169
 
                               rec, n_fields,
1170
 
                               rec_get_field_start_offs(rec, n_fields),
1171
 
                               buf, buf_size));
1172
 
        }
1173
 
 
1174
 
        status = rec_get_status(rec);
1175
 
 
1176
 
        switch (status) {
1177
 
        case REC_STATUS_ORDINARY:
1178
 
                ut_ad(n_fields <= dict_index_get_n_fields(index));
1179
 
                break;
1180
 
        case REC_STATUS_NODE_PTR:
1181
 
                /* it doesn't make sense to copy the child page number field */
1182
 
                ut_ad(n_fields <= dict_index_get_n_unique_in_tree(index));
1183
 
                break;
1184
 
        case REC_STATUS_INFIMUM:
1185
 
        case REC_STATUS_SUPREMUM:
1186
 
                /* infimum or supremum record: no sense to copy anything */
1187
 
        default:
1188
 
                ut_error;
1189
 
                return(NULL);
1190
 
        }
1191
 
 
1192
 
        nulls = rec - (REC_N_NEW_EXTRA_BYTES + 1);
1193
 
        lens = nulls - UT_BITS_IN_BYTES(index->n_nullable);
1194
 
        UNIV_PREFETCH_R(lens);
1195
 
        prefix_len = 0;
1196
 
        null_mask = 1;
1197
 
 
1198
 
        /* read the lengths of fields 0..n */
1199
 
        for (i = 0; i < n_fields; i++) {
1200
 
                const dict_field_t*     field;
1201
 
                const dict_col_t*       col;
1202
 
 
1203
 
                field = dict_index_get_nth_field(index, i);
1204
 
                col = dict_field_get_col(field);
1205
 
 
1206
 
                if (!(col->prtype & DATA_NOT_NULL)) {
1207
 
                        /* nullable field => read the null flag */
1208
 
                        if (UNIV_UNLIKELY(!(byte) null_mask)) {
1209
 
                                nulls--;
1210
 
                                null_mask = 1;
1211
 
                        }
1212
 
 
1213
 
                        if (*nulls & null_mask) {
1214
 
                                null_mask <<= 1;
1215
 
                                continue;
1216
 
                        }
1217
 
 
1218
 
                        null_mask <<= 1;
1219
 
                }
1220
 
 
1221
 
                if (field->fixed_len) {
1222
 
                        prefix_len += field->fixed_len;
1223
 
                } else {
1224
 
                        ulint   len = *lens--;
1225
 
                        if (col->len > 255 || col->mtype == DATA_BLOB) {
1226
 
                                if (len & 0x80) {
1227
 
                                        /* 1exxxxxx */
1228
 
                                        len &= 0x3f;
1229
 
                                        len <<= 8;
1230
 
                                        len |= *lens--;
1231
 
                                        UNIV_PREFETCH_R(lens);
1232
 
                                }
1233
 
                        }
1234
 
                        prefix_len += len;
1235
 
                }
1236
 
        }
1237
 
 
1238
 
        UNIV_PREFETCH_R(rec + prefix_len);
1239
 
 
1240
 
        prefix_len += rec - (lens + 1);
1241
 
 
1242
 
        if ((*buf == NULL) || (*buf_size < prefix_len)) {
1243
 
                if (*buf != NULL) {
1244
 
                        mem_free(*buf);
1245
 
                }
1246
 
 
1247
 
                *buf = mem_alloc(prefix_len);
1248
 
                *buf_size = prefix_len;
1249
 
        }
1250
 
 
1251
 
        memcpy(*buf, lens + 1, prefix_len);
1252
 
 
1253
 
        return(*buf + (rec - (lens + 1)));
1254
 
}
1255
 
 
1256
 
/*******************************************************************
1257
 
Validates the consistency of an old-style physical record. */
1258
 
static
1259
 
ibool
1260
 
rec_validate_old(
1261
 
/*=============*/
1262
 
                        /* out: TRUE if ok */
1263
 
        rec_t*  rec)    /* in: physical record */
1264
 
{
1265
 
        byte*   data;
1266
 
        ulint   len;
1267
 
        ulint   n_fields;
1268
 
        ulint   len_sum         = 0;
1269
 
        ulint   sum             = 0;
1270
 
        ulint   i;
1271
 
 
1272
 
        ut_a(rec);
1273
 
        n_fields = rec_get_n_fields_old(rec);
1274
 
 
1275
 
        if ((n_fields == 0) || (n_fields > REC_MAX_N_FIELDS)) {
1276
 
                fprintf(stderr, "InnoDB: Error: record has %lu fields\n",
1277
 
                        (ulong) n_fields);
1278
 
                return(FALSE);
1279
 
        }
1280
 
 
1281
 
        for (i = 0; i < n_fields; i++) {
1282
 
                data = rec_get_nth_field_old(rec, i, &len);
1283
 
 
1284
 
                if (!((len < UNIV_PAGE_SIZE) || (len == UNIV_SQL_NULL))) {
1285
 
                        fprintf(stderr,
1286
 
                                "InnoDB: Error: record field %lu len %lu\n",
1287
 
                                (ulong) i,
1288
 
                                (ulong) len);
1289
 
                        return(FALSE);
1290
 
                }
1291
 
 
1292
 
                if (len != UNIV_SQL_NULL) {
1293
 
                        len_sum += len;
1294
 
                        sum += *(data + len -1); /* dereference the
1295
 
                                                 end of the field to
1296
 
                                                 cause a memory trap
1297
 
                                                 if possible */
1298
 
                } else {
1299
 
                        len_sum += rec_get_nth_field_size(rec, i);
1300
 
                }
1301
 
        }
1302
 
 
1303
 
        if (len_sum != rec_get_data_size_old(rec)) {
1304
 
                fprintf(stderr,
1305
 
                        "InnoDB: Error: record len should be %lu, len %lu\n",
1306
 
                        (ulong) len_sum,
1307
 
                        rec_get_data_size_old(rec));
1308
 
                return(FALSE);
1309
 
        }
1310
 
 
1311
 
        rec_dummy = sum; /* This is here only to fool the compiler */
1312
 
 
1313
 
        return(TRUE);
1314
 
}
1315
 
 
1316
 
/*******************************************************************
1317
 
Validates the consistency of a physical record. */
1318
 
 
1319
 
ibool
1320
 
rec_validate(
1321
 
/*=========*/
1322
 
                                /* out: TRUE if ok */
1323
 
        rec_t*          rec,    /* in: physical record */
1324
 
        const ulint*    offsets)/* in: array returned by rec_get_offsets() */
1325
 
{
1326
 
        const byte*     data;
1327
 
        ulint           len;
1328
 
        ulint           n_fields;
1329
 
        ulint           len_sum         = 0;
1330
 
        ulint           sum             = 0;
1331
 
        ulint           i;
1332
 
 
1333
 
        ut_a(rec);
1334
 
        n_fields = rec_offs_n_fields(offsets);
1335
 
 
1336
 
        if ((n_fields == 0) || (n_fields > REC_MAX_N_FIELDS)) {
1337
 
                fprintf(stderr, "InnoDB: Error: record has %lu fields\n",
1338
 
                        (ulong) n_fields);
1339
 
                return(FALSE);
1340
 
        }
1341
 
 
1342
 
        ut_a(rec_offs_comp(offsets) || n_fields <= rec_get_n_fields_old(rec));
1343
 
 
1344
 
        for (i = 0; i < n_fields; i++) {
1345
 
                data = rec_get_nth_field(rec, offsets, i, &len);
1346
 
 
1347
 
                if (!((len < UNIV_PAGE_SIZE) || (len == UNIV_SQL_NULL))) {
1348
 
                        fprintf(stderr,
1349
 
                                "InnoDB: Error: record field %lu len %lu\n",
1350
 
                                (ulong) i,
1351
 
                                (ulong) len);
1352
 
                        return(FALSE);
1353
 
                }
1354
 
 
1355
 
                if (len != UNIV_SQL_NULL) {
1356
 
                        len_sum += len;
1357
 
                        sum += *(data + len -1); /* dereference the
1358
 
                                                 end of the field to
1359
 
                                                 cause a memory trap
1360
 
                                                 if possible */
1361
 
                } else if (!rec_offs_comp(offsets)) {
1362
 
                        len_sum += rec_get_nth_field_size(rec, i);
1363
 
                }
1364
 
        }
1365
 
 
1366
 
        if (len_sum != (ulint)(rec_get_end(rec, offsets) - rec)) {
1367
 
                fprintf(stderr,
1368
 
                        "InnoDB: Error: record len should be %lu, len %lu\n",
1369
 
                        (ulong) len_sum,
1370
 
                        (ulong) (rec_get_end(rec, offsets) - rec));
1371
 
                return(FALSE);
1372
 
        }
1373
 
 
1374
 
        rec_dummy = sum; /* This is here only to fool the compiler */
1375
 
 
1376
 
        if (!rec_offs_comp(offsets)) {
1377
 
                ut_a(rec_validate_old(rec));
1378
 
        }
1379
 
 
1380
 
        return(TRUE);
1381
 
}
1382
 
 
1383
 
/*******************************************************************
1384
 
Prints an old-style physical record. */
1385
 
 
1386
 
void
1387
 
rec_print_old(
1388
 
/*==========*/
1389
 
        FILE*           file,   /* in: file where to print */
1390
 
        rec_t*          rec)    /* in: physical record */
1391
 
{
1392
 
        const byte*     data;
1393
 
        ulint           len;
1394
 
        ulint           n;
1395
 
        ulint           i;
1396
 
 
1397
 
        ut_ad(rec);
1398
 
 
1399
 
        n = rec_get_n_fields_old(rec);
1400
 
 
1401
 
        fprintf(file, "PHYSICAL RECORD: n_fields %lu;"
1402
 
                " %u-byte offsets; info bits %lu\n",
1403
 
                (ulong) n,
1404
 
                rec_get_1byte_offs_flag(rec) ? 1 : 2,
1405
 
                (ulong) rec_get_info_bits(rec, FALSE));
1406
 
 
1407
 
        for (i = 0; i < n; i++) {
1408
 
 
1409
 
                data = rec_get_nth_field_old(rec, i, &len);
1410
 
 
1411
 
                fprintf(file, " %lu:", (ulong) i);
1412
 
 
1413
 
                if (len != UNIV_SQL_NULL) {
1414
 
                        if (len <= 30) {
1415
 
 
1416
 
                                ut_print_buf(file, data, len);
1417
 
                        } else {
1418
 
                                ut_print_buf(file, data, 30);
1419
 
 
1420
 
                                fputs("...(truncated)", file);
1421
 
                        }
1422
 
                } else {
1423
 
                        fprintf(file, " SQL NULL, size %lu ",
1424
 
                                rec_get_nth_field_size(rec, i));
1425
 
                }
1426
 
                putc(';', file);
1427
 
        }
1428
 
 
1429
 
        putc('\n', file);
1430
 
 
1431
 
        rec_validate_old(rec);
1432
 
}
1433
 
 
1434
 
/*******************************************************************
1435
 
Prints a physical record. */
1436
 
 
1437
 
void
1438
 
rec_print_new(
1439
 
/*==========*/
1440
 
        FILE*           file,   /* in: file where to print */
1441
 
        rec_t*          rec,    /* in: physical record */
1442
 
        const ulint*    offsets)/* in: array returned by rec_get_offsets() */
1443
 
{
1444
 
        const byte*     data;
1445
 
        ulint           len;
1446
 
        ulint           i;
1447
 
 
1448
 
        ut_ad(rec_offs_validate(rec, NULL, offsets));
1449
 
 
1450
 
        if (!rec_offs_comp(offsets)) {
1451
 
                rec_print_old(file, rec);
1452
 
                return;
1453
 
        }
1454
 
 
1455
 
        ut_ad(rec);
1456
 
 
1457
 
        fprintf(file, "PHYSICAL RECORD: n_fields %lu;"
1458
 
                " compact format; info bits %lu\n",
1459
 
                (ulong) rec_offs_n_fields(offsets),
1460
 
                (ulong) rec_get_info_bits(rec, TRUE));
1461
 
 
1462
 
        for (i = 0; i < rec_offs_n_fields(offsets); i++) {
1463
 
 
1464
 
                data = rec_get_nth_field(rec, offsets, i, &len);
1465
 
 
1466
 
                fprintf(file, " %lu:", (ulong) i);
1467
 
 
1468
 
                if (len != UNIV_SQL_NULL) {
1469
 
                        if (len <= 30) {
1470
 
 
1471
 
                                ut_print_buf(file, data, len);
1472
 
                        } else {
1473
 
                                ut_print_buf(file, data, 30);
1474
 
 
1475
 
                                fputs("...(truncated)", file);
1476
 
                        }
1477
 
                } else {
1478
 
                        fputs(" SQL NULL", file);
1479
 
                }
1480
 
                putc(';', file);
1481
 
        }
1482
 
 
1483
 
        putc('\n', file);
1484
 
 
1485
 
        rec_validate(rec, offsets);
1486
 
}
1487
 
 
1488
 
/*******************************************************************
1489
 
Prints a physical record. */
1490
 
 
1491
 
void
1492
 
rec_print(
1493
 
/*======*/
1494
 
        FILE*           file,   /* in: file where to print */
1495
 
        rec_t*          rec,    /* in: physical record */
1496
 
        dict_index_t*   index)  /* in: record descriptor */
1497
 
{
1498
 
        ut_ad(index);
1499
 
 
1500
 
        if (!dict_table_is_comp(index->table)) {
1501
 
                rec_print_old(file, rec);
1502
 
                return;
1503
 
        } else {
1504
 
                mem_heap_t*     heap    = NULL;
1505
 
                ulint           offsets_[REC_OFFS_NORMAL_SIZE];
1506
 
                *offsets_ = (sizeof offsets_) / sizeof *offsets_;
1507
 
 
1508
 
                rec_print_new(file, rec,
1509
 
                              rec_get_offsets(rec, index, offsets_,
1510
 
                                              ULINT_UNDEFINED, &heap));
1511
 
                if (UNIV_LIKELY_NULL(heap)) {
1512
 
                        mem_heap_free(heap);
1513
 
                }
1514
 
        }
1515
 
}