~drizzle-trunk/drizzle/development

/*

  Copyright (C) 2010 Zimin

  This program is free software; you can redistribute it and/or

  modify it under the terms of the GNU General Public License

  as published by the Free Software Foundation; either version 2

  of the License, or (at your option) any later version.

  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License

  along with this program; if not, write to the Free Software

  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

#ifndef PLUGIN_FILESYSTEM_ENGINE_FILESYSTEM_ENGINE_H

#define PLUGIN_FILESYSTEM_ENGINE_FILESYSTEM_ENGINE_H

#include <drizzled/cursor.h>

#include <drizzled/thr_lock.h>

#include <boost/scoped_ptr.hpp>

#include <sys/types.h>

#include <sys/stat.h>

#include <fstream>

#include "transparent_file.h"

#include "formatinfo.h"

#include "filesystemlock.h"

class FilesystemTableShare

{

  FilesystemTableShare();

  FilesystemTableShare(const FilesystemTableShare &);

  FilesystemTableShare& operator=(const FilesystemTableShare &);

public:

  explicit FilesystemTableShare(const std::string name);

  ~FilesystemTableShare();

  uint32_t use_count;

  const std::string table_name;

  bool update_file_opened;

  bool needs_reopen;

  pthread_mutex_t mutex;

  FormatInfo format;

  std::vector< std::map<std::string, std::string> > vm;

  FilesystemLock filesystem_lock;

};

class FilesystemCursor : public drizzled::Cursor

{

  FilesystemTableShare *share;       /* Shared lock info */

  boost::scoped_ptr<TransparentFile> file_buff;

  int file_desc;

  std::string update_file_name;

  int update_file_desc;

  size_t tag_depth;

  off_t current_position;

  off_t next_position;

  bool thread_locked;

  uint32_t sql_command_type; /* Type of SQL command to process */

  /* each slot means an interval in a file which will be deleted later */

  std::vector< std::pair<off_t, off_t> > slots;

public:

  FilesystemCursor(drizzled::plugin::StorageEngine &engine, drizzled::Table &table_arg);

  ~FilesystemCursor()

  {

  }

  /** @brief

    The name that will be used for display purposes.

   */

  const char *table_type(void) const { return "FILESYSTEM"; }

  /*

     Called in test_quick_select to determine if indexes should be used.

   */

  virtual double scan_time() { return (double) (stats.records+stats.deleted) / 20.0+10; }

  /* The next method will never be called */

  virtual bool fast_key_read() { return 1;}

  drizzled::ha_rows estimate_rows_upper_bound() { return HA_POS_ERROR; }

  int doOpen(const drizzled::TableIdentifier &, int, uint32_t);

  int close(void);

  int doStartTableScan(bool scan=1);

  int rnd_next(unsigned char *);

  int rnd_pos(unsigned char * , unsigned char *);

  void position(const unsigned char *);

  int info(uint);

  int doEndTableScan();

  int doInsertRecord(unsigned char * buf);

  int doUpdateRecord(const unsigned char *, unsigned char *);

  int doDeleteRecord(const unsigned char *);

  virtual void get_auto_increment(uint64_t offset, uint64_t increment,

                                  uint64_t nb_desired_values,

                                  uint64_t *first_value,

                                  uint64_t *nb_reserved_values) { (void)offset; (void)increment; (void)nb_desired_values; (void)first_value; (void)nb_reserved_values; }

  FilesystemTableShare *get_share(const char *table_name);

  void free_share();

  void critical_section_enter();

  void critical_section_exit();

private:

  void recordToString(std::string& output);

  void addSlot();

  int openUpdateFile();

  int find_current_row(unsigned char *buf);

};

#endif /* PLUGIN_FILESYSTEM_ENGINE_FILESYSTEM_ENGINE_H */