← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/heap/hp_dspace.cc

  • Committer: Brian Aker
  • Date: 2010-05-26 21:49:18 UTC
  • mto: This revision was merged to the branch mainline in revision 1568.
  • Revision ID: brian@gaz-20100526214918-8kdibq48e9lnyr6t
https://launchpad.net/bugs/586009
This fixes bug 586009, increases the size of the log files so that the UNION
test doesn't hit Innodb's default limit. Increases the size of the initial
Innodb data file, and fixes one case where an empty string on error was
causing a crash on OSX.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/heap/hp_dspace.cc
12
12
 
13
13
   You should have received a copy of the GNU General Public License
14
14
   along with this program; if not, write to the Free Software
15
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
15
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
16
16
 
17
17
/* Implements various base dataspace-related functions - allocate, free, clear */
18
18
 
179
179
 
180
180
 
181
181
/**
 
182
  Allocate or reallocate a chunkset in the dataspace
 
183
 
 
184
  Attempts to allocate a new chunkset or change the size of an existing chunkset
 
185
 
 
186
  @param  info            the hosting dataspace
 
187
  @param  chunk_count     the number of chunks that we expect as the result
 
188
  @param  existing_set    non-null value asks function to resize existing chunkset,
 
189
                          return value would point to this set
 
190
 
 
191
  @return  Pointer to the first chunk in the new or updated chunkset, or NULL if unsuccessful
 
192
*/
 
193
 
 
194
static unsigned char *hp_allocate_variable_chunkset(HP_DATASPACE *info,
 
195
                                           uint32_t chunk_count, unsigned char* existing_set)
 
196
{
 
197
  int alloc_count= chunk_count, i;
 
198
  unsigned char *first_chunk= 0, *curr_chunk= 0, *prev_chunk= 0, *last_existing_chunk= 0;
 
199
 
 
200
  assert(alloc_count);
 
201
 
 
202
  if (existing_set)
 
203
  {
 
204
    first_chunk= existing_set;
 
205
 
 
206
    curr_chunk= existing_set;
 
207
    while (curr_chunk && alloc_count)
 
208
    {
 
209
      prev_chunk= curr_chunk;
 
210
      curr_chunk= *((unsigned char**)(curr_chunk + info->offset_link));
 
211
      alloc_count--;
 
212
    }
 
213
 
 
214
    if (!alloc_count)
 
215
    {
 
216
      if (curr_chunk)
 
217
      {
 
218
        /* We came through all chunks and there is more left, let's truncate the list */
 
219
        *((unsigned char**)(prev_chunk + info->offset_link)) = NULL;
 
220
        hp_free_chunks(info, curr_chunk);
 
221
      }
 
222
 
 
223
      return first_chunk;
 
224
    }
 
225
 
 
226
    last_existing_chunk = prev_chunk;
 
227
  }
 
228
 
 
229
  /* We can reach this point only if we're allocating new chunkset or more chunks in existing set */
 
230
 
 
231
  for (i=0; i<alloc_count; i++)
 
232
  {
 
233
      curr_chunk= hp_allocate_one_chunk(info);
 
234
      if (!curr_chunk)
 
235
      {
 
236
        /* no space in the current block */
 
237
 
 
238
        if (last_existing_chunk)
 
239
        {
 
240
          /* Truncate whatever was added at the end of the existing chunkset */
 
241
          prev_chunk= last_existing_chunk;
 
242
          curr_chunk= *((unsigned char**)(prev_chunk + info->offset_link));
 
243
          *((unsigned char**)(prev_chunk + info->offset_link)) = NULL;
 
244
          hp_free_chunks(info, curr_chunk);
 
245
        }
 
246
        else if (first_chunk)
 
247
        {
 
248
          /* free any chunks previously allocated */
 
249
          hp_free_chunks(info, first_chunk);
 
250
        }
 
251
 
 
252
        return NULL;
 
253
      }
 
254
 
 
255
      /* mark as if this chunk is last in the chunkset */
 
256
      *((unsigned char**) (curr_chunk + info->offset_link))= 0;
 
257
 
 
258
      if (prev_chunk)
 
259
      {
 
260
        /* tie them into a linked list */
 
261
        *((unsigned char**) (prev_chunk + info->offset_link))= curr_chunk;
 
262
        curr_chunk[info->offset_status]= CHUNK_STATUS_LINKED;                   /* Record linked from active */
 
263
      }
 
264
      else
 
265
      {
 
266
        curr_chunk[info->offset_status]= CHUNK_STATUS_ACTIVE;                     /* Record active */
 
267
      }
 
268
 
 
269
      if (!first_chunk)
 
270
      {
 
271
        first_chunk= curr_chunk;
 
272
      }
 
273
 
 
274
      prev_chunk= curr_chunk;
 
275
  }
 
276
 
 
277
  return first_chunk;
 
278
}
 
279
 
 
280
 
 
281
/**
182
282
  Allocate a new chunkset in the dataspace
183
283
 
184
284
  Attempts to allocate a new chunkset
189
289
  @return  Pointer to the first chunk in the new or updated chunkset, or NULL if unsuccessful
190
290
*/
191
291
 
192
 
unsigned char *hp_allocate_chunkset(HP_DATASPACE *info, uint32_t )
 
292
unsigned char *hp_allocate_chunkset(HP_DATASPACE *info, uint32_t chunk_count)
193
293
{
194
294
  unsigned char* result;
195
295
 
196
 
  result= hp_allocate_one_chunk(info);
197
 
  if (result)
198
 
  {
199
 
    result[info->offset_status]= CHUNK_STATUS_ACTIVE;
 
296
 
 
297
  if (info->is_variable_size)
 
298
  {
 
299
    result = hp_allocate_variable_chunkset(info, chunk_count, NULL);
 
300
  }
 
301
  else
 
302
  {
 
303
    result= hp_allocate_one_chunk(info);
 
304
    if (result)
 
305
    {
 
306
      result[info->offset_status]= CHUNK_STATUS_ACTIVE;
 
307
    }
 
308
 
 
309
    return(result);
200
310
  }
201
311
 
202
312
  return(result);
204
314
 
205
315
 
206
316
/**
 
317
  Reallocate an existing chunkset in the dataspace
 
318
 
 
319
  Attempts to change the size of an existing chunkset
 
320
 
 
321
  @param  info            the hosting dataspace
 
322
  @param  chunk_count     the number of chunks that we expect as the result
 
323
  @param  pos             pointer to the existing chunkset
 
324
 
 
325
  @return  Error code or zero if successful
 
326
*/
 
327
 
 
328
int hp_reallocate_chunkset(HP_DATASPACE *info, uint32_t chunk_count, unsigned char* pos)
 
329
{
 
330
 
 
331
  if (!info->is_variable_size)
 
332
  {
 
333
    /* Update should never change chunk_count in fixed-size mode */
 
334
    errno=HA_ERR_WRONG_COMMAND;
 
335
    return errno;
 
336
  }
 
337
 
 
338
  /* Reallocate never moves the first chunk */
 
339
  if (!hp_allocate_variable_chunkset(info, chunk_count, pos))
 
340
    return(errno);
 
341
 
 
342
  return(0);
 
343
}
 
344
 
 
345
 
 
346
/**
207
347
  Allocate a single chunk in the dataspace
208
348
 
209
349
  Attempts to allocate a new chunk or reuse one from deleted list
241
381
 
242
382
  info->chunk_count++;
243
383
  curr_chunk= ((unsigned char*) info->block.level_info[0].last_blocks +
244
 
               block_pos * info->block.recbuffer);
 
384
    block_pos * info->block.recbuffer);
245
385
 
246
386
 
247
387
  return curr_chunk;
262
402
{
263
403
  unsigned char* curr_chunk= pos;
264
404
 
265
 
  if (curr_chunk) 
266
 
  {
 
405
  while (curr_chunk) {
267
406
    info->del_chunk_count++;
268
407
    *((unsigned char**) curr_chunk)= info->del_link;
269
408
    info->del_link= curr_chunk;
270
409
 
271
410
    curr_chunk[info->offset_status]= CHUNK_STATUS_DELETED;
 
411
 
 
412
 
 
413
    if (!info->is_variable_size)
 
414
    {
 
415
      break;
 
416
    }
 
417
 
 
418
    /* Delete next chunk in this chunkset */
 
419
    curr_chunk= *((unsigned char**)(curr_chunk + info->offset_link));
272
420
  }
273
421
}