← 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: 2009-01-07 21:26:58 UTC
  • Revision ID: brian@tangent.org-20090107212658-2fh0s2uwh10w68y2
Committing fix lock_multi

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