← Back to branch summary

~thomir-deactivatedaccount/drizzle/drizzle-fix-bug653747

« back to all changes in this revision

Viewing changes to plugin/blitzdb/ha_blitz.cc

  • Committer: Brian Aker
  • Date: 2010-10-10 02:07:52 UTC
  • mfrom: (1827.2.3 staging)
  • Revision ID: brian@tangent.org-20101010020752-ktv73isay5dxtvp3
Merge in switch on table_share_instance inheritance.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/blitzdb/ha_blitz.cc
128
128
 
129
129
  /* Temporary fix for blocking composite keys. We need to add this
130
130
     check because version 1 doesn't handle composite indexes. */
131
 
  for (uint32_t i = 0; i < table.getShare()->keys; i++) {
 
131
  for (uint32_t i = 0; i < table.getMutableShare()->keys; i++) {
132
132
    if (table.key_info[i].key_parts > 1)
133
133
      return HA_ERR_UNSUPPORTED;
134
134
  }
142
142
    return ecode;
143
143
 
144
144
  /* Create b+tree index(es) for this table. */
145
 
  for (uint32_t i = 0; i < table.getShare()->keys; i++) {
 
145
  for (uint32_t i = 0; i < table.getMutableShare()->keys; i++) {
146
146
    if ((ecode = btree.create(identifier.getPath().c_str(), i)) != 0)
147
147
      return ecode;
148
148
  }
421
421
     will use to uniquely identify a row. The actual allocation is
422
422
     done by the kernel so all we do here is specify the size of it.*/
423
423
  if (share->primary_key_exists) {
424
 
    ref_length = table->key_info[table->getShare()->getPrimaryKey()].key_length;
 
424
    ref_length = table->key_info[table->getMutableShare()->getPrimaryKey()].key_length;
425
425
  } else {
426
426
    ref_length = sizeof(held_key_len) + sizeof(uint64_t);
427
427
  }
932
932
      /* Now write the new key. */
933
933
      prefix_len = make_index_key(key_buffer, i, new_row);
934
934
 
935
 
      if (i == table->getShare()->getPrimaryKey()) {
 
935
      if (i == table->getMutableShare()->getPrimaryKey()) {
936
936
        key = merge_key(key_buffer, prefix_len, key_buffer, prefix_len, &klen);
937
937
        rv = share->btrees[i].write(key, klen);
938
938
      } else {
959
959
  if (table_based) {
960
960
    rv = share->dict.write_row(held_key, held_key_len, row_buf, row_len);
961
961
  } else {
962
 
    int klen = make_index_key(key_buffer, table->getShare()->getPrimaryKey(), old_row);
 
962
    int klen = make_index_key(key_buffer, table->getMutableShare()->getPrimaryKey(), old_row);
963
963
 
964
964
    /* Delete with the old key. */
965
965
    share->dict.delete_row(key_buffer, klen);
966
966
 
967
967
    /* Write with the new key. */
968
 
    klen = make_index_key(key_buffer, table->getShare()->getPrimaryKey(), new_row);
 
968
    klen = make_index_key(key_buffer, table->getMutableShare()->getPrimaryKey(), new_row);
969
969
    rv = share->dict.write_row(key_buffer, klen, row_buf, row_len);
970
970
  }
971
971
 
1079
1079
  /* Getting here means that there is a PK in this table. Get the
1080
1080
     binary representation of the PK, pack it to BlitzDB's key buffer
1081
1081
     and return the size of it. */
1082
 
  return make_index_key(pack_to, table->getShare()->getPrimaryKey(), row);
 
1082
  return make_index_key(pack_to, table->getMutableShare()->getPrimaryKey(), row);
1083
1083
}
1084
1084
 
1085
1085
size_t ha_blitz::make_index_key(char *pack_to, int key_num,
1240
1240
 
1241
1241
  /* Nothing special to do if the table is fixed length */
1242
1242
  if (share->fixed_length_table) {
1243
 
    memcpy(row_buffer, row_to_pack, table->getShare()->getRecordLength());
1244
 
    return (size_t)table->getShare()->getRecordLength();
 
1243
    memcpy(row_buffer, row_to_pack, table->getMutableShare()->getRecordLength());
 
1244
    return (size_t)table->getMutableShare()->getRecordLength();
1245
1245
  }
1246
1246
 
1247
1247
  /* Copy NULL bits */
1248
 
  memcpy(row_buffer, row_to_pack, table->getShare()->null_bytes);
1249
 
  pos = row_buffer + table->getShare()->null_bytes;
 
1248
  memcpy(row_buffer, row_to_pack, table->getMutableShare()->null_bytes);
 
1249
  pos = row_buffer + table->getMutableShare()->null_bytes;
1250
1250
 
1251
1251
  /* Pack each field into the buffer */
1252
1252
  for (Field **field = table->getFields(); *field; field++) {
1270
1270
  /* Start by copying NULL bits which is the beginning block
1271
1271
     of a Drizzle row. */
1272
1272
  pos = (const unsigned char *)from;
1273
 
  memcpy(to, pos, table->getShare()->null_bytes);
1274
 
  pos += table->getShare()->null_bytes;
 
1273
  memcpy(to, pos, table->getMutableShare()->null_bytes);
 
1274
  pos += table->getMutableShare()->null_bytes;
1275
1275
 
1276
1276
  /* Unpack all fields in the provided row. */
1277
1277
  for (Field **field = table->getFields(); *field; field++) {
1334
1334
 
1335
1335
  /* Prepare Index Structure(s) */
1336
1336
  KeyInfo *curr = &table->getMutableShare()->getKeyInfo(0);
1337
 
  share_ptr->btrees = new BlitzTree[table->getShare()->keys];
 
1337
  share_ptr->btrees = new BlitzTree[table->getMutableShare()->keys];
1338
1338
 
1339
 
  for (uint32_t i = 0; i < table->getShare()->keys; i++, curr++) {
 
1339
  for (uint32_t i = 0; i < table->getMutableShare()->keys; i++, curr++) {
1340
1340
    share_ptr->btrees[i].open(table_path.c_str(), i, BDBOWRITER);
1341
1341
    share_ptr->btrees[i].parts = new BlitzKeyPart[curr->key_parts];
1342
1342
 
1371
1371
  /* Set Meta Data */
1372
1372
  share_ptr->auto_increment_value = share_ptr->dict.read_meta_autoinc();
1373
1373
  share_ptr->table_name = table_path;
1374
 
  share_ptr->nkeys = table->getShare()->keys;
 
1374
  share_ptr->nkeys = table->getMutableShare()->keys;
1375
1375
  share_ptr->use_count = 1;
1376
1376
 
1377
 
  share_ptr->fixed_length_table = !(table->getShare()->db_create_options
 
1377
  share_ptr->fixed_length_table = !(table->getMutableShare()->db_create_options
1378
1378
                                    & HA_OPTION_PACK_RECORD);
1379
1379
 
1380
 
  if (table->getShare()->getPrimaryKey() >= MAX_KEY)
 
1380
  if (table->getMutableShare()->getPrimaryKey() >= MAX_KEY)
1381
1381
    share_ptr->primary_key_exists = false;
1382
1382
  else
1383
1383
    share_ptr->primary_key_exists = true;