← 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: 2008-09-05 23:02:34 UTC
  • mfrom: (379 codestyle)
  • mto: This revision was merged to the branch mainline in revision 383.
  • Revision ID: brian@tangent.org-20080905230234-tq426zr79cnzjwo3
Merge from Monty, cleanup in tabs during merg.

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