← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/filesystem_engine/filesystem_engine.h

  • Committer: Andrew Hutchings
  • Date: 2011-02-01 10:23:22 UTC
  • mto: (2136.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 2137.
  • Revision ID: andrew@linuxjedi.co.uk-20110201102322-oxztcyrjzg3c7yta
Fix counters cleanup

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/filesystem_engine/filesystem_engine.h
 
1
/*
 
2
  Copyright (C) 2010 Zimin
 
3
 
 
4
  This program is free software; you can redistribute it and/or
 
5
  modify it under the terms of the GNU General Public License
 
6
  as published by the Free Software Foundation; either version 2
 
7
  of the License, or (at your option) any later version.
 
8
 
 
9
  This program is distributed in the hope that it will be useful,
 
10
  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
  GNU General Public License for more details.
 
13
 
 
14
  You should have received a copy of the GNU General Public License
 
15
  along with this program; if not, write to the Free Software
 
16
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
17
*/
 
18
 
 
19
#ifndef PLUGIN_FILESYSTEM_ENGINE_FILESYSTEM_ENGINE_H
 
20
#define PLUGIN_FILESYSTEM_ENGINE_FILESYSTEM_ENGINE_H
 
21
 
 
22
#include <drizzled/cursor.h>
 
23
#include <drizzled/thr_lock.h>
 
24
 
 
25
#include <boost/scoped_ptr.hpp>
 
26
 
 
27
#include <sys/types.h>
 
28
#include <sys/stat.h>
 
29
#include <fstream>
 
30
 
 
31
#include "transparent_file.h"
 
32
#include "formatinfo.h"
 
33
#include "filesystemlock.h"
 
34
 
 
35
class FilesystemTableShare
 
36
{
 
37
  FilesystemTableShare();
 
38
  FilesystemTableShare(const FilesystemTableShare &);
 
39
  FilesystemTableShare& operator=(const FilesystemTableShare &);
 
40
public:
 
41
  explicit FilesystemTableShare(const std::string name);
 
42
  ~FilesystemTableShare();
 
43
 
 
44
  uint32_t use_count;
 
45
  const std::string table_name;
 
46
  bool update_file_opened;
 
47
  bool needs_reopen;
 
48
  pthread_mutex_t mutex;
 
49
  FormatInfo format;
 
50
  std::vector< std::map<std::string, std::string> > vm;
 
51
  FilesystemLock filesystem_lock;
 
52
};
 
53
 
 
54
class FilesystemCursor : public drizzled::Cursor
 
55
{
 
56
  FilesystemTableShare *share;       /* Shared lock info */
 
57
  boost::scoped_ptr<TransparentFile> file_buff;
 
58
  int file_desc;
 
59
  std::string update_file_name;
 
60
  int update_file_desc;
 
61
  size_t tag_depth;
 
62
  off_t current_position;
 
63
  off_t next_position;
 
64
  bool thread_locked;
 
65
  uint32_t sql_command_type; /* Type of SQL command to process */
 
66
  /* each slot means an interval in a file which will be deleted later */
 
67
  std::vector< std::pair<off_t, off_t> > slots;
 
68
 
 
69
public:
 
70
  FilesystemCursor(drizzled::plugin::StorageEngine &engine, drizzled::Table &table_arg);
 
71
  ~FilesystemCursor()
 
72
  {
 
73
  }
 
74
 
 
75
  /** @brief
 
76
    The name that will be used for display purposes.
 
77
   */
 
78
  const char *table_type(void) const { return "FILESYSTEM"; }
 
79
 
 
80
  /*
 
81
     Called in test_quick_select to determine if indexes should be used.
 
82
   */
 
83
  virtual double scan_time() { return (double) (stats.records+stats.deleted) / 20.0+10; }
 
84
 
 
85
  /* The next method will never be called */
 
86
  virtual bool fast_key_read() { return 1;}
 
87
  drizzled::ha_rows estimate_rows_upper_bound() { return HA_POS_ERROR; }
 
88
 
 
89
  int doOpen(const drizzled::identifier::Table &, int, uint32_t);
 
90
  int close(void);
 
91
  int doStartTableScan(bool scan=1);
 
92
  int rnd_next(unsigned char *);
 
93
  int rnd_pos(unsigned char * , unsigned char *);
 
94
  void position(const unsigned char *);
 
95
  int info(uint);
 
96
  int doEndTableScan();
 
97
  int doInsertRecord(unsigned char * buf);
 
98
  int doUpdateRecord(const unsigned char *, unsigned char *);
 
99
  int doDeleteRecord(const unsigned char *);
 
100
 
 
101
  virtual void get_auto_increment(uint64_t offset, uint64_t increment,
 
102
                                  uint64_t nb_desired_values,
 
103
                                  uint64_t *first_value,
 
104
                                  uint64_t *nb_reserved_values) { (void)offset; (void)increment; (void)nb_desired_values; (void)first_value; (void)nb_reserved_values; }
 
105
  FilesystemTableShare *get_share(const char *table_name);
 
106
  void free_share();
 
107
  void critical_section_enter();
 
108
  void critical_section_exit();
 
109
private:
 
110
  void recordToString(std::string& output);
 
111
  void addSlot();
 
112
  int openUpdateFile();
 
113
  int find_current_row(unsigned char *buf);
 
114
};
 
115
 
 
116
#endif /* PLUGIN_FILESYSTEM_ENGINE_FILESYSTEM_ENGINE_H */