~drizzle-trunk/drizzle/development

#include "drizzled/server_includes.h"

#include "drizzled/field.h"

#include "drizzled/field/blob.h"

#include "drizzled/field/timestamp.h"

#include "plugin/myisam/myisam.h"

#include "drizzled/table.h"

#include "drizzled/session.h"

#include <mysys/my_dir.h>

 

#include "ha_archive.h"

 

#include <stdio.h>

#include <string>

#include <map>

static const string engine_name("ARCHIVE");

static unsigned int global_version;

 

/* The file extension */

#define ARZ ".arz"               // The data file

#define ARN ".ARN"               // Files used during an optimize call

 

 

 

static bool archive_use_aio= false;

/*

  We just implement one additional file extension.

*/

static const char *ha_archive_exts[] = {

  ARZ,

  NULL

};

 

class ArchiveEngine : public drizzled::plugin::StorageEngine

{

  typedef std::map<string, ArchiveShare*> ArchiveMap;

  ArchiveMap archive_open_tables;

 

public:

  ArchiveEngine(const string &name_arg)

   : drizzled::plugin::StorageEngine(name_arg,

                                     HTON_FILE_BASED |

                                     HTON_STATS_RECORDS_IS_EXACT |

                                     HTON_HAS_RECORDS |

                                     HTON_HAS_DATA_DICTIONARY)

  {

    table_definition_ext= ARZ;

  }

 

  virtual Cursor *create(TableShare &table,

                          MEM_ROOT *mem_root)

  {

    return new (mem_root) ha_archive(*this, table);

  }

 

  const char **bas_ext() const {

    return ha_archive_exts;

  }

 

  int doCreateTable(Session *session, const char *table_name,

                    Table& table_arg,

                    drizzled::message::Table& proto);

 

  int doGetTableDefinition(Session& session,

                           const char* path,

                           const char *db,

                           const char *table_name,

                           const bool is_tmp,

                           drizzled::message::Table *table_proto);

 

  void doGetTableNames(CachedDirectory &directory, string& , set<string>& set_of_names);

 

  int doDropTable(Session&, const string table_path);

  ArchiveShare *findOpenTable(const string table_name);

  void addOpenTable(const string &table_name, ArchiveShare *);

  void deleteOpenTable(const string &table_name);

 

  uint32_t max_supported_keys()          const { return 1; }

  uint32_t max_supported_key_length()    const { return sizeof(uint64_t); }

  uint32_t max_supported_key_part_length() const { return sizeof(uint64_t); }

};

 

 

void ArchiveEngine::doGetTableNames(CachedDirectory &directory, 

                                    string&, 

  CachedDirectory::Entries entries= directory.getEntries();

  for (CachedDirectory::Entries::iterator entry_iter= entries.begin(); 

    CachedDirectory::Entry *entry= *entry_iter;

    string *filename= &entry->filename;

        is_prefix(filename->c_str(), TMP_FILE_PREFIX))

int ArchiveEngine::doDropTable(Session&,

                               const string table_path)

  string new_path(table_path);