← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/blitzdb/ha_blitz.cc

  • Committer: Brian Aker
  • Date: 2010-10-22 23:33:58 UTC
  • mfrom: (1869.1.7 refactor)
  • Revision ID: brian@tangent.org-20101022233358-kmtrpm1yvmmyaame
Merge in overhaul to how cursor and table are handled. Cursor now only knows
about table, and will always have a table and engine reference.

This cleans up a number of ownership issues, the biggest being that it now
creates the space needed for the next big refactor in locks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/blitzdb/ha_blitz.cc
54
54
    tcmapdel(blitz_table_cache);
55
55
  }
56
56
 
57
 
  virtual drizzled::Cursor *create(drizzled::TableShare &table) {
 
57
  virtual drizzled::Cursor *create(drizzled::Table &table) {
58
58
    return new ha_blitz(*this, table);
59
59
  }
60
60
 
365
365
}
366
366
 
367
367
ha_blitz::ha_blitz(drizzled::plugin::StorageEngine &engine_arg,
368
 
                   TableShare &table_arg) : Cursor(engine_arg, table_arg),
 
368
                   Table &table_arg) : Cursor(engine_arg, table_arg),
369
369
                                            btree_cursor(NULL),
370
370
                                            table_scan(false),
371
371
                                            table_based(false),
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 = getTable()->key_info[getTable()->getShare()->getPrimaryKey()].key_length;
425
425
  } else {
426
426
    ref_length = sizeof(held_key_len) + sizeof(uint64_t);
427
427
  }
460
460
 
461
461
int ha_blitz::doStartTableScan(bool scan) {
462
462
  /* Obtain the query type for this scan */
463
 
  sql_command_type = session_sql_command(table->getSession());
 
463
  sql_command_type = session_sql_command(getTable()->getSession());
464
464
  table_scan = scan;
465
465
  table_based = true;
466
466
 
488
488
  held_key = NULL;
489
489
 
490
490
  if (current_key == NULL) {
491
 
    table->status = STATUS_NOT_FOUND;
 
491
    getTable()->status = STATUS_NOT_FOUND;
492
492
    return HA_ERR_END_OF_FILE;
493
493
  }
494
494
 
519
519
  /* It is now memory-leak-safe to point current_key to next_key. */
520
520
  current_key = next_key;
521
521
  current_key_len = next_key_len;
522
 
  table->status = 0;
 
522
  getTable()->status = 0;
523
523
  return 0;
524
524
}
525
525
 
585
585
 
586
586
int ha_blitz::doStartIndexScan(uint32_t key_num, bool) {
587
587
  active_index = key_num;
588
 
  sql_command_type = session_sql_command(table->getSession());
 
588
  sql_command_type = session_sql_command(getTable()->getSession());
589
589
 
590
590
  /* This is unlikely to happen but just for assurance, re-obtain
591
591
     the lock if this thread already has a certain lock. This makes
630
630
  bt_key = btree_cursor[active_index].next_key(&bt_klen);
631
631
 
632
632
  if (bt_key == NULL) {
633
 
    table->status = STATUS_NOT_FOUND;
 
633
    getTable()->status = STATUS_NOT_FOUND;
634
634
    return HA_ERR_END_OF_FILE;
635
635
  }
636
636
 
639
639
 
640
640
  if ((row = share->dict.get_row(dict_key, dict_klen, &rlen)) == NULL) {
641
641
    free(bt_key);
642
 
    table->status = STATUS_NOT_FOUND;
 
642
    getTable()->status = STATUS_NOT_FOUND;
643
643
    return HA_ERR_KEY_NOT_FOUND;
644
644
  }
645
645
 
794
794
  ha_statistic_increment(&system_status_var::ha_write_count);
795
795
 
796
796
  /* Prepare Auto Increment field if one exists. */
797
 
  if (table->next_number_field && drizzle_row == table->getInsertRecord()) {
 
797
  if (getTable()->next_number_field && drizzle_row == getTable()->getInsertRecord()) {
798
798
    pthread_mutex_lock(&blitz_utility_mutex);
799
799
    if ((rv = update_auto_increment()) != 0) {
800
800
      pthread_mutex_unlock(&blitz_utility_mutex);
801
801
      return rv;
802
802
    }
803
803
 
804
 
    uint64_t next_val = table->next_number_field->val_int();
 
804
    uint64_t next_val = getTable()->next_number_field->val_int();
805
805
 
806
806
    if (next_val > share->auto_increment_value) {
807
807
      share->auto_increment_value = next_val;
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 == getTable()->getShare()->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, getTable()->getShare()->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, getTable()->getShare()->getPrimaryKey(), new_row);
969
969
    rv = share->dict.write_row(key_buffer, klen, row_buf, row_len);
970
970
  }
971
971
 
1057
1057
}
1058
1058
 
1059
1059
uint32_t ha_blitz::max_row_length(void) {
1060
 
  uint32_t length = (table->getRecordLength() + table->sizeFields() * 2);
1061
 
  uint32_t *pos = table->getBlobField();
1062
 
  uint32_t *end = pos + table->sizeBlobFields();
 
1060
  uint32_t length = (getTable()->getRecordLength() + getTable()->sizeFields() * 2);
 
1061
  uint32_t *pos = getTable()->getBlobField();
 
1062
  uint32_t *end = pos + getTable()->sizeBlobFields();
1063
1063
 
1064
1064
  while (pos != end) {
1065
 
    length += 2 + ((Field_blob *)table->getField(*pos))->get_length();
 
1065
    length += 2 + ((Field_blob *)getTable()->getField(*pos))->get_length();
1066
1066
    pos++;
1067
1067
  }
1068
1068
 
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, getTable()->getShare()->getPrimaryKey(), row);
1083
1083
}
1084
1084
 
1085
1085
size_t ha_blitz::make_index_key(char *pack_to, int key_num,
1086
1086
                                const unsigned char *row) {
1087
 
  KeyInfo *key = &table->key_info[key_num];
 
1087
  KeyInfo *key = &getTable()->key_info[key_num];
1088
1088
  KeyPartInfo *key_part = key->key_part;
1089
1089
  KeyPartInfo *key_part_end = key_part + key->key_parts;
1090
1090
 
1145
1145
}
1146
1146
 
1147
1147
size_t ha_blitz::btree_key_length(const char *key, const int key_num) {
1148
 
  KeyInfo *key_info = &table->key_info[key_num];
 
1148
  KeyInfo *key_info = &getTable()->key_info[key_num];
1149
1149
  KeyPartInfo *key_part = key_info->key_part;
1150
1150
  KeyPartInfo *key_part_end = key_part + key_info->key_parts;
1151
1151
  char *pos = (char *)key;
1185
1185
/* Converts a native Drizzle index key to BlitzDB's format. */
1186
1186
char *ha_blitz::native_to_blitz_key(const unsigned char *native_key,
1187
1187
                                    const int key_num, int *return_key_len) {
1188
 
  KeyInfo *key = &table->key_info[key_num];
 
1188
  KeyInfo *key = &getTable()->key_info[key_num];
1189
1189
  KeyPartInfo *key_part = key->key_part;
1190
1190
  KeyPartInfo *key_part_end = key_part + key->key_parts;
1191
1191
 
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, getTable()->getShare()->getRecordLength());
 
1244
    return (size_t)getTable()->getShare()->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, getTable()->getShare()->null_bytes);
 
1249
  pos = row_buffer + getTable()->getShare()->null_bytes;
1250
1250
 
1251
1251
  /* Pack each field into the buffer */
1252
 
  for (Field **field = table->getFields(); *field; field++) {
 
1252
  for (Field **field = getTable()->getFields(); *field; field++) {
1253
1253
    if (!((*field)->is_null()))
1254
1254
      pos = (*field)->pack(pos, row_to_pack + (*field)->offset(row_to_pack));
1255
1255
  }
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, getTable()->getShare()->null_bytes);
 
1274
  pos += getTable()->getShare()->null_bytes;
1275
1275
 
1276
1276
  /* Unpack all fields in the provided row. */
1277
 
  for (Field **field = table->getFields(); *field; field++) {
 
1277
  for (Field **field = getTable()->getFields(); *field; field++) {
1278
1278
    if (!((*field)->is_null())) {
1279
 
      pos = (*field)->unpack(to + (*field)->offset(table->getInsertRecord()), pos);
 
1279
      pos = (*field)->unpack(to + (*field)->offset(getTable()->getInsertRecord()), pos);
1280
1280
    }
1281
1281
  }
1282
1282
 
1308
1308
 
1309
1309
BlitzShare *ha_blitz::get_share(const char *name) {
1310
1310
  BlitzShare *share_ptr;
1311
 
  BlitzEngine *bz_engine = (BlitzEngine *)engine;
 
1311
  BlitzEngine *bz_engine = (BlitzEngine *)getEngine();
1312
1312
  std::string table_path(name);
1313
1313
 
1314
1314
  pthread_mutex_lock(&blitz_utility_mutex);
1333
1333
  }
1334
1334
 
1335
1335
  /* Prepare Index Structure(s) */
1336
 
  KeyInfo *curr = &table->getMutableShare()->getKeyInfo(0);
1337
 
  share_ptr->btrees = new BlitzTree[table->getShare()->keys];
 
1336
  KeyInfo *curr = &getTable()->getMutableShare()->getKeyInfo(0);
 
1337
  share_ptr->btrees = new BlitzTree[getTable()->getShare()->keys];
1338
1338
 
1339
 
  for (uint32_t i = 0; i < table->getShare()->keys; i++, curr++) {
 
1339
  for (uint32_t i = 0; i < getTable()->getShare()->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
 
1343
 
    if (table->key_info[i].flags & HA_NOSAME)
 
1343
    if (getTable()->key_info[i].flags & HA_NOSAME)
1344
1344
      share_ptr->btrees[i].unique = true;
1345
1345
 
1346
1346
    share_ptr->btrees[i].length = curr->key_length;
1353
1353
      if (f->null_ptr) {
1354
1354
        share_ptr->btrees[i].parts[j].null_bitmask = f->null_bit;
1355
1355
        share_ptr->btrees[i].parts[j].null_pos
1356
 
          = (uint32_t)(f->null_ptr - (unsigned char *)table->getInsertRecord());
 
1356
          = (uint32_t)(f->null_ptr - (unsigned char *)getTable()->getInsertRecord());
1357
1357
      }
1358
1358
 
1359
1359
      share_ptr->btrees[i].parts[j].flag = curr->key_part[j].key_part_flag;
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 = getTable()->getShare()->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 = !(getTable()->getShare()->db_create_options
1378
1378
                                    & HA_OPTION_PACK_RECORD);
1379
1379
 
1380
 
  if (table->getShare()->getPrimaryKey() >= MAX_KEY)
 
1380
  if (getTable()->getShare()->getPrimaryKey() >= MAX_KEY)
1381
1381
    share_ptr->primary_key_exists = false;
1382
1382
  else
1383
1383
    share_ptr->primary_key_exists = true;
1408
1408
      share->btrees[i].close();
1409
1409
    }
1410
1410
 
1411
 
    BlitzEngine *bz_engine = (BlitzEngine *)engine;
 
1411
    BlitzEngine *bz_engine = (BlitzEngine *)getEngine();
1412
1412
    bz_engine->deleteTableShare(share->table_name);
1413
1413
 
1414
1414
    delete[] share->btrees;