← Back to branch summary

~ubuntu-branches/ubuntu/trusty/drizzle/trusty

« back to all changes in this revision

Viewing changes to plugin/archive/ha_archive.h

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2010-10-02 14:17:48 UTC
  • mfrom: (1.1.1 upstream)
  • mto: (2.1.17 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20101002141748-m6vbfbfjhrw1153e
Tags: 2010.09.1802-1
* New upstream release.
* Removed pid-file argument hack.
* Updated GPL-2 address to be new address.
* Directly copy in drizzledump.1 since debian doesn't have sphinx 1.0 yet.
* Link to jquery from libjs-jquery. Add it as a depend.
* Add drizzled.8 symlink to the install files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/archive/ha_archive.h
22
22
  ha_example.h.
23
23
*/
24
24
 
25
 
typedef struct st_archive_record_buffer {
26
 
  unsigned char *buffer;
27
 
  uint32_t length;
28
 
} archive_record_buffer;
29
 
 
30
 
 
31
25
class ArchiveShare {
32
26
public:
33
27
  ArchiveShare();
37
31
  bool prime(uint64_t *auto_increment);
38
32
 
39
33
  std::string table_name;
40
 
  char data_file_name[FN_REFLEN];
 
34
  std::string data_file_name;
41
35
  uint32_t use_count;
42
 
  pthread_mutex_t mutex;
43
 
  drizzled::THR_LOCK lock;
 
36
  pthread_mutex_t _mutex;
 
37
  drizzled::THR_LOCK _lock;
44
38
  azio_stream archive_write;     /* Archive file we are working with */
45
39
  bool archive_write_open;
46
40
  bool dirty;               /* Flag for if a flush should occur */
50
44
  uint64_t  version;
51
45
  drizzled::ha_rows rows_recorded;    /* Number of rows in tables */
52
46
  drizzled::ha_rows version_rows;
 
47
 
 
48
  pthread_mutex_t &mutex()
 
49
  {
 
50
    return _mutex;
 
51
  }
53
52
};
54
53
 
55
54
/*
75
74
  const unsigned char *current_key;
76
75
  uint32_t current_key_len;
77
76
  uint32_t current_k_offset;
78
 
  archive_record_buffer *record_buffer;
 
77
  std::vector <unsigned char> record_buffer;
79
78
  bool archive_reader_open;
80
79
 
81
 
  archive_record_buffer *create_record_buffer(unsigned int length);
82
 
  void destroy_record_buffer(archive_record_buffer *r);
83
 
 
84
80
public:
85
81
  ha_archive(drizzled::plugin::StorageEngine &engine_arg,
86
82
             drizzled::TableShare &table_arg);
92
88
  void get_auto_increment(uint64_t, uint64_t, uint64_t,
93
89
                          uint64_t *first_value, uint64_t *nb_reserved_values);
94
90
  drizzled::ha_rows records() { return share->rows_recorded; }
95
 
  int index_init(uint32_t keynr, bool sorted);
 
91
  int doStartIndexScan(uint32_t keynr, bool sorted);
96
92
  virtual int index_read(unsigned char * buf, const unsigned char * key,
97
93
                         uint32_t key_len,
98
94
                         drizzled::ha_rkey_function find_flag);
99
 
  virtual int index_read_idx(unsigned char * buf, uint32_t index,
100
 
                             const unsigned char * key,
101
 
                             uint32_t key_len,
102
 
                             drizzled::ha_rkey_function find_flag);
103
95
  int index_next(unsigned char * buf);
 
96
  int doOpen(const drizzled::TableIdentifier &identifier, int mode, uint32_t test_if_locked);
104
97
  int open(const char *name, int mode, uint32_t test_if_locked);
105
98
  int close(void);
106
 
  int write_row(unsigned char * buf);
 
99
  int doInsertRecord(unsigned char * buf);
107
100
  int real_write_row(unsigned char *buf, azio_stream *writer);
108
101
  int delete_all_rows();
109
 
  int rnd_init(bool scan=1);
 
102
  int doStartTableScan(bool scan=1);
110
103
  int rnd_next(unsigned char *buf);
111
104
  int rnd_pos(unsigned char * buf, unsigned char *pos);
112
105
  ArchiveShare *get_share(const char *table_name, int *rc);
125
118
public:
126
119
  void start_bulk_insert(drizzled::ha_rows rows);
127
120
  int end_bulk_insert();
128
 
  enum drizzled::row_type get_row_type() const
129
 
  {
130
 
    return drizzled::ROW_TYPE_COMPRESSED;
131
 
  }
 
121
 
132
122
  drizzled::THR_LOCK_DATA **store_lock(drizzled::Session *session,
133
123
                                       drizzled::THR_LOCK_DATA **to,
134
124
                                       drizzled::thr_lock_type lock_type);