ha_berkeley.h 6.4 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   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.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   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.
unknown's avatar
unknown committed
12

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21 22 23 24 25
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


#ifdef __GNUC__
#pragma interface			/* gcc class implementation */
#endif

/* class for the the myisam handler */

#include <db.h>

26 27
#define BDB_HIDDEN_PRIMARY_KEY_LENGTH 5

unknown's avatar
unknown committed
28
typedef struct st_berkeley_share {
29
  ulonglong auto_ident;
30
  ha_rows rows, org_rows, *rec_per_key;
unknown's avatar
unknown committed
31
  THR_LOCK lock;
32
  pthread_mutex_t mutex;
unknown's avatar
unknown committed
33
  char *table_name;
34 35
  DB *status_block, *file, **key_file;
  u_int32_t *key_type;
unknown's avatar
unknown committed
36
  uint table_name_length,use_count;
37
  uint status,version;
unknown's avatar
unknown committed
38 39
} BDB_SHARE;

40

unknown's avatar
unknown committed
41 42 43 44 45 46 47 48 49 50 51 52 53 54
class ha_berkeley: public handler
{
  THR_LOCK_DATA lock;
  DBT last_key,current_row;
  gptr alloc_ptr;
  byte *rec_buff;
  char *key_buff, *key_buff2, *primary_key_buff;
  DB *file, **key_file;
  DB_TXN *transaction;
  u_int32_t *key_type;
  DBC *cursor;
  BDB_SHARE *share;
  ulong int_option_flag;
  ulong alloced_rec_buff_length;
55 56
  ulong changed_rows;
  uint primary_key,last_dup_key, hidden_primary_key, version;
unknown's avatar
unknown committed
57 58
  u_int32_t lock_on_read;
  bool fixed_length_row, fixed_length_primary_key, key_read, using_ignore;
unknown's avatar
unknown committed
59
  bool	fix_rec_buff_for_blob(ulong length);
60 61
  byte current_ident[BDB_HIDDEN_PRIMARY_KEY_LENGTH];

unknown's avatar
unknown committed
62
  ulong max_row_length(const byte *buf);
63
  int pack_row(DBT *row,const  byte *record, bool new_row);
unknown's avatar
unknown committed
64
  void unpack_row(char *record, DBT *row);
65
  void ha_berkeley::unpack_key(char *record, DBT *key, uint index);
66 67
  DBT *create_key(DBT *key, uint keynr, char *buff, const byte *record,
		  int key_length = MAX_KEY_LENGTH);
68
  DBT *pack_key(DBT *key, uint keynr, char *buff, const byte *key_ptr,
unknown's avatar
unknown committed
69 70 71 72
		uint key_length);
  int remove_key(DB_TXN *trans, uint keynr, const byte *record,
		 DBT *packed_record, DBT *prim_key);
  int remove_keys(DB_TXN *trans,const byte *record, DBT *new_record,
73
		  DBT *prim_key, key_map keys);
74 75 76 77
  int restore_keys(DB_TXN *trans, key_map changed_keys, uint primary_key,
		   const byte *old_row, DBT *old_key,
		   const byte *new_row, DBT *new_key,
		   ulong thd_options);
unknown's avatar
unknown committed
78 79
  int key_cmp(uint keynr, const byte * old_row, const byte * new_row);
  int update_primary_key(DB_TXN *trans, bool primary_key_changed,
80 81 82
			 const byte * old_row, DBT *old_key,
			 const byte * new_row, DBT *prim_key,
			 ulong thd_options, bool local_using_ignore);
83
  int read_row(int error, char *buf, uint keynr, DBT *row, DBT *key, bool);
unknown's avatar
unknown committed
84 85 86 87
  DBT *get_pos(DBT *to, byte *pos);

 public:
  ha_berkeley(TABLE *table): handler(table), alloc_ptr(0),rec_buff(0), file(0),
88 89 90
    int_option_flag(HA_READ_NEXT | HA_READ_PREV |
		    HA_REC_NOT_IN_SEQ |
		    HA_KEYPOS_TO_RNDPOS | HA_READ_ORDER | HA_LASTKEY_ORDER |
91
		    HA_LONGLONG_KEYS | HA_NULL_KEY | HA_HAVE_KEY_READ_ONLY |
unknown's avatar
unknown committed
92
		    HA_BLOB_KEY | HA_NOT_EXACT_COUNT |
93 94
		    HA_PRIMARY_KEY_IN_READ_INDEX | HA_DROP_BEFORE_CREATE |
		    HA_AUTO_PART_KEY),
95
    last_dup_key((uint) -1),version(0),using_ignore(0)
unknown's avatar
unknown committed
96 97 98 99 100 101 102
  {
  }
  ~ha_berkeley() {}
  const char *table_type() const { return "BerkeleyDB"; }
  const char **bas_ext() const;
  ulong option_flag() const { return int_option_flag; }
  uint max_record_length() const { return HA_MAX_REC_LENGTH; }
unknown's avatar
unknown committed
103 104
  uint max_keys()	   const { return MAX_KEY-1; }
  uint max_key_parts()	   const { return MAX_REF_PARTS; }
unknown's avatar
unknown committed
105
  uint max_key_length()    const { return MAX_KEY_LENGTH; }
106 107
  uint extra_rec_buf_length()	 { return BDB_HIDDEN_PRIMARY_KEY_LENGTH; }
  ha_rows estimate_number_of_rows();
unknown's avatar
unknown committed
108 109 110
  bool fast_key_read()	   { return 1;}
  bool has_transactions()  { return 1;}

111
  int open(const char *name, int mode, uint test_if_locked);
unknown's avatar
unknown committed
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
  int close(void);
  double scan_time();
  int write_row(byte * buf);
  int update_row(const byte * old_data, byte * new_data);
  int delete_row(const byte * buf);
  int index_init(uint index);
  int index_end();
  int index_read(byte * buf, const byte * key,
		 uint key_len, enum ha_rkey_function find_flag);
  int index_read_idx(byte * buf, uint index, const byte * key,
		     uint key_len, enum ha_rkey_function find_flag);
  int index_next(byte * buf);
  int index_next_same(byte * buf, const byte *key, uint keylen);
  int index_prev(byte * buf);
  int index_first(byte * buf);
  int index_last(byte * buf);
  int rnd_init(bool scan=1);
  int rnd_end();
  int rnd_next(byte *buf);
  int rnd_pos(byte * buf, byte *pos);
  void position(const byte *record);
  void info(uint);
  int extra(enum ha_extra_function operation);
  int reset(void);
  int external_lock(THD *thd, int lock_type);
137
  void position(byte *record);
138 139 140 141
  int analyze(THD* thd,HA_CHECK_OPT* check_opt);
  int optimize(THD* thd, HA_CHECK_OPT* check_opt);
  int check(THD* thd, HA_CHECK_OPT* check_opt);

unknown's avatar
unknown committed
142 143 144 145 146 147
  ha_rows records_in_range(int inx,
			   const byte *start_key,uint start_key_len,
			   enum ha_rkey_function start_search_flag,
			   const byte *end_key,uint end_key_len,
			   enum ha_rkey_function end_search_flag);

148
  int create(const char *name, register TABLE *form,
149
	     HA_CREATE_INFO *create_info);
150
  int delete_table(const char *name);
unknown's avatar
unknown committed
151 152
  THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
			     enum thr_lock_type lock_type);
153

154
  void get_status();
155 156 157 158 159 160 161 162
  inline void get_auto_primary_key(byte *to)
  {
    ulonglong tmp;
    pthread_mutex_lock(&share->mutex);
    share->auto_ident++;
    int5store(to,share->auto_ident);
    pthread_mutex_unlock(&share->mutex);
  }
163
  longlong ha_berkeley::get_auto_increment();
unknown's avatar
unknown committed
164 165
};

166
extern bool berkeley_skip, berkeley_shared_data;
unknown's avatar
unknown committed
167 168
extern u_int32_t berkeley_init_flags,berkeley_env_flags, berkeley_lock_type,
                 berkeley_lock_types[];
169
extern ulong berkeley_cache_size, berkeley_max_lock;
unknown's avatar
unknown committed
170 171 172 173 174 175 176
extern char *berkeley_home, *berkeley_tmpdir, *berkeley_logdir;
extern long berkeley_lock_scan_time;
extern TYPELIB berkeley_lock_typelib;

bool berkeley_init(void);
bool berkeley_end(void);
bool berkeley_flush_logs(void);
177 178
int berkeley_commit(THD *thd, void *trans);
int berkeley_rollback(THD *thd, void *trans);
unknown's avatar
unknown committed
179
int berkeley_show_logs(THD *thd);