← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handler.cc

  • Committer: Monty Taylor
  • Date: 2009-03-24 21:22:31 UTC
  • mto: (960.5.2 mordred)
  • mto: This revision was merged to the branch mainline in revision 964.
  • Revision ID: mordred@inaugust.com-20090324212231-5bvd7qlj4yj88ha6
Reworked transformed handlerton into class StorageEngine.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/handler.cc
189
189
                              void *path)
190
190
{
191
191
  StorageEngine *engine= plugin_data(plugin, StorageEngine *);
192
 
  if (engine->state == SHOW_OPTION_YES && engine->drop_database)
 
192
  if (engine->state == SHOW_OPTION_YES)
193
193
    engine->drop_database(engine, (char *)path);
194
194
  return false;
195
195
}
209
209
    there's no need to rollback here as all transactions must
210
210
    be rolled back already
211
211
  */
212
 
  if (engine->state == SHOW_OPTION_YES && engine->close_connection &&
 
212
  if (engine->state == SHOW_OPTION_YES && 
213
213
      session_get_ha_data(session, engine))
214
214
    engine->close_connection(engine, session);
215
215
  return false;
531
531
    times per transaction.
532
532
 
533
533
*/
534
 
void trans_register_ha(Session *session, bool all, StorageEngine *ht_arg)
 
534
void trans_register_ha(Session *session, bool all, StorageEngine *engine)
535
535
{
536
536
  Session_TRANS *trans;
537
537
  Ha_trx_info *ha_info;
544
544
  else
545
545
    trans= &session->transaction.stmt;
546
546
 
547
 
  ha_info= session->ha_data[ht_arg->slot].ha_info + static_cast<unsigned>(all);
 
547
  ha_info= session->ha_data[engine->slot].ha_info + static_cast<unsigned>(all);
548
548
 
549
549
  if (ha_info->is_started())
550
550
    return; /* already registered, return */
551
551
 
552
 
  ha_info->register_ha(trans, ht_arg);
 
552
  ha_info->register_ha(trans, engine);
553
553
 
554
 
  trans->no_2pc|=(ht_arg->prepare==0);
 
554
  trans->no_2pc|= not engine->has_2pc();
555
555
  if (session->transaction.xid_state.xid.is_null())
556
556
    session->transaction.xid_state.xid.set(session->query_id);
557
557
 
574
574
    for (; ha_info; ha_info= ha_info->next())
575
575
    {
576
576
      int err;
577
 
      StorageEngine *ht= ha_info->ht();
 
577
      StorageEngine *engine= ha_info->ht();
578
578
      status_var_increment(session->status_var.ha_prepare_count);
579
 
      if (ht->prepare)
 
579
      if ((err= engine->prepare(engine, session, all)))
580
580
      {
581
 
        if ((err= ht->prepare(ht, session, all)))
582
 
        {
583
 
          my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
584
 
          ha_rollback_trans(session, all);
585
 
          error=1;
586
 
          break;
587
 
        }
 
581
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
 
582
        ha_rollback_trans(session, all);
 
583
        error=1;
 
584
        break;
588
585
      }
589
586
      else
590
587
      {
591
588
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
592
589
                            ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
593
 
                            ha_resolve_storage_engine_name(ht));
 
590
                            ha_resolve_storage_engine_name(engine));
594
591
      }
595
592
    }
596
593
  }
704
701
      for (; ha_info && !error; ha_info= ha_info->next())
705
702
      {
706
703
        int err;
707
 
        StorageEngine *ht= ha_info->ht();
 
704
        StorageEngine *engine= ha_info->ht();
708
705
        /*
709
706
          Do not call two-phase commit if this particular
710
707
          transaction is read-only. This allows for simpler
716
713
          Sic: we know that prepare() is not NULL since otherwise
717
714
          trans->no_2pc would have been set.
718
715
        */
719
 
        if ((err= ht->prepare(ht, session, all)))
 
716
        if ((err= engine->prepare(engine, session, all)))
720
717
        {
721
718
          my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
722
719
          error= 1;
753
750
    for (; ha_info; ha_info= ha_info_next)
754
751
    {
755
752
      int err;
756
 
      StorageEngine *ht= ha_info->ht();
757
 
      if ((err= ht->commit(ht, session, all)))
 
753
      StorageEngine *engine= ha_info->ht();
 
754
      if ((err= engine->commit(engine, session, all)))
758
755
      {
759
756
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
760
757
        error=1;
796
793
    for (; ha_info; ha_info= ha_info_next)
797
794
    {
798
795
      int err;
799
 
      StorageEngine *ht= ha_info->ht();
800
 
      if ((err= ht->rollback(ht, session, all)))
 
796
      StorageEngine *engine= ha_info->ht();
 
797
      if ((err= engine->rollback(engine, session, all)))
801
798
      { // cannot happen
802
799
        my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
803
800
        error=1;
878
875
                                void *arg)
879
876
{
880
877
  StorageEngine *engine= plugin_data(plugin, StorageEngine *);
881
 
  if (engine->state == SHOW_OPTION_YES && engine->recover)
 
878
  if (engine->state == SHOW_OPTION_YES)
882
879
  {
883
880
    engine->commit_by_xid(engine, ((struct xahton_st *)arg)->xid);
884
881
    ((struct xahton_st *)arg)->result= 0;
891
888
                                  void *arg)
892
889
{
893
890
  StorageEngine *engine= plugin_data(plugin, StorageEngine *);
894
 
  if (engine->state == SHOW_OPTION_YES && engine->recover)
 
891
  if (engine->state == SHOW_OPTION_YES)
895
892
  {
896
893
    engine->rollback_by_xid(engine, ((struct xahton_st *)arg)->xid);
897
894
    ((struct xahton_st *)arg)->result= 0;
944
941
  struct xarecover_st *info= (struct xarecover_st *) arg;
945
942
  int got;
946
943
 
947
 
  if (engine->state == SHOW_OPTION_YES && engine->recover)
 
944
  if (engine->state == SHOW_OPTION_YES)
948
945
  {
949
946
    while ((got= engine->recover(engine, info->list, info->len)) > 0 )
950
947
    {
1122
1119
{
1123
1120
  StorageEngine *engine= plugin_data(plugin, StorageEngine *);
1124
1121
 
1125
 
  if (engine->state == SHOW_OPTION_YES && engine->release_temporary_latches)
 
1122
  if (engine->state == SHOW_OPTION_YES)
1126
1123
    engine->release_temporary_latches(engine, session);
1127
1124
 
1128
1125
  return false;
1151
1148
  for (ha_info= sv->ha_list; ha_info; ha_info= ha_info->next())
1152
1149
  {
1153
1150
    int err;
1154
 
    StorageEngine *ht= ha_info->ht();
1155
 
    assert(ht);
1156
 
    assert(ht->savepoint_set != 0);
1157
 
    if ((err= ht->savepoint_rollback(ht, session,
1158
 
                                     (unsigned char *)(sv+1)+ht->savepoint_offset)))
 
1151
    StorageEngine *engine= ha_info->ht();
 
1152
    assert(engine);
 
1153
    if ((err= engine->savepoint_rollback(engine, session,
 
1154
                                     (unsigned char *)(sv+1)+engine->savepoint_offset)))
1159
1155
    { // cannot happen
1160
1156
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
1161
1157
      error=1;
1162
1158
    }
1163
1159
    status_var_increment(session->status_var.ha_savepoint_rollback_count);
1164
 
    trans->no_2pc|= ht->prepare == 0;
 
1160
    trans->no_2pc|= not engine->has_2pc();
1165
1161
  }
1166
1162
  /*
1167
1163
    rolling back the transaction in all storage engines that were not part of
1171
1167
       ha_info= ha_info_next)
1172
1168
  {
1173
1169
    int err;
1174
 
    StorageEngine *ht= ha_info->ht();
1175
 
    if ((err= ht->rollback(ht, session, !(0))))
 
1170
    StorageEngine *engine= ha_info->ht();
 
1171
    if ((err= engine->rollback(engine, session, !(0))))
1176
1172
    { // cannot happen
1177
1173
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
1178
1174
      error=1;
1199
1195
  for (; ha_info; ha_info= ha_info->next())
1200
1196
  {
1201
1197
    int err;
1202
 
    StorageEngine *ht= ha_info->ht();
1203
 
    assert(ht);
1204
 
    if (! ht->savepoint_set)
 
1198
    StorageEngine *engine= ha_info->ht();
 
1199
    assert(engine);
 
1200
/*    if (! engine->savepoint_set)
1205
1201
    {
1206
1202
      my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "SAVEPOINT");
1207
1203
      error=1;
1208
1204
      break;
1209
 
    }
1210
 
    if ((err= ht->savepoint_set(ht, session, (unsigned char *)(sv+1)+ht->savepoint_offset)))
 
1205
    } */
 
1206
    if ((err= engine->savepoint_set(engine, session, (unsigned char *)(sv+1)+engine->savepoint_offset)))
1211
1207
    { // cannot happen
1212
1208
      my_error(ER_GET_ERRNO, MYF(0), err);
1213
1209
      error=1;
1230
1226
  for (; ha_info; ha_info= ha_info->next())
1231
1227
  {
1232
1228
    int err;
1233
 
    StorageEngine *ht= ha_info->ht();
 
1229
    StorageEngine *engine= ha_info->ht();
1234
1230
    /* Savepoint life time is enclosed into transaction life time. */
1235
 
    assert(ht);
1236
 
    if (!ht->savepoint_release)
1237
 
      continue;
1238
 
    if ((err= ht->savepoint_release(ht, session,
1239
 
                                    (unsigned char *)(sv+1) + ht->savepoint_offset)))
 
1231
    assert(engine);
 
1232
    if ((err= engine->savepoint_release(engine, session,
 
1233
                                    (unsigned char *)(sv+1) + engine->savepoint_offset)))
1240
1234
    { // cannot happen
1241
1235
      my_error(ER_GET_ERRNO, MYF(0), err);
1242
1236
      error=1;
1249
1243
static bool snapshot_handlerton(Session *session, plugin_ref plugin, void *arg)
1250
1244
{
1251
1245
  StorageEngine *engine= plugin_data(plugin, StorageEngine *);
1252
 
  if (engine->state == SHOW_OPTION_YES &&
1253
 
      engine->start_consistent_snapshot)
 
1246
  if (engine->state == SHOW_OPTION_YES)
1254
1247
  {
1255
1248
    engine->start_consistent_snapshot(engine, session);
1256
1249
    *((bool *)arg)= false;
1281
1274
                             void *)
1282
1275
{
1283
1276
  StorageEngine *engine= plugin_data(plugin, StorageEngine *);
1284
 
  if (engine->state == SHOW_OPTION_YES && engine->flush_logs &&
 
1277
  if (engine->state == SHOW_OPTION_YES &&
1285
1278
      engine->flush_logs(engine))
1286
1279
    return true;
1287
1280
  return false;
1288
1281
}
1289
1282
 
1290
1283
 
1291
 
bool ha_flush_logs(StorageEngine *db_type)
 
1284
bool ha_flush_logs(StorageEngine *engine)
1292
1285
{
1293
 
  if (db_type == NULL)
 
1286
  if (engine == NULL)
1294
1287
  {
1295
1288
    if (plugin_foreach(NULL, flush_handlerton,
1296
1289
                          DRIZZLE_STORAGE_ENGINE_PLUGIN, 0))
1298
1291
  }
1299
1292
  else
1300
1293
  {
1301
 
    if (db_type->state != SHOW_OPTION_YES ||
1302
 
        (db_type->flush_logs && db_type->flush_logs(db_type)))
 
1294
    if (engine->state != SHOW_OPTION_YES ||
 
1295
        (engine->flush_logs(engine)))
1303
1296
      return true;
1304
1297
  }
1305
1298
  return false;
1382
1375
  if(!table_type)
1383
1376
    return false;
1384
1377
 
1385
 
  if(!(table_type->state == SHOW_OPTION_YES && table_type->create))
 
1378
  if(!(table_type->state == SHOW_OPTION_YES))
1386
1379
    return false;
1387
1380
 
1388
1381
  if ((file= table_type->create(table_type, NULL, session->mem_root)))
3006
2999
 
3007
3000
  int err= HA_ERR_NO_SUCH_TABLE;
3008
3001
 
3009
 
  if (engine->state == SHOW_OPTION_YES && engine->table_exists_in_engine)
 
3002
  if (engine->state == SHOW_OPTION_YES)
3010
3003
    err = engine->table_exists_in_engine(engine, session, vargs->db, vargs->name);
3011
3004
 
3012
3005
  vargs->err = err;
4091
4084
  List<char> *found_exts= (List<char> *) arg;
4092
4085
  StorageEngine *engine= plugin_data(plugin, StorageEngine *);
4093
4086
  handler *file;
4094
 
  if (engine->state == SHOW_OPTION_YES && engine->create &&
 
4087
  if (engine->state == SHOW_OPTION_YES &&
4095
4088
      (file= engine->create(engine, (TABLE_SHARE*) 0, current_session->mem_root)))
4096
4089
  {
4097
4090
    List_iterator_fast<char> it(*found_exts);
4157
4150
  return false;
4158
4151
}
4159
4152
 
4160
 
bool ha_show_status(Session *session, StorageEngine *db_type, enum ha_stat_type stat)
 
4153
bool ha_show_status(Session *session, StorageEngine *engine, enum ha_stat_type stat)
4161
4154
{
4162
4155
  List<Item> field_list;
4163
4156
  Protocol *protocol= session->protocol;
4171
4164
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
4172
4165
    return true;
4173
4166
 
4174
 
  result= db_type->show_status &&
4175
 
    db_type->show_status(db_type, session, stat_print, stat) ? 1 : 0;
 
4167
  result= engine->show_status(engine, session, stat_print, stat) ? 1 : 0;
4176
4168
 
4177
4169
  if (!result)
4178
4170
    session->my_eof();