← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/heap/hp_create.c

  • Committer: Eric Herman
  • Date: 2008-12-06 19:42:46 UTC
  • mto: (656.1.6 devel)
  • mto: This revision was merged to the branch mainline in revision 665.
  • Revision ID: eric@mysql.com-20081206194246-5cdexuu81i366eek
removed trailing whitespace with simple script:

for file in $(find . -name "*.c") $(find . -name "*.cc") $(find . -name "*.h"); do ruby -pe 'gsub(/\s+$/, $/)' < $file > $file.out; mv $file.out $file; done;

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/heap/hp_create.c
26
26
 
27
27
#define FIXED_REC_OVERHEAD (sizeof(unsigned char))
28
28
#define VARIABLE_REC_OVERHEAD (sizeof(unsigned char**) + sizeof(unsigned char))
29
 
 
 
29
 
30
30
/* Minimum size that a chunk can take, 12 bytes on 32bit, 24 bytes on 64bit */
31
31
#define VARIABLE_MIN_CHUNK_SIZE \
32
32
        ((sizeof(unsigned char**) + VARIABLE_REC_OVERHEAD + sizeof(unsigned char**) - 1) & ~(sizeof(unsigned char**) - 1))
54
54
      hp_free(share);
55
55
      share= 0;
56
56
    }
57
 
  }  
 
57
  }
58
58
 
59
59
  if (!share)
60
60
  {
176
176
    chunk_length= (uint) (chunk_length + sizeof(unsigned char**) - 1) & ~(sizeof(unsigned char**) - 1);
177
177
 
178
178
 
179
 
    
 
179
 
180
180
    for (i= key_segs= max_length= 0, keyinfo= keydef; i < keys; i++, keyinfo++)
181
181
    {
182
182
      memset(&keyinfo->block, 0, sizeof(keyinfo->block));
235
235
        }
236
236
      }
237
237
      keyinfo->length= length;
238
 
      length+= keyinfo->rb_tree.size_of_element + 
 
238
      length+= keyinfo->rb_tree.size_of_element +
239
239
               ((keyinfo->algorithm == HA_KEY_ALG_BTREE) ? sizeof(unsigned char*) : 0);
240
240
      if (length > max_length)
241
241
        max_length= length;
265
265
    */
266
266
    max_rows_for_stated_memory= (ha_rows) (create_info->max_table_size /
267
267
      (keys_memory_size + chunk_length));
268
 
    max_records = ((max_records && max_records < max_rows_for_stated_memory) ? 
 
268
    max_records = ((max_records && max_records < max_rows_for_stated_memory) ?
269
269
                      max_records : max_rows_for_stated_memory);
270
 
 
 
270
 
271
271
    share->column_defs= (HP_COLUMNDEF*) (share + 1);
272
272
    memcpy(share->column_defs, columndef, (size_t) (sizeof(columndef[0]) * columns));
273
273
 
274
 
    share->keydef= (HP_KEYDEF*) (share->column_defs + columns);    
 
274
    share->keydef= (HP_KEYDEF*) (share->column_defs + columns);
275
275
    share->key_stat_version= 1;
276
276
    keyseg= (HA_KEYSEG*) (share->keydef + keys);
277
277
    init_block(&share->recordspace.block, chunk_length, min_records, max_records);
370
370
static int keys_compare(heap_rb_param *param, unsigned char *key1, unsigned char *key2)
371
371
{
372
372
  uint32_t not_used[2];
373
 
  return ha_key_cmp(param->keyseg, key1, key2, param->key_length, 
 
373
  return ha_key_cmp(param->keyseg, key1, key2, param->key_length,
374
374
                    param->search_flag, not_used);
375
375
}
376
376
 
382
382
  max_records= cmax(min_records,max_records);
383
383
  if (!max_records)
384
384
    max_records= 1000;                  /* As good as quess as anything */
385
 
  
 
385
 
386
386
  /* we want to start each chunk at 8 bytes boundary, round recbuffer to the next 8 */
387
 
  recbuffer= (uint) (chunk_length + sizeof(unsigned char**) - 1) & ~(sizeof(unsigned char**) - 1);  
 
387
  recbuffer= (uint) (chunk_length + sizeof(unsigned char**) - 1) & ~(sizeof(unsigned char**) - 1);
388
388
  records_in_block= max_records / 10;
389
389
  if (records_in_block < 10 && max_records)
390
390
    records_in_block= 10;