← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/records.cc

  • Committer: Monty Taylor
  • Date: 2008-11-16 20:15:33 UTC
  • mto: (584.1.9 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116201533-d0f19s1bk1h95iyw
Removed a big bank of includes from item.h.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/records.cc
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
 
16
 
16
17
/**
17
18
  @file
18
19
 
19
20
  @brief
20
21
  Functions for easy reading of records, possible through a cache
21
22
*/
22
 
#include "config.h"
23
 
#include "drizzled/error.h"
24
 
#include "drizzled/table.h"
25
 
#include "drizzled/session.h"
26
 
#include "drizzled/records.h"
27
 
#include "drizzled/optimizer/range.h"
28
 
#include "drizzled/internal/my_sys.h"
29
 
#include "drizzled/internal/iocache.h"
30
 
 
31
 
namespace drizzled
32
 
{
33
 
 
 
23
#include <drizzled/server_includes.h>
 
24
#include <drizzled/error.h>
 
25
 
 
26
static int rr_quick(READ_RECORD *info);
34
27
int rr_sequential(READ_RECORD *info);
35
 
static int rr_quick(READ_RECORD *info);
36
28
static int rr_from_tempfile(READ_RECORD *info);
37
29
static int rr_unpack_from_tempfile(READ_RECORD *info);
38
30
static int rr_unpack_from_buffer(READ_RECORD *info);
43
35
static int rr_index_first(READ_RECORD *info);
44
36
static int rr_index(READ_RECORD *info);
45
37
 
46
 
void init_read_record_idx(READ_RECORD *info, 
47
 
                          Session *, 
48
 
                          Table *table,
49
 
                          bool print_error, 
50
 
                          uint32_t idx)
 
38
 
 
39
/**
 
40
  Initialize READ_RECORD structure to perform full index scan (in forward
 
41
  direction) using read_record.read_record() interface.
 
42
 
 
43
    This function has been added at late stage and is used only by
 
44
    UPDATE/DELETE. Other statements perform index scans using
 
45
    join_read_first/next functions.
 
46
 
 
47
  @param info         READ_RECORD structure to initialize.
 
48
  @param session          Thread handle
 
49
  @param table        Table to be accessed
 
50
  @param print_error  If true, call table->file->print_error() if an error
 
51
                      occurs (except for end-of-records error)
 
52
  @param idx          index to scan
 
53
*/
 
54
 
 
55
void init_read_record_idx(READ_RECORD *info, Session *, Table *table,
 
56
                          bool print_error, uint32_t idx)
51
57
{
52
 
  table->emptyRecord();
 
58
  empty_record(table);
53
59
  memset(info, 0, sizeof(*info));
54
60
  info->table= table;
55
 
  info->cursor=  table->cursor;
 
61
  info->file=  table->file;
56
62
  info->record= table->record[0];
57
63
  info->print_error= print_error;
58
64
 
59
65
  table->status=0;                      /* And it's always found */
60
 
  if (!table->cursor->inited)
61
 
    table->cursor->ha_index_init(idx, 1);
 
66
  if (!table->file->inited)
 
67
    table->file->ha_index_init(idx, 1);
62
68
  /* read_record will be changed to rr_index in rr_index_first */
63
69
  info->read_record= rr_index_first;
64
70
}
65
71
 
66
72
 
67
 
void init_read_record(READ_RECORD *info,
68
 
                      Session *session, 
69
 
                      Table *table,
70
 
                      optimizer::SqlSelect *select,
71
 
                      int use_record_cache, 
72
 
                      bool print_error)
 
73
/*
 
74
  init_read_record is used to scan by using a number of different methods.
 
75
  Which method to use is set-up in this call so that later calls to
 
76
  the info->read_record will call the appropriate method using a function
 
77
  pointer.
 
78
 
 
79
  There are five methods that relate completely to the sort function
 
80
  filesort. The result of a filesort is retrieved using read_record
 
81
  calls. The other two methods are used for normal table access.
 
82
 
 
83
  The filesort will produce references to the records sorted, these
 
84
  references can be stored in memory or in a temporary file.
 
85
 
 
86
  The temporary file is normally used when the references doesn't fit into
 
87
  a properly sized memory buffer. For most small queries the references
 
88
  are stored in the memory buffer.
 
89
 
 
90
  The temporary file is also used when performing an update where a key is
 
91
  modified.
 
92
 
 
93
  Methods used when ref's are in memory (using rr_from_pointers):
 
94
    rr_unpack_from_buffer:
 
95
    ----------------------
 
96
      This method is used when table->sort.addon_field is allocated.
 
97
      This is allocated for most SELECT queries not involving any BLOB's.
 
98
      In this case the records are fetched from a memory buffer.
 
99
    rr_from_pointers:
 
100
    -----------------
 
101
      Used when the above is not true, UPDATE, DELETE and so forth and
 
102
      SELECT's involving BLOB's. It is also used when the addon_field
 
103
      buffer is not allocated due to that its size was bigger than the
 
104
      session variable max_length_for_sort_data.
 
105
      In this case the record data is fetched from the handler using the
 
106
      saved reference using the rnd_pos handler call.
 
107
 
 
108
  Methods used when ref's are in a temporary file (using rr_from_tempfile)
 
109
    rr_unpack_from_tempfile:
 
110
    ------------------------
 
111
      Same as rr_unpack_from_buffer except that references are fetched from
 
112
      temporary file. Should obviously not really happen other than in
 
113
      strange configurations.
 
114
 
 
115
    rr_from_tempfile:
 
116
    -----------------
 
117
      Same as rr_from_pointers except that references are fetched from
 
118
      temporary file instead of from 
 
119
    rr_from_cache:
 
120
    --------------
 
121
      This is a special variant of rr_from_tempfile that can be used for
 
122
      handlers that is not using the HA_FAST_KEY_READ table flag. Instead
 
123
      of reading the references one by one from the temporary file it reads
 
124
      a set of them, sorts them and reads all of them into a buffer which
 
125
      is then used for a number of subsequent calls to rr_from_cache.
 
126
      It is only used for SELECT queries and a number of other conditions
 
127
      on table size.
 
128
 
 
129
  All other accesses use either index access methods (rr_quick) or a full
 
130
  table scan (rr_sequential).
 
131
  rr_quick:
 
132
  ---------
 
133
    rr_quick uses one of the QUICK_SELECT classes in opt_range.cc to
 
134
    perform an index scan. There are loads of functionality hidden
 
135
    in these quick classes. It handles all index scans of various kinds.
 
136
  rr_sequential:
 
137
  --------------
 
138
    This is the most basic access method of a table using rnd_init,
 
139
    rnd_next and rnd_end. No indexes are used.
 
140
*/
 
141
void init_read_record(READ_RECORD *info,Session *session, Table *table,
 
142
                      SQL_SELECT *select,
 
143
                      int use_record_cache, bool print_error)
73
144
{
74
 
  internal::IO_CACHE *tempfile;
 
145
  IO_CACHE *tempfile;
75
146
 
76
147
  memset(info, 0, sizeof(*info));
77
148
  info->session=session;
78
149
  info->table=table;
79
 
  info->cursor= table->cursor;
 
150
  info->file= table->file;
80
151
  info->forms= &info->table;            /* Only one table */
81
 
 
 
152
  
 
153
  if (table->s->tmp_table == NON_TRANSACTIONAL_TMP_TABLE &&
 
154
      !table->sort.addon_field)
 
155
    table->file->extra(HA_EXTRA_MMAP);
 
156
  
82
157
  if (table->sort.addon_field)
83
158
  {
84
159
    info->rec_buf= table->sort.addon_buf;
86
161
  }
87
162
  else
88
163
  {
89
 
    table->emptyRecord();
 
164
    empty_record(table);
90
165
    info->record= table->record[0];
91
 
    info->ref_length= table->cursor->ref_length;
 
166
    info->ref_length= table->file->ref_length;
92
167
  }
93
168
  info->select=select;
94
 
  info->print_error= print_error;
 
169
  info->print_error=print_error;
95
170
  info->ignore_not_found_rows= 0;
96
171
  table->status=0;                      /* And it's always found */
97
172
 
98
 
  if (select && my_b_inited(select->file))
99
 
    tempfile= select->file;
 
173
  if (select && my_b_inited(&select->file))
 
174
    tempfile= &select->file;
100
175
  else
101
176
    tempfile= table->sort.io_cache;
102
177
  if (tempfile && my_b_inited(tempfile)) // Test if ref-records was used
104
179
    info->read_record= (table->sort.addon_field ?
105
180
                        rr_unpack_from_tempfile : rr_from_tempfile);
106
181
    info->io_cache=tempfile;
107
 
    reinit_io_cache(info->io_cache,internal::READ_CACHE,0L,0,0);
108
 
    info->ref_pos=table->cursor->ref;
109
 
    if (!table->cursor->inited)
110
 
      table->cursor->ha_rnd_init(0);
 
182
    reinit_io_cache(info->io_cache,READ_CACHE,0L,0,0);
 
183
    info->ref_pos=table->file->ref;
 
184
    if (!table->file->inited)
 
185
      table->file->ha_rnd_init(0);
111
186
 
112
187
    /*
113
188
      table->sort.addon_field is checked because if we use addon fields,
115
190
      and table->sort.io_cache is read sequentially
116
191
    */
117
192
    if (!table->sort.addon_field &&
118
 
        session->variables.read_rnd_buff_size &&
119
 
        !(table->cursor->getEngine()->check_flag(HTON_BIT_FAST_KEY_READ)) &&
120
 
        (table->db_stat & HA_READ_ONLY ||
121
 
        table->reginfo.lock_type <= TL_READ_NO_INSERT) &&
122
 
        (uint64_t) table->s->reclength* (table->cursor->stats.records+
123
 
                                                table->cursor->stats.deleted) >
124
 
        (uint64_t) MIN_FILE_LENGTH_TO_USE_ROW_CACHE &&
125
 
        info->io_cache->end_of_file/info->ref_length * table->s->reclength >
126
 
        (internal::my_off_t) MIN_ROWS_TO_USE_TABLE_CACHE &&
127
 
        !table->s->blob_fields &&
 
193
        session->variables.read_rnd_buff_size &&
 
194
        !(table->file->ha_table_flags() & HA_FAST_KEY_READ) &&
 
195
        (table->db_stat & HA_READ_ONLY ||
 
196
         table->reginfo.lock_type <= TL_READ_NO_INSERT) &&
 
197
        (uint64_t) table->s->reclength* (table->file->stats.records+
 
198
                                          table->file->stats.deleted) >
 
199
        (uint64_t) MIN_FILE_LENGTH_TO_USE_ROW_CACHE &&
 
200
        info->io_cache->end_of_file/info->ref_length * table->s->reclength >
 
201
        (my_off_t) MIN_ROWS_TO_USE_TABLE_CACHE &&
 
202
        !table->s->blob_fields &&
128
203
        info->ref_length <= MAX_REFLENGTH)
129
204
    {
130
205
      if (! init_rr_cache(session, info))
131
206
      {
132
 
        info->read_record=rr_from_cache;
 
207
        info->read_record=rr_from_cache;
133
208
      }
134
209
    }
135
210
  }
139
214
  }
140
215
  else if (table->sort.record_pointers)
141
216
  {
142
 
    table->cursor->ha_rnd_init(0);
 
217
    table->file->ha_rnd_init(0);
143
218
    info->cache_pos=table->sort.record_pointers;
144
 
    info->cache_end=info->cache_pos+
 
219
    info->cache_end=info->cache_pos+ 
145
220
                    table->sort.found_records*info->ref_length;
146
221
    info->read_record= (table->sort.addon_field ?
147
222
                        rr_unpack_from_buffer : rr_from_pointers);
148
223
  }
149
224
  else
150
225
  {
151
 
    info->read_record= rr_sequential;
152
 
    table->cursor->ha_rnd_init(1);
 
226
    info->read_record=rr_sequential;
 
227
    table->file->ha_rnd_init(1);
153
228
    /* We can use record cache if we don't update dynamic length tables */
154
229
    if (!table->no_cache &&
155
 
        (use_record_cache > 0 ||
156
 
        (int) table->reginfo.lock_type <= (int) TL_READ_WITH_SHARED_LOCKS ||
157
 
        !(table->s->db_options_in_use & HA_OPTION_PACK_RECORD)))
158
 
      table->cursor->extra_opt(HA_EXTRA_CACHE, session->variables.read_buff_size);
 
230
        (use_record_cache > 0 ||
 
231
         (int) table->reginfo.lock_type <= (int) TL_READ_HIGH_PRIORITY ||
 
232
         !(table->s->db_options_in_use & HA_OPTION_PACK_RECORD) ||
 
233
         (use_record_cache < 0 &&
 
234
          !(table->file->ha_table_flags() & HA_NOT_DELETE_WITH_CACHE))))
 
235
      table->file->extra_opt(HA_EXTRA_CACHE, session->variables.read_buff_size);
159
236
  }
 
237
  /* 
 
238
    Do condition pushdown for UPDATE/DELETE.
 
239
    TODO: Remove this from here as it causes two condition pushdown calls 
 
240
    when we're running a SELECT and the condition cannot be pushed down.
 
241
  */
 
242
  if (session->variables.engine_condition_pushdown && 
 
243
      select && select->cond && 
 
244
      (select->cond->used_tables() & table->map) &&
 
245
      !table->file->pushed_cond)
 
246
    table->file->cond_push(select->cond);
160
247
 
161
248
  return;
162
249
} /* init_read_record */
163
250
 
164
251
 
 
252
 
165
253
void end_read_record(READ_RECORD *info)
166
254
{                   /* free cache if used */
167
255
  if (info->cache)
171
259
  }
172
260
  if (info->table)
173
261
  {
174
 
    info->table->filesort_free_buffers();
175
 
    (void) info->cursor->extra(HA_EXTRA_NO_CACHE);
 
262
    filesort_free_buffers(info->table,0);
 
263
    (void) info->file->extra(HA_EXTRA_NO_CACHE);
176
264
    if (info->read_record != rr_quick) // otherwise quick_range does it
177
 
      (void) info->cursor->ha_index_or_rnd_end();
 
265
      (void) info->file->ha_index_or_rnd_end();
178
266
    info->table=0;
179
267
  }
180
268
}
186
274
  else
187
275
  {
188
276
    if (info->print_error)
189
 
      info->table->print_error(error, MYF(0));
 
277
      info->table->file->print_error(error, MYF(0));
190
278
    if (error < 0)                            // Fix negative BDB errno
191
279
      error= 1;
192
280
  }
193
281
  return error;
194
282
}
195
283
 
 
284
 
196
285
/** Read a record from head-database. */
 
286
 
197
287
static int rr_quick(READ_RECORD *info)
198
288
{
199
289
  int tmp;
210
300
      break;
211
301
    }
212
302
  }
213
 
 
 
303
  update_virtual_fields_marked_for_write(info->table);
214
304
  return tmp;
215
305
}
216
306
 
 
307
 
217
308
/**
218
309
  Reads first row in an index scan.
219
310
 
226
317
  @retval
227
318
    1   Error
228
319
*/
 
320
 
229
321
static int rr_index_first(READ_RECORD *info)
230
322
{
231
 
  int tmp= info->cursor->index_first(info->record);
 
323
  int tmp= info->file->index_first(info->record);
232
324
  info->read_record= rr_index;
233
325
  if (tmp)
234
326
    tmp= rr_handle_error(info, tmp);
235
327
  return tmp;
236
328
}
237
329
 
 
330
 
238
331
/**
239
332
  Reads index sequentially after first row.
240
333
 
250
343
  @retval
251
344
    1   Error
252
345
*/
 
346
 
253
347
static int rr_index(READ_RECORD *info)
254
348
{
255
 
  int tmp= info->cursor->index_next(info->record);
 
349
  int tmp= info->file->index_next(info->record);
256
350
  if (tmp)
257
351
    tmp= rr_handle_error(info, tmp);
258
352
  return tmp;
259
353
}
260
354
 
 
355
 
261
356
int rr_sequential(READ_RECORD *info)
262
357
{
263
358
  int tmp;
264
 
  while ((tmp= info->cursor->rnd_next(info->record)))
 
359
  while ((tmp=info->file->rnd_next(info->record)))
265
360
  {
266
361
    if (info->session->killed)
267
362
    {
269
364
      return 1;
270
365
    }
271
366
    /*
272
 
      TODO> Fix this so that engine knows how to behave on its own.
273
367
      rnd_next can return RECORD_DELETED for MyISAM when one thread is
274
368
      reading and another deleting without locks.
275
369
    */
279
373
      break;
280
374
    }
281
375
  }
282
 
 
 
376
  if (!tmp)
 
377
    update_virtual_fields_marked_for_write(info->table);
283
378
  return tmp;
284
379
}
285
380
 
 
381
 
286
382
static int rr_from_tempfile(READ_RECORD *info)
287
383
{
288
384
  int tmp;
289
385
  for (;;)
290
386
  {
291
387
    if (my_b_read(info->io_cache,info->ref_pos,info->ref_length))
292
 
      return -1;                                        /* End of cursor */
293
 
    if (!(tmp=info->cursor->rnd_pos(info->record,info->ref_pos)))
 
388
      return -1;                                        /* End of file */
 
389
    if (!(tmp=info->file->rnd_pos(info->record,info->ref_pos)))
294
390
      break;
295
391
    /* The following is extremely unlikely to happen */
296
392
    if (tmp == HA_ERR_RECORD_DELETED ||
302
398
  return tmp;
303
399
} /* rr_from_tempfile */
304
400
 
 
401
 
305
402
/**
306
 
  Read a result set record from a temporary cursor after sorting.
 
403
  Read a result set record from a temporary file after sorting.
307
404
 
308
 
  The function first reads the next sorted record from the temporary cursor.
309
 
  into a buffer. If a success it calls a callback function that unpacks
 
405
  The function first reads the next sorted record from the temporary file.
 
406
  into a buffer. If a success it calls a callback function that unpacks 
310
407
  the fields values use in the result set from this buffer into their
311
408
  positions in the regular record buffer.
312
409
 
317
414
  @retval
318
415
    -1   There is no record to be read anymore.
319
416
*/
 
417
 
320
418
static int rr_unpack_from_tempfile(READ_RECORD *info)
321
419
{
322
420
  if (my_b_read(info->io_cache, info->rec_buf, info->ref_length))
335
433
  for (;;)
336
434
  {
337
435
    if (info->cache_pos == info->cache_end)
338
 
      return -1;                                        /* End of cursor */
 
436
      return -1;                                        /* End of file */
339
437
    cache_pos= info->cache_pos;
340
438
    info->cache_pos+= info->ref_length;
341
439
 
342
 
    if (!(tmp=info->cursor->rnd_pos(info->record,cache_pos)))
 
440
    if (!(tmp=info->file->rnd_pos(info->record,cache_pos)))
343
441
      break;
344
442
 
345
443
    /* The following is extremely unlikely to happen */
356
454
  Read a result set record from a buffer after sorting.
357
455
 
358
456
  The function first reads the next sorted record from the sort buffer.
359
 
  If a success it calls a callback function that unpacks
 
457
  If a success it calls a callback function that unpacks 
360
458
  the fields values use in the result set from this buffer into their
361
459
  positions in the regular record buffer.
362
460
 
367
465
  @retval
368
466
    -1   There is no record to be read anymore.
369
467
*/
 
468
 
370
469
static int rr_unpack_from_buffer(READ_RECORD *info)
371
470
{
372
471
  if (info->cache_pos == info->cache_end)
377
476
 
378
477
  return 0;
379
478
}
 
479
        /* cacheing of records from a database */
380
480
 
381
 
/* cacheing of records from a database */
382
481
static int init_rr_cache(Session *session, READ_RECORD *info)
383
482
{
384
483
  uint32_t rec_cache_size;
396
495
 
397
496
  // We have to allocate one more byte to use uint3korr (see comments for it)
398
497
  if (info->cache_records <= 2 ||
399
 
      !(info->cache=(unsigned char*) malloc(rec_cache_size+info->cache_records*
400
 
                                            info->struct_length+1)))
 
498
      !(info->cache=(unsigned char*) my_malloc_lock(rec_cache_size+info->cache_records*
 
499
                                           info->struct_length+1,
 
500
                                           MYF(0))))
401
501
    return(1);
402
502
#ifdef HAVE_purify
403
503
  // Avoid warnings in qsort
409
509
  return(0);
410
510
} /* init_rr_cache */
411
511
 
 
512
 
412
513
static int rr_from_cache(READ_RECORD *info)
413
514
{
414
515
  register uint32_t i;
415
516
  uint32_t length;
416
 
  internal::my_off_t rest_of_file;
 
517
  my_off_t rest_of_file;
417
518
  int16_t error;
418
519
  unsigned char *position,*ref_position,*record_pos;
419
520
  uint32_t record;
424
525
    {
425
526
      if (info->cache_pos[info->error_offset])
426
527
      {
427
 
        shortget(error,info->cache_pos);
428
 
        if (info->print_error)
429
 
          info->table->print_error(error,MYF(0));
 
528
        shortget(error,info->cache_pos);
 
529
        if (info->print_error)
 
530
          info->table->file->print_error(error,MYF(0));
430
531
      }
431
532
      else
432
533
      {
433
 
        error=0;
434
 
        memcpy(info->record,info->cache_pos, (size_t) info->table->s->reclength);
 
534
        error=0;
 
535
        memcpy(info->record,info->cache_pos,
 
536
               (size_t) info->table->s->reclength);
435
537
      }
436
538
      info->cache_pos+=info->reclength;
437
539
      return ((int) error);
438
540
    }
439
541
    length=info->rec_cache_size;
440
542
    rest_of_file=info->io_cache->end_of_file - my_b_tell(info->io_cache);
441
 
    if ((internal::my_off_t) length > rest_of_file)
 
543
    if ((my_off_t) length > rest_of_file)
442
544
      length= (uint32_t) rest_of_file;
443
545
    if (!length || my_b_read(info->io_cache,info->cache,length))
444
546
    {
445
 
      return -1;                        /* End of cursor */
 
547
      return -1;                        /* End of file */
446
548
    }
447
549
 
448
550
    length/=info->ref_length;
455
557
      int3store(ref_position,(long) i);
456
558
      ref_position+=3;
457
559
    }
458
 
    internal::my_qsort(info->read_positions, length, info->struct_length,
459
 
                       (qsort_cmp) rr_cmp);
 
560
    my_qsort(info->read_positions, length, info->struct_length,
 
561
             (qsort_cmp) rr_cmp);
460
562
 
461
563
    position=info->read_positions;
462
564
    for (i=0 ; i < length ; i++)
466
568
      record=uint3korr(position);
467
569
      position+=3;
468
570
      record_pos=info->cache+record*info->reclength;
469
 
      if ((error=(int16_t) info->cursor->rnd_pos(record_pos,info->ref_pos)))
 
571
      if ((error=(int16_t) info->file->rnd_pos(record_pos,info->ref_pos)))
470
572
      {
471
 
        record_pos[info->error_offset]=1;
472
 
        shortstore(record_pos,error);
 
573
        record_pos[info->error_offset]=1;
 
574
        shortstore(record_pos,error);
473
575
      }
474
576
      else
475
 
        record_pos[info->error_offset]=0;
 
577
        record_pos[info->error_offset]=0;
476
578
    }
477
579
    info->cache_end=(info->cache_pos=info->cache)+length*info->reclength;
478
580
  }
479
581
} /* rr_from_cache */
480
582
 
 
583
 
481
584
static int rr_cmp(unsigned char *a,unsigned char *b)
482
585
{
483
586
  if (a[0] != b[0])
500
603
  return (int) a[7] - (int) b[7];
501
604
#endif
502
605
}
503
 
 
504
 
} /* namespace drizzled */