← Back to branch summary

~mysql/mysql-server/mysql-6.0

« back to all changes in this revision

Viewing changes to innobase/data/data0data.c

  • Committer: monty at mysql
  • Date: 2001-02-17 12:19:19 UTC
  • mto: (554.1.1)
  • mto: This revision was merged to the branch mainline in revision 556.
  • Revision ID: sp1r-monty@donna.mysql.com-20010217121919-07904
Added Innobase to source distribution

Show diffs side-by-side

added added

removed removed

Lines of Context:
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 "ut0rnd.h"
 
16
 
 
17
 
 
18
byte    data_error;     /* data pointers of tuple fields are initialized
 
19
                        to point here for error checking */
 
20
 
 
21
ulint   data_dummy;     /* this is used to fool the compiler in
 
22
                        dtuple_validate */
 
23
 
 
24
byte    data_buf[8192]; /* used in generating test tuples */
 
25
ulint   data_rnd = 756511;
 
26
 
 
27
 
 
28
/* Some non-inlined functions used in the MySQL interface: */
 
29
void 
 
30
dfield_set_data_noninline(
 
31
        dfield_t*       field,  /* in: field */
 
32
        void*           data,   /* in: data */
 
33
        ulint           len)    /* in: length or UNIV_SQL_NULL */
 
34
{
 
35
        dfield_set_data(field, data, len);
 
36
}
 
37
void* 
 
38
dfield_get_data_noninline(
 
39
        dfield_t* field)        /* in: field */
 
40
{
 
41
        return(dfield_get_data(field));
 
42
}
 
43
ulint
 
44
dfield_get_len_noninline(
 
45
        dfield_t* field)        /* in: field */
 
46
{
 
47
        return(dfield_get_len(field));
 
48
}
 
49
ulint 
 
50
dtuple_get_n_fields_noninline(
 
51
        dtuple_t*       tuple)  /* in: tuple */
 
52
{
 
53
        return(dtuple_get_n_fields(tuple));
 
54
}
 
55
dfield_t* 
 
56
dtuple_get_nth_field_noninline(
 
57
        dtuple_t*       tuple,  /* in: tuple */
 
58
        ulint           n)      /* in: index of field */
 
59
{
 
60
        return(dtuple_get_nth_field(tuple, n));
 
61
}
 
62
 
 
63
/*************************************************************************
 
64
Creates a dtuple for use in MySQL. */
 
65
 
 
66
dtuple_t*
 
67
dtuple_create_for_mysql(
 
68
/*====================*/
 
69
                                /* out, own created dtuple */
 
70
        void**  heap,           /* out: created memory heap */
 
71
        ulint   n_fields)       /* in: number of fields */
 
72
{
 
73
        *heap = (void*)mem_heap_create(500);
 
74
 
 
75
        return(dtuple_create(*((mem_heap_t**)heap), n_fields));  
 
76
}
 
77
 
 
78
/*************************************************************************
 
79
Frees a dtuple used in MySQL. */
 
80
 
 
81
void
 
82
dtuple_free_for_mysql(
 
83
/*==================*/
 
84
        void*   heap) /* in: memory heap where tuple was created */
 
85
{
 
86
        mem_heap_free((mem_heap_t*)heap);
 
87
}
 
88
 
 
89
/*************************************************************************
 
90
Sets number of fields used in a tuple. Normally this is set in
 
91
dtuple_create, but if you want later to set it smaller, you can use this. */ 
 
92
 
 
93
void
 
94
dtuple_set_n_fields(
 
95
/*================*/
 
96
        dtuple_t*       tuple,          /* in: tuple */
 
97
        ulint           n_fields)       /* in: number of fields */
 
98
{
 
99
        ut_ad(tuple);
 
100
 
 
101
        tuple->n_fields = n_fields;
 
102
        tuple->n_fields_cmp = n_fields;
 
103
}
 
104
 
 
105
/**************************************************************
 
106
Checks that a data field is typed. Asserts an error if not. */
 
107
 
 
108
ibool
 
109
dfield_check_typed(
 
110
/*===============*/
 
111
                                /* out: TRUE if ok */
 
112
        dfield_t*       field)  /* in: data field */
 
113
{
 
114
        ut_a(dfield_get_type(field)->mtype <= DATA_SYS);
 
115
        ut_a(dfield_get_type(field)->mtype >= DATA_VARCHAR);
 
116
 
 
117
        return(TRUE);
 
118
}
 
119
 
 
120
/**************************************************************
 
121
Checks that a data tuple is typed. Asserts an error if not. */
 
122
 
 
123
ibool
 
124
dtuple_check_typed(
 
125
/*===============*/
 
126
                                /* out: TRUE if ok */
 
127
        dtuple_t*       tuple)  /* in: tuple */
 
128
{
 
129
        dfield_t*       field;
 
130
        ulint           i;
 
131
 
 
132
        for (i = 0; i < dtuple_get_n_fields(tuple); i++) {
 
133
 
 
134
                field = dtuple_get_nth_field(tuple, i);
 
135
 
 
136
                ut_a(dfield_check_typed(field));
 
137
        }
 
138
 
 
139
        return(TRUE);
 
140
}
 
141
 
 
142
/**************************************************************
 
143
Validates the consistency of a tuple which must be complete, i.e,
 
144
all fields must have been set. */
 
145
 
 
146
ibool
 
147
dtuple_validate(
 
148
/*============*/
 
149
                                /* out: TRUE if ok */
 
150
        dtuple_t*       tuple)  /* in: tuple */
 
151
{
 
152
        dfield_t*       field;
 
153
        byte*           data;
 
154
        ulint           n_fields;
 
155
        ulint           len;
 
156
        ulint           i;
 
157
        ulint           j;
 
158
        ulint           sum     = 0; /* A dummy variable used
 
159
                                        to prevent the compiler
 
160
                                        from erasing the loop below */
 
161
        ut_a(tuple->magic_n = DATA_TUPLE_MAGIC_N);
 
162
 
 
163
        n_fields = dtuple_get_n_fields(tuple);
 
164
 
 
165
        /* We dereference all the data of each field to test
 
166
        for memory traps */
 
167
 
 
168
        for (i = 0; i < n_fields; i++) {
 
169
 
 
170
                field = dtuple_get_nth_field(tuple, i);
 
171
                len = dfield_get_len(field);
 
172
        
 
173
                if (len != UNIV_SQL_NULL) {
 
174
 
 
175
                        data = field->data;
 
176
 
 
177
                        for (j = 0; j < len; j++) {
 
178
 
 
179
                                data_dummy  += *data; /* fool the compiler not
 
180
                                                        to optimize out this
 
181
                                                        code */
 
182
                                data++;
 
183
                        }
 
184
                }
 
185
        }
 
186
 
 
187
        ut_a(dtuple_check_typed(tuple));
 
188
 
 
189
        return(TRUE);
 
190
}
 
191
 
 
192
/*****************************************************************
 
193
Pretty prints a dfield value according to its data type. */
 
194
 
 
195
void
 
196
dfield_print(
 
197
/*=========*/
 
198
        dfield_t*       dfield)  /* in: dfield */
 
199
{
 
200
        byte*   data;
 
201
        ulint   len;
 
202
        ulint   mtype;
 
203
        ulint   i;
 
204
 
 
205
        len = dfield_get_len(dfield);
 
206
        data = dfield_get_data(dfield);
 
207
 
 
208
        if (len == UNIV_SQL_NULL) {
 
209
                printf("NULL");
 
210
 
 
211
                return;
 
212
        }
 
213
 
 
214
        mtype = dtype_get_mtype(dfield_get_type(dfield));
 
215
 
 
216
        if ((mtype == DATA_CHAR) || (mtype == DATA_VARCHAR)) {
 
217
        
 
218
                for (i = 0; i < len; i++) {
 
219
 
 
220
                        if (isprint((char)(*data))) {
 
221
                                printf("%c", (char)*data);
 
222
                        } else {
 
223
                                printf(" ");
 
224
                        }
 
225
 
 
226
                        data++;
 
227
                }
 
228
        } else if (mtype == DATA_INT) {
 
229
                ut_a(len == 4); /* only works for 32-bit integers */
 
230
                printf("%li", (int)mach_read_from_4(data));
 
231
        } else {
 
232
                ut_error;
 
233
        }
 
234
}
 
235
 
 
236
/*****************************************************************
 
237
Pretty prints a dfield value according to its data type. Also the hex string
 
238
is printed if a string contains non-printable characters. */ 
 
239
 
 
240
void
 
241
dfield_print_also_hex(
 
242
/*==================*/
 
243
        dfield_t*       dfield)  /* in: dfield */
 
244
{
 
245
        byte*   data;
 
246
        ulint   len;
 
247
        ulint   mtype;
 
248
        ulint   i;
 
249
        ibool   print_also_hex;
 
250
 
 
251
        len = dfield_get_len(dfield);
 
252
        data = dfield_get_data(dfield);
 
253
 
 
254
        if (len == UNIV_SQL_NULL) {
 
255
                printf("NULL");
 
256
 
 
257
                return;
 
258
        }
 
259
 
 
260
        mtype = dtype_get_mtype(dfield_get_type(dfield));
 
261
 
 
262
        if ((mtype == DATA_CHAR) || (mtype == DATA_VARCHAR)) {
 
263
 
 
264
                print_also_hex = FALSE;
 
265
        
 
266
                for (i = 0; i < len; i++) {
 
267
 
 
268
                        if (isprint((char)(*data))) {
 
269
                                printf("%c", (char)*data);
 
270
                        } else {
 
271
                                print_also_hex = TRUE;
 
272
                                printf(" ");
 
273
                        }
 
274
 
 
275
                        data++;
 
276
                }
 
277
 
 
278
                if (!print_also_hex) {
 
279
 
 
280
                        return;
 
281
                }
 
282
 
 
283
                printf(" Hex: ");
 
284
                
 
285
                data = dfield_get_data(dfield);
 
286
                
 
287
                for (i = 0; i < len; i++) {
 
288
                        printf("%02x", (ulint)*data);
 
289
 
 
290
                        data++;
 
291
                }
 
292
        } else if (mtype == DATA_INT) {
 
293
                ut_a(len == 4); /* inly works for 32-bit integers */
 
294
                printf("%li", (int)mach_read_from_4(data));
 
295
        } else {
 
296
                ut_error;
 
297
        }
 
298
}
 
299
 
 
300
/**************************************************************
 
301
The following function prints the contents of a tuple. */
 
302
 
 
303
void
 
304
dtuple_print(
 
305
/*=========*/
 
306
        dtuple_t*       tuple)  /* in: tuple */
 
307
{
 
308
        dfield_t*       field;
 
309
        ulint           n_fields;
 
310
        ulint           i;
 
311
 
 
312
        n_fields = dtuple_get_n_fields(tuple);
 
313
 
 
314
        printf("DATA TUPLE: %lu fields;\n", n_fields);
 
315
 
 
316
        for (i = 0; i < n_fields; i++) {
 
317
                printf(" %lu:", i);     
 
318
 
 
319
                field = dtuple_get_nth_field(tuple, i);
 
320
                
 
321
                if (field->len != UNIV_SQL_NULL) {
 
322
                        ut_print_buf(field->data, field->len);
 
323
                } else {
 
324
                        printf(" SQL NULL");
 
325
                }
 
326
 
 
327
                printf(";");
 
328
        }
 
329
 
 
330
        printf("\n");
 
331
 
 
332
        dtuple_validate(tuple);
 
333
}
 
334
 
 
335
/**************************************************************
 
336
The following function prints the contents of a tuple to a buffer. */
 
337
 
 
338
ulint
 
339
dtuple_sprintf(
 
340
/*===========*/
 
341
                                /* out: printed length in bytes */
 
342
        char*           buf,    /* in: print buffer */
 
343
        ulint           buf_len,/* in: buf length in bytes */
 
344
        dtuple_t*       tuple)  /* in: tuple */
 
345
{
 
346
        dfield_t*       field;
 
347
        ulint           n_fields;
 
348
        ulint           len;
 
349
        ulint           i;
 
350
 
 
351
        len = 0;
 
352
 
 
353
        n_fields = dtuple_get_n_fields(tuple);
 
354
 
 
355
        for (i = 0; i < n_fields; i++) {
 
356
                if (len + 30 > buf_len) {
 
357
 
 
358
                        return(len);
 
359
                }
 
360
 
 
361
                len += sprintf(buf + len, " %lu:", i);  
 
362
 
 
363
                field = dtuple_get_nth_field(tuple, i);
 
364
                
 
365
                if (field->len != UNIV_SQL_NULL) {
 
366
                        if (5 * field->len + len + 30 > buf_len) {
 
367
 
 
368
                                return(len);
 
369
                        }
 
370
                
 
371
                        len += ut_sprintf_buf(buf + len, field->data,
 
372
                                                                field->len);
 
373
                } else {
 
374
                        len += sprintf(buf + len, " SQL NULL");
 
375
                }
 
376
 
 
377
                len += sprintf(buf + len, ";");
 
378
        }
 
379
 
 
380
        return(len);
 
381
}
 
382
 
 
383
/******************************************************************
 
384
Generates random numbers, where 10/16 is uniformly
 
385
distributed between 0 and n1, 5/16 between 0 and n2,
 
386
and 1/16 between 0 and n3. */
 
387
static
 
388
ulint
 
389
dtuple_gen_rnd_ulint(
 
390
/*=================*/
 
391
                        /* out: random ulint */
 
392
        ulint   n1,     
 
393
        ulint   n2,
 
394
        ulint   n3)
 
395
{
 
396
        ulint   m;
 
397
        ulint   n;
 
398
 
 
399
        m = ut_rnd_gen_ulint() % 16;
 
400
        
 
401
        if (m < 10) {
 
402
                n = n1;
 
403
        } else if (m < 15) {
 
404
                n = n2;
 
405
        } else {
 
406
                n = n3;
 
407
        }
 
408
        
 
409
        m = ut_rnd_gen_ulint();
 
410
 
 
411
        return(m % n);
 
412
}
 
413
 
 
414
/***************************************************************
 
415
Generates a random tuple. */
 
416
 
 
417
dtuple_t*
 
418
dtuple_gen_rnd_tuple(
 
419
/*=================*/
 
420
                                /* out: pointer to the tuple */
 
421
        mem_heap_t*     heap)   /* in: memory heap where generated */
 
422
{
 
423
        ulint           n_fields;
 
424
        dfield_t*       field;
 
425
        ulint           len;
 
426
        dtuple_t*       tuple;  
 
427
        ulint           i;
 
428
        ulint           j;
 
429
        byte*           ptr;
 
430
 
 
431
        n_fields = dtuple_gen_rnd_ulint(5, 30, 300) + 1;
 
432
 
 
433
        tuple = dtuple_create(heap, n_fields);
 
434
 
 
435
        for (i = 0; i < n_fields; i++) {
 
436
 
 
437
                if (n_fields < 7) {
 
438
                        len = dtuple_gen_rnd_ulint(5, 30, 400);
 
439
                } else {
 
440
                        len = dtuple_gen_rnd_ulint(7, 5, 17);
 
441
                }
 
442
 
 
443
                field = dtuple_get_nth_field(tuple, i);
 
444
                
 
445
                if (len == 0) {
 
446
                        dfield_set_data(field, NULL, UNIV_SQL_NULL);
 
447
                } else {
 
448
                        ptr = mem_heap_alloc(heap, len);
 
449
                        dfield_set_data(field, ptr, len - 1);
 
450
 
 
451
                        for (j = 0; j < len; j++) {
 
452
                                *ptr = (byte)(65 + 
 
453
                                        dtuple_gen_rnd_ulint(22, 22, 22));
 
454
                                ptr++;
 
455
                        }
 
456
                }
 
457
 
 
458
                dtype_set(dfield_get_type(field), DATA_VARCHAR,
 
459
                                                        DATA_ENGLISH, 500, 0);
 
460
        }
 
461
 
 
462
        ut_a(dtuple_validate(tuple));
 
463
 
 
464
        return(tuple);
 
465
}
 
466
 
 
467
/*******************************************************************
 
468
Generates a test tuple for sort and comparison tests. */
 
469
 
 
470
void
 
471
dtuple_gen_test_tuple(
 
472
/*==================*/
 
473
        dtuple_t*       tuple,  /* in/out: a tuple with 3 fields */
 
474
        ulint           i)      /* in: a number < 512 */
 
475
{
 
476
        ulint           j;
 
477
        dfield_t*       field;
 
478
        void*           data    = NULL;
 
479
        ulint           len     = 0;
 
480
 
 
481
        for (j = 0; j < 3; j++) {
 
482
                switch (i % 8) {
 
483
                        case 0:
 
484
                                data = ""; len = 0; break;
 
485
                        case 1:
 
486
                                data = "A"; len = 1; break;
 
487
                        case 2:
 
488
                                data = "AA"; len = 2; break;
 
489
                        case 3:
 
490
                                data = "AB"; len = 2; break;
 
491
                        case 4:
 
492
                                data = "B"; len = 1; break;
 
493
                        case 5:
 
494
                                data = "BA"; len = 2; break;
 
495
                        case 6:
 
496
                                data = "BB"; len = 2; break;
 
497
                        case 7:
 
498
                                len = UNIV_SQL_NULL; break;
 
499
                }
 
500
 
 
501
                field = dtuple_get_nth_field(tuple, 2 - j);
 
502
                
 
503
                dfield_set_data(field, data, len);
 
504
                dtype_set(dfield_get_type(field), DATA_VARCHAR,
 
505
                                DATA_ENGLISH, 100, 0);
 
506
                
 
507
                i = i / 8;
 
508
        }
 
509
        
 
510
        ut_ad(dtuple_validate(tuple));
 
511
}
 
512
 
 
513
/*******************************************************************
 
514
Generates a test tuple for B-tree speed tests. */
 
515
 
 
516
void
 
517
dtuple_gen_test_tuple3(
 
518
/*===================*/
 
519
        dtuple_t*       tuple,  /* in/out: a tuple with >= 3 fields */
 
520
        ulint           i,      /* in: a number < 1000000 */
 
521
        ulint           type,   /* in: DTUPLE_TEST_FIXED30, ... */
 
522
        byte*           buf)    /* in: a buffer of size >= 16 bytes */
 
523
{
 
524
        dfield_t*       field;
 
525
        ulint           third_size;
 
526
 
 
527
        ut_ad(tuple && buf);
 
528
        ut_ad(i < 1000000);
 
529
        
 
530
        field = dtuple_get_nth_field(tuple, 0);
 
531
 
 
532
        ut_strcpy((char*)buf, "0000000");
 
533
 
 
534
        buf[1] = (byte)('0' + (i / 100000) % 10);
 
535
        buf[2] = (byte)('0' + (i / 10000) % 10);
 
536
        buf[3] = (byte)('0' + (i / 1000) % 10);
 
537
        buf[4] = (byte)('0' + (i / 100) % 10);
 
538
        buf[5] = (byte)('0' + (i / 10) % 10);
 
539
        buf[6] = (byte)('0' + (i % 10));
 
540
        
 
541
        dfield_set_data(field, buf, 8);
 
542
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
543
 
 
544
        field = dtuple_get_nth_field(tuple, 1);
 
545
 
 
546
        i = i % 1000; /* ut_rnd_gen_ulint() % 1000000; */
 
547
 
 
548
        ut_strcpy((char*)buf + 8, "0000000");
 
549
 
 
550
        buf[9] = (byte)('0' + (i / 100000) % 10);
 
551
        buf[10] = (byte)('0' + (i / 10000) % 10);
 
552
        buf[11] = (byte)('0' + (i / 1000) % 10);
 
553
        buf[12] = (byte)('0' + (i / 100) % 10);
 
554
        buf[13] = (byte)('0' + (i / 10) % 10);
 
555
        buf[14] = (byte)('0' + (i % 10));
 
556
        
 
557
        dfield_set_data(field, buf + 8, 8);
 
558
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
559
 
 
560
        field = dtuple_get_nth_field(tuple, 2);
 
561
 
 
562
        data_rnd += 8757651;
 
563
 
 
564
        if (type == DTUPLE_TEST_FIXED30) {
 
565
                third_size = 30;
 
566
        } else if (type == DTUPLE_TEST_RND30) {
 
567
                third_size = data_rnd % 30;
 
568
        } else if (type == DTUPLE_TEST_RND3500) {
 
569
                third_size = data_rnd % 3500;
 
570
        } else if (type == DTUPLE_TEST_FIXED2000) {
 
571
                third_size = 2000;
 
572
        } else if (type == DTUPLE_TEST_FIXED3) {
 
573
                third_size = 3;
 
574
        } else {
 
575
                ut_error;
 
576
        }
 
577
        
 
578
        if (type == DTUPLE_TEST_FIXED30) {
 
579
                dfield_set_data(field,
 
580
                        "12345678901234567890123456789", third_size);
 
581
        } else {
 
582
                dfield_set_data(field, data_buf, third_size);
 
583
        }
 
584
        
 
585
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
586
 
 
587
        ut_ad(dtuple_validate(tuple));
 
588
}
 
589
 
 
590
/*******************************************************************
 
591
Generates a test tuple for B-tree speed tests. */
 
592
 
 
593
void
 
594
dtuple_gen_search_tuple3(
 
595
/*=====================*/
 
596
        dtuple_t*       tuple,  /* in/out: a tuple with 1 or 2 fields */
 
597
        ulint           i,      /* in: a number < 1000000 */
 
598
        byte*           buf)    /* in: a buffer of size >= 16 bytes */
 
599
{
 
600
        dfield_t*       field;
 
601
 
 
602
        ut_ad(tuple && buf);
 
603
        ut_ad(i < 1000000);
 
604
        
 
605
        field = dtuple_get_nth_field(tuple, 0);
 
606
 
 
607
        ut_strcpy((char*)buf, "0000000");
 
608
 
 
609
        buf[1] = (byte)('0' + (i / 100000) % 10);
 
610
        buf[2] = (byte)('0' + (i / 10000) % 10);
 
611
        buf[3] = (byte)('0' + (i / 1000) % 10);
 
612
        buf[4] = (byte)('0' + (i / 100) % 10);
 
613
        buf[5] = (byte)('0' + (i / 10) % 10);
 
614
        buf[6] = (byte)('0' + (i % 10));
 
615
        
 
616
        dfield_set_data(field, buf, 8);
 
617
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
618
 
 
619
        if (dtuple_get_n_fields(tuple) == 1) {
 
620
 
 
621
                return;
 
622
        }
 
623
 
 
624
        field = dtuple_get_nth_field(tuple, 1);
 
625
 
 
626
        i = (i * 1000) % 1000000;
 
627
 
 
628
        ut_strcpy((char*)buf + 8, "0000000");
 
629
 
 
630
        buf[9] = (byte)('0' + (i / 100000) % 10);
 
631
        buf[10] = (byte)('0' + (i / 10000) % 10);
 
632
        buf[11] = (byte)('0' + (i / 1000) % 10);
 
633
        buf[12] = (byte)('0' + (i / 100) % 10);
 
634
        buf[13] = (byte)('0' + (i / 10) % 10);
 
635
        buf[14] = (byte)('0' + (i % 10));
 
636
        
 
637
        dfield_set_data(field, buf + 8, 8);
 
638
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
639
 
 
640
        ut_ad(dtuple_validate(tuple));
 
641
}
 
642
 
 
643
/*******************************************************************
 
644
Generates a test tuple for TPC-A speed test. */
 
645
 
 
646
void
 
647
dtuple_gen_test_tuple_TPC_A(
 
648
/*========================*/
 
649
        dtuple_t*       tuple,  /* in/out: a tuple with >= 3 fields */
 
650
        ulint           i,      /* in: a number < 10000 */
 
651
        byte*           buf)    /* in: a buffer of size >= 16 bytes */
 
652
{
 
653
        dfield_t*       field;
 
654
        ulint           third_size;
 
655
 
 
656
        ut_ad(tuple && buf);
 
657
        ut_ad(i < 10000);
 
658
        
 
659
        field = dtuple_get_nth_field(tuple, 0);
 
660
 
 
661
        ut_strcpy((char*)buf, "0000");
 
662
 
 
663
        buf[0] = (byte)('0' + (i / 1000) % 10);
 
664
        buf[1] = (byte)('0' + (i / 100) % 10);
 
665
        buf[2] = (byte)('0' + (i / 10) % 10);
 
666
        buf[3] = (byte)('0' + (i % 10));
 
667
        
 
668
        dfield_set_data(field, buf, 5);
 
669
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
670
 
 
671
        field = dtuple_get_nth_field(tuple, 1);
 
672
        
 
673
        dfield_set_data(field, buf + 8, 5);
 
674
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
675
 
 
676
        field = dtuple_get_nth_field(tuple, 2);
 
677
 
 
678
        third_size = 90;
 
679
        
 
680
        dfield_set_data(field, data_buf, third_size);
 
681
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
682
 
 
683
        ut_ad(dtuple_validate(tuple));
 
684
}
 
685
 
 
686
/*******************************************************************
 
687
Generates a test tuple for B-tree speed tests. */
 
688
 
 
689
void
 
690
dtuple_gen_search_tuple_TPC_A(
 
691
/*==========================*/
 
692
        dtuple_t*       tuple,  /* in/out: a tuple with 1 field */
 
693
        ulint           i,      /* in: a number < 10000 */
 
694
        byte*           buf)    /* in: a buffer of size >= 16 bytes */
 
695
{
 
696
        dfield_t*       field;
 
697
 
 
698
        ut_ad(tuple && buf);
 
699
        ut_ad(i < 10000);
 
700
        
 
701
        field = dtuple_get_nth_field(tuple, 0);
 
702
 
 
703
        ut_strcpy((char*)buf, "0000");
 
704
 
 
705
        buf[0] = (byte)('0' + (i / 1000) % 10);
 
706
        buf[1] = (byte)('0' + (i / 100) % 10);
 
707
        buf[2] = (byte)('0' + (i / 10) % 10);
 
708
        buf[3] = (byte)('0' + (i % 10));
 
709
        
 
710
        dfield_set_data(field, buf, 5);
 
711
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
712
 
 
713
        ut_ad(dtuple_validate(tuple));
 
714
}
 
715
 
 
716
/*******************************************************************
 
717
Generates a test tuple for TPC-C speed test. */
 
718
 
 
719
void
 
720
dtuple_gen_test_tuple_TPC_C(
 
721
/*========================*/
 
722
        dtuple_t*       tuple,  /* in/out: a tuple with >= 12 fields */
 
723
        ulint           i,      /* in: a number < 100000 */
 
724
        byte*           buf)    /* in: a buffer of size >= 16 bytes */
 
725
{
 
726
        dfield_t*       field;
 
727
        ulint           size;
 
728
        ulint           j;
 
729
 
 
730
        ut_ad(tuple && buf);
 
731
        ut_ad(i < 100000);
 
732
        
 
733
        field = dtuple_get_nth_field(tuple, 0);
 
734
 
 
735
        buf[0] = (byte)('0' + (i / 10000) % 10);
 
736
        buf[1] = (byte)('0' + (i / 1000) % 10);
 
737
        buf[2] = (byte)('0' + (i / 100) % 10);
 
738
        buf[3] = (byte)('0' + (i / 10) % 10);
 
739
        buf[4] = (byte)('0' + (i % 10));
 
740
        
 
741
        dfield_set_data(field, buf, 5);
 
742
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
743
 
 
744
        field = dtuple_get_nth_field(tuple, 1);
 
745
        
 
746
        dfield_set_data(field, buf, 5);
 
747
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
748
 
 
749
        for (j = 0; j < 10; j++) {
 
750
 
 
751
                field = dtuple_get_nth_field(tuple, 2 + j);
 
752
 
 
753
                size = 24;
 
754
        
 
755
                dfield_set_data(field, data_buf, size);
 
756
                dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH,
 
757
                                                                100, 0);
 
758
        }
 
759
 
 
760
        ut_ad(dtuple_validate(tuple));
 
761
}
 
762
 
 
763
/*******************************************************************
 
764
Generates a test tuple for B-tree speed tests. */
 
765
 
 
766
void
 
767
dtuple_gen_search_tuple_TPC_C(
 
768
/*==========================*/
 
769
        dtuple_t*       tuple,  /* in/out: a tuple with 1 field */
 
770
        ulint           i,      /* in: a number < 100000 */
 
771
        byte*           buf)    /* in: a buffer of size >= 16 bytes */
 
772
{
 
773
        dfield_t*       field;
 
774
 
 
775
        ut_ad(tuple && buf);
 
776
        ut_ad(i < 100000);
 
777
        
 
778
        field = dtuple_get_nth_field(tuple, 0);
 
779
 
 
780
        buf[0] = (byte)('0' + (i / 10000) % 10);
 
781
        buf[1] = (byte)('0' + (i / 1000) % 10);
 
782
        buf[2] = (byte)('0' + (i / 100) % 10);
 
783
        buf[3] = (byte)('0' + (i / 10) % 10);
 
784
        buf[4] = (byte)('0' + (i % 10));
 
785
        
 
786
        dfield_set_data(field, buf, 5);
 
787
        dtype_set(dfield_get_type(field), DATA_VARCHAR, DATA_ENGLISH, 100, 0);
 
788
 
 
789
        ut_ad(dtuple_validate(tuple));
 
790
}