← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/ha_myisam.h

Merged in latest plugin-slot-reorg.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/ha_myisam.h
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
 
17
 
#ifdef USE_PRAGMA_INTERFACE
18
 
#pragma interface                       /* gcc class implementation */
19
 
#endif
 
17
#ifndef STORAGE_MYISAM_HA_MYISAM_H
 
18
#define STORAGE_MYISAM_HA_MYISAM_H
 
19
 
 
20
#include <drizzled/handler.h>
 
21
#include <mysys/thr_lock.h>
20
22
 
21
23
/* class for the the myisam handler */
22
24
 
23
 
#include <storage/myisam/myisam.h>
 
25
#include <plugin/myisam/myisam.h>
24
26
 
25
27
#define HA_RECOVER_NONE         0       /* No automatic recover */
26
28
#define HA_RECOVER_DEFAULT      1       /* Automatic recover active */
28
30
#define HA_RECOVER_FORCE        4       /* Recover even if we loose rows */
29
31
#define HA_RECOVER_QUICK        8       /* Don't check rows in data file */
30
32
 
31
 
extern ulong myisam_sort_buffer_size;
32
33
extern TYPELIB myisam_recover_typelib;
33
34
extern ulong myisam_recover_options;
34
35
 
36
37
extern "C" {
37
38
#endif
38
39
 
39
 
bool index_cond_func_myisam(void *arg);
40
 
 
41
40
#ifdef __cplusplus
42
41
}
43
42
#endif
48
47
  uint64_t int_table_flags;
49
48
  char    *data_file_name, *index_file_name;
50
49
  bool can_enable_indexes;
51
 
  int repair(THD *thd, MI_CHECK &param, bool optimize);
 
50
  int repair(Session *session, MI_CHECK &param, bool optimize);
52
51
 
53
52
 public:
54
 
  ha_myisam(handlerton *hton, TABLE_SHARE *table_arg);
 
53
  ha_myisam(drizzled::plugin::StorageEngine *engine, TableShare *table_arg);
55
54
  ~ha_myisam() {}
56
55
  handler *clone(MEM_ROOT *mem_root);
57
 
  const char *table_type() const { return "MyISAM"; }
58
56
  const char *index_type(uint32_t key_number);
59
 
  const char **bas_ext() const;
60
57
  uint64_t table_flags() const { return int_table_flags; }
61
58
  int index_init(uint32_t idx, bool sorted);
62
59
  int index_end();
63
 
  uint32_t index_flags(uint32_t inx, uint32_t part __attribute__((unused)),
64
 
                       bool all_parts __attribute__((unused))) const
65
 
  {
66
 
    return ((table_share->key_info[inx].algorithm == HA_KEY_ALG_FULLTEXT) ?
67
 
            0 : HA_READ_NEXT | HA_READ_PREV | HA_READ_RANGE |
68
 
            HA_READ_ORDER | HA_KEYREAD_ONLY | 
69
 
            (keys_with_parts.is_set(inx)?0:HA_DO_INDEX_COND_PUSHDOWN));
70
 
  }
 
60
  uint32_t index_flags(uint32_t inx, uint32_t part, bool all_parts) const;
71
61
  uint32_t max_supported_keys()          const { return MI_MAX_KEY; }
72
62
  uint32_t max_supported_key_length()    const { return MI_MAX_KEY_LENGTH; }
73
63
  uint32_t max_supported_key_part_length() const { return MI_MAX_KEY_LENGTH; }
98
88
  int extra(enum ha_extra_function operation);
99
89
  int extra_opt(enum ha_extra_function operation, uint32_t cache_size);
100
90
  int reset(void);
101
 
  int external_lock(THD *thd, int lock_type);
 
91
  int external_lock(Session *session, int lock_type);
102
92
  int delete_all_rows(void);
103
93
  int disable_indexes(uint32_t mode);
104
94
  int enable_indexes(uint32_t mode);
106
96
  void start_bulk_insert(ha_rows rows);
107
97
  int end_bulk_insert();
108
98
  ha_rows records_in_range(uint32_t inx, key_range *min_key, key_range *max_key);
109
 
  void update_create_info(HA_CREATE_INFO *create_info);
110
99
  int create(const char *name, Table *form, HA_CREATE_INFO *create_info);
111
 
  THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
 
100
  THR_LOCK_DATA **store_lock(Session *session, THR_LOCK_DATA **to,
112
101
                             enum thr_lock_type lock_type);
113
102
  virtual void get_auto_increment(uint64_t offset, uint64_t increment,
114
103
                                  uint64_t nb_desired_values,
115
104
                                  uint64_t *first_value,
116
105
                                  uint64_t *nb_reserved_values);
117
 
  int rename_table(const char * from, const char * to);
118
 
  int delete_table(const char *name);
119
 
  int check(THD* thd, HA_CHECK_OPT* check_opt);
120
 
  int analyze(THD* thd,HA_CHECK_OPT* check_opt);
121
 
  int repair(THD* thd, HA_CHECK_OPT* check_opt);
122
 
  bool check_and_repair(THD *thd);
123
 
  bool is_crashed() const;
124
 
  bool auto_repair() const { return myisam_recover_options != 0; }
125
 
  int optimize(THD* thd, HA_CHECK_OPT* check_opt);
126
 
  int assign_to_keycache(THD* thd, HA_CHECK_OPT* check_opt);
127
 
  bool check_if_incompatible_data(HA_CREATE_INFO *info, uint32_t table_changes);
128
 
#ifdef HAVE_QUERY_CACHE
129
 
  bool register_query_cache_table(THD *thd, char *table_key,
130
 
                                     uint32_t key_length,
131
 
                                     qc_engine_callback
132
 
                                     *engine_callback,
133
 
                                     uint64_t *engine_data);
134
 
#endif
135
106
  MI_INFO *file_ptr(void)
136
107
  {
137
108
    return file;
139
110
  int read_range_first(const key_range *start_key, const key_range *end_key,
140
111
                       bool eq_range_arg, bool sorted);
141
112
  int read_range_next();
142
 
public:
143
 
  /**
144
 
   * Multi Range Read interface
145
 
   */
146
 
  int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
147
 
                            uint32_t n_ranges, uint32_t mode, HANDLER_BUFFER *buf);
148
 
  int multi_range_read_next(char **range_info);
149
 
  ha_rows multi_range_read_info_const(uint32_t keyno, RANGE_SEQ_IF *seq,
150
 
                                      void *seq_init_param, 
151
 
                                      uint32_t n_ranges, uint32_t *bufsz,
152
 
                                      uint32_t *flags, COST_VECT *cost);
153
 
  int multi_range_read_info(uint32_t keyno, uint32_t n_ranges, uint32_t keys,
154
 
                            uint32_t *bufsz, uint32_t *flags, COST_VECT *cost);
155
 
  
156
 
  /* Index condition pushdown implementation */
157
 
  Item *idx_cond_push(uint32_t keyno, Item* idx_cond);
158
113
private:
159
 
  DsMrr_impl ds_mrr;
160
114
  key_map keys_with_parts;
161
 
  friend bool index_cond_func_myisam(void *arg);
162
115
};
163
116
 
 
117
#endif /* STORAGE_MYISAM_HA_MYISAM_H */