1
/* Copyright (C) 2003 MySQL AB
3
This program is free software; you can redistribute it and/or modify
4
it under the terms of the GNU General Public License as published by
5
the Free Software Foundation; version 2 of the License.
7
This program is distributed in the hope that it will be useful,
8
but WITHOUT ANY WARRANTY; without even the implied warranty of
9
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10
GNU General Public License for more details.
12
You should have received a copy of the GNU General Public License
13
along with this program; if not, write to the Free Software
14
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
16
#ifdef USE_PRAGMA_INTERFACE
17
#pragma interface /* gcc class implementation */
24
Please read ha_archive.cc first. If you are looking for more general
25
answers on how storage engines work, look at ha_example.cc and
29
typedef struct st_archive_record_buffer {
32
} archive_record_buffer;
35
typedef struct st_archive_share {
37
char data_file_name[FN_REFLEN];
38
uint table_name_length,use_count;
39
pthread_mutex_t mutex;
41
azio_stream archive_write; /* Archive file we are working with */
42
bool archive_write_open;
43
bool dirty; /* Flag for if a flush should occur */
44
bool crashed; /* Meta file is crashed */
45
ha_rows rows_recorded; /* Number of rows in tables */
46
ulonglong mean_rec_length;
47
char real_path[FN_REFLEN];
51
Version for file format.
52
1 - Initial Version (Never Released)
53
2 - Stream Compression, seperate blobs, no packing
54
3 - One steam (row and blobs), with packing
56
#define ARCHIVE_VERSION 3
58
class ha_archive: public handler
60
THR_LOCK_DATA lock; /* MySQL lock */
61
ARCHIVE_SHARE *share; /* Shared lock info */
63
azio_stream archive; /* Archive file we are working with */
64
my_off_t current_position; /* The position of the row we just read */
65
uchar byte_buffer[IO_SIZE]; /* Initial buffer for our string */
66
String buffer; /* Buffer used for blob storage */
67
ha_rows scan_rows; /* Number of rows left in scan */
68
bool delayed_insert; /* If the insert is delayed */
69
bool bulk_insert; /* If we are performing a bulk insert */
70
const uchar *current_key;
72
uint current_k_offset;
73
archive_record_buffer *record_buffer;
74
bool archive_reader_open;
76
archive_record_buffer *create_record_buffer(unsigned int length);
77
void destroy_record_buffer(archive_record_buffer *r);
80
ha_archive(handlerton *hton, TABLE_SHARE *table_arg);
84
const char *table_type() const { return "ARCHIVE"; }
85
const char *index_type(uint inx) { return "NONE"; }
86
const char **bas_ext() const;
87
ulonglong table_flags() const
89
return (HA_NO_TRANSACTIONS | HA_REC_NOT_IN_SEQ | HA_CAN_BIT_FIELD |
90
HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE |
91
HA_STATS_RECORDS_IS_EXACT |
93
HA_FILE_BASED | HA_CAN_INSERT_DELAYED | HA_CAN_GEOMETRY);
95
ulong index_flags(uint idx, uint part, bool all_parts) const
97
return HA_ONLY_WHOLE_INDEX;
99
virtual void get_auto_increment(ulonglong offset, ulonglong increment,
100
ulonglong nb_desired_values,
101
ulonglong *first_value,
102
ulonglong *nb_reserved_values);
103
uint max_supported_keys() const { return 1; }
104
uint max_supported_key_length() const { return sizeof(ulonglong); }
105
uint max_supported_key_part_length() const { return sizeof(ulonglong); }
106
ha_rows records() { return share->rows_recorded; }
107
int index_init(uint keynr, bool sorted);
108
virtual int index_read(uchar * buf, const uchar * key,
109
uint key_len, enum ha_rkey_function find_flag);
110
virtual int index_read_idx(uchar * buf, uint index, const uchar * key,
111
uint key_len, enum ha_rkey_function find_flag);
112
int index_next(uchar * buf);
113
int open(const char *name, int mode, uint test_if_locked);
115
int write_row(uchar * buf);
116
int real_write_row(uchar *buf, azio_stream *writer);
117
int delete_all_rows();
118
int rnd_init(bool scan=1);
119
int rnd_next(uchar *buf);
120
int rnd_pos(uchar * buf, uchar *pos);
121
int get_row(azio_stream *file_to_read, uchar *buf);
122
int get_row_version2(azio_stream *file_to_read, uchar *buf);
123
int get_row_version3(azio_stream *file_to_read, uchar *buf);
124
ARCHIVE_SHARE *get_share(const char *table_name, int *rc);
126
int init_archive_writer();
127
int init_archive_reader();
128
bool auto_repair() const { return 1; } // For the moment we just do this
129
int read_data_header(azio_stream *file_to_read);
130
void position(const uchar *record);
132
void update_create_info(HA_CREATE_INFO *create_info);
133
int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info);
134
int optimize(THD* thd, HA_CHECK_OPT* check_opt);
135
int repair(THD* thd, HA_CHECK_OPT* check_opt);
136
void start_bulk_insert(ha_rows rows);
137
int end_bulk_insert();
138
enum row_type get_row_type() const
140
return ROW_TYPE_COMPRESSED;
142
THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
143
enum thr_lock_type lock_type);
144
bool is_crashed() const;
145
int check(THD* thd, HA_CHECK_OPT* check_opt);
146
bool check_and_repair(THD *thd);
147
uint32 max_row_length(const uchar *buf);
148
bool fix_rec_buff(unsigned int length);
149
int unpack_row(azio_stream *file_to_read, uchar *record);
150
unsigned int pack_row(uchar *record);