← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.cc

  • Committer: Brian Aker
  • Date: 2011-01-11 05:13:54 UTC
  • mto: (2075.2.1 drizzle)
  • mto: This revision was merged to the branch mainline in revision 2076.
  • Revision ID: brian@tangent.org-20110111051354-m8ba2xvtjfldrler
First pass through error correction in SE interface for drop table.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/storage_engine.cc
435
435
  return true;
436
436
}
437
437
 
438
 
/**
439
 
   returns ENOENT if the file doesn't exists.
440
 
*/
441
 
int StorageEngine::dropTable(Session& session,
442
 
                             const TableIdentifier &identifier)
443
 
{
444
 
  int error= 0;
445
 
  int error_proto;
446
 
  message::table::shared_ptr src_proto;
447
 
  StorageEngine *engine;
448
 
 
449
 
  error_proto= StorageEngine::getTableDefinition(session, identifier, src_proto);
450
 
 
451
 
  if (error_proto == ER_CORRUPT_TABLE_DEFINITION)
452
 
  {
453
 
    std::string error_message;
454
 
    identifier.getSQLPath(error_message);
455
 
 
456
 
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
457
 
             error_message.c_str(),
458
 
             src_proto->InitializationErrorString().c_str());
459
 
 
460
 
    return ER_CORRUPT_TABLE_DEFINITION;
461
 
  }
462
 
 
463
 
  if (src_proto)
464
 
    engine= StorageEngine::findByName(session, src_proto->engine().name());
465
 
  else
466
 
    engine= StorageEngine::findByName(session, "");
467
 
 
468
 
  if (not engine)
469
 
  {
470
 
    std::string error_message;
471
 
    identifier.getSQLPath(error_message);
472
 
 
473
 
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0), error_message.c_str(), "");
474
 
 
475
 
    return ER_CORRUPT_TABLE_DEFINITION;
476
 
  }
477
 
 
478
 
  error= StorageEngine::dropTable(session, *engine, identifier);
479
 
 
480
 
  if (error_proto && error == 0)
481
 
    return 0;
482
 
 
483
 
  return error;
484
 
}
485
 
 
486
 
int StorageEngine::dropTable(Session& session,
487
 
                             StorageEngine &engine,
488
 
                             const TableIdentifier &identifier)
489
 
{
490
 
  int error;
491
 
 
 
438
class DropTableByIdentifier: public std::unary_function<EngineVector::value_type, bool>
 
439
{
 
440
  Session::reference session;
 
441
  TableIdentifier::const_reference identifier;
 
442
  drizzled::error_t &error;
 
443
 
 
444
public:
 
445
 
 
446
  DropTableByIdentifier(Session::reference session_arg,
 
447
                        TableIdentifier::const_reference identifier_arg,
 
448
                        drizzled::error_t &error_arg) :
 
449
    session(session_arg),
 
450
    identifier(identifier_arg),
 
451
    error(error_arg)
 
452
  { }
 
453
 
 
454
  result_type operator() (argument_type engine)
 
455
  {
 
456
    if (not engine->doDoesTableExist(session, identifier))
 
457
      return false;
 
458
 
 
459
    int local_error= engine->doDropTable(session, identifier);
 
460
 
 
461
 
 
462
    if (not local_error)
 
463
      return true;
 
464
 
 
465
    switch (local_error)
 
466
    {
 
467
    case HA_ERR_NO_SUCH_TABLE:
 
468
    case ENOENT:
 
469
      error= static_cast<drizzled::error_t>(HA_ERR_NO_SUCH_TABLE);
 
470
      return false;
 
471
 
 
472
    default:
 
473
      error= static_cast<drizzled::error_t>(local_error);
 
474
      return true;
 
475
    }
 
476
  } 
 
477
};
 
478
 
 
479
 
 
480
bool StorageEngine::dropTable(Session::reference session,
 
481
                              TableIdentifier::const_reference identifier,
 
482
                              drizzled::error_t &error)
 
483
{
 
484
  error= EE_OK;
 
485
 
 
486
  EngineVector::const_iterator iter= std::find_if(vector_of_engines.begin(), vector_of_engines.end(),
 
487
                                                  DropTableByIdentifier(session, identifier, error));
 
488
 
 
489
  if (error)
 
490
  {
 
491
    return false;
 
492
  }
 
493
  else if (iter == vector_of_engines.end())
 
494
  {
 
495
    error= ER_BAD_TABLE_ERROR;
 
496
    return false;
 
497
  }
 
498
 
 
499
  drizzled::message::Cache::singleton().erase(identifier);
 
500
 
 
501
  return true;
 
502
}
 
503
 
 
504
bool StorageEngine::dropTable(Session& session,
 
505
                              const TableIdentifier &identifier)
 
506
{
 
507
  drizzled::error_t error;
 
508
 
 
509
  if (not dropTable(session, identifier, error))
 
510
  {
 
511
    return false;
 
512
  }
 
513
 
 
514
  return true;
 
515
}
 
516
 
 
517
bool StorageEngine::dropTable(Session::reference session,
 
518
                              StorageEngine &engine,
 
519
                              TableIdentifier::const_reference identifier,
 
520
                              drizzled::error_t &error)
 
521
{
 
522
  error= EE_OK;
492
523
  engine.setTransactionReadWrite(session);
493
524
  
494
525
  if (unlikely(plugin::EventObserver::beforeDropTable(session, identifier)))
497
528
  }
498
529
  else
499
530
  {
500
 
    error= engine.doDropTable(session, identifier);
 
531
    error= static_cast<drizzled::error_t>(engine.doDropTable(session, identifier));
 
532
 
501
533
    if (unlikely(plugin::EventObserver::afterDropTable(session, identifier, error)))
502
534
    {
503
535
      error= ER_EVENT_OBSERVER_PLUGIN;
506
538
 
507
539
  drizzled::message::Cache::singleton().erase(identifier);
508
540
 
509
 
  return error;
 
541
  if (error)
 
542
  {
 
543
    return false;
 
544
  }
 
545
 
 
546
  return true;
510
547
}
511
548
 
512
549
 
554
591
                                                 table_message);
555
592
    }
556
593
 
557
 
    if (error)
 
594
    if (error == ER_TABLE_PERMISSION_DENIED)
 
595
    {
 
596
      my_error(ER_TABLE_PERMISSION_DENIED, identifier);
 
597
    }
 
598
    else if (error)
558
599
    {
559
600
      std::string path;
560
601
      identifier.getSQLPath(path);