← Back to branch summary

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

« back to all changes in this revision

Viewing changes to storage/innobase/data/data0data.c

  • 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/data/data0data.c
 
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
#include "data0data.h"
 
10
 
 
11
#ifdef UNIV_NONINL
 
12
#include "data0data.ic"
 
13
#endif
 
14
 
 
15
#include "rem0rec.h"
 
16
#include "rem0cmp.h"
 
17
#include "page0page.h"
 
18
#include "dict0dict.h"
 
19
#include "btr0cur.h"
 
20
 
 
21
#include <ctype.h>
 
22
 
 
23
#ifdef UNIV_DEBUG
 
24
byte    data_error;     /* data pointers of tuple fields are initialized
 
25
                        to point here for error checking */
 
26
 
 
27
ulint   data_dummy;     /* this is used to fool the compiler in
 
28
                        dtuple_validate */
 
29
#endif /* UNIV_DEBUG */
 
30
 
 
31
/* Some non-inlined functions used in the MySQL interface: */
 
32
void
 
33
dfield_set_data_noninline(
 
34
        dfield_t*       field,  /* in: field */
 
35
        void*           data,   /* in: data */
 
36
        ulint           len)    /* in: length or UNIV_SQL_NULL */
 
37
{
 
38
        dfield_set_data(field, data, len);
 
39
}
 
40
void*
 
41
dfield_get_data_noninline(
 
42
        dfield_t* field)        /* in: field */
 
43
{
 
44
        return(dfield_get_data(field));
 
45
}
 
46
ulint
 
47
dfield_get_len_noninline(
 
48
        dfield_t* field)        /* in: field */
 
49
{
 
50
        return(dfield_get_len(field));
 
51
}
 
52
ulint
 
53
dtuple_get_n_fields_noninline(
 
54
        dtuple_t*       tuple)  /* in: tuple */
 
55
{
 
56
        return(dtuple_get_n_fields(tuple));
 
57
}
 
58
dfield_t*
 
59
dtuple_get_nth_field_noninline(
 
60
        dtuple_t*       tuple,  /* in: tuple */
 
61
        ulint           n)      /* in: index of field */
 
62
{
 
63
        return(dtuple_get_nth_field(tuple, n));
 
64
}
 
65
 
 
66
/*************************************************************************
 
67
Tests if dfield data length and content is equal to the given. */
 
68
 
 
69
ibool
 
70
dfield_data_is_binary_equal(
 
71
/*========================*/
 
72
                                /* out: TRUE if equal */
 
73
        dfield_t*       field,  /* in: field */
 
74
        ulint           len,    /* in: data length or UNIV_SQL_NULL */
 
75
        byte*           data)   /* in: data */
 
76
{
 
77
        if (len != field->len) {
 
78
 
 
79
                return(FALSE);
 
80
        }
 
81
 
 
82
        if (len == UNIV_SQL_NULL) {
 
83
 
 
84
                return(TRUE);
 
85
        }
 
86
 
 
87
        if (0 != ut_memcmp(field->data, data, len)) {
 
88
 
 
89
                return(FALSE);
 
90
        }
 
91
 
 
92
        return(TRUE);
 
93
}
 
94
 
 
95
/****************************************************************
 
96
Returns TRUE if lengths of two dtuples are equal and respective data fields
 
97
in them are equal when compared with collation in char fields (not as binary
 
98
strings). */
 
99
 
 
100
ibool
 
101
dtuple_datas_are_ordering_equal(
 
102
/*============================*/
 
103
                                /* out: TRUE if length and fieds are equal
 
104
                                when compared with cmp_data_data:
 
105
                                NOTE: in character type fields some letters
 
106
                                are identified with others! (collation) */
 
107
        dtuple_t*       tuple1, /* in: tuple 1 */
 
108
        dtuple_t*       tuple2) /* in: tuple 2 */
 
109
{
 
110
        dfield_t*       field1;
 
111
        dfield_t*       field2;
 
112
        ulint           n_fields;
 
113
        ulint           i;
 
114
 
 
115
        ut_ad(tuple1 && tuple2);
 
116
        ut_ad(tuple1->magic_n == DATA_TUPLE_MAGIC_N);
 
117
        ut_ad(tuple2->magic_n == DATA_TUPLE_MAGIC_N);
 
118
        ut_ad(dtuple_check_typed(tuple1));
 
119
        ut_ad(dtuple_check_typed(tuple2));
 
120
 
 
121
        n_fields = dtuple_get_n_fields(tuple1);
 
122
 
 
123
        if (n_fields != dtuple_get_n_fields(tuple2)) {
 
124
 
 
125
                return(FALSE);
 
126
        }
 
127
 
 
128
        for (i = 0; i < n_fields; i++) {
 
129
 
 
130
                field1 = dtuple_get_nth_field(tuple1, i);
 
131
                field2 = dtuple_get_nth_field(tuple2, i);
 
132
 
 
133
                if (0 != cmp_dfield_dfield(field1, field2)) {
 
134
 
 
135
                        return(FALSE);
 
136
                }
 
137
        }
 
138
 
 
139
        return(TRUE);
 
140
}
 
141
 
 
142
/*************************************************************************
 
143
Creates a dtuple for use in MySQL. */
 
144
 
 
145
dtuple_t*
 
146
dtuple_create_for_mysql(
 
147
/*====================*/
 
148
                                /* out, own created dtuple */
 
149
        void**  heap,           /* out: created memory heap */
 
150
        ulint   n_fields)       /* in: number of fields */
 
151
{
 
152
        *heap = (void*)mem_heap_create(500);
 
153
 
 
154
        return(dtuple_create(*((mem_heap_t**)heap), n_fields));
 
155
}
 
156
 
 
157
/*************************************************************************
 
158
Frees a dtuple used in MySQL. */
 
159
 
 
160
void
 
161
dtuple_free_for_mysql(
 
162
/*==================*/
 
163
        void*   heap) /* in: memory heap where tuple was created */
 
164
{
 
165
        mem_heap_free((mem_heap_t*)heap);
 
166
}
 
167
 
 
168
/*************************************************************************
 
169
Sets number of fields used in a tuple. Normally this is set in
 
170
dtuple_create, but if you want later to set it smaller, you can use this. */
 
171
 
 
172
void
 
173
dtuple_set_n_fields(
 
174
/*================*/
 
175
        dtuple_t*       tuple,          /* in: tuple */
 
176
        ulint           n_fields)       /* in: number of fields */
 
177
{
 
178
        ut_ad(tuple);
 
179
 
 
180
        tuple->n_fields = n_fields;
 
181
        tuple->n_fields_cmp = n_fields;
 
182
}
 
183
 
 
184
/**************************************************************
 
185
Checks that a data field is typed. */
 
186
static
 
187
ibool
 
188
dfield_check_typed_no_assert(
 
189
/*=========================*/
 
190
                                /* out: TRUE if ok */
 
191
        dfield_t*       field)  /* in: data field */
 
192
{
 
193
        if (dfield_get_type(field)->mtype > DATA_MYSQL
 
194
            || dfield_get_type(field)->mtype < DATA_VARCHAR) {
 
195
 
 
196
                fprintf(stderr,
 
197
                        "InnoDB: Error: data field type %lu, len %lu\n",
 
198
                        (ulong) dfield_get_type(field)->mtype,
 
199
                        (ulong) dfield_get_len(field));
 
200
                return(FALSE);
 
201
        }
 
202
 
 
203
        return(TRUE);
 
204
}
 
205
 
 
206
/**************************************************************
 
207
Checks that a data tuple is typed. */
 
208
 
 
209
ibool
 
210
dtuple_check_typed_no_assert(
 
211
/*=========================*/
 
212
                                /* out: TRUE if ok */
 
213
        dtuple_t*       tuple)  /* in: tuple */
 
214
{
 
215
        dfield_t*       field;
 
216
        ulint           i;
 
217
 
 
218
        if (dtuple_get_n_fields(tuple) > REC_MAX_N_FIELDS) {
 
219
                fprintf(stderr,
 
220
                        "InnoDB: Error: index entry has %lu fields\n",
 
221
                        (ulong) dtuple_get_n_fields(tuple));
 
222
dump:
 
223
                fputs("InnoDB: Tuple contents: ", stderr);
 
224
                dtuple_print(stderr, tuple);
 
225
                putc('\n', stderr);
 
226
 
 
227
                return(FALSE);
 
228
        }
 
229
 
 
230
        for (i = 0; i < dtuple_get_n_fields(tuple); i++) {
 
231
 
 
232
                field = dtuple_get_nth_field(tuple, i);
 
233
 
 
234
                if (!dfield_check_typed_no_assert(field)) {
 
235
                        goto dump;
 
236
                }
 
237
        }
 
238
 
 
239
        return(TRUE);
 
240
}
 
241
 
 
242
/**************************************************************
 
243
Checks that a data field is typed. Asserts an error if not. */
 
244
 
 
245
ibool
 
246
dfield_check_typed(
 
247
/*===============*/
 
248
                                /* out: TRUE if ok */
 
249
        dfield_t*       field)  /* in: data field */
 
250
{
 
251
        if (dfield_get_type(field)->mtype > DATA_MYSQL
 
252
            || dfield_get_type(field)->mtype < DATA_VARCHAR) {
 
253
 
 
254
                fprintf(stderr,
 
255
                        "InnoDB: Error: data field type %lu, len %lu\n",
 
256
                        (ulong) dfield_get_type(field)->mtype,
 
257
                        (ulong) dfield_get_len(field));
 
258
 
 
259
                ut_error;
 
260
        }
 
261
 
 
262
        return(TRUE);
 
263
}
 
264
 
 
265
/**************************************************************
 
266
Checks that a data tuple is typed. Asserts an error if not. */
 
267
 
 
268
ibool
 
269
dtuple_check_typed(
 
270
/*===============*/
 
271
                                /* out: TRUE if ok */
 
272
        dtuple_t*       tuple)  /* in: tuple */
 
273
{
 
274
        dfield_t*       field;
 
275
        ulint           i;
 
276
 
 
277
        for (i = 0; i < dtuple_get_n_fields(tuple); i++) {
 
278
 
 
279
                field = dtuple_get_nth_field(tuple, i);
 
280
 
 
281
                ut_a(dfield_check_typed(field));
 
282
        }
 
283
 
 
284
        return(TRUE);
 
285
}
 
286
 
 
287
#ifdef UNIV_DEBUG
 
288
/**************************************************************
 
289
Validates the consistency of a tuple which must be complete, i.e,
 
290
all fields must have been set. */
 
291
 
 
292
ibool
 
293
dtuple_validate(
 
294
/*============*/
 
295
                                /* out: TRUE if ok */
 
296
        dtuple_t*       tuple)  /* in: tuple */
 
297
{
 
298
        dfield_t*       field;
 
299
        byte*           data;
 
300
        ulint           n_fields;
 
301
        ulint           len;
 
302
        ulint           i;
 
303
        ulint           j;
 
304
 
 
305
        ut_ad(tuple->magic_n == DATA_TUPLE_MAGIC_N);
 
306
 
 
307
        n_fields = dtuple_get_n_fields(tuple);
 
308
 
 
309
        /* We dereference all the data of each field to test
 
310
        for memory traps */
 
311
 
 
312
        for (i = 0; i < n_fields; i++) {
 
313
 
 
314
                field = dtuple_get_nth_field(tuple, i);
 
315
                len = dfield_get_len(field);
 
316
 
 
317
                if (len != UNIV_SQL_NULL) {
 
318
 
 
319
                        data = field->data;
 
320
 
 
321
                        for (j = 0; j < len; j++) {
 
322
 
 
323
                                data_dummy  += *data; /* fool the compiler not
 
324
                                                      to optimize out this
 
325
                                                      code */
 
326
                                data++;
 
327
                        }
 
328
                }
 
329
        }
 
330
 
 
331
        ut_a(dtuple_check_typed(tuple));
 
332
 
 
333
        return(TRUE);
 
334
}
 
335
#endif /* UNIV_DEBUG */
 
336
 
 
337
/*****************************************************************
 
338
Pretty prints a dfield value according to its data type. */
 
339
 
 
340
void
 
341
dfield_print(
 
342
/*=========*/
 
343
        dfield_t*       dfield)  /* in: dfield */
 
344
{
 
345
        byte*   data;
 
346
        ulint   len;
 
347
        ulint   mtype;
 
348
        ulint   i;
 
349
 
 
350
        len = dfield_get_len(dfield);
 
351
        data = dfield_get_data(dfield);
 
352
 
 
353
        if (len == UNIV_SQL_NULL) {
 
354
                fputs("NULL", stderr);
 
355
 
 
356
                return;
 
357
        }
 
358
 
 
359
        mtype = dtype_get_mtype(dfield_get_type(dfield));
 
360
 
 
361
        if ((mtype == DATA_CHAR) || (mtype == DATA_VARCHAR)) {
 
362
 
 
363
                for (i = 0; i < len; i++) {
 
364
                        int     c = *data++;
 
365
                        putc(isprint(c) ? c : ' ', stderr);
 
366
                }
 
367
        } else if (mtype == DATA_INT) {
 
368
                ut_a(len == 4); /* only works for 32-bit integers */
 
369
                fprintf(stderr, "%d", (int)mach_read_from_4(data));
 
370
        } else {
 
371
                ut_error;
 
372
        }
 
373
}
 
374
 
 
375
/*****************************************************************
 
376
Pretty prints a dfield value according to its data type. Also the hex string
 
377
is printed if a string contains non-printable characters. */
 
378
 
 
379
void
 
380
dfield_print_also_hex(
 
381
/*==================*/
 
382
        dfield_t*       dfield)  /* in: dfield */
 
383
{
 
384
        byte*   data;
 
385
        ulint   len;
 
386
        ulint   mtype;
 
387
        ulint   i;
 
388
        ibool   print_also_hex;
 
389
 
 
390
        len = dfield_get_len(dfield);
 
391
        data = dfield_get_data(dfield);
 
392
 
 
393
        if (len == UNIV_SQL_NULL) {
 
394
                fputs("NULL", stderr);
 
395
 
 
396
                return;
 
397
        }
 
398
 
 
399
        mtype = dtype_get_mtype(dfield_get_type(dfield));
 
400
 
 
401
        if ((mtype == DATA_CHAR) || (mtype == DATA_VARCHAR)) {
 
402
 
 
403
                print_also_hex = FALSE;
 
404
 
 
405
                for (i = 0; i < len; i++) {
 
406
                        int c = *data++;
 
407
                        if (!isprint(c)) {
 
408
                                print_also_hex = TRUE;
 
409
                                c = ' ';
 
410
                        }
 
411
                        putc(c, stderr);
 
412
                }
 
413
 
 
414
                if (!print_also_hex) {
 
415
 
 
416
                        return;
 
417
                }
 
418
 
 
419
                fputs(" Hex: ", stderr);
 
420
 
 
421
                data = dfield_get_data(dfield);
 
422
 
 
423
                for (i = 0; i < len; i++) {
 
424
                        fprintf(stderr, "%02lx", (ulint)*data);
 
425
 
 
426
                        data++;
 
427
                }
 
428
        } else if (mtype == DATA_INT) {
 
429
                ut_a(len == 4); /* only works for 32-bit integers */
 
430
                fprintf(stderr, "%d", (int)mach_read_from_4(data));
 
431
        } else {
 
432
                ut_error;
 
433
        }
 
434
}
 
435
 
 
436
/*****************************************************************
 
437
Print a dfield value using ut_print_buf. */
 
438
static
 
439
void
 
440
dfield_print_raw(
 
441
/*=============*/
 
442
        FILE*           f,              /* in: output stream */
 
443
        dfield_t*       dfield)         /* in: dfield */
 
444
{
 
445
        ulint   len     = dfield->len;
 
446
        if (len != UNIV_SQL_NULL) {
 
447
                ulint   print_len = ut_min(len, 1000);
 
448
                ut_print_buf(f, dfield->data, print_len);
 
449
                if (len != print_len) {
 
450
                        fprintf(f, "(total %lu bytes)", (ulong) len);
 
451
                }
 
452
        } else {
 
453
                fputs(" SQL NULL", f);
 
454
        }
 
455
}
 
456
 
 
457
/**************************************************************
 
458
The following function prints the contents of a tuple. */
 
459
 
 
460
void
 
461
dtuple_print(
 
462
/*=========*/
 
463
        FILE*           f,      /* in: output stream */
 
464
        dtuple_t*       tuple)  /* in: tuple */
 
465
{
 
466
        ulint           n_fields;
 
467
        ulint           i;
 
468
 
 
469
        n_fields = dtuple_get_n_fields(tuple);
 
470
 
 
471
        fprintf(f, "DATA TUPLE: %lu fields;\n", (ulong) n_fields);
 
472
 
 
473
        for (i = 0; i < n_fields; i++) {
 
474
                fprintf(f, " %lu:", (ulong) i);
 
475
 
 
476
                dfield_print_raw(f, dtuple_get_nth_field(tuple, i));
 
477
 
 
478
                putc(';', f);
 
479
        }
 
480
 
 
481
        putc('\n', f);
 
482
        ut_ad(dtuple_validate(tuple));
 
483
}
 
484
 
 
485
/******************************************************************
 
486
Moves parts of long fields in entry to the big record vector so that
 
487
the size of tuple drops below the maximum record size allowed in the
 
488
database. Moves data only from those fields which are not necessary
 
489
to determine uniquely the insertion place of the tuple in the index. */
 
490
 
 
491
big_rec_t*
 
492
dtuple_convert_big_rec(
 
493
/*===================*/
 
494
                                /* out, own: created big record vector,
 
495
                                NULL if we are not able to shorten
 
496
                                the entry enough, i.e., if there are
 
497
                                too many short fields in entry */
 
498
        dict_index_t*   index,  /* in: index */
 
499
        dtuple_t*       entry,  /* in: index entry */
 
500
        ulint*          ext_vec,/* in: array of externally stored fields,
 
501
                                or NULL: if a field already is externally
 
502
                                stored, then we cannot move it to the vector
 
503
                                this function returns */
 
504
        ulint           n_ext_vec)/* in: number of elements is ext_vec */
 
505
{
 
506
        mem_heap_t*     heap;
 
507
        big_rec_t*      vector;
 
508
        dfield_t*       dfield;
 
509
        ulint           size;
 
510
        ulint           n_fields;
 
511
        ulint           longest;
 
512
        ulint           longest_i               = ULINT_MAX;
 
513
        ibool           is_externally_stored;
 
514
        ulint           i;
 
515
        ulint           j;
 
516
 
 
517
        ut_a(dtuple_check_typed_no_assert(entry));
 
518
 
 
519
        size = rec_get_converted_size(index, entry);
 
520
 
 
521
        if (UNIV_UNLIKELY(size > 1000000000)) {
 
522
                fprintf(stderr,
 
523
                        "InnoDB: Warning: tuple size very big: %lu\n",
 
524
                        (ulong) size);
 
525
                fputs("InnoDB: Tuple contents: ", stderr);
 
526
                dtuple_print(stderr, entry);
 
527
                putc('\n', stderr);
 
528
        }
 
529
 
 
530
        heap = mem_heap_create(size + dtuple_get_n_fields(entry)
 
531
                               * sizeof(big_rec_field_t) + 1000);
 
532
 
 
533
        vector = mem_heap_alloc(heap, sizeof(big_rec_t));
 
534
 
 
535
        vector->heap = heap;
 
536
        vector->fields = mem_heap_alloc(heap, dtuple_get_n_fields(entry)
 
537
                                        * sizeof(big_rec_field_t));
 
538
 
 
539
        /* Decide which fields to shorten: the algorithm is to look for
 
540
        the longest field whose type is DATA_BLOB */
 
541
 
 
542
        n_fields = 0;
 
543
 
 
544
        while (rec_get_converted_size(index, entry)
 
545
               >= ut_min(page_get_free_space_of_empty(
 
546
                                 dict_table_is_comp(index->table)) / 2,
 
547
                         REC_MAX_DATA_SIZE)) {
 
548
 
 
549
                longest = 0;
 
550
                for (i = dict_index_get_n_unique_in_tree(index);
 
551
                     i < dtuple_get_n_fields(entry); i++) {
 
552
 
 
553
                        /* Skip over fields which already are externally
 
554
                        stored */
 
555
 
 
556
                        is_externally_stored = FALSE;
 
557
 
 
558
                        if (ext_vec) {
 
559
                                for (j = 0; j < n_ext_vec; j++) {
 
560
                                        if (ext_vec[j] == i) {
 
561
                                                is_externally_stored = TRUE;
 
562
                                        }
 
563
                                }
 
564
                        }
 
565
 
 
566
                        if (!is_externally_stored) {
 
567
 
 
568
                                dfield = dtuple_get_nth_field(entry, i);
 
569
 
 
570
                                if (dfield->len != UNIV_SQL_NULL
 
571
                                    && dfield->len > longest) {
 
572
 
 
573
                                        longest = dfield->len;
 
574
 
 
575
                                        longest_i = i;
 
576
                                }
 
577
                        }
 
578
                }
 
579
 
 
580
                /* We do not store externally fields which are smaller than
 
581
                DICT_MAX_INDEX_COL_LEN */
 
582
 
 
583
#if DICT_MAX_INDEX_COL_LEN <= REC_1BYTE_OFFS_LIMIT
 
584
# error "DICT_MAX_INDEX_COL_LEN <= REC_1BYTE_OFFS_LIMIT"
 
585
#endif
 
586
 
 
587
                if (longest < BTR_EXTERN_FIELD_REF_SIZE + 10
 
588
                    + DICT_MAX_INDEX_COL_LEN) {
 
589
                        /* Cannot shorten more */
 
590
 
 
591
                        mem_heap_free(heap);
 
592
 
 
593
                        return(NULL);
 
594
                }
 
595
 
 
596
                /* Move data from field longest_i to big rec vector;
 
597
                we do not let data size of the remaining entry
 
598
                drop below 128 which is the limit for the 2-byte
 
599
                offset storage format in a physical record. This
 
600
                we accomplish by storing 128 bytes of data in entry
 
601
                itself, and only the remaining part to big rec vec.
 
602
 
 
603
                We store the first bytes locally to the record. Then
 
604
                we can calculate all ordering fields in all indexes
 
605
                from locally stored data. */
 
606
 
 
607
                dfield = dtuple_get_nth_field(entry, longest_i);
 
608
                vector->fields[n_fields].field_no = longest_i;
 
609
 
 
610
                ut_a(dfield->len > DICT_MAX_INDEX_COL_LEN);
 
611
 
 
612
                vector->fields[n_fields].len = dfield->len
 
613
                        - DICT_MAX_INDEX_COL_LEN;
 
614
 
 
615
                vector->fields[n_fields].data = mem_heap_alloc(
 
616
                        heap, vector->fields[n_fields].len);
 
617
 
 
618
                /* Copy data (from the end of field) to big rec vector */
 
619
 
 
620
                ut_memcpy(vector->fields[n_fields].data,
 
621
                          ((byte*)dfield->data) + dfield->len
 
622
                          - vector->fields[n_fields].len,
 
623
                          vector->fields[n_fields].len);
 
624
                dfield->len = dfield->len - vector->fields[n_fields].len
 
625
                        + BTR_EXTERN_FIELD_REF_SIZE;
 
626
 
 
627
                /* Set the extern field reference in dfield to zero */
 
628
                memset(((byte*)dfield->data)
 
629
                       + dfield->len - BTR_EXTERN_FIELD_REF_SIZE,
 
630
                       0, BTR_EXTERN_FIELD_REF_SIZE);
 
631
                n_fields++;
 
632
        }
 
633
 
 
634
        vector->n_fields = n_fields;
 
635
        return(vector);
 
636
}
 
637
 
 
638
/******************************************************************
 
639
Puts back to entry the data stored in vector. Note that to ensure the
 
640
fields in entry can accommodate the data, vector must have been created
 
641
from entry with dtuple_convert_big_rec. */
 
642
 
 
643
void
 
644
dtuple_convert_back_big_rec(
 
645
/*========================*/
 
646
        dict_index_t*   index __attribute__((unused)),  /* in: index */
 
647
        dtuple_t*       entry,  /* in: entry whose data was put to vector */
 
648
        big_rec_t*      vector) /* in, own: big rec vector; it is
 
649
                                freed in this function */
 
650
{
 
651
        dfield_t*       dfield;
 
652
        ulint           i;
 
653
 
 
654
        for (i = 0; i < vector->n_fields; i++) {
 
655
 
 
656
                dfield = dtuple_get_nth_field(entry,
 
657
                                              vector->fields[i].field_no);
 
658
                /* Copy data from big rec vector */
 
659
 
 
660
                ut_memcpy(((byte*)dfield->data)
 
661
                          + dfield->len - BTR_EXTERN_FIELD_REF_SIZE,
 
662
                          vector->fields[i].data,
 
663
                          vector->fields[i].len);
 
664
                dfield->len = dfield->len + vector->fields[i].len
 
665
                        - BTR_EXTERN_FIELD_REF_SIZE;
 
666
        }
 
667
 
 
668
        mem_heap_free(vector->heap);
 
669
}
 
670
 
 
671
/******************************************************************
 
672
Frees the memory in a big rec vector. */
 
673
 
 
674
void
 
675
dtuple_big_rec_free(
 
676
/*================*/
 
677
        big_rec_t*      vector) /* in, own: big rec vector; it is
 
678
                                freed in this function */
 
679
{
 
680
        mem_heap_free(vector->heap);
 
681
}