← 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: 2010-03-31 05:53:34 UTC
  • Revision ID: brian@gaz-20100331055334-yqqmzlgqb2xq1p5b
Mass overhaul to use schema_identifier.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/storage_engine.cc
48
48
#include "drizzled/xid.h"
49
49
#include "drizzled/sql_table.h"
50
50
#include "drizzled/global_charset_info.h"
51
 
#include "drizzled/plugin/authorization.h"
52
51
#include "drizzled/charset.h"
53
52
#include "drizzled/internal/my_sys.h"
54
53
#include "drizzled/db.h"
73
72
 
74
73
static std::set<std::string> set_of_table_definition_ext;
75
74
 
 
75
EngineVector &StorageEngine::getSchemaEngines()
 
76
{
 
77
  return vector_of_schema_engines;
 
78
}
 
79
 
76
80
StorageEngine::StorageEngine(const string name_arg,
77
81
                             const bitset<HTON_BIT_SIZE> &flags_arg) :
78
82
  Plugin(name_arg, "StorageEngine"),
481
485
{
482
486
  int error= 1;
483
487
  Table table;
484
 
  TableShare share(identifier.getDBName().c_str(), 0, identifier.getTableName().c_str(), identifier.getPath().c_str());
 
488
  TableShare share(identifier.getSchemaName().c_str(), 0, identifier.getTableName().c_str(), identifier.getPath().c_str());
485
489
  message::Table tmp_proto;
486
490
 
487
491
  if (parse_table_proto(session, table_message, &share) || open_table_from_share(&session, &share, "", 0, 0, &table))
534
538
/**
535
539
  TODO -> Remove this to force all engines to implement their own file. Solves the "we only looked at dfe" problem.
536
540
*/
537
 
void StorageEngine::doGetTableNames(CachedDirectory&, string&, set<string>&)
 
541
void StorageEngine::doGetTableNames(CachedDirectory&, SchemaIdentifier&, set<string>&)
538
542
{ }
539
543
 
540
544
class AddTableName : 
541
545
  public unary_function<StorageEngine *, void>
542
546
{
543
 
  string db;
544
 
  CachedDirectory& directory;
 
547
  CachedDirectory &directory;
 
548
  SchemaIdentifier &identifier;
545
549
  TableNameList &set_of_names;
546
550
 
547
551
public:
548
552
 
549
 
  AddTableName(CachedDirectory& directory_arg, const string& database_name, set<string>& of_names) :
 
553
  AddTableName(CachedDirectory &directory_arg, SchemaIdentifier &identifier_arg, set<string>& of_names) :
550
554
    directory(directory_arg),
551
 
    set_of_names(of_names)
552
 
  {
553
 
    db= database_name;
554
 
  }
555
 
 
556
 
  result_type operator() (argument_type engine)
557
 
  {
558
 
    engine->doGetTableNames(directory, db, set_of_names);
559
 
  }
560
 
};
561
 
 
562
 
class AddSchemaNames : 
563
 
  public unary_function<StorageEngine *, void>
564
 
{
565
 
  SchemaNameList &set_of_names;
566
 
 
567
 
public:
568
 
 
569
 
  AddSchemaNames(set<string>& of_names) :
570
 
    set_of_names(of_names)
571
 
  {
572
 
  }
573
 
 
574
 
  result_type operator() (argument_type engine)
575
 
  {
576
 
    engine->doGetSchemaNames(set_of_names);
577
 
  }
578
 
};
579
 
 
580
 
void StorageEngine::getSchemaNames(Session &session, SchemaNameList &set_of_names)
581
 
{
582
 
  // Add hook here for engines to register schema.
583
 
  for_each(vector_of_schema_engines.begin(), vector_of_schema_engines.end(),
584
 
           AddSchemaNames(set_of_names));
585
 
 
586
 
  plugin::Authorization::pruneSchemaNames(session.getSecurityContext(),
587
 
                                          set_of_names);
588
 
}
589
 
 
590
 
class StorageEngineGetSchemaDefinition: public unary_function<StorageEngine *, bool>
591
 
{
592
 
  std::string schema_name;
593
 
  message::Schema &schema_proto;
594
 
 
595
 
public:
596
 
  StorageEngineGetSchemaDefinition(const std::string schema_name_arg,
597
 
                                   message::Schema &schema_proto_arg) :
598
 
    schema_name(schema_name_arg),
599
 
    schema_proto(schema_proto_arg) 
600
 
  {
601
 
    transform(schema_name.begin(), schema_name.end(),
602
 
              schema_name.begin(), ::tolower);
603
 
  }
604
 
 
605
 
  result_type operator() (argument_type engine)
606
 
  {
607
 
    return engine->doGetSchemaDefinition(schema_name, schema_proto);
608
 
  }
609
 
};
610
 
 
611
 
/*
612
 
  Return value is "if parsed"
613
 
*/
614
 
bool StorageEngine::getSchemaDefinition(TableIdentifier &identifier, message::Schema &proto)
615
 
{
616
 
  return StorageEngine::getSchemaDefinition(identifier.getSchemaName(), proto);
617
 
}
618
 
 
619
 
bool StorageEngine::getSchemaDefinition(const std::string &schema_name, message::Schema &proto)
620
 
{
621
 
  proto.Clear();
622
 
 
623
 
  EngineVector::iterator iter=
624
 
    find_if(vector_of_schema_engines.begin(), vector_of_schema_engines.end(),
625
 
            StorageEngineGetSchemaDefinition(schema_name, proto));
626
 
 
627
 
  if (iter != vector_of_schema_engines.end())
628
 
  {
629
 
    return true;
630
 
  }
631
 
 
632
 
  return false;
633
 
}
634
 
 
635
 
bool StorageEngine::doesSchemaExist(const std::string &schema_name)
636
 
{
637
 
  message::Schema proto;
638
 
 
639
 
  return StorageEngine::getSchemaDefinition(schema_name, proto);
640
 
}
641
 
 
642
 
bool StorageEngine::doesSchemaExist(TableIdentifier &identifier)
643
 
{
644
 
  message::Schema proto;
645
 
 
646
 
  return StorageEngine::getSchemaDefinition(identifier.getSchemaName(), proto);
647
 
}
648
 
 
649
 
 
650
 
const CHARSET_INFO *StorageEngine::getSchemaCollation(const std::string &schema_name)
651
 
{
652
 
  message::Schema schmema_proto;
653
 
  bool found;
654
 
 
655
 
  found= StorageEngine::getSchemaDefinition(schema_name, schmema_proto);
656
 
 
657
 
  if (found && schmema_proto.has_collation())
658
 
  {
659
 
    const string buffer= schmema_proto.collation();
660
 
    const CHARSET_INFO* cs= get_charset_by_name(buffer.c_str());
661
 
 
662
 
    if (not cs)
663
 
    {
664
 
      errmsg_printf(ERRMSG_LVL_ERROR,
665
 
                    _("Error while loading database options: '%s':"), schema_name.c_str());
666
 
      errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_UNKNOWN_COLLATION), buffer.c_str());
667
 
 
668
 
      return default_charset_info;
669
 
    }
670
 
 
671
 
    return cs;
672
 
  }
673
 
 
674
 
  return default_charset_info;
675
 
}
676
 
 
677
 
class CreateSchema : 
678
 
  public unary_function<StorageEngine *, void>
679
 
{
680
 
  const drizzled::message::Schema &schema_message;
681
 
 
682
 
public:
683
 
 
684
 
  CreateSchema(const drizzled::message::Schema &arg) :
685
 
    schema_message(arg)
686
 
  {
687
 
  }
688
 
 
689
 
  result_type operator() (argument_type engine)
690
 
  {
691
 
    // @todo eomeday check that at least one engine said "true"
692
 
    (void)engine->doCreateSchema(schema_message);
693
 
  }
694
 
};
695
 
 
696
 
bool StorageEngine::createSchema(const drizzled::message::Schema &schema_message)
697
 
{
698
 
  // Add hook here for engines to register schema.
699
 
  for_each(vector_of_schema_engines.begin(), vector_of_schema_engines.end(),
700
 
           CreateSchema(schema_message));
701
 
 
702
 
  return true;
703
 
}
704
 
 
705
 
class DropSchema : 
706
 
  public unary_function<StorageEngine *, void>
707
 
{
708
 
  uint64_t &success_count;
709
 
  const string &schema_name;
710
 
 
711
 
public:
712
 
 
713
 
  DropSchema(const string &arg, uint64_t &count_arg) :
714
 
    success_count(count_arg),
715
 
    schema_name(arg)
716
 
  {
717
 
  }
718
 
 
719
 
  result_type operator() (argument_type engine)
720
 
  {
721
 
    // @todo someday check that at least one engine said "true"
722
 
    bool success= engine->doDropSchema(schema_name);
723
 
 
724
 
    if (success)
725
 
      success_count++;
726
 
  }
727
 
};
728
 
 
729
 
bool StorageEngine::dropSchema(const string &schema_name)
730
 
{
731
 
  uint64_t counter= 0;
732
 
  // Add hook here for engines to register schema.
733
 
  for_each(vector_of_schema_engines.begin(), vector_of_schema_engines.end(),
734
 
           DropSchema(schema_name, counter));
735
 
 
736
 
  return counter ? true : false;
737
 
}
738
 
 
739
 
class AlterSchema : 
740
 
  public unary_function<StorageEngine *, void>
741
 
{
742
 
  uint64_t &success_count;
743
 
  const drizzled::message::Schema &schema_message;
744
 
 
745
 
public:
746
 
 
747
 
  AlterSchema(const drizzled::message::Schema &arg, uint64_t &count_arg) :
748
 
    success_count(count_arg),
749
 
    schema_message(arg)
750
 
  {
751
 
  }
752
 
 
753
 
  result_type operator() (argument_type engine)
754
 
  {
755
 
    // @todo eomeday check that at least one engine said "true"
756
 
    bool success= engine->doAlterSchema(schema_message);
757
 
 
758
 
    if (success)
759
 
      success_count++;
760
 
  }
761
 
};
762
 
 
763
 
bool StorageEngine::alterSchema(const drizzled::message::Schema &schema_message)
764
 
{
765
 
  uint64_t success_count= 0;
766
 
 
767
 
  for_each(vector_of_schema_engines.begin(), vector_of_schema_engines.end(),
768
 
           AlterSchema(schema_message, success_count));
769
 
 
770
 
  return success_count ? true : false;
771
 
}
772
 
 
773
 
 
774
 
void StorageEngine::getTableNames(Session &session, const string &schema_name, TableNameList &set_of_names)
775
 
{
776
 
  string tmp_path;
777
 
 
778
 
  build_table_filename(tmp_path, schema_name.c_str(), "", false);
779
 
 
780
 
  CachedDirectory directory(tmp_path, set_of_table_definition_ext);
781
 
 
782
 
  if (not schema_name.compare("information_schema"))
 
555
    identifier(identifier_arg),
 
556
    set_of_names(of_names)
 
557
  {
 
558
  }
 
559
 
 
560
  result_type operator() (argument_type engine)
 
561
  {
 
562
    engine->doGetTableNames(directory, identifier, set_of_names);
 
563
  }
 
564
};
 
565
 
 
566
 
 
567
static SchemaIdentifier INFORMATION_SCHEMA_IDENTIFIER("information_schema");
 
568
static SchemaIdentifier DATA_DICTIONARY_IDENTIFIER("data_dictionary");
 
569
 
 
570
void StorageEngine::getTableNames(Session &session, SchemaIdentifier &schema_identifier, TableNameList &set_of_names)
 
571
{
 
572
  CachedDirectory directory(schema_identifier.getPath(), set_of_table_definition_ext);
 
573
 
 
574
  if (schema_identifier == INFORMATION_SCHEMA_IDENTIFIER)
783
575
  { }
784
 
  else if (not schema_name.compare("data_dictionary"))
 
576
  else if (schema_identifier == DATA_DICTIONARY_IDENTIFIER)
785
577
  { }
786
578
  else
787
579
  {
789
581
    {
790
582
      errno= directory.getError();
791
583
      if (errno == ENOENT)
792
 
        my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), schema_name.c_str());
 
584
        my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), schema_identifier.getSQLPath().c_str());
793
585
      else
794
586
        my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), directory.getPath(), errno);
795
587
      return;
797
589
  }
798
590
 
799
591
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
800
 
           AddTableName(directory, schema_name, set_of_names));
801
 
 
802
 
  session.doGetTableNames(directory, schema_name, set_of_names);
803
 
 
 
592
           AddTableName(directory, schema_identifier, set_of_names));
 
593
 
 
594
  session.doGetTableNames(directory, schema_identifier, set_of_names);
804
595
}
805
596
 
806
597
/* This will later be converted to TableIdentifiers */
1215
1006
 
1216
1007
  file_name.append(DEFAULT_DEFINITION_FILE_EXT);
1217
1008
 
1218
 
  snprintf(definition_file_tmp, sizeof(definition_file_tmp), "%s.%sXXXXXX", file_name.c_str(), DEFAULT_DEFINITION_FILE_EXT.c_str());
 
1009
  snprintf(definition_file_tmp, sizeof(definition_file_tmp), "%sXXXXXX", file_name.c_str());
1219
1010
 
1220
1011
  int fd= mkstemp(definition_file_tmp);
1221
1012
 
1272
1063
 
1273
1064
class CanCreateTable: public unary_function<StorageEngine *, bool>
1274
1065
{
1275
 
  const TableIdentifier &identifier;
 
1066
  TableIdentifier &identifier;
1276
1067
 
1277
1068
public:
1278
 
  CanCreateTable(const TableIdentifier &identifier_arg) :
 
1069
  CanCreateTable(TableIdentifier &identifier_arg) :
1279
1070
    identifier(identifier_arg)
1280
1071
  { }
1281
1072