← Back to branch summary

~stewart/drizzle/seapitester-state-history

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.cc

  • Committer: Lee Bieber
  • Date: 2011-01-12 04:30:24 UTC
  • mfrom: (2075.1.3 build)
  • Revision ID: kalebral@gmail.com-20110112043024-zgws6jzd54oym9um
Merge Brian - fix bug 527084 - DROP TABLE: getTableDefiniton returns EEXIST but doDropTable returns ENOENT leads to SIGSEGV
Merge Shrews - fix bug 686781 - Transaction message segmenting does not work in all cases 
Merge Stewart - fix bug 376299: sum_distinct-big test fails after resetting max_heap_table_size

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);
 
524
 
 
525
  assert(identifier.isTmp());
493
526
  
494
527
  if (unlikely(plugin::EventObserver::beforeDropTable(session, identifier)))
495
528
  {
497
530
  }
498
531
  else
499
532
  {
500
 
    error= engine.doDropTable(session, identifier);
 
533
    error= static_cast<drizzled::error_t>(engine.doDropTable(session, identifier));
 
534
 
501
535
    if (unlikely(plugin::EventObserver::afterDropTable(session, identifier, error)))
502
536
    {
503
537
      error= ER_EVENT_OBSERVER_PLUGIN;
506
540
 
507
541
  drizzled::message::Cache::singleton().erase(identifier);
508
542
 
509
 
  return error;
 
543
  if (error)
 
544
  {
 
545
    return false;
 
546
  }
 
547
 
 
548
  return true;
510
549
}
511
550
 
512
551
 
554
593
                                                 table_message);
555
594
    }
556
595
 
557
 
    if (error)
 
596
    if (error == ER_TABLE_PERMISSION_DENIED)
 
597
    {
 
598
      my_error(ER_TABLE_PERMISSION_DENIED, identifier);
 
599
    }
 
600
    else if (error)
558
601
    {
559
602
      std::string path;
560
603
      identifier.getSQLPath(path);
763
806
*/
764
807
void StorageEngine::print_error(int error, myf errflag, Table &table)
765
808
{
766
 
  print_error(error, errflag, &table);
767
 
}
768
 
 
769
 
void StorageEngine::print_error(int error, myf errflag, Table *table)
770
 
{
771
809
  drizzled::error_t textno= ER_GET_ERRNO;
772
810
  switch (error) {
773
811
  case EACCES:
789
827
    break;
790
828
  case HA_ERR_FOUND_DUPP_KEY:
791
829
  {
792
 
    assert(table);
793
 
    uint32_t key_nr= table->get_dup_key(error);
 
830
    uint32_t key_nr= table.get_dup_key(error);
794
831
    if ((int) key_nr >= 0)
795
832
    {
796
833
      const char *err_msg= ER(ER_DUP_ENTRY_WITH_KEY_NAME);
797
834
 
798
 
      print_keydup_error(key_nr, err_msg, *table);
 
835
      print_keydup_error(key_nr, err_msg, table);
799
836
 
800
837
      return;
801
838
    }
804
841
  }
805
842
  case HA_ERR_FOREIGN_DUPLICATE_KEY:
806
843
  {
807
 
    assert(table);
808
 
    uint32_t key_nr= table->get_dup_key(error);
 
844
    uint32_t key_nr= table.get_dup_key(error);
809
845
    if ((int) key_nr >= 0)
810
846
    {
811
847
      uint32_t max_length;
815
851
      String str(key,sizeof(key),system_charset_info);
816
852
 
817
853
      /* Table is opened and defined at this point */
818
 
      key_unpack(&str,table,(uint32_t) key_nr);
 
854
      key_unpack(&str, &table,(uint32_t) key_nr);
819
855
      max_length= (DRIZZLE_ERRMSG_SIZE-
820
856
                   (uint32_t) strlen(ER(ER_FOREIGN_DUPLICATE_KEY)));
821
857
      if (str.length() >= max_length)
823
859
        str.length(max_length-4);
824
860
        str.append(STRING_WITH_LEN("..."));
825
861
      }
826
 
      my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table->getShare()->getTableName(),
 
862
      my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table.getShare()->getTableName(),
827
863
        str.c_ptr(), key_nr+1);
828
864
      return;
829
865
    }
900
936
    textno=ER_TABLE_DEF_CHANGED;
901
937
    break;
902
938
  case HA_ERR_NO_SUCH_TABLE:
903
 
    assert(table);
904
 
    my_error(ER_NO_SUCH_TABLE, MYF(0), table->getShare()->getSchemaName(),
905
 
             table->getShare()->getTableName());
 
939
    my_error(ER_NO_SUCH_TABLE, MYF(0), table.getShare()->getSchemaName(),
 
940
             table.getShare()->getTableName());
906
941
    return;
907
942
  case HA_ERR_RBR_LOGGING_FAILED:
908
943
    textno= ER_BINLOG_ROW_LOGGING_FAILED;
909
944
    break;
910
945
  case HA_ERR_DROP_INDEX_FK:
911
946
  {
912
 
    assert(table);
913
947
    const char *ptr= "???";
914
 
    uint32_t key_nr= table->get_dup_key(error);
 
948
    uint32_t key_nr= table.get_dup_key(error);
915
949
    if ((int) key_nr >= 0)
916
 
      ptr= table->key_info[key_nr].name;
 
950
      ptr= table.key_info[key_nr].name;
917
951
    my_error(ER_DROP_INDEX_FK, MYF(0), ptr);
918
952
    return;
919
953
  }
958
992
      return;
959
993
    }
960
994
  }
961
 
  my_error(textno, errflag, table->getShare()->getTableName(), error);
 
995
 
 
996
  my_error(textno, errflag, table.getShare()->getTableName(), error);
962
997
}
963
998
 
964
999