← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/records.cc

  • Committer: Brian Aker
  • Date: 2010-05-07 06:18:08 UTC
  • mto: (1527.1.1 staging)
  • mto: This revision was merged to the branch mainline in revision 1526.
  • Revision ID: brian@gaz-20100507061808-xtbz9dgb32o783yg
Remove members to functions that are no longer used.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/records.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/**
17
17
  @file
27
27
#include "drizzled/optimizer/range.h"
28
28
#include "drizzled/internal/my_sys.h"
29
29
#include "drizzled/internal/iocache.h"
30
 
#include "drizzled/drizzled.h"
31
30
 
32
31
namespace drizzled
33
32
{
34
33
 
35
 
static int rr_sequential(ReadRecord *info);
36
 
static int rr_quick(ReadRecord *info);
37
 
static int rr_from_tempfile(ReadRecord *info);
38
 
static int rr_unpack_from_tempfile(ReadRecord *info);
39
 
static int rr_unpack_from_buffer(ReadRecord *info);
40
 
static int rr_from_pointers(ReadRecord *info);
41
 
static int rr_from_cache(ReadRecord *info);
 
34
int rr_sequential(READ_RECORD *info);
 
35
static int rr_quick(READ_RECORD *info);
 
36
static int rr_from_tempfile(READ_RECORD *info);
 
37
static int rr_unpack_from_tempfile(READ_RECORD *info);
 
38
static int rr_unpack_from_buffer(READ_RECORD *info);
 
39
static int rr_from_pointers(READ_RECORD *info);
 
40
static int rr_from_cache(READ_RECORD *info);
 
41
static int init_rr_cache(Session *session, READ_RECORD *info);
42
42
static int rr_cmp(unsigned char *a,unsigned char *b);
43
 
static int rr_index_first(ReadRecord *info);
44
 
static int rr_index(ReadRecord *info);
45
 
 
46
 
void ReadRecord::init_reard_record_sequential()
47
 
{
48
 
  read_record= rr_sequential;
49
 
}
50
 
 
51
 
void ReadRecord::init_read_record_idx(Session *, 
52
 
                                      Table *table_arg,
53
 
                                      bool print_error_arg, 
54
 
                                      uint32_t idx)
55
 
{
56
 
  table_arg->emptyRecord();
57
 
  table= table_arg;
58
 
  cursor=  table->cursor;
59
 
  record= table->getInsertRecord();
60
 
  print_error= print_error_arg;
 
43
static int rr_index_first(READ_RECORD *info);
 
44
static int rr_index(READ_RECORD *info);
 
45
 
 
46
void init_read_record_idx(READ_RECORD *info, 
 
47
                          Session *, 
 
48
                          Table *table,
 
49
                          bool print_error, 
 
50
                          uint32_t idx)
 
51
{
 
52
  table->emptyRecord();
 
53
  memset(info, 0, sizeof(*info));
 
54
  info->table= table;
 
55
  info->cursor=  table->cursor;
 
56
  info->record= table->record[0];
 
57
  info->print_error= print_error;
61
58
 
62
59
  table->status=0;                      /* And it's always found */
63
 
  if (not table->cursor->inited)
64
 
    table->cursor->startIndexScan(idx, 1);
 
60
  if (!table->cursor->inited)
 
61
    table->cursor->ha_index_init(idx, 1);
65
62
  /* read_record will be changed to rr_index in rr_index_first */
66
 
  read_record= rr_index_first;
 
63
  info->read_record= rr_index_first;
67
64
}
68
65
 
69
66
 
70
 
void ReadRecord::init_read_record(Session *session_arg, 
71
 
                                  Table *table_arg,
72
 
                                  optimizer::SqlSelect *select_arg,
73
 
                                  int use_record_cache, 
74
 
                                  bool print_error_arg)
 
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)
75
73
{
76
74
  internal::IO_CACHE *tempfile;
77
75
 
78
 
  session= session_arg;
79
 
  table= table_arg;
80
 
  cursor= table->cursor;
81
 
  forms= &table;                /* Only one table */
 
76
  memset(info, 0, sizeof(*info));
 
77
  info->session=session;
 
78
  info->table=table;
 
79
  info->cursor= table->cursor;
 
80
  info->forms= &info->table;            /* Only one table */
82
81
 
83
82
  if (table->sort.addon_field)
84
83
  {
85
 
    rec_buf= table->sort.addon_buf;
86
 
    ref_length= table->sort.addon_length;
 
84
    info->rec_buf= table->sort.addon_buf;
 
85
    info->ref_length= table->sort.addon_length;
87
86
  }
88
87
  else
89
88
  {
90
89
    table->emptyRecord();
91
 
    record= table->getInsertRecord();
92
 
    ref_length= table->cursor->ref_length;
 
90
    info->record= table->record[0];
 
91
    info->ref_length= table->cursor->ref_length;
93
92
  }
94
 
  select= select_arg;
95
 
  print_error= print_error_arg;
96
 
  ignore_not_found_rows= 0;
 
93
  info->select=select;
 
94
  info->print_error= print_error;
 
95
  info->ignore_not_found_rows= 0;
97
96
  table->status=0;                      /* And it's always found */
98
97
 
99
98
  if (select && my_b_inited(select->file))
100
 
  {
101
99
    tempfile= select->file;
102
 
  }
103
100
  else
104
 
  {
105
101
    tempfile= table->sort.io_cache;
106
 
  }
107
 
 
108
102
  if (tempfile && my_b_inited(tempfile)) // Test if ref-records was used
109
103
  {
110
 
    read_record= (table->sort.addon_field ?
111
 
                  rr_unpack_from_tempfile : rr_from_tempfile);
112
 
 
113
 
    io_cache=tempfile;
114
 
    io_cache->reinit_io_cache(internal::READ_CACHE,0L,0,0);
115
 
    ref_pos=table->cursor->ref;
 
104
    info->read_record= (table->sort.addon_field ?
 
105
                        rr_unpack_from_tempfile : rr_from_tempfile);
 
106
    info->io_cache=tempfile;
 
107
    reinit_io_cache(info->io_cache,internal::READ_CACHE,0L,0,0);
 
108
    info->ref_pos=table->cursor->ref;
116
109
    if (!table->cursor->inited)
117
 
      table->cursor->startTableScan(0);
 
110
      table->cursor->ha_rnd_init(0);
118
111
 
119
112
    /*
120
113
      table->sort.addon_field is checked because if we use addon fields,
126
119
        !(table->cursor->getEngine()->check_flag(HTON_BIT_FAST_KEY_READ)) &&
127
120
        (table->db_stat & HA_READ_ONLY ||
128
121
        table->reginfo.lock_type <= TL_READ_NO_INSERT) &&
129
 
        (uint64_t) table->getShare()->getRecordLength() * (table->cursor->stats.records+
 
122
        (uint64_t) table->s->reclength* (table->cursor->stats.records+
130
123
                                                table->cursor->stats.deleted) >
131
124
        (uint64_t) MIN_FILE_LENGTH_TO_USE_ROW_CACHE &&
132
 
        io_cache->end_of_file/ref_length * table->getShare()->getRecordLength() >
 
125
        info->io_cache->end_of_file/info->ref_length * table->s->reclength >
133
126
        (internal::my_off_t) MIN_ROWS_TO_USE_TABLE_CACHE &&
134
 
        !table->getShare()->blob_fields &&
135
 
        ref_length <= MAX_REFLENGTH)
 
127
        !table->s->blob_fields &&
 
128
        info->ref_length <= MAX_REFLENGTH)
136
129
    {
137
 
      if (init_rr_cache())
 
130
      if (! init_rr_cache(session, info))
138
131
      {
139
 
        read_record= rr_from_cache;
 
132
        info->read_record=rr_from_cache;
140
133
      }
141
134
    }
142
135
  }
143
136
  else if (select && select->quick)
144
137
  {
145
 
    read_record= rr_quick;
 
138
    info->read_record=rr_quick;
146
139
  }
147
140
  else if (table->sort.record_pointers)
148
141
  {
149
 
    table->cursor->startTableScan(0);
150
 
    cache_pos=table->sort.record_pointers;
151
 
    cache_end= cache_pos+ table->sort.found_records * ref_length;
152
 
    read_record= (table->sort.addon_field ?  rr_unpack_from_buffer : rr_from_pointers);
 
142
    table->cursor->ha_rnd_init(0);
 
143
    info->cache_pos=table->sort.record_pointers;
 
144
    info->cache_end=info->cache_pos+
 
145
                    table->sort.found_records*info->ref_length;
 
146
    info->read_record= (table->sort.addon_field ?
 
147
                        rr_unpack_from_buffer : rr_from_pointers);
153
148
  }
154
149
  else
155
150
  {
156
 
    read_record= rr_sequential;
157
 
    table->cursor->startTableScan(1);
 
151
    info->read_record= rr_sequential;
 
152
    table->cursor->ha_rnd_init(1);
158
153
    /* We can use record cache if we don't update dynamic length tables */
159
154
    if (!table->no_cache &&
160
155
        (use_record_cache > 0 ||
161
156
        (int) table->reginfo.lock_type <= (int) TL_READ_WITH_SHARED_LOCKS ||
162
 
        !(table->getShare()->db_options_in_use & HA_OPTION_PACK_RECORD)))
163
 
    {
 
157
        !(table->s->db_options_in_use & HA_OPTION_PACK_RECORD)))
164
158
      table->cursor->extra_opt(HA_EXTRA_CACHE, session->variables.read_buff_size);
165
 
    }
166
159
  }
167
160
 
168
161
  return;
169
162
} /* init_read_record */
170
163
 
171
164
 
172
 
void ReadRecord::end_read_record()
 
165
void end_read_record(READ_RECORD *info)
173
166
{                   /* free cache if used */
174
 
  if (cache)
 
167
  if (info->cache)
175
168
  {
176
 
    global_read_rnd_buffer.sub(session->variables.read_rnd_buff_size);
177
 
    free((char*) cache);
178
 
    cache= NULL;
 
169
    free((char*) info->cache);
 
170
    info->cache=0;
179
171
  }
180
 
  if (table)
 
172
  if (info->table)
181
173
  {
182
 
    table->filesort_free_buffers();
183
 
    (void) cursor->extra(HA_EXTRA_NO_CACHE);
184
 
    if (read_record != rr_quick) // otherwise quick_range does it
185
 
      (void) cursor->ha_index_or_rnd_end();
186
 
 
187
 
    table= NULL;
 
174
    info->table->filesort_free_buffers();
 
175
    (void) info->cursor->extra(HA_EXTRA_NO_CACHE);
 
176
    if (info->read_record != rr_quick) // otherwise quick_range does it
 
177
      (void) info->cursor->ha_index_or_rnd_end();
 
178
    info->table=0;
188
179
  }
189
180
}
190
181
 
191
 
static int rr_handle_error(ReadRecord *info, int error)
 
182
static int rr_handle_error(READ_RECORD *info, int error)
192
183
{
193
184
  if (error == HA_ERR_END_OF_FILE)
194
185
    error= -1;
203
194
}
204
195
 
205
196
/** Read a record from head-database. */
206
 
static int rr_quick(ReadRecord *info)
 
197
static int rr_quick(READ_RECORD *info)
207
198
{
208
199
  int tmp;
209
200
  while ((tmp= info->select->quick->get_next()))
210
201
  {
211
 
    if (info->session->getKilled())
 
202
    if (info->session->killed)
212
203
    {
213
204
      my_error(ER_SERVER_SHUTDOWN, MYF(0));
214
205
      return 1;
235
226
  @retval
236
227
    1   Error
237
228
*/
238
 
static int rr_index_first(ReadRecord *info)
 
229
static int rr_index_first(READ_RECORD *info)
239
230
{
240
231
  int tmp= info->cursor->index_first(info->record);
241
232
  info->read_record= rr_index;
259
250
  @retval
260
251
    1   Error
261
252
*/
262
 
static int rr_index(ReadRecord *info)
 
253
static int rr_index(READ_RECORD *info)
263
254
{
264
255
  int tmp= info->cursor->index_next(info->record);
265
256
  if (tmp)
267
258
  return tmp;
268
259
}
269
260
 
270
 
int rr_sequential(ReadRecord *info)
 
261
int rr_sequential(READ_RECORD *info)
271
262
{
272
263
  int tmp;
273
264
  while ((tmp= info->cursor->rnd_next(info->record)))
274
265
  {
275
 
    if (info->session->getKilled())
 
266
    if (info->session->killed)
276
267
    {
277
268
      info->session->send_kill_message();
278
269
      return 1;
292
283
  return tmp;
293
284
}
294
285
 
295
 
static int rr_from_tempfile(ReadRecord *info)
 
286
static int rr_from_tempfile(READ_RECORD *info)
296
287
{
297
288
  int tmp;
298
289
  for (;;)
326
317
  @retval
327
318
    -1   There is no record to be read anymore.
328
319
*/
329
 
static int rr_unpack_from_tempfile(ReadRecord *info)
 
320
static int rr_unpack_from_tempfile(READ_RECORD *info)
330
321
{
331
322
  if (my_b_read(info->io_cache, info->rec_buf, info->ref_length))
332
323
    return -1;
336
327
  return 0;
337
328
}
338
329
 
339
 
static int rr_from_pointers(ReadRecord *info)
 
330
static int rr_from_pointers(READ_RECORD *info)
340
331
{
341
332
  int tmp;
342
333
  unsigned char *cache_pos;
343
334
 
344
 
 
345
335
  for (;;)
346
336
  {
347
337
    if (info->cache_pos == info->cache_end)
377
367
  @retval
378
368
    -1   There is no record to be read anymore.
379
369
*/
380
 
static int rr_unpack_from_buffer(ReadRecord *info)
 
370
static int rr_unpack_from_buffer(READ_RECORD *info)
381
371
{
382
372
  if (info->cache_pos == info->cache_end)
383
373
    return -1;                      /* End of buffer */
389
379
}
390
380
 
391
381
/* cacheing of records from a database */
392
 
bool ReadRecord::init_rr_cache()
 
382
static int init_rr_cache(Session *session, READ_RECORD *info)
393
383
{
394
 
  uint32_t local_rec_cache_size;
395
 
 
396
 
  struct_length= 3 + MAX_REFLENGTH;
397
 
  reclength= ALIGN_SIZE(table->getShare()->getRecordLength() + 1);
398
 
  if (reclength < struct_length)
399
 
    reclength= ALIGN_SIZE(struct_length);
400
 
 
401
 
  error_offset= table->getShare()->getRecordLength();
402
 
  cache_records= (session->variables.read_rnd_buff_size /
403
 
                        (reclength + struct_length));
404
 
  local_rec_cache_size= cache_records * reclength;
405
 
  rec_cache_size= cache_records * ref_length;
406
 
 
407
 
  if (not global_read_rnd_buffer.add(session->variables.read_rnd_buff_size))
408
 
  {
409
 
    my_error(ER_OUT_OF_GLOBAL_READRNDMEMORY, MYF(ME_ERROR+ME_WAITTANG));
410
 
    return false;
411
 
  }
 
384
  uint32_t rec_cache_size;
 
385
 
 
386
  info->struct_length= 3+MAX_REFLENGTH;
 
387
  info->reclength= ALIGN_SIZE(info->table->s->reclength+1);
 
388
  if (info->reclength < info->struct_length)
 
389
    info->reclength= ALIGN_SIZE(info->struct_length);
 
390
 
 
391
  info->error_offset= info->table->s->reclength;
 
392
  info->cache_records= (session->variables.read_rnd_buff_size /
 
393
                        (info->reclength+info->struct_length));
 
394
  rec_cache_size= info->cache_records*info->reclength;
 
395
  info->rec_cache_size= info->cache_records*info->ref_length;
412
396
 
413
397
  // We have to allocate one more byte to use uint3korr (see comments for it)
414
 
  if (cache_records <= 2 ||
415
 
      !(cache=(unsigned char*) malloc(local_rec_cache_size + cache_records * struct_length + 1)))
416
 
  {
417
 
    return false;
418
 
  }
419
 
#ifdef HAVE_VALGRIND
 
398
  if (info->cache_records <= 2 ||
 
399
      !(info->cache=(unsigned char*) malloc(rec_cache_size+info->cache_records*
 
400
                                            info->struct_length+1)))
 
401
    return(1);
 
402
#ifdef HAVE_purify
420
403
  // Avoid warnings in qsort
421
 
  memset(cache, 0, local_rec_cache_size + cache_records * struct_length + 1);
 
404
  memset(info->cache, 0,
 
405
         rec_cache_size+info->cache_records* info->struct_length+1);
422
406
#endif
423
 
  read_positions= cache + local_rec_cache_size;
424
 
  cache_pos= cache_end= cache;
425
 
 
426
 
  return true;
 
407
  info->read_positions=info->cache+rec_cache_size;
 
408
  info->cache_pos=info->cache_end=info->cache;
 
409
  return(0);
427
410
} /* init_rr_cache */
428
411
 
429
 
static int rr_from_cache(ReadRecord *info)
 
412
static int rr_from_cache(READ_RECORD *info)
430
413
{
 
414
  register uint32_t i;
431
415
  uint32_t length;
432
416
  internal::my_off_t rest_of_file;
433
417
  int16_t error;
447
431
      else
448
432
      {
449
433
        error=0;
450
 
        memcpy(info->record,info->cache_pos, (size_t) info->table->getShare()->getRecordLength());
 
434
        memcpy(info->record,info->cache_pos, (size_t) info->table->s->reclength);
451
435
      }
452
 
      info->cache_pos+= info->reclength;
 
436
      info->cache_pos+=info->reclength;
453
437
      return ((int) error);
454
438
    }
455
439
    length=info->rec_cache_size;
456
 
    rest_of_file= info->io_cache->end_of_file - my_b_tell(info->io_cache);
 
440
    rest_of_file=info->io_cache->end_of_file - my_b_tell(info->io_cache);
457
441
    if ((internal::my_off_t) length > rest_of_file)
458
 
    {
459
442
      length= (uint32_t) rest_of_file;
460
 
    }
461
 
 
462
 
    if (!length || my_b_read(info->io_cache, info->getCache(), length))
 
443
    if (!length || my_b_read(info->io_cache,info->cache,length))
463
444
    {
464
445
      return -1;                        /* End of cursor */
465
446
    }
466
447
 
467
448
    length/=info->ref_length;
468
 
    position=info->getCache();
 
449
    position=info->cache;
469
450
    ref_position=info->read_positions;
470
 
    for (uint32_t i= 0 ; i < length ; i++,position+=info->ref_length)
 
451
    for (i=0 ; i < length ; i++,position+=info->ref_length)
471
452
    {
472
453
      memcpy(ref_position,position,(size_t) info->ref_length);
473
454
      ref_position+=MAX_REFLENGTH;
478
459
                       (qsort_cmp) rr_cmp);
479
460
 
480
461
    position=info->read_positions;
481
 
    for (uint32_t i= 0 ; i < length ; i++)
 
462
    for (i=0 ; i < length ; i++)
482
463
    {
483
 
      memcpy(info->ref_pos, position, (size_t)info->ref_length);
 
464
      memcpy(info->ref_pos,position,(size_t) info->ref_length);
484
465
      position+=MAX_REFLENGTH;
485
466
      record=uint3korr(position);
486
467
      position+=3;
487
 
      record_pos= info->getCache() + record * info->reclength;
 
468
      record_pos=info->cache+record*info->reclength;
488
469
      if ((error=(int16_t) info->cursor->rnd_pos(record_pos,info->ref_pos)))
489
470
      {
490
471
        record_pos[info->error_offset]=1;
493
474
      else
494
475
        record_pos[info->error_offset]=0;
495
476
    }
496
 
    info->cache_end= (info->cache_pos= info->getCache())+length*info->reclength;
 
477
    info->cache_end=(info->cache_pos=info->cache)+length*info->reclength;
497
478
  }
498
479
} /* rr_from_cache */
499
480