← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handler.h

  • Committer: Monty Taylor
  • Date: 2008-08-01 22:33:44 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080801223344-vzhlflfmtijp1imv
First pass at gettexizing the error messages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/handler.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
1
/* Copyright (C) 2000-2006 MySQL AB
 
2
 
 
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.
 
6
 
 
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.
 
11
 
 
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 */
 
15
 
 
16
 
 
17
/* Definitions for parameters to do with handler-routines */
 
18
 
 
19
#ifdef USE_PRAGMA_INTERFACE
 
20
#pragma interface                       /* gcc class implementation */
 
21
#endif
 
22
 
 
23
#include <mysys/my_handler.h>
 
24
#include <storage/myisam/keycache.h>
 
25
 
 
26
#ifndef NO_HASH
 
27
#define NO_HASH                         /* Not yet implemented */
 
28
#endif
 
29
 
 
30
// the following is for checking tables
 
31
 
 
32
#define HA_ADMIN_ALREADY_DONE     1
 
33
#define HA_ADMIN_OK               0
 
34
#define HA_ADMIN_NOT_IMPLEMENTED -1
 
35
#define HA_ADMIN_FAILED          -2
 
36
#define HA_ADMIN_CORRUPT         -3
 
37
#define HA_ADMIN_INTERNAL_ERROR  -4
 
38
#define HA_ADMIN_INVALID         -5
 
39
#define HA_ADMIN_REJECT          -6
 
40
#define HA_ADMIN_TRY_ALTER       -7
 
41
#define HA_ADMIN_WRONG_CHECKSUM  -8
 
42
#define HA_ADMIN_NOT_BASE_TABLE  -9
 
43
#define HA_ADMIN_NEEDS_UPGRADE  -10
 
44
#define HA_ADMIN_NEEDS_ALTER    -11
 
45
#define HA_ADMIN_NEEDS_CHECK    -12
 
46
 
 
47
/* Bits to show what an alter table will do */
 
48
#include <drizzled/sql_bitmap.h>
 
49
 
 
50
#define HA_MAX_ALTER_FLAGS 39
 
51
typedef Bitmap<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;
 
52
 
 
53
#define HA_ADD_INDEX                  (0)
 
54
#define HA_DROP_INDEX                 (1)
 
55
#define HA_ALTER_INDEX                (2)
 
56
#define HA_RENAME_INDEX               (3)
 
57
#define HA_ADD_UNIQUE_INDEX           (4)
 
58
#define HA_DROP_UNIQUE_INDEX          (5)
 
59
#define HA_ALTER_UNIQUE_INDEX         (6)
 
60
#define HA_RENAME_UNIQUE_INDEX        (7)
 
61
#define HA_ADD_PK_INDEX               (8)
 
62
#define HA_DROP_PK_INDEX              (9)
 
63
#define HA_ALTER_PK_INDEX             (10)
 
64
#define HA_ADD_COLUMN                 (11)
 
65
#define HA_DROP_COLUMN                (12)
 
66
#define HA_CHANGE_COLUMN              (13)
 
67
#define HA_ALTER_COLUMN_NAME          (14)
 
68
#define HA_ALTER_COLUMN_TYPE          (15)
 
69
#define HA_ALTER_COLUMN_ORDER         (16)
 
70
#define HA_ALTER_COLUMN_NULLABLE      (17)
 
71
#define HA_COLUMN_DEFAULT_VALUE       (18)
 
72
#define HA_COLUMN_STORAGE             (19)
 
73
#define HA_COLUMN_FORMAT              (20)
 
74
#define HA_ADD_FOREIGN_KEY            (21)
 
75
#define HA_DROP_FOREIGN_KEY           (22)
 
76
#define HA_ALTER_FOREIGN_KEY          (23)
 
77
#define HA_ADD_CONSTRAINT             (24)
 
78
#define HA_CHANGE_CHARACTER_SET       (30)
 
79
#define HA_SET_DEFAULT_CHARACTER_SET  (31)
 
80
#define HA_CHANGE_AUTOINCREMENT_VALUE (32)
 
81
#define HA_ALTER_STORAGE              (33)
 
82
#define HA_ALTER_TABLESPACE           (34)
 
83
#define HA_ALTER_ROW_FORMAT           (35)
 
84
#define HA_RENAME_TABLE               (36)
 
85
#define HA_ALTER_STORAGE_ENGINE       (37)
 
86
#define HA_RECREATE                   (38)
 
87
/* Remember to increase HA_MAX_ALTER_FLAGS when adding more flags! */
 
88
 
 
89
/* Return values for check_if_supported_alter */
 
90
 
 
91
#define HA_ALTER_ERROR               -1
 
92
#define HA_ALTER_SUPPORTED_WAIT_LOCK  0
 
93
#define HA_ALTER_SUPPORTED_NO_LOCK    1
 
94
#define HA_ALTER_NOT_SUPPORTED        2
 
95
 
 
96
/* Bits in table_flags() to show what database can do */
 
97
 
 
98
#define HA_NO_TRANSACTIONS     (1 << 0) /* Doesn't support transactions */
 
99
#define HA_PARTIAL_COLUMN_READ (1 << 1) /* read may not return all columns */
 
100
#define HA_TABLE_SCAN_ON_INDEX (1 << 2) /* No separate data/index file */
 
101
/*
 
102
  The following should be set if the following is not true when scanning
 
103
  a table with rnd_next()
 
104
  - We will see all rows (including deleted ones)
 
105
  - Row positions are 'table->s->db_record_offset' apart
 
106
  If this flag is not set, filesort will do a postion() call for each matched
 
107
  row to be able to find the row later.
 
108
*/
 
109
#define HA_REC_NOT_IN_SEQ      (1 << 3)
 
110
/* This is now a dead option, just left for compatibility */
 
111
#define HA_CAN_GEOMETRY        (1 << 4)
 
112
/*
 
113
  Reading keys in random order is as fast as reading keys in sort order
 
114
  (Used in records.cc to decide if we should use a record cache and by
 
115
  filesort to decide if we should sort key + data or key + pointer-to-row
 
116
*/
 
117
#define HA_FAST_KEY_READ       (1 << 5)
 
118
/*
 
119
  Set the following flag if we on delete should force all key to be read
 
120
  and on update read all keys that changes
 
121
*/
 
122
#define HA_REQUIRES_KEY_COLUMNS_FOR_DELETE (1 << 6)
 
123
#define HA_NULL_IN_KEY         (1 << 7) /* One can have keys with NULL */
 
124
#define HA_DUPLICATE_POS       (1 << 8)    /* ha_position() gives dup row */
 
125
#define HA_NO_BLOBS            (1 << 9) /* Doesn't support blobs */
 
126
#define HA_CAN_INDEX_BLOBS     (1 << 10)
 
127
#define HA_AUTO_PART_KEY       (1 << 11) /* auto-increment in multi-part key */
 
128
#define HA_REQUIRE_PRIMARY_KEY (1 << 12) /* .. and can't create a hidden one */
 
129
#define HA_STATS_RECORDS_IS_EXACT (1 << 13) /* stats.records is exact */
 
130
/*
 
131
  INSERT_DELAYED only works with handlers that uses MySQL internal table
 
132
  level locks
 
133
*/
 
134
#define HA_CAN_INSERT_DELAYED  (1 << 14)
 
135
/*
 
136
  If we get the primary key columns for free when we do an index read
 
137
  It also implies that we have to retrive the primary key when using
 
138
  position() and rnd_pos().
 
139
*/
 
140
#define HA_PRIMARY_KEY_IN_READ_INDEX (1 << 15)
 
141
/*
 
142
  If HA_PRIMARY_KEY_REQUIRED_FOR_POSITION is set, it means that to position()
 
143
  uses a primary key. Without primary key, we can't call position().
 
144
*/ 
 
145
#define HA_PRIMARY_KEY_REQUIRED_FOR_POSITION (1 << 16) 
 
146
#define HA_CAN_RTREEKEYS       (1 << 17) /* Historical, no longer supported */
 
147
#define HA_NOT_DELETE_WITH_CACHE (1 << 18)
 
148
/*
 
149
  The following is we need to a primary key to delete (and update) a row.
 
150
  If there is no primary key, all columns needs to be read on update and delete
 
151
*/
 
152
#define HA_PRIMARY_KEY_REQUIRED_FOR_DELETE (1 << 19)
 
153
#define HA_NO_PREFIX_CHAR_KEYS (1 << 20)
 
154
#define HA_CAN_FULLTEXT        (1 << 21) /* Historical, no longer supported */
 
155
#define HA_CAN_SQL_HANDLER     (1 << 22) /* Historical, no longer supported */
 
156
#define HA_NO_AUTO_INCREMENT   (1 << 23)
 
157
#define HA_HAS_CHECKSUM        (1 << 24)
 
158
/* Table data are stored in separate files (for lower_case_table_names) */
 
159
#define HA_FILE_BASED          (1 << 26)
 
160
#define HA_NO_VARCHAR          (1 << 27) /* Historical, no longer supported */
 
161
#define HA_CAN_BIT_FIELD       (1 << 28) /* Historical, no longer supported */
 
162
#define HA_NEED_READ_RANGE_BUFFER (1 << 29) /* for read_multi_range */
 
163
#define HA_ANY_INDEX_MAY_BE_UNIQUE (1 << 30)
 
164
#define HA_NO_COPY_ON_ALTER    (1LL << 31)
 
165
#define HA_HAS_RECORDS         (1LL << 32) /* records() gives exact count*/
 
166
/* Has it's own method of binlog logging */
 
167
#define HA_HAS_OWN_BINLOGGING  (1LL << 33) /* Historical, no longer supported */
 
168
#define HA_MRR_CANT_SORT       (1LL << 34)
 
169
 
 
170
/*
 
171
  Engine is capable of row-format and statement-format logging,
 
172
  respectively
 
173
*/
 
174
#define HA_BINLOG_ROW_CAPABLE  (1LL << 35)
 
175
#define HA_BINLOG_STMT_CAPABLE (1LL << 36)
 
176
 
 
177
#define HA_ONLINE_ALTER        (1LL << 37)
 
178
 
 
179
/*
 
180
  Set of all binlog flags. Currently only contain the capabilities
 
181
  flags.
18
182
 */
19
 
 
20
 
#ifndef DRIZZLED_CURSOR_H
21
 
#define DRIZZLED_CURSOR_H
22
 
 
23
 
#include <drizzled/atomics.h>
24
 
#include <drizzled/definitions.h>
25
 
#include <drizzled/discrete_interval.h>
26
 
#include <drizzled/error_t.h>
27
 
#include <drizzled/ha_statistics.h>
28
 
#include <drizzled/handler_structs.h>
29
 
#include <drizzled/identifier.h>
30
 
#include <drizzled/key_map.h>
31
 
#include <drizzled/message/table.h>
32
 
#include <drizzled/sql_list.h>
33
 
#include <drizzled/thr_lock.h>
34
 
#include <drizzled/xid.h>
35
 
 
36
 
#include <bitset>
37
 
#include <algorithm>
38
 
 
39
 
#include <drizzled/visibility.h>
40
 
 
41
 
namespace drizzled
42
 
{
43
 
 
44
 
#define HA_MAX_ALTER_FLAGS 40
45
 
 
46
 
typedef std::bitset<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;
47
 
 
48
 
class AlterInfo;
49
 
class CreateField;
50
 
class ForeignKeyInfo;
 
183
#define HA_BINLOG_FLAGS (HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE)
 
184
 
 
185
/* bits in index_flags(index_number) for what you can do with index */
 
186
#define HA_READ_NEXT            1       /* TODO really use this flag */
 
187
#define HA_READ_PREV            2       /* supports ::index_prev */
 
188
#define HA_READ_ORDER           4       /* index_next/prev follow sort order */
 
189
#define HA_READ_RANGE           8       /* can find all records in a range */
 
190
#define HA_ONLY_WHOLE_INDEX     16      /* Can't use part key searches */
 
191
#define HA_KEYREAD_ONLY         64      /* Support HA_EXTRA_KEYREAD */
 
192
/*
 
193
  Index scan will not return records in rowid order. Not guaranteed to be
 
194
  set for unordered (e.g. HASH) indexes.
 
195
*/
 
196
#define HA_KEY_SCAN_NOT_ROR     128 
 
197
#define HA_DO_INDEX_COND_PUSHDOWN  256 /* Supports Index Condition Pushdown */
 
198
 
 
199
 
 
200
 
 
201
/*
 
202
  HA_PARTITION_FUNCTION_SUPPORTED indicates that the function is
 
203
  supported at all.
 
204
  HA_FAST_CHANGE_PARTITION means that optimised variants of the changes
 
205
  exists but they are not necessarily done online.
 
206
 
 
207
  HA_ONLINE_DOUBLE_WRITE means that the handler supports writing to both
 
208
  the new partition and to the old partitions when updating through the
 
209
  old partitioning schema while performing a change of the partitioning.
 
210
  This means that we can support updating of the table while performing
 
211
  the copy phase of the change. For no lock at all also a double write
 
212
  from new to old must exist and this is not required when this flag is
 
213
  set.
 
214
  This is actually removed even before it was introduced the first time.
 
215
  The new idea is that handlers will handle the lock level already in
 
216
  store_lock for ALTER TABLE partitions.
 
217
 
 
218
  HA_PARTITION_ONE_PHASE is a flag that can be set by handlers that take
 
219
  care of changing the partitions online and in one phase. Thus all phases
 
220
  needed to handle the change are implemented inside the storage engine.
 
221
  The storage engine must also support auto-discovery since the frm file
 
222
  is changed as part of the change and this change must be controlled by
 
223
  the storage engine. A typical engine to support this is NDB (through
 
224
  WL #2498).
 
225
*/
 
226
#define HA_PARTITION_FUNCTION_SUPPORTED         (1L << 1)
 
227
#define HA_FAST_CHANGE_PARTITION                (1L << 2)
 
228
#define HA_PARTITION_ONE_PHASE                  (1L << 3)
 
229
 
 
230
/* operations for disable/enable indexes */
 
231
#define HA_KEY_SWITCH_NONUNIQ      0
 
232
#define HA_KEY_SWITCH_ALL          1
 
233
#define HA_KEY_SWITCH_NONUNIQ_SAVE 2
 
234
#define HA_KEY_SWITCH_ALL_SAVE     3
 
235
 
 
236
/*
 
237
  Note: the following includes binlog and closing 0.
 
238
  so: innodb + bdb + ndb + binlog + myisam + myisammrg + archive +
 
239
      example + csv + heap + blackhole + federated + 0
 
240
  (yes, the sum is deliberately inaccurate)
 
241
  TODO remove the limit, use dynarrays
 
242
*/
 
243
#define MAX_HA 15
 
244
 
 
245
/*
 
246
  Parameters for open() (in register form->filestat)
 
247
  HA_GET_INFO does an implicit HA_ABORT_IF_LOCKED
 
248
*/
 
249
 
 
250
#define HA_OPEN_KEYFILE         1
 
251
#define HA_OPEN_RNDFILE         2
 
252
#define HA_GET_INDEX            4
 
253
#define HA_GET_INFO             8       /* do a ha_info() after open */
 
254
#define HA_READ_ONLY            16      /* File opened as readonly */
 
255
/* Try readonly if can't open with read and write */
 
256
#define HA_TRY_READ_ONLY        32
 
257
#define HA_WAIT_IF_LOCKED       64      /* Wait if locked on open */
 
258
#define HA_ABORT_IF_LOCKED      128     /* skip if locked on open.*/
 
259
#define HA_BLOCK_LOCK           256     /* unlock when reading some records */
 
260
#define HA_OPEN_TEMPORARY       512
 
261
 
 
262
/* For transactional LOCK TABLE. handler::lock_table() */
 
263
#define HA_LOCK_IN_SHARE_MODE      F_RDLCK
 
264
#define HA_LOCK_IN_EXCLUSIVE_MODE  F_WRLCK
 
265
 
 
266
/* Some key definitions */
 
267
#define HA_KEY_NULL_LENGTH      1
 
268
#define HA_KEY_BLOB_LENGTH      2
 
269
 
 
270
#define HA_LEX_CREATE_TMP_TABLE 1
 
271
#define HA_LEX_CREATE_IF_NOT_EXISTS 2
 
272
#define HA_LEX_CREATE_TABLE_LIKE 4
 
273
#define HA_OPTION_NO_CHECKSUM   (1L << 17)
 
274
#define HA_OPTION_NO_DELAY_KEY_WRITE (1L << 18)
 
275
#define HA_MAX_REC_LENGTH       65535
 
276
 
 
277
/* Table caching type */
 
278
#define HA_CACHE_TBL_NONTRANSACT 0
 
279
#define HA_CACHE_TBL_NOCACHE     1
 
280
#define HA_CACHE_TBL_ASKTRANSACT 2
 
281
#define HA_CACHE_TBL_TRANSACT    4
 
282
 
 
283
/* Options of START TRANSACTION statement (and later of SET TRANSACTION stmt) */
 
284
#define MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT 1
 
285
 
 
286
/* Flags for method is_fatal_error */
 
287
#define HA_CHECK_DUP_KEY 1
 
288
#define HA_CHECK_DUP_UNIQUE 2
 
289
#define HA_CHECK_DUP (HA_CHECK_DUP_KEY + HA_CHECK_DUP_UNIQUE)
 
290
 
 
291
enum legacy_db_type
 
292
{
 
293
  DB_TYPE_UNKNOWN=0,DB_TYPE_DIAB_ISAM=1,
 
294
  DB_TYPE_HASH,DB_TYPE_MISAM,DB_TYPE_PISAM,
 
295
  DB_TYPE_RMS_ISAM, DB_TYPE_HEAP, DB_TYPE_ISAM,
 
296
  DB_TYPE_MRG_ISAM, DB_TYPE_MYISAM, DB_TYPE_MRG_MYISAM,
 
297
  DB_TYPE_BERKELEY_DB, DB_TYPE_INNODB,
 
298
  DB_TYPE_GEMINI, DB_TYPE_NDBCLUSTER,
 
299
  DB_TYPE_EXAMPLE_DB, DB_TYPE_ARCHIVE_DB, DB_TYPE_CSV_DB,
 
300
  DB_TYPE_FEDERATED_DB,
 
301
  DB_TYPE_BLACKHOLE_DB,
 
302
  DB_TYPE_PARTITION_DB,
 
303
  DB_TYPE_BINLOG,
 
304
  DB_TYPE_SOLID,
 
305
  DB_TYPE_PBXT,
 
306
  DB_TYPE_TABLE_FUNCTION,
 
307
  DB_TYPE_MEMCACHE,
 
308
  DB_TYPE_FALCON,
 
309
  DB_TYPE_MARIA,
 
310
  DB_TYPE_FIRST_DYNAMIC=42,
 
311
  DB_TYPE_DEFAULT=127 // Must be last
 
312
};
 
313
 
 
314
enum row_type { ROW_TYPE_NOT_USED=-1, ROW_TYPE_DEFAULT, ROW_TYPE_FIXED,
 
315
                ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED,
 
316
                ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT, ROW_TYPE_PAGE };
 
317
 
 
318
enum column_format_type { COLUMN_FORMAT_TYPE_NOT_USED= -1,
 
319
                          COLUMN_FORMAT_TYPE_DEFAULT=   0,
 
320
                          COLUMN_FORMAT_TYPE_FIXED=     1,
 
321
                          COLUMN_FORMAT_TYPE_DYNAMIC=   2 };
 
322
 
 
323
enum enum_binlog_func {
 
324
  BFN_RESET_LOGS=        1,
 
325
  BFN_RESET_SLAVE=       2,
 
326
  BFN_BINLOG_WAIT=       3,
 
327
  BFN_BINLOG_END=        4,
 
328
  BFN_BINLOG_PURGE_FILE= 5
 
329
};
 
330
 
 
331
enum enum_binlog_command {
 
332
  LOGCOM_CREATE_TABLE,
 
333
  LOGCOM_ALTER_TABLE,
 
334
  LOGCOM_RENAME_TABLE,
 
335
  LOGCOM_DROP_TABLE,
 
336
  LOGCOM_CREATE_DB,
 
337
  LOGCOM_ALTER_DB,
 
338
  LOGCOM_DROP_DB
 
339
};
 
340
 
 
341
/* struct to hold information about the table that should be created */
 
342
 
 
343
/* Bits in used_fields */
 
344
#define HA_CREATE_USED_AUTO             (1L << 0)
 
345
#define HA_CREATE_USED_RAID             (1L << 1) /* Historical, no longer supported */
 
346
#define HA_CREATE_USED_UNION            (1L << 2)
 
347
#define HA_CREATE_USED_INSERT_METHOD    (1L << 3)
 
348
#define HA_CREATE_USED_MIN_ROWS         (1L << 4)
 
349
#define HA_CREATE_USED_MAX_ROWS         (1L << 5)
 
350
#define HA_CREATE_USED_AVG_ROW_LENGTH   (1L << 6)
 
351
#define HA_CREATE_USED_PACK_KEYS        (1L << 7)
 
352
#define HA_CREATE_USED_CHARSET          (1L << 8)
 
353
#define HA_CREATE_USED_DEFAULT_CHARSET  (1L << 9)
 
354
#define HA_CREATE_USED_DATADIR          (1L << 10)
 
355
#define HA_CREATE_USED_INDEXDIR         (1L << 11)
 
356
#define HA_CREATE_USED_ENGINE           (1L << 12)
 
357
#define HA_CREATE_USED_CHECKSUM         (1L << 13)
 
358
#define HA_CREATE_USED_DELAY_KEY_WRITE  (1L << 14)
 
359
#define HA_CREATE_USED_ROW_FORMAT       (1L << 15)
 
360
#define HA_CREATE_USED_COMMENT          (1L << 16)
 
361
#define HA_CREATE_USED_PASSWORD         (1L << 17)
 
362
#define HA_CREATE_USED_CONNECTION       (1L << 18)
 
363
#define HA_CREATE_USED_KEY_BLOCK_SIZE   (1L << 19)
 
364
#define HA_CREATE_USED_TRANSACTIONAL    (1L << 20)
 
365
#define HA_CREATE_USED_PAGE_CHECKSUM    (1L << 21)
 
366
 
 
367
typedef uint64_t my_xid; // this line is the same as in log_event.h
 
368
#define MYSQL_XID_PREFIX "MySQLXid"
 
369
#define MYSQL_XID_PREFIX_LEN 8 // must be a multiple of 8
 
370
#define MYSQL_XID_OFFSET (MYSQL_XID_PREFIX_LEN+sizeof(server_id))
 
371
#define MYSQL_XID_GTRID_LEN (MYSQL_XID_OFFSET+sizeof(my_xid))
 
372
 
 
373
#define XIDDATASIZE MYSQL_XIDDATASIZE
 
374
#define MAXGTRIDSIZE 64
 
375
#define MAXBQUALSIZE 64
 
376
 
 
377
#define COMPATIBLE_DATA_YES 0
 
378
#define COMPATIBLE_DATA_NO  1
 
379
 
 
380
/**
 
381
  struct xid_t is binary compatible with the XID structure as
 
382
  in the X/Open CAE Specification, Distributed Transaction Processing:
 
383
  The XA Specification, X/Open Company Ltd., 1991.
 
384
  http://www.opengroup.org/bookstore/catalog/c193.htm
 
385
 
 
386
  @see MYSQL_XID in mysql/plugin.h
 
387
*/
 
388
struct xid_t {
 
389
  long formatID;
 
390
  long gtrid_length;
 
391
  long bqual_length;
 
392
  char data[XIDDATASIZE];  // not \0-terminated !
 
393
 
 
394
  xid_t() {}                                /* Remove gcc warning */  
 
395
  bool eq(struct xid_t *xid)
 
396
  { return eq(xid->gtrid_length, xid->bqual_length, xid->data); }
 
397
  bool eq(long g, long b, const char *d)
 
398
  { return g == gtrid_length && b == bqual_length && !memcmp(d, data, g+b); }
 
399
  void set(struct xid_t *xid)
 
400
  { memcpy(this, xid, xid->length()); }
 
401
  void set(long f, const char *g, long gl, const char *b, long bl)
 
402
  {
 
403
    formatID= f;
 
404
    memcpy(data, g, gtrid_length= gl);
 
405
    memcpy(data+gl, b, bqual_length= bl);
 
406
  }
 
407
  void set(uint64_t xid)
 
408
  {
 
409
    my_xid tmp;
 
410
    formatID= 1;
 
411
    set(MYSQL_XID_PREFIX_LEN, 0, MYSQL_XID_PREFIX);
 
412
    memcpy(data+MYSQL_XID_PREFIX_LEN, &server_id, sizeof(server_id));
 
413
    tmp= xid;
 
414
    memcpy(data+MYSQL_XID_OFFSET, &tmp, sizeof(tmp));
 
415
    gtrid_length=MYSQL_XID_GTRID_LEN;
 
416
  }
 
417
  void set(long g, long b, const char *d)
 
418
  {
 
419
    formatID= 1;
 
420
    gtrid_length= g;
 
421
    bqual_length= b;
 
422
    memcpy(data, d, g+b);
 
423
  }
 
424
  bool is_null() { return formatID == -1; }
 
425
  void null() { formatID= -1; }
 
426
  my_xid quick_get_my_xid()
 
427
  {
 
428
    my_xid tmp;
 
429
    memcpy(&tmp, data+MYSQL_XID_OFFSET, sizeof(tmp));
 
430
    return tmp;
 
431
  }
 
432
  my_xid get_my_xid()
 
433
  {
 
434
    return gtrid_length == MYSQL_XID_GTRID_LEN && bqual_length == 0 &&
 
435
           !memcmp(data+MYSQL_XID_PREFIX_LEN, &server_id, sizeof(server_id)) &&
 
436
           !memcmp(data, MYSQL_XID_PREFIX, MYSQL_XID_PREFIX_LEN) ?
 
437
           quick_get_my_xid() : 0;
 
438
  }
 
439
  uint length()
 
440
  {
 
441
    return sizeof(formatID)+sizeof(gtrid_length)+sizeof(bqual_length)+
 
442
           gtrid_length+bqual_length;
 
443
  }
 
444
  uchar *key()
 
445
  {
 
446
    return (uchar *)&gtrid_length;
 
447
  }
 
448
  uint key_length()
 
449
  {
 
450
    return sizeof(gtrid_length)+sizeof(bqual_length)+gtrid_length+bqual_length;
 
451
  }
 
452
};
 
453
typedef struct xid_t XID;
 
454
 
 
455
/* for recover() handlerton call */
 
456
#define MIN_XID_LIST_SIZE  128
 
457
#define MAX_XID_LIST_SIZE  (1024*128)
 
458
 
 
459
struct handlerton;
 
460
 
 
461
/* The handler for a table type.  Will be included in the TABLE structure */
 
462
 
 
463
struct st_table;
 
464
typedef struct st_table TABLE;
 
465
typedef struct st_table_share TABLE_SHARE;
 
466
struct st_foreign_key_info;
 
467
typedef struct st_foreign_key_info FOREIGN_KEY_INFO;
 
468
typedef bool (stat_print_fn)(THD *thd, const char *type, uint type_len,
 
469
                             const char *file, uint file_len,
 
470
                             const char *status, uint status_len);
 
471
enum ha_stat_type { HA_ENGINE_STATUS, HA_ENGINE_LOGS, HA_ENGINE_MUTEX };
 
472
extern st_plugin_int *hton2plugin[MAX_HA];
 
473
 
 
474
/*
 
475
  handlerton is a singleton structure - one instance per storage engine -
 
476
  to provide access to storage engine functionality that works on the
 
477
  "global" level (unlike handler class that works on a per-table basis)
 
478
 
 
479
  usually handlerton instance is defined statically in ha_xxx.cc as
 
480
 
 
481
  static handlerton { ... } xxx_hton;
 
482
 
 
483
  savepoint_*, prepare, recover, and *_by_xid pointers can be 0.
 
484
*/
 
485
struct handlerton
 
486
{
 
487
  /*
 
488
    Historical marker for if the engine is available of not
 
489
  */
 
490
  SHOW_COMP_OPTION state;
 
491
 
 
492
  /*
 
493
    Historical number used for frm file to determine the correct storage engine.
 
494
    This is going away and new engines will just use "name" for this.
 
495
  */
 
496
  enum legacy_db_type db_type;
 
497
  /*
 
498
    each storage engine has it's own memory area (actually a pointer)
 
499
    in the thd, for storing per-connection information.
 
500
    It is accessed as
 
501
 
 
502
      thd->ha_data[xxx_hton.slot]
 
503
 
 
504
   slot number is initialized by MySQL after xxx_init() is called.
 
505
   */
 
506
   uint slot;
 
507
   /*
 
508
     to store per-savepoint data storage engine is provided with an area
 
509
     of a requested size (0 is ok here).
 
510
     savepoint_offset must be initialized statically to the size of
 
511
     the needed memory to store per-savepoint information.
 
512
     After xxx_init it is changed to be an offset to savepoint storage
 
513
     area and need not be used by storage engine.
 
514
     see binlog_hton and binlog_savepoint_set/rollback for an example.
 
515
   */
 
516
   uint savepoint_offset;
 
517
   /*
 
518
     handlerton methods:
 
519
 
 
520
     close_connection is only called if
 
521
     thd->ha_data[xxx_hton.slot] is non-zero, so even if you don't need
 
522
     this storage area - set it to something, so that MySQL would know
 
523
     this storage engine was accessed in this connection
 
524
   */
 
525
   int  (*close_connection)(handlerton *hton, THD *thd);
 
526
   /*
 
527
     sv points to an uninitialized storage area of requested size
 
528
     (see savepoint_offset description)
 
529
   */
 
530
   int  (*savepoint_set)(handlerton *hton, THD *thd, void *sv);
 
531
   /*
 
532
     sv points to a storage area, that was earlier passed
 
533
     to the savepoint_set call
 
534
   */
 
535
   int  (*savepoint_rollback)(handlerton *hton, THD *thd, void *sv);
 
536
   int  (*savepoint_release)(handlerton *hton, THD *thd, void *sv);
 
537
   /*
 
538
     'all' is true if it's a real commit, that makes persistent changes
 
539
     'all' is false if it's not in fact a commit but an end of the
 
540
     statement that is part of the transaction.
 
541
     NOTE 'all' is also false in auto-commit mode where 'end of statement'
 
542
     and 'real commit' mean the same event.
 
543
   */
 
544
   int  (*commit)(handlerton *hton, THD *thd, bool all);
 
545
   int  (*rollback)(handlerton *hton, THD *thd, bool all);
 
546
   int  (*prepare)(handlerton *hton, THD *thd, bool all);
 
547
   int  (*recover)(handlerton *hton, XID *xid_list, uint len);
 
548
   int  (*commit_by_xid)(handlerton *hton, XID *xid);
 
549
   int  (*rollback_by_xid)(handlerton *hton, XID *xid);
 
550
   void *(*create_cursor_read_view)(handlerton *hton, THD *thd);
 
551
   void (*set_cursor_read_view)(handlerton *hton, THD *thd, void *read_view);
 
552
   void (*close_cursor_read_view)(handlerton *hton, THD *thd, void *read_view);
 
553
   handler *(*create)(handlerton *hton, TABLE_SHARE *table, MEM_ROOT *mem_root);
 
554
   void (*drop_database)(handlerton *hton, char* path);
 
555
   int (*start_consistent_snapshot)(handlerton *hton, THD *thd);
 
556
   bool (*flush_logs)(handlerton *hton);
 
557
   bool (*show_status)(handlerton *hton, THD *thd, stat_print_fn *print, enum ha_stat_type stat);
 
558
   int (*fill_files_table)(handlerton *hton, THD *thd,
 
559
                           TABLE_LIST *tables,
 
560
                           class Item *cond);
 
561
   uint32_t flags;                                /* global handler flags */
 
562
   int (*release_temporary_latches)(handlerton *hton, THD *thd);
 
563
 
 
564
   int (*discover)(handlerton *hton, THD* thd, const char *db, 
 
565
                   const char *name,
 
566
                   uchar **frmblob, 
 
567
                   size_t *frmlen);
 
568
   int (*table_exists_in_engine)(handlerton *hton, THD* thd, const char *db,
 
569
                                 const char *name);
 
570
   uint32_t license; /* Flag for Engine License */
 
571
   void *data; /* Location for engines to keep personal structures */
 
572
};
 
573
 
 
574
 
 
575
/* Possible flags of a handlerton (there can be 32 of them) */
 
576
#define HTON_NO_FLAGS                 0
 
577
#define HTON_CLOSE_CURSORS_AT_COMMIT (1 << 0)
 
578
#define HTON_ALTER_NOT_SUPPORTED     (1 << 1) //Engine does not support alter
 
579
#define HTON_CAN_RECREATE            (1 << 2) //Delete all is used fro truncate
 
580
#define HTON_HIDDEN                  (1 << 3) //Engine does not appear in lists
 
581
#define HTON_FLUSH_AFTER_RENAME      (1 << 4)
 
582
#define HTON_NOT_USER_SELECTABLE     (1 << 5)
 
583
#define HTON_TEMPORARY_NOT_SUPPORTED (1 << 6) //Having temporary tables not supported
 
584
#define HTON_SUPPORT_LOG_TABLES      (1 << 7) //Engine supports log tables
 
585
#define HTON_NO_PARTITION            (1 << 8) //You can not partition these tables
 
586
 
 
587
class Ha_trx_info;
 
588
 
 
589
struct THD_TRANS
 
590
{
 
591
  /* true is not all entries in the ht[] support 2pc */
 
592
  bool        no_2pc;
 
593
  /* storage engines that registered in this transaction */
 
594
  Ha_trx_info *ha_list;
 
595
  /* 
 
596
    The purpose of this flag is to keep track of non-transactional
 
597
    tables that were modified in scope of:
 
598
    - transaction, when the variable is a member of
 
599
    THD::transaction.all
 
600
    - top-level statement or sub-statement, when the variable is a
 
601
    member of THD::transaction.stmt
 
602
    This member has the following life cycle:
 
603
    * stmt.modified_non_trans_table is used to keep track of
 
604
    modified non-transactional tables of top-level statements. At
 
605
    the end of the previous statement and at the beginning of the session,
 
606
    it is reset to false.  If such functions
 
607
    as mysql_insert, mysql_update, mysql_delete etc modify a
 
608
    non-transactional table, they set this flag to true.  At the
 
609
    end of the statement, the value of stmt.modified_non_trans_table 
 
610
    is merged with all.modified_non_trans_table and gets reset.
 
611
    * all.modified_non_trans_table is reset at the end of transaction
 
612
    
 
613
    * Since we do not have a dedicated context for execution of a
 
614
    sub-statement, to keep track of non-transactional changes in a
 
615
    sub-statement, we re-use stmt.modified_non_trans_table. 
 
616
    At entrance into a sub-statement, a copy of the value of
 
617
    stmt.modified_non_trans_table (containing the changes of the
 
618
    outer statement) is saved on stack. Then 
 
619
    stmt.modified_non_trans_table is reset to false and the
 
620
    substatement is executed. Then the new value is merged with the
 
621
    saved value.
 
622
  */
 
623
  bool modified_non_trans_table;
 
624
 
 
625
  void reset() { no_2pc= false; modified_non_trans_table= false; }
 
626
};
 
627
 
 
628
 
 
629
/**
 
630
  Either statement transaction or normal transaction - related
 
631
  thread-specific storage engine data.
 
632
 
 
633
  If a storage engine participates in a statement/transaction,
 
634
  an instance of this class is present in
 
635
  thd->transaction.{stmt|all}.ha_list. The addition to
 
636
  {stmt|all}.ha_list is made by trans_register_ha().
 
637
 
 
638
  When it's time to commit or rollback, each element of ha_list
 
639
  is used to access storage engine's prepare()/commit()/rollback()
 
640
  methods, and also to evaluate if a full two phase commit is
 
641
  necessary.
 
642
 
 
643
  @sa General description of transaction handling in handler.cc.
 
644
*/
 
645
 
 
646
class Ha_trx_info
 
647
{
 
648
public:
 
649
  /** Register this storage engine in the given transaction context. */
 
650
  void register_ha(THD_TRANS *trans, handlerton *ht_arg)
 
651
  {
 
652
    assert(m_flags == 0);
 
653
    assert(m_ht == NULL);
 
654
    assert(m_next == NULL);
 
655
 
 
656
    m_ht= ht_arg;
 
657
    m_flags= (int) TRX_READ_ONLY; /* Assume read-only at start. */
 
658
 
 
659
    m_next= trans->ha_list;
 
660
    trans->ha_list= this;
 
661
  }
 
662
 
 
663
  /** Clear, prepare for reuse. */
 
664
  void reset()
 
665
  {
 
666
    m_next= NULL;
 
667
    m_ht= NULL;
 
668
    m_flags= 0;
 
669
  }
 
670
 
 
671
  Ha_trx_info() { reset(); }
 
672
 
 
673
  void set_trx_read_write()
 
674
  {
 
675
    assert(is_started());
 
676
    m_flags|= (int) TRX_READ_WRITE;
 
677
  }
 
678
  bool is_trx_read_write() const
 
679
  {
 
680
    assert(is_started());
 
681
    return m_flags & (int) TRX_READ_WRITE;
 
682
  }
 
683
  bool is_started() const { return m_ht != NULL; }
 
684
  /** Mark this transaction read-write if the argument is read-write. */
 
685
  void coalesce_trx_with(const Ha_trx_info *stmt_trx)
 
686
  {
 
687
    /*
 
688
      Must be called only after the transaction has been started.
 
689
      Can be called many times, e.g. when we have many
 
690
      read-write statements in a transaction.
 
691
    */
 
692
    assert(is_started());
 
693
    if (stmt_trx->is_trx_read_write())
 
694
      set_trx_read_write();
 
695
  }
 
696
  Ha_trx_info *next() const
 
697
  {
 
698
    assert(is_started());
 
699
    return m_next;
 
700
  }
 
701
  handlerton *ht() const
 
702
  {
 
703
    assert(is_started());
 
704
    return m_ht;
 
705
  }
 
706
private:
 
707
  enum { TRX_READ_ONLY= 0, TRX_READ_WRITE= 1 };
 
708
  /** Auxiliary, used for ha_list management */
 
709
  Ha_trx_info *m_next;
 
710
  /**
 
711
    Although a given Ha_trx_info instance is currently always used
 
712
    for the same storage engine, 'ht' is not-NULL only when the
 
713
    corresponding storage is a part of a transaction.
 
714
  */
 
715
  handlerton *m_ht;
 
716
  /**
 
717
    Transaction flags related to this engine.
 
718
    Not-null only if this instance is a part of transaction.
 
719
    May assume a combination of enum values above.
 
720
  */
 
721
  uchar       m_flags;
 
722
};
 
723
 
 
724
 
 
725
enum enum_tx_isolation { ISO_READ_UNCOMMITTED, ISO_READ_COMMITTED,
 
726
                         ISO_REPEATABLE_READ, ISO_SERIALIZABLE};
 
727
 
 
728
typedef struct {
 
729
  uint64_t data_file_length;
 
730
  uint64_t max_data_file_length;
 
731
  uint64_t index_file_length;
 
732
  uint64_t delete_length;
 
733
  ha_rows records;
 
734
  uint32_t mean_rec_length;
 
735
  time_t create_time;
 
736
  time_t check_time;
 
737
  time_t update_time;
 
738
  uint64_t check_sum;
 
739
} PARTITION_INFO;
 
740
 
 
741
#define UNDEF_NODEGROUP 65535
51
742
class Item;
52
 
class Item_ident;
53
 
class LEX;
54
 
class Select_Lex;
55
 
class Select_Lex_Unit;
56
 
class String;
57
 
class Table;
58
 
class TableList;
59
 
class TableShare;
60
 
class select_result;
61
 
class sys_var_str;
62
 
struct Order;
63
 
 
64
 
typedef List<Item> List_item;
 
743
struct st_table_log_memory_entry;
 
744
 
 
745
#define NOT_A_PARTITION_ID ((uint32_t)-1)
 
746
 
 
747
enum ha_choice { HA_CHOICE_UNDEF, HA_CHOICE_NO, HA_CHOICE_YES };
 
748
 
 
749
typedef struct st_ha_create_information
 
750
{
 
751
  CHARSET_INFO *table_charset, *default_table_charset;
 
752
  LEX_STRING connect_string;
 
753
  LEX_STRING comment;
 
754
  const char *data_file_name, *index_file_name;
 
755
  const char *alias;
 
756
  uint64_t max_rows,min_rows;
 
757
  uint64_t auto_increment_value;
 
758
  uint32_t table_options;
 
759
  uint32_t avg_row_length;
 
760
  uint32_t used_fields;
 
761
  uint32_t key_block_size;
 
762
  SQL_LIST merge_list;
 
763
  handlerton *db_type;
 
764
  enum row_type row_type;
 
765
  uint null_bits;                       /* NULL bits at start of record */
 
766
  uint options;                         /* OR of HA_CREATE_ options */
 
767
  uint merge_insert_method;
 
768
  uint extra_size;                      /* length of extra data segment */
 
769
  /* 0 not used, 1 if not transactional, 2 if transactional */
 
770
  enum ha_choice transactional;
 
771
  bool table_existed;                   /* 1 in create if table existed */
 
772
  bool frm_only;                        /* 1 if no ha_create_table() */
 
773
  bool varchar;                         /* 1 if table has a VARCHAR */
 
774
  enum ha_choice page_checksum;         /* If we have page_checksums */
 
775
} HA_CREATE_INFO;
 
776
 
 
777
typedef struct st_ha_alter_information
 
778
{
 
779
  KEY  *key_info_buffer;
 
780
  uint key_count;
 
781
  uint index_drop_count;
 
782
  uint *index_drop_buffer;
 
783
  uint index_add_count;
 
784
  uint *index_add_buffer;
 
785
  void *data;
 
786
} HA_ALTER_INFO;
 
787
 
 
788
 
 
789
typedef struct st_key_create_information
 
790
{
 
791
  enum ha_key_alg algorithm;
 
792
  uint32_t block_size;
 
793
  LEX_STRING parser_name;
 
794
  LEX_STRING comment;
 
795
} KEY_CREATE_INFO;
 
796
 
 
797
 
 
798
/*
 
799
  Class for maintaining hooks used inside operations on tables such
 
800
  as: create table functions, delete table functions, and alter table
 
801
  functions.
 
802
 
 
803
  Class is using the Template Method pattern to separate the public
 
804
  usage interface from the private inheritance interface.  This
 
805
  imposes no overhead, since the public non-virtual function is small
 
806
  enough to be inlined.
 
807
 
 
808
  The hooks are usually used for functions that does several things,
 
809
  e.g., create_table_from_items(), which both create a table and lock
 
810
  it.
 
811
 */
 
812
class TABLEOP_HOOKS
 
813
{
 
814
public:
 
815
  TABLEOP_HOOKS() {}
 
816
  virtual ~TABLEOP_HOOKS() {}
 
817
 
 
818
  inline void prelock(TABLE **tables, uint count)
 
819
  {
 
820
    do_prelock(tables, count);
 
821
  }
 
822
 
 
823
  inline int postlock(TABLE **tables, uint count)
 
824
  {
 
825
    return do_postlock(tables, count);
 
826
  }
 
827
private:
 
828
  /* Function primitive that is called prior to locking tables */
 
829
  virtual void do_prelock(TABLE **tables __attribute__((unused)),
 
830
                          uint count __attribute__((unused)))
 
831
  {
 
832
    /* Default is to do nothing */
 
833
  }
 
834
 
 
835
  /**
 
836
     Primitive called after tables are locked.
 
837
 
 
838
     If an error is returned, the tables will be unlocked and error
 
839
     handling start.
 
840
 
 
841
     @return Error code or zero.
 
842
   */
 
843
  virtual int do_postlock(TABLE **tables __attribute__((unused)),
 
844
                          uint count __attribute__((unused)))
 
845
  {
 
846
    return 0;                           /* Default is to do nothing */
 
847
  }
 
848
};
 
849
 
 
850
typedef struct st_savepoint SAVEPOINT;
 
851
extern uint32_t savepoint_alloc_size;
65
852
extern KEY_CREATE_INFO default_key_create_info;
66
853
 
67
854
/* Forward declaration for condition pushdown to storage engine */
68
855
typedef class Item COND;
69
856
 
70
 
typedef struct system_status_var system_status_var;
71
 
 
72
 
namespace optimizer { class CostVector; }
73
 
namespace plugin { class StorageEngine; }
74
 
 
 
857
typedef struct st_ha_check_opt
 
858
{
 
859
  st_ha_check_opt() {}                        /* Remove gcc warning */
 
860
  uint32_t sort_buffer_size;
 
861
  uint flags;       /* isam layer flags (e.g. for myisamchk) */
 
862
  uint sql_flags;   /* sql layer flags - for something myisamchk cannot do */
 
863
  KEY_CACHE *key_cache; /* new key cache when changing key cache */
 
864
  void init();
 
865
} HA_CHECK_OPT;
 
866
 
 
867
 
 
868
 
 
869
/*
 
870
  This is a buffer area that the handler can use to store rows.
 
871
  'end_of_used_area' should be kept updated after calls to
 
872
  read-functions so that other parts of the code can use the
 
873
  remaining area (until next read calls is issued).
 
874
*/
 
875
 
 
876
typedef struct st_handler_buffer
 
877
{
 
878
  uchar *buffer;         /* Buffer one can start using */
 
879
  uchar *buffer_end;     /* End of buffer */
 
880
  uchar *end_of_used_area;     /* End of area that was used by handler */
 
881
} HANDLER_BUFFER;
 
882
 
 
883
typedef struct system_status_var SSV;
 
884
 
 
885
 
 
886
typedef void *range_seq_t;
 
887
 
 
888
typedef struct st_range_seq_if
 
889
{
 
890
  /*
 
891
    Initialize the traversal of range sequence
 
892
    
 
893
    SYNOPSIS
 
894
      init()
 
895
        init_params  The seq_init_param parameter 
 
896
        n_ranges     The number of ranges obtained 
 
897
        flags        A combination of HA_MRR_SINGLE_POINT, HA_MRR_FIXED_KEY
 
898
 
 
899
    RETURN
 
900
      An opaque value to be used as RANGE_SEQ_IF::next() parameter
 
901
  */
 
902
  range_seq_t (*init)(void *init_params, uint n_ranges, uint flags);
 
903
 
 
904
 
 
905
  /*
 
906
    Get the next range in the range sequence
 
907
 
 
908
    SYNOPSIS
 
909
      next()
 
910
        seq    The value returned by RANGE_SEQ_IF::init()
 
911
        range  OUT Information about the next range
 
912
    
 
913
    RETURN
 
914
      0 - Ok, the range structure filled with info about the next range
 
915
      1 - No more ranges
 
916
  */
 
917
  uint (*next) (range_seq_t seq, KEY_MULTI_RANGE *range);
 
918
} RANGE_SEQ_IF;
 
919
 
 
920
uint16_t &mrr_persistent_flag_storage(range_seq_t seq, uint idx);
 
921
char* &mrr_get_ptr_by_idx(range_seq_t seq, uint idx);
 
922
 
 
923
class COST_VECT
 
924
{ 
 
925
public:
 
926
  double io_count;     /* number of I/O                 */
 
927
  double avg_io_cost;  /* cost of an average I/O oper.  */
 
928
  double cpu_cost;     /* cost of operations in CPU     */
 
929
  double mem_cost;     /* cost of used memory           */ 
 
930
  double import_cost;  /* cost of remote operations     */
 
931
  
 
932
  enum { IO_COEFF=1 };
 
933
  enum { CPU_COEFF=1 };
 
934
  enum { MEM_COEFF=1 };
 
935
  enum { IMPORT_COEFF=1 };
 
936
 
 
937
  COST_VECT() {}                              // keep gcc happy
 
938
 
 
939
  double total_cost() 
 
940
  {
 
941
    return IO_COEFF*io_count*avg_io_cost + CPU_COEFF * cpu_cost +
 
942
           MEM_COEFF*mem_cost + IMPORT_COEFF*import_cost;
 
943
  }
 
944
 
 
945
  void zero()
 
946
  {
 
947
    avg_io_cost= 1.0;
 
948
    io_count= cpu_cost= mem_cost= import_cost= 0.0;
 
949
  }
 
950
 
 
951
  void multiply(double m)
 
952
  {
 
953
    io_count *= m;
 
954
    cpu_cost *= m;
 
955
    import_cost *= m;
 
956
    /* Don't multiply mem_cost */
 
957
  }
 
958
 
 
959
  void add(const COST_VECT* cost)
 
960
  {
 
961
    double io_count_sum= io_count + cost->io_count;
 
962
    add_io(cost->io_count, cost->avg_io_cost);
 
963
    io_count= io_count_sum;
 
964
    cpu_cost += cost->cpu_cost;
 
965
  }
 
966
  void add_io(double add_io_cnt, double add_avg_cost)
 
967
  {
 
968
    double io_count_sum= io_count + add_io_cnt;
 
969
    avg_io_cost= (io_count * avg_io_cost + 
 
970
                  add_io_cnt * add_avg_cost) / io_count_sum;
 
971
    io_count= io_count_sum;
 
972
  }
 
973
};
 
974
 
 
975
void get_sweep_read_cost(TABLE *table, ha_rows nrows, bool interrupted, 
 
976
                         COST_VECT *cost);
 
977
 
 
978
/*
 
979
  The below two are not used (and not handled) in this milestone of this WL
 
980
  entry because there seems to be no use for them at this stage of
 
981
  implementation.
 
982
*/
 
983
#define HA_MRR_SINGLE_POINT 1
 
984
#define HA_MRR_FIXED_KEY  2
 
985
 
 
986
/* 
 
987
  Indicates that RANGE_SEQ_IF::next(&range) doesn't need to fill in the
 
988
  'range' parameter.
 
989
*/
 
990
#define HA_MRR_NO_ASSOCIATION 4
 
991
 
 
992
/* 
 
993
  The MRR user will provide ranges in key order, and MRR implementation
 
994
  must return rows in key order.
 
995
*/
 
996
#define HA_MRR_SORTED 8
 
997
 
 
998
/* MRR implementation doesn't have to retrieve full records */
 
999
#define HA_MRR_INDEX_ONLY 16
 
1000
 
 
1001
/* 
 
1002
  The passed memory buffer is of maximum possible size, the caller can't
 
1003
  assume larger buffer.
 
1004
*/
 
1005
#define HA_MRR_LIMITS 32
 
1006
 
 
1007
 
 
1008
/*
 
1009
  Flag set <=> default MRR implementation is used
 
1010
  (The choice is made by **_info[_const]() function which may set this
 
1011
   flag. SQL layer remembers the flag value and then passes it to
 
1012
   multi_read_range_init().
 
1013
*/
 
1014
#define HA_MRR_USE_DEFAULT_IMPL 64
 
1015
 
 
1016
/*
 
1017
  Used only as parameter to multi_range_read_info():
 
1018
  Flag set <=> the caller guarantees that the bounds of the scanned ranges
 
1019
  will not have NULL values.
 
1020
*/
 
1021
#define HA_MRR_NO_NULL_ENDPOINTS 128
 
1022
 
 
1023
 
 
1024
class ha_statistics
 
1025
{
 
1026
public:
 
1027
  uint64_t data_file_length;            /* Length off data file */
 
1028
  uint64_t max_data_file_length;        /* Length off data file */
 
1029
  uint64_t index_file_length;
 
1030
  uint64_t max_index_file_length;
 
1031
  uint64_t delete_length;               /* Free bytes */
 
1032
  uint64_t auto_increment_value;
 
1033
  /*
 
1034
    The number of records in the table. 
 
1035
      0    - means the table has exactly 0 rows
 
1036
    other  - if (table_flags() & HA_STATS_RECORDS_IS_EXACT)
 
1037
               the value is the exact number of records in the table
 
1038
             else
 
1039
               it is an estimate
 
1040
  */
 
1041
  ha_rows records;
 
1042
  ha_rows deleted;                      /* Deleted records */
 
1043
  uint32_t mean_rec_length;             /* physical reclength */
 
1044
  time_t create_time;                   /* When table was created */
 
1045
  time_t check_time;
 
1046
  time_t update_time;
 
1047
  uint block_size;                      /* index block size */
 
1048
 
 
1049
  ha_statistics():
 
1050
    data_file_length(0), max_data_file_length(0),
 
1051
    index_file_length(0), delete_length(0), auto_increment_value(0),
 
1052
    records(0), deleted(0), mean_rec_length(0), create_time(0),
 
1053
    check_time(0), update_time(0), block_size(0)
 
1054
  {}
 
1055
};
 
1056
 
 
1057
uint calculate_key_len(TABLE *, uint, const uchar *, key_part_map);
75
1058
/*
76
1059
  bitmap with first N+1 bits set
77
1060
  (keypart_map for a key prefix of [0..N] keyparts)
78
1061
*/
79
 
template<class T>
80
 
inline key_part_map make_keypart_map(T a)
81
 
{
82
 
  return (((key_part_map)2 << a) - 1);
83
 
}
84
 
 
 
1062
#define make_keypart_map(N) (((key_part_map)2 << (N)) - 1)
85
1063
/*
86
1064
  bitmap with first N bits set
87
1065
  (keypart_map for a key prefix of [0..N-1] keyparts)
88
1066
*/
89
 
template<class T>
90
 
inline key_part_map make_prev_keypart_map(T a)
91
 
{
92
 
  return (((key_part_map)1 << a) - 1);
93
 
}
 
1067
#define make_prev_keypart_map(N) (((key_part_map)1 << (N)) - 1)
94
1068
 
95
1069
/**
96
 
  The Cursor class is the interface for dynamically loadable
 
1070
  The handler class is the interface for dynamically loadable
97
1071
  storage engines. Do not add ifdefs and take care when adding or
98
1072
  changing virtual functions to avoid vtable confusion
99
1073
 
103
1077
     storage engine
104
1078
 
105
1079
  2. KeyTupleFormat - used to pass index search tuples (aka "keys") to
106
 
     storage engine. See optimizer/range.cc for description of this format.
 
1080
     storage engine. See opt_range.cc for description of this format.
107
1081
 
108
1082
  TableRecordFormat
109
1083
  =================
110
1084
  [Warning: this description is work in progress and may be incomplete]
111
1085
  The table record is stored in a fixed-size buffer:
112
 
 
 
1086
   
113
1087
    record: null_bytes, column1_data, column2_data, ...
114
 
 
115
 
  The offsets of the parts of the buffer are also fixed: every column has
 
1088
  
 
1089
  The offsets of the parts of the buffer are also fixed: every column has 
116
1090
  an offset to its column{i}_data, and if it is nullable it also has its own
117
 
  bit in null_bytes.
 
1091
  bit in null_bytes. 
118
1092
 
119
1093
  The record buffer only includes data about columns that are marked in the
120
1094
  relevant column set (table->read_set and/or table->write_set, depending on
121
 
  the situation).
 
1095
  the situation). 
122
1096
  <not-sure>It could be that it is required that null bits of non-present
123
1097
  columns are set to 1</not-sure>
124
1098
 
125
1099
  VARIOUS EXCEPTIONS AND SPECIAL CASES
126
1100
 
127
 
  f the table has no nullable columns, then null_bytes is still
128
 
  present, its length is one byte <not-sure> which must be set to 0xFF
 
1101
  f the table has no nullable columns, then null_bytes is still 
 
1102
  present, its length is one byte <not-sure> which must be set to 0xFF 
129
1103
  at all times. </not-sure>
 
1104
  
 
1105
  If the table has columns of type BIT, then certain bits from those columns
 
1106
  may be stored in null_bytes as well. Grep around for Field_bit for
 
1107
  details.
130
1108
 
131
 
  For blob columns (see Field_blob), the record buffer stores length of the
132
 
  data, following by memory pointer to the blob data. The pointer is owned
 
1109
  For blob columns (see Field_blob), the record buffer stores length of the 
 
1110
  data, following by memory pointer to the blob data. The pointer is owned 
133
1111
  by the storage engine and is valid until the next operation.
134
1112
 
135
1113
  If a blob column has NULL value, then its length and blob data pointer
136
1114
  must be set to 0.
137
1115
*/
138
 
class DRIZZLED_API Cursor
 
1116
 
 
1117
class handler :public Sql_alloc
139
1118
{
140
 
  friend class SEAPITesterCursor;
141
 
  Table &table;               /* The current open table */
142
 
  plugin::StorageEngine &engine;      /* storage engine of this Cursor */
143
 
 
 
1119
public:
 
1120
  typedef uint64_t Table_flags;
144
1121
protected:
 
1122
  struct st_table_share *table_share;   /* The table definition */
 
1123
  struct st_table *table;               /* The current open table */
 
1124
  Table_flags cached_table_flags;       /* Set on init() and open() */
 
1125
 
145
1126
  ha_rows estimation_rows_to_insert;
146
 
 
147
1127
public:
148
 
  inline plugin::StorageEngine *getEngine() const       /* table_type for handler */
149
 
  {
150
 
    return &engine;
151
 
  }
152
 
  unsigned char *ref;                           /* Pointer to current row */
153
 
  unsigned char *dup_ref;                       /* Pointer to duplicate row */
154
 
 
155
 
  TableShare *getShare();
156
 
 
157
 
  Table *getTable() const
158
 
  {
159
 
    return &table;
160
 
  }
 
1128
  handlerton *ht;                 /* storage engine of this handler */
 
1129
  uchar *ref;                           /* Pointer to current row */
 
1130
  uchar *dup_ref;                       /* Pointer to duplicate row */
161
1131
 
162
1132
  ha_statistics stats;
163
1133
  /** MultiRangeRead-related members: */
164
1134
  range_seq_t mrr_iter;    /* Interator to traverse the range sequence */
165
1135
  RANGE_SEQ_IF mrr_funcs;  /* Range sequence traversal functions */
166
 
 
167
 
  uint32_t ranges_in_seq; /* Total number of ranges in the traversed sequence */
 
1136
  HANDLER_BUFFER *multi_range_buffer; /* MRR buffer info */
 
1137
  uint ranges_in_seq; /* Total number of ranges in the traversed sequence */
168
1138
  /* true <=> source MRR ranges and the output are ordered */
169
1139
  bool mrr_is_output_sorted;
170
1140
 
171
1141
  /** true <=> we're currently traversing a range in mrr_cur_range. */
172
1142
  bool mrr_have_range;
173
 
 
174
 
  bool eq_range;
175
 
 
176
1143
  /** Current range (the one we're now returning rows from) */
177
1144
  KEY_MULTI_RANGE mrr_cur_range;
178
1145
 
179
1146
  /** The following are for read_range() */
180
1147
  key_range save_end_range, *end_range;
181
 
  KeyPartInfo *range_key_part;
 
1148
  KEY_PART_INFO *range_key_part;
182
1149
  int key_compare_result_on_equal;
 
1150
  bool eq_range;
 
1151
  /* 
 
1152
    true <=> the engine guarantees that returned records are within the range
 
1153
    being scanned.
 
1154
  */
 
1155
  bool in_range_check_pushed_down;
183
1156
 
184
 
  uint32_t errkey;                              /* Last dup key */
185
 
  uint32_t key_used_on_scan;
186
 
  uint32_t active_index;
 
1157
  uint errkey;                          /* Last dup key */
 
1158
  uint key_used_on_scan;
 
1159
  uint active_index;
187
1160
  /** Length of ref (1-8 or the clustered key length) */
188
 
  uint32_t ref_length;
 
1161
  uint ref_length;
189
1162
  enum {NONE=0, INDEX, RND} inited;
190
1163
  bool locked;
 
1164
  bool implicit_emptied;                /* Can be !=0 only if HEAP */
 
1165
  const Item *pushed_cond;
 
1166
 
 
1167
  Item *pushed_idx_cond;
 
1168
  uint pushed_idx_cond_keyno;  /* The index which the above condition is for */
191
1169
 
192
1170
  /**
193
1171
    next_insert_id is the next value which should be inserted into the
199
1177
    get_auto_increment().
200
1178
  */
201
1179
  uint64_t next_insert_id;
202
 
  uint64_t getNextInsertId()
203
 
  {
204
 
    return next_insert_id;
205
 
  }
206
 
 
207
 
  /**
208
 
    Used by SHOW TABLE STATUS to get the current auto_inc from the engine
209
 
  */
210
 
  uint64_t getAutoIncrement()
211
 
  {
212
 
    return stats.auto_increment_value;
213
 
  }
214
 
 
215
1180
  /**
216
1181
    insert id for the current row (*autogenerated*; if not
217
1182
    autogenerated, it's 0).
218
1183
    At first successful insertion, this variable is stored into
219
 
    Session::first_successful_insert_id_in_cur_stmt.
 
1184
    THD::first_successful_insert_id_in_cur_stmt.
220
1185
  */
221
1186
  uint64_t insert_id_for_cur_row;
222
1187
  /**
225
1190
  */
226
1191
  Discrete_interval auto_inc_interval_for_cur_row;
227
1192
 
228
 
  Cursor(plugin::StorageEngine &engine_arg, Table &share_arg);
229
 
  virtual ~Cursor(void);
230
 
  virtual Cursor *clone(memory::Root *mem_root);
231
 
 
 
1193
  handler(handlerton *ht_arg, TABLE_SHARE *share_arg)
 
1194
    :table_share(share_arg), table(0),
 
1195
    estimation_rows_to_insert(0), ht(ht_arg),
 
1196
    ref(0), in_range_check_pushed_down(false),
 
1197
    key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
 
1198
    ref_length(sizeof(my_off_t)),
 
1199
    inited(NONE),
 
1200
    locked(false), implicit_emptied(0),
 
1201
    pushed_cond(0), pushed_idx_cond(NULL), pushed_idx_cond_keyno(MAX_KEY),
 
1202
    next_insert_id(0), insert_id_for_cur_row(0)
 
1203
    {}
 
1204
  virtual ~handler(void)
 
1205
  {
 
1206
    assert(locked == false);
 
1207
    /* TODO: assert(inited == NONE); */
 
1208
  }
 
1209
  virtual handler *clone(MEM_ROOT *mem_root);
 
1210
  /** This is called after create to allow us to set up cached variables */
 
1211
  void init()
 
1212
  {
 
1213
    cached_table_flags= table_flags();
 
1214
  }
232
1215
  /* ha_ methods: pubilc wrappers for private virtual API */
233
1216
 
234
 
  int ha_open(const identifier::Table &identifier, int mode, int test_if_locked);
235
 
  int startIndexScan(uint32_t idx, bool sorted) __attribute__ ((warn_unused_result));
236
 
  int endIndexScan();
237
 
  int startTableScan(bool scan) __attribute__ ((warn_unused_result));
238
 
  int endTableScan();
 
1217
  int ha_open(TABLE *table, const char *name, int mode, int test_if_locked);
 
1218
  int ha_index_init(uint idx, bool sorted)
 
1219
  {
 
1220
    int result;
 
1221
    assert(inited==NONE);
 
1222
    if (!(result= index_init(idx, sorted)))
 
1223
      inited=INDEX;
 
1224
    end_range= NULL;
 
1225
    return(result);
 
1226
  }
 
1227
  int ha_index_end()
 
1228
  {
 
1229
    assert(inited==INDEX);
 
1230
    inited=NONE;
 
1231
    end_range= NULL;
 
1232
    return(index_end());
 
1233
  }
 
1234
  int ha_rnd_init(bool scan)
 
1235
  {
 
1236
    int result;
 
1237
    assert(inited==NONE || (inited==RND && scan));
 
1238
    inited= (result= rnd_init(scan)) ? NONE: RND;
 
1239
    return(result);
 
1240
  }
 
1241
  int ha_rnd_end()
 
1242
  {
 
1243
    assert(inited==RND);
 
1244
    inited=NONE;
 
1245
    return(rnd_end());
 
1246
  }
239
1247
  int ha_reset();
240
 
 
241
1248
  /* this is necessary in many places, e.g. in HANDLER command */
242
 
  int ha_index_or_rnd_end();
243
 
 
 
1249
  int ha_index_or_rnd_end()
 
1250
  {
 
1251
    return inited == INDEX ? ha_index_end() : inited == RND ? ha_rnd_end() : 0;
 
1252
  }
 
1253
  Table_flags ha_table_flags() const { return cached_table_flags; }
244
1254
  /**
245
1255
    These functions represent the public interface to *users* of the
246
 
    Cursor class, hence they are *not* virtual. For the inheritance
247
 
    interface, see the (private) functions doInsertRecord(), doUpdateRecord(),
248
 
    and doDeleteRecord() below.
 
1256
    handler class, hence they are *not* virtual. For the inheritance
 
1257
    interface, see the (private) functions write_row(), update_row(),
 
1258
    and delete_row() below.
249
1259
  */
250
 
  int ha_external_lock(Session *session, int lock_type);
251
 
  int insertRecord(unsigned char * buf) __attribute__ ((warn_unused_result));
252
 
  int updateRecord(const unsigned char * old_data, unsigned char * new_data) __attribute__ ((warn_unused_result));
253
 
  int deleteRecord(const unsigned char * buf) __attribute__ ((warn_unused_result));
 
1260
  int ha_external_lock(THD *thd, int lock_type);
 
1261
  int ha_write_row(uchar * buf);
 
1262
  int ha_update_row(const uchar * old_data, uchar * new_data);
 
1263
  int ha_delete_row(const uchar * buf);
254
1264
  void ha_release_auto_increment();
255
1265
 
 
1266
  int ha_check_for_upgrade(HA_CHECK_OPT *check_opt);
256
1267
  /** to be actually called to get 'check()' functionality*/
257
 
  int ha_check(Session *session, HA_CHECK_OPT *check_opt);
258
 
 
259
 
  void ha_start_bulk_insert(ha_rows rows);
260
 
  int ha_end_bulk_insert();
 
1268
  int ha_check(THD *thd, HA_CHECK_OPT *check_opt);
 
1269
  int ha_repair(THD* thd, HA_CHECK_OPT* check_opt);
 
1270
  void ha_start_bulk_insert(ha_rows rows)
 
1271
  {
 
1272
    estimation_rows_to_insert= rows;
 
1273
    start_bulk_insert(rows);
 
1274
  }
 
1275
  int ha_end_bulk_insert()
 
1276
  {
 
1277
    estimation_rows_to_insert= 0;
 
1278
    return end_bulk_insert();
 
1279
  }
 
1280
  int ha_bulk_update_row(const uchar *old_data, uchar *new_data,
 
1281
                         uint *dup_key_found);
261
1282
  int ha_delete_all_rows();
262
1283
  int ha_reset_auto_increment(uint64_t value);
263
 
  int ha_analyze(Session* session, HA_CHECK_OPT* check_opt);
264
 
 
265
 
  int ha_disable_indexes(uint32_t mode);
266
 
  int ha_enable_indexes(uint32_t mode);
 
1284
  int ha_optimize(THD* thd, HA_CHECK_OPT* check_opt);
 
1285
  int ha_analyze(THD* thd, HA_CHECK_OPT* check_opt);
 
1286
  bool ha_check_and_repair(THD *thd);
 
1287
  int ha_disable_indexes(uint mode);
 
1288
  int ha_enable_indexes(uint mode);
267
1289
  int ha_discard_or_import_tablespace(bool discard);
268
 
  void closeMarkForDelete(const char *name);
 
1290
  void ha_prepare_for_alter();
 
1291
  int ha_rename_table(const char *from, const char *to);
 
1292
  int ha_delete_table(const char *name);
 
1293
  void ha_drop_table(const char *name);
 
1294
 
 
1295
  int ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info);
 
1296
 
 
1297
  int ha_create_handler_files(const char *name, const char *old_name,
 
1298
                              int action_flag, HA_CREATE_INFO *info);
269
1299
 
270
1300
  void adjust_next_insert_id_after_explicit_value(uint64_t nr);
271
1301
  int update_auto_increment();
272
 
 
 
1302
  void print_keydup_error(uint key_nr, const char *msg);
 
1303
  virtual void print_error(int error, myf errflag);
 
1304
  virtual bool get_error_message(int error, String *buf);
 
1305
  uint get_dup_key(int error);
 
1306
  virtual void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share)
 
1307
  {
 
1308
    table= table_arg;
 
1309
    table_share= share;
 
1310
  }
273
1311
  /* Estimates calculation */
274
1312
  virtual double scan_time(void)
275
 
  { return static_cast<double>(stats.data_file_length) / IO_SIZE + 2; }
276
 
  virtual double read_time(uint32_t, uint32_t ranges, ha_rows rows)
277
 
  { return ranges + rows; }
278
 
 
279
 
  virtual double index_only_read_time(uint32_t keynr, double records);
280
 
 
281
 
  virtual ha_rows multi_range_read_info_const(uint32_t keyno, RANGE_SEQ_IF *seq,
282
 
                                              void *seq_init_param,
283
 
                                              uint32_t n_ranges, uint32_t *bufsz,
284
 
                                              uint32_t *flags, optimizer::CostVector *cost);
285
 
  virtual int multi_range_read_info(uint32_t keyno, uint32_t n_ranges, uint32_t keys,
286
 
                                    uint32_t *bufsz, uint32_t *flags, optimizer::CostVector *cost);
 
1313
  { return uint64_t2double(stats.data_file_length) / IO_SIZE + 2; }
 
1314
  virtual double read_time(uint index __attribute__((unused)),
 
1315
                           uint ranges, ha_rows rows)
 
1316
  { return rows2double(ranges+rows); }
 
1317
 
 
1318
  virtual double index_only_read_time(uint keynr, double records);
 
1319
  
 
1320
  virtual ha_rows multi_range_read_info_const(uint keyno, RANGE_SEQ_IF *seq,
 
1321
                                              void *seq_init_param, 
 
1322
                                              uint n_ranges, uint *bufsz,
 
1323
                                              uint *flags, COST_VECT *cost);
 
1324
  virtual int multi_range_read_info(uint keyno, uint n_ranges, uint keys,
 
1325
                                    uint *bufsz, uint *flags, COST_VECT *cost);
287
1326
  virtual int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
288
 
                                    uint32_t n_ranges, uint32_t mode);
 
1327
                                    uint n_ranges, uint mode,
 
1328
                                    HANDLER_BUFFER *buf);
289
1329
  virtual int multi_range_read_next(char **range_info);
290
1330
 
291
1331
 
292
 
  virtual const key_map *keys_to_use_for_scanning();
293
 
  bool has_transactions();
 
1332
  virtual const key_map *keys_to_use_for_scanning() { return &key_map_empty; }
 
1333
  bool has_transactions()
 
1334
  { return (ha_table_flags() & HA_NO_TRANSACTIONS) == 0; }
 
1335
  virtual uint extra_rec_buf_length() const { return 0; }
294
1336
 
295
1337
  /**
296
1338
    This method is used to analyse the error to see whether the error
297
1339
    is ignorable or not, certain handlers can have more error that are
298
 
    ignorable than others. E.g. the partition Cursor can get inserts
 
1340
    ignorable than others. E.g. the partition handler can get inserts
299
1341
    into a range where there is no partition and this is an ignorable
300
1342
    error.
301
1343
    HA_ERR_FOUND_DUP_UNIQUE is a special case in MyISAM that means the
302
1344
    same thing as HA_ERR_FOUND_DUP_KEY but can in some cases lead to
303
1345
    a slightly different error message.
304
1346
  */
305
 
  virtual bool is_fatal_error(int error, uint32_t flags);
 
1347
  virtual bool is_fatal_error(int error, uint flags)
 
1348
  {
 
1349
    if (!error ||
 
1350
        ((flags & HA_CHECK_DUP_KEY) &&
 
1351
         (error == HA_ERR_FOUND_DUPP_KEY ||
 
1352
          error == HA_ERR_FOUND_DUPP_UNIQUE)))
 
1353
      return false;
 
1354
    return true;
 
1355
  }
306
1356
 
307
1357
  /**
308
1358
    Number of rows in table. It will only be called if
309
1359
    (table_flags() & (HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT)) != 0
310
1360
  */
311
 
  virtual ha_rows records();
312
 
  virtual uint64_t tableSize();
313
 
  virtual uint64_t rowSize();
 
1361
  virtual ha_rows records() { return stats.records; }
314
1362
  /**
315
1363
    Return upper bound of current number of records in the table
316
1364
    (max. of how many records one will retrieve when doing a full table scan)
320
1368
  virtual ha_rows estimate_rows_upper_bound()
321
1369
  { return stats.records+EXTRA_RECORDS; }
322
1370
 
323
 
  virtual const char *index_type(uint32_t)
 
1371
  /**
 
1372
    Get the row type from the storage engine.  If this method returns
 
1373
    ROW_TYPE_NOT_USED, the information in HA_CREATE_INFO should be used.
 
1374
  */
 
1375
  virtual enum row_type get_row_type() const { return ROW_TYPE_NOT_USED; }
 
1376
 
 
1377
  virtual const char *index_type(uint key_number __attribute__((unused)))
324
1378
  { assert(0); return "";}
325
1379
 
326
1380
 
327
 
  uint32_t get_index(void) const { return active_index; }
 
1381
  /**
 
1382
    Signal that the table->read_set and table->write_set table maps changed
 
1383
    The handler is allowed to set additional bits in the above map in this
 
1384
    call. Normally the handler should ignore all calls until we have done
 
1385
    a ha_rnd_init() or ha_index_init(), write_row(), update_row or delete_row()
 
1386
    as there may be several calls to this routine.
 
1387
  */
 
1388
  virtual void column_bitmaps_signal();
 
1389
  uint get_index(void) const { return active_index; }
328
1390
  virtual int close(void)=0;
329
1391
 
330
1392
  /**
 
1393
    @retval  0   Bulk update used by handler
 
1394
    @retval  1   Bulk update not used, normal operation used
 
1395
  */
 
1396
  virtual bool start_bulk_update() { return 1; }
 
1397
  /**
 
1398
    @retval  0   Bulk delete used by handler
 
1399
    @retval  1   Bulk delete not used, normal operation used
 
1400
  */
 
1401
  virtual bool start_bulk_delete() { return 1; }
 
1402
  /**
 
1403
    After this call all outstanding updates must be performed. The number
 
1404
    of duplicate key errors are reported in the duplicate key parameter.
 
1405
    It is allowed to continue to the batched update after this call, the
 
1406
    handler has to wait until end_bulk_update with changing state.
 
1407
 
 
1408
    @param    dup_key_found       Number of duplicate keys found
 
1409
 
 
1410
    @retval  0           Success
 
1411
    @retval  >0          Error code
 
1412
  */
 
1413
  virtual int exec_bulk_update(uint *dup_key_found __attribute__((unused)))
 
1414
  {
 
1415
    assert(false);
 
1416
    return HA_ERR_WRONG_COMMAND;
 
1417
  }
 
1418
  /**
 
1419
    Perform any needed clean-up, no outstanding updates are there at the
 
1420
    moment.
 
1421
  */
 
1422
  virtual void end_bulk_update() { return; }
 
1423
  /**
 
1424
    Execute all outstanding deletes and close down the bulk delete.
 
1425
 
 
1426
    @retval 0             Success
 
1427
    @retval >0            Error code
 
1428
  */
 
1429
  virtual int end_bulk_delete()
 
1430
  {
 
1431
    assert(false);
 
1432
    return HA_ERR_WRONG_COMMAND;
 
1433
  }
 
1434
  /**
331
1435
     @brief
332
1436
     Positions an index cursor to the index specified in the handle. Fetches the
333
1437
     row if available. If the key value is null, begin at the first key of the
334
1438
     index.
335
1439
  */
336
 
  virtual int index_read_map(unsigned char * buf, const unsigned char *key,
 
1440
  virtual int index_read_map(uchar * buf, const uchar * key,
337
1441
                             key_part_map keypart_map,
338
1442
                             enum ha_rkey_function find_flag)
339
1443
  {
340
 
    uint32_t key_len= calculate_key_len(active_index, keypart_map);
 
1444
    uint key_len= calculate_key_len(table, active_index, key, keypart_map);
341
1445
    return  index_read(buf, key, key_len, find_flag);
342
1446
  }
343
1447
  /**
346
1450
     row if available. If the key value is null, begin at the first key of the
347
1451
     index.
348
1452
  */
349
 
  virtual int index_read_idx_map(unsigned char * buf, uint32_t index,
350
 
                                 const unsigned char * key,
 
1453
  virtual int index_read_idx_map(uchar * buf, uint index, const uchar * key,
351
1454
                                 key_part_map keypart_map,
352
1455
                                 enum ha_rkey_function find_flag);
353
 
  virtual int index_next(unsigned char *) __attribute__ ((warn_unused_result))
354
 
   { return  HA_ERR_WRONG_COMMAND; }
355
 
  virtual int index_prev(unsigned char *)
356
 
   { return  HA_ERR_WRONG_COMMAND; }
357
 
  virtual int index_first(unsigned char *)
358
 
   { return  HA_ERR_WRONG_COMMAND; }
359
 
  virtual int index_last(unsigned char *)
360
 
   { return  HA_ERR_WRONG_COMMAND; }
361
 
  virtual int index_next_same(unsigned char *, const unsigned char *, uint32_t);
362
 
 
363
 
private:
364
 
  uint32_t calculate_key_len(uint32_t key_position, key_part_map keypart_map_arg);
365
 
public:
366
 
 
 
1456
  virtual int index_next(uchar * buf __attribute__((unused)))
 
1457
   { return  HA_ERR_WRONG_COMMAND; }
 
1458
  virtual int index_prev(uchar * buf __attribute__((unused)))
 
1459
   { return  HA_ERR_WRONG_COMMAND; }
 
1460
  virtual int index_first(uchar * buf __attribute__((unused)))
 
1461
   { return  HA_ERR_WRONG_COMMAND; }
 
1462
  virtual int index_last(uchar * buf __attribute__((unused)))
 
1463
   { return  HA_ERR_WRONG_COMMAND; }
 
1464
  virtual int index_next_same(uchar *buf __attribute__((unused)),
 
1465
                              const uchar *key __attribute__((unused)),
 
1466
                              uint keylen __attribute__((unused)));
367
1467
  /**
368
1468
     @brief
369
1469
     The following functions works like index_read, but it find the last
370
1470
     row with the current key value or prefix.
371
1471
  */
372
 
  virtual int index_read_last_map(unsigned char * buf, const unsigned char * key,
 
1472
  virtual int index_read_last_map(uchar * buf, const uchar * key,
373
1473
                                  key_part_map keypart_map)
374
1474
  {
375
 
    uint32_t key_len= calculate_key_len(active_index, keypart_map);
 
1475
    uint key_len= calculate_key_len(table, active_index, key, keypart_map);
376
1476
    return index_read_last(buf, key, key_len);
377
1477
  }
378
1478
  virtual int read_range_first(const key_range *start_key,
380
1480
                               bool eq_range, bool sorted);
381
1481
  virtual int read_range_next();
382
1482
  int compare_key(key_range *range);
383
 
  virtual int rnd_next(unsigned char *)=0;
384
 
  virtual int rnd_pos(unsigned char *, unsigned char *)=0;
385
 
  virtual int read_first_row(unsigned char *buf, uint32_t primary_key);
386
 
  virtual int rnd_same(unsigned char *, uint32_t)
387
 
    { return HA_ERR_WRONG_COMMAND; }
388
 
  virtual ha_rows records_in_range(uint32_t, key_range *, key_range *)
 
1483
  int compare_key2(key_range *range);
 
1484
  virtual int rnd_next(uchar *buf __attribute__((unused)))=0;
 
1485
  virtual int rnd_pos(uchar * buf __attribute__((unused)),
 
1486
                      uchar *pos __attribute__((unused)))=0;
 
1487
  /**
 
1488
    One has to use this method when to find
 
1489
    random position by record as the plain
 
1490
    position() call doesn't work for some
 
1491
    handlers for random position.
 
1492
  */
 
1493
  virtual int rnd_pos_by_record(uchar *record);
 
1494
  virtual int read_first_row(uchar *buf, uint primary_key);
 
1495
  /**
 
1496
    The following function is only needed for tables that may be temporary
 
1497
    tables during joins.
 
1498
  */
 
1499
  virtual int restart_rnd_next(uchar *buf __attribute__((unused)),
 
1500
                               uchar *pos __attribute__((unused)))
 
1501
    { return HA_ERR_WRONG_COMMAND; }
 
1502
  virtual int rnd_same(uchar *buf __attribute__((unused)),
 
1503
                       uint inx __attribute__((unused)))
 
1504
    { return HA_ERR_WRONG_COMMAND; }
 
1505
  virtual ha_rows records_in_range(uint inx __attribute__((unused)),
 
1506
                                   key_range *min_key __attribute__((unused)),
 
1507
                                   key_range *max_key __attribute__((unused)))
389
1508
    { return (ha_rows) 10; }
390
 
  virtual void position(const unsigned char *record)=0;
391
 
  virtual int info(uint32_t)=0; // see my_base.h for full description
392
 
  virtual uint32_t calculate_key_hash_value(Field **)
 
1509
  virtual void position(const uchar *record)=0;
 
1510
  virtual int info(uint)=0; // see my_base.h for full description
 
1511
  virtual uint32_t calculate_key_hash_value(Field **field_array __attribute__((unused)))
393
1512
  { assert(0); return 0; }
394
 
  virtual int extra(enum ha_extra_function)
 
1513
  virtual int extra(enum ha_extra_function operation __attribute__((unused)))
395
1514
  { return 0; }
396
 
  virtual int extra_opt(enum ha_extra_function operation, uint32_t)
 
1515
  virtual int extra_opt(enum ha_extra_function operation,
 
1516
                        uint32_t cache_size __attribute__((unused)))
397
1517
  { return extra(operation); }
398
1518
 
399
1519
  /**
417
1537
  */
418
1538
  virtual void try_semi_consistent_read(bool) {}
419
1539
  virtual void unlock_row(void) {}
 
1540
  virtual int start_stmt(THD *thd __attribute__((unused)),
 
1541
                         thr_lock_type lock_type __attribute__((unused)))
 
1542
  {return 0;}
420
1543
  virtual void get_auto_increment(uint64_t offset, uint64_t increment,
421
1544
                                  uint64_t nb_desired_values,
422
1545
                                  uint64_t *first_value,
423
 
                                  uint64_t *nb_reserved_values)= 0;
424
 
 
 
1546
                                  uint64_t *nb_reserved_values);
425
1547
  void set_next_insert_id(uint64_t id)
426
1548
  {
427
1549
    next_insert_id= id;
442
1564
      insert_id_for_cur_row;
443
1565
  }
444
1566
 
 
1567
  virtual void update_create_info(HA_CREATE_INFO *create_info __attribute__((unused))) {}
 
1568
  int check_old_types(void);
 
1569
  virtual int assign_to_keycache(THD* thd __attribute__((unused)),
 
1570
                                 HA_CHECK_OPT* check_opt __attribute__((unused)))
 
1571
  { return HA_ADMIN_NOT_IMPLEMENTED; }
445
1572
  /* end of the list of admin commands */
446
1573
 
447
1574
  virtual int indexes_are_disabled(void) {return 0;}
448
 
  virtual void append_create_info(String *)
 
1575
  virtual char *update_table_comment(const char * comment)
 
1576
  { return (char*) comment;}
 
1577
  virtual void append_create_info(String *packet __attribute__((unused)))
449
1578
  {}
450
1579
  /**
451
1580
      If index == MAX_KEY then a check for table is made and if index <
457
1586
    @retval   true            Foreign key defined on table or index
458
1587
    @retval   false           No foreign key defined
459
1588
  */
 
1589
  virtual bool is_fk_defined_on_table_or_index(uint index __attribute__((unused)))
 
1590
  { return false; }
460
1591
  virtual char* get_foreign_key_create_info(void)
461
 
  { return NULL;}  /* gets foreign key create string from InnoDB */
462
 
  /** used in ALTER Table; if changing storage engine is allowed.
463
 
      e.g. not be allowed if table has foreign key constraints in engine.
464
 
   */
465
 
  virtual bool can_switch_engines(void) { return true; }
 
1592
  { return(NULL);}  /* gets foreign key create string from InnoDB */
 
1593
  /** used in ALTER TABLE; 1 if changing storage engine is allowed */
 
1594
  virtual bool can_switch_engines(void) { return 1; }
466
1595
  /** used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
467
 
  virtual int get_foreign_key_list(Session *, List<ForeignKeyInfo> *)
 
1596
  virtual int get_foreign_key_list(THD *thd __attribute__((unused)),
 
1597
                                   List<FOREIGN_KEY_INFO> *f_key_list __attribute__((unused)))
468
1598
  { return 0; }
469
 
  virtual uint32_t referenced_by_foreign_key() { return 0;}
470
 
  virtual void free_foreign_key_create_info(char *) {}
471
 
 
 
1599
  virtual uint referenced_by_foreign_key() { return 0;}
 
1600
  virtual void init_table_handle_for_HANDLER()
 
1601
  { return; }       /* prepare InnoDB for HANDLER */
 
1602
  virtual void free_foreign_key_create_info(char* str __attribute__((unused))) {}
 
1603
  /** The following can be called without an open handler */
 
1604
  virtual const char *table_type() const =0;
 
1605
  /**
 
1606
    If frm_error() is called then we will use this to find out what file
 
1607
    extentions exist for the storage engine. This is also used by the default
 
1608
    rename_table and delete_table method in handler.cc.
 
1609
 
 
1610
    For engines that have two file name extentions (separate meta/index file
 
1611
    and data file), the order of elements is relevant. First element of engine
 
1612
    file name extentions array should be meta/index file extention. Second
 
1613
    element - data file extention. This order is assumed by
 
1614
    prepare_for_repair() when REPAIR TABLE ... USE_FRM is issued.
 
1615
  */
 
1616
  virtual const char **bas_ext() const =0;
 
1617
 
 
1618
  virtual int get_default_no_partitions(HA_CREATE_INFO *info __attribute__((unused))) { return 1;}
 
1619
  virtual bool get_no_parts(const char *name __attribute__((unused)),
 
1620
                            uint *no_parts)
 
1621
  {
 
1622
    *no_parts= 0;
 
1623
    return 0;
 
1624
  }
 
1625
 
 
1626
  virtual uint32_t index_flags(uint idx, uint part, bool all_parts) const =0;
 
1627
 
 
1628
  virtual int add_index(TABLE *table_arg __attribute__((unused)),
 
1629
                        KEY *key_info __attribute__((unused)),
 
1630
                        uint num_of_keys __attribute__((unused)))
 
1631
  { return (HA_ERR_WRONG_COMMAND); }
 
1632
  virtual int prepare_drop_index(TABLE *table_arg __attribute__((unused)),
 
1633
                                 uint *key_num __attribute__((unused)),
 
1634
                                 uint num_of_keys __attribute__((unused)))
 
1635
  { return (HA_ERR_WRONG_COMMAND); }
 
1636
  virtual int final_drop_index(TABLE *table_arg __attribute__((unused)))
 
1637
  { return (HA_ERR_WRONG_COMMAND); }
 
1638
 
 
1639
  uint max_record_length() const
 
1640
  { return min(HA_MAX_REC_LENGTH, max_supported_record_length()); }
 
1641
  uint max_keys() const
 
1642
  { return min(MAX_KEY, max_supported_keys()); }
 
1643
  uint max_key_parts() const
 
1644
  { return min(MAX_REF_PARTS, max_supported_key_parts()); }
 
1645
  uint max_key_length() const
 
1646
  { return min(MAX_KEY_LENGTH, max_supported_key_length()); }
 
1647
  uint max_key_part_length(void) const
 
1648
  { return min(MAX_KEY_LENGTH, max_supported_key_part_length()); }
 
1649
 
 
1650
  virtual uint max_supported_record_length(void) const
 
1651
  { return HA_MAX_REC_LENGTH; }
 
1652
  virtual uint max_supported_keys(void) const { return 0; }
 
1653
  virtual uint max_supported_key_parts(void) const { return MAX_REF_PARTS; }
 
1654
  virtual uint max_supported_key_length(void) const { return MAX_KEY_LENGTH; }
 
1655
  virtual uint max_supported_key_part_length(void) const { return 255; }
 
1656
  virtual uint min_record_length(uint options __attribute__((unused))) const
 
1657
  { return 1; }
 
1658
 
 
1659
  virtual bool low_byte_first(void) const { return 1; }
 
1660
  virtual uint checksum(void) const { return 0; }
 
1661
  virtual bool is_crashed(void) const  { return 0; }
 
1662
  virtual bool auto_repair(void) const { return 0; }
 
1663
 
 
1664
 
 
1665
#define CHF_CREATE_FLAG 0
 
1666
#define CHF_DELETE_FLAG 1
 
1667
#define CHF_RENAME_FLAG 2
 
1668
 
 
1669
 
 
1670
  /**
 
1671
    @note lock_count() can return > 1 if the table is MERGE or partitioned.
 
1672
  */
 
1673
  virtual uint lock_count(void) const { return 1; }
472
1674
  /**
473
1675
    Is not invoked for non-transactional temporary tables.
474
1676
 
476
1678
    or partitioned.
477
1679
 
478
1680
    @note that one can NOT rely on table->in_use in store_lock().  It may
479
 
    refer to a different thread if called from abortLockForThread().
 
1681
    refer to a different thread if called from mysql_lock_abort_for_thread().
480
1682
 
481
1683
    @note If the table is MERGE, store_lock() can return less locks
482
1684
    than lock_count() claimed. This can happen when the MERGE children
483
1685
    are not attached when this is called from another thread.
484
1686
  */
485
 
  virtual THR_LOCK_DATA **store_lock(Session *,
 
1687
  virtual THR_LOCK_DATA **store_lock(THD *thd,
486
1688
                                     THR_LOCK_DATA **to,
487
 
                                     enum thr_lock_type)
 
1689
                                     enum thr_lock_type lock_type)=0;
 
1690
 
 
1691
  /** Type of table for caching query */
 
1692
  virtual uint8_t table_cache_type() { return HA_CACHE_TBL_NONTRANSACT; }
 
1693
 
 
1694
 
 
1695
  /**
 
1696
    @brief Register a named table with a call back function to the query cache.
 
1697
 
 
1698
    @param thd The thread handle
 
1699
    @param table_key A pointer to the table name in the table cache
 
1700
    @param key_length The length of the table name
 
1701
    @param[out] engine_callback The pointer to the storage engine call back
 
1702
      function
 
1703
    @param[out] engine_data Storage engine specific data which could be
 
1704
      anything
 
1705
 
 
1706
    This method offers the storage engine, the possibility to store a reference
 
1707
    to a table name which is going to be used with query cache. 
 
1708
    The method is called each time a statement is written to the cache and can
 
1709
    be used to verify if a specific statement is cachable. It also offers
 
1710
    the possibility to register a generic (but static) call back function which
 
1711
    is called each time a statement is matched against the query cache.
 
1712
 
 
1713
    @note If engine_data supplied with this function is different from
 
1714
      engine_data supplied with the callback function, and the callback returns
 
1715
      false, a table invalidation on the current table will occur.
 
1716
 
 
1717
    @return Upon success the engine_callback will point to the storage engine
 
1718
      call back function, if any, and engine_data will point to any storage
 
1719
      engine data used in the specific implementation.
 
1720
      @retval true Success
 
1721
      @retval false The specified table or current statement should not be
 
1722
        cached
 
1723
  */
 
1724
 
 
1725
  virtual bool
 
1726
    register_query_cache_table(THD *thd __attribute__((unused)),
 
1727
                               char *table_key __attribute__((unused)),
 
1728
                               uint key_length __attribute__((unused)),
 
1729
                               qc_engine_callback *engine_callback,
 
1730
                               uint64_t *engine_data __attribute__((unused)))
488
1731
  {
489
 
    assert(0); // Impossible programming situation
490
 
 
491
 
    return(to);
 
1732
    *engine_callback= 0;
 
1733
    return true;
492
1734
  }
493
1735
 
 
1736
 
494
1737
 /*
495
1738
   @retval true   Primary key (if there is one) is clustered
496
1739
                  key covering all fields
497
1740
   @retval false  otherwise
498
1741
 */
499
1742
 virtual bool primary_key_is_clustered() { return false; }
500
 
 virtual int cmp_ref(const unsigned char *ref1, const unsigned char *ref2)
 
1743
 virtual int cmp_ref(const uchar *ref1, const uchar *ref2)
501
1744
 {
502
1745
   return memcmp(ref1, ref2, ref_length);
503
1746
 }
504
1747
 
505
 
  virtual bool isOrdered(void)
 
1748
 /*
 
1749
   Condition pushdown to storage engines
 
1750
 */
 
1751
 
 
1752
 /**
 
1753
   Push condition down to the table handler.
 
1754
 
 
1755
   @param  cond   Condition to be pushed. The condition tree must not be
 
1756
                  modified by the by the caller.
 
1757
 
 
1758
   @return
 
1759
     The 'remainder' condition that caller must use to filter out records.
 
1760
     NULL means the handler will not return rows that do not match the
 
1761
     passed condition.
 
1762
 
 
1763
   @note
 
1764
   The pushed conditions form a stack (from which one can remove the
 
1765
   last pushed condition using cond_pop).
 
1766
   The table handler filters out rows using (pushed_cond1 AND pushed_cond2 
 
1767
   AND ... AND pushed_condN)
 
1768
   or less restrictive condition, depending on handler's capabilities.
 
1769
 
 
1770
   handler->ha_reset() call empties the condition stack.
 
1771
   Calls to rnd_init/rnd_end, index_init/index_end etc do not affect the
 
1772
   condition stack.
 
1773
 */ 
 
1774
 virtual const COND *cond_push(const COND *cond) { return cond; }
 
1775
 
 
1776
 /**
 
1777
   Pop the top condition from the condition stack of the handler instance.
 
1778
 
 
1779
   Pops the top if condition stack, if stack is not empty.
 
1780
 */
 
1781
 virtual void cond_pop(void) { return; }
 
1782
 
 
1783
 virtual Item
 
1784
   *idx_cond_push(uint keyno __attribute__((unused)),
 
1785
                  Item* idx_cond __attribute__((unused)))
 
1786
 { return idx_cond; }
 
1787
 
 
1788
 /*
 
1789
    Part of old fast alter table, to be depricated
 
1790
  */
 
1791
 virtual bool
 
1792
   check_if_incompatible_data(HA_CREATE_INFO *create_info __attribute__((unused)),
 
1793
                              uint table_changes __attribute__((unused)))
 
1794
 { return COMPATIBLE_DATA_NO; }
 
1795
 
 
1796
 /* On-line ALTER TABLE interface */
 
1797
 
 
1798
 /**
 
1799
    Check if a storage engine supports a particular alter table on-line
 
1800
 
 
1801
    @param    altered_table     A temporary table show what table is to
 
1802
                                change to
 
1803
    @param    create_info       Information from the parsing phase about new
 
1804
                                table properties.
 
1805
    @param    alter_flags       Bitmask that shows what will be changed
 
1806
    @param    table_changes     Shows if table layout has changed (for
 
1807
                                backwards compatibility with
 
1808
                                check_if_incompatible_data
 
1809
 
 
1810
    @retval   HA_ALTER_ERROR                Unexpected error
 
1811
    @retval   HA_ALTER_SUPPORTED_WAIT_LOCK  Supported, but requires DDL lock
 
1812
    @retval   HA_ALTER_SUPPORTED_NO_LOCK    Supported
 
1813
    @retval   HA_ALTER_NOT_SUPPORTED        Not supported
 
1814
 
 
1815
    @note
 
1816
      The default implementation is implemented to support fast
 
1817
      alter table (storage engines that support some changes by
 
1818
      just changing the frm file) without any change in the handler
 
1819
      implementation.
 
1820
 */
 
1821
 virtual int
 
1822
   check_if_supported_alter(TABLE *altered_table __attribute__((unused)),
 
1823
                            HA_CREATE_INFO *create_info,
 
1824
                            HA_ALTER_FLAGS *alter_flags __attribute__((unused)),
 
1825
                            uint table_changes)
 
1826
 {
 
1827
   if (this->check_if_incompatible_data(create_info, table_changes)
 
1828
       == COMPATIBLE_DATA_NO)
 
1829
     return(HA_ALTER_NOT_SUPPORTED);
 
1830
   else
 
1831
     return(HA_ALTER_SUPPORTED_WAIT_LOCK);
 
1832
 }
 
1833
 /**
 
1834
   Tell storage engine to prepare for the on-line alter table (pre-alter)
 
1835
 
 
1836
   @param     thd               The thread handle
 
1837
   @param     altered_table     A temporary table show what table is to
 
1838
                                change to
 
1839
   @param     alter_info        Storage place for data used during phase1
 
1840
                                and phase2
 
1841
   @param     alter_flags       Bitmask that shows what will be changed
 
1842
 
 
1843
   @retval   0      OK
 
1844
   @retval   error  error code passed from storage engine
 
1845
 */
 
1846
 virtual int alter_table_phase1(THD *thd __attribute__((unused)),
 
1847
                                TABLE *altered_table __attribute__((unused)),
 
1848
                                HA_CREATE_INFO *create_info __attribute__((unused)),
 
1849
                                HA_ALTER_INFO *alter_info __attribute__((unused)),
 
1850
                                HA_ALTER_FLAGS *alter_flags  __attribute__((unused)))
 
1851
 {
 
1852
   return HA_ERR_UNSUPPORTED;
 
1853
 }
 
1854
 /**
 
1855
    Tell storage engine to perform the on-line alter table (alter)
 
1856
 
 
1857
    @param    thd               The thread handle
 
1858
    @param    altered_table     A temporary table show what table is to
 
1859
                                change to
 
1860
    @param    alter_info        Storage place for data used during phase1
 
1861
                                and phase2
 
1862
    @param    alter_flags       Bitmask that shows what will be changed
 
1863
 
 
1864
    @retval  0      OK
 
1865
    @retval  error  error code passed from storage engine
 
1866
 
 
1867
    @note
 
1868
      If check_if_supported_alter returns HA_ALTER_SUPPORTED_WAIT_LOCK
 
1869
      this call is to be wrapped with a DDL lock. This is currently NOT
 
1870
      supported.
 
1871
 */
 
1872
 virtual int alter_table_phase2(THD *thd  __attribute__((unused)),
 
1873
                                TABLE *altered_table  __attribute__((unused)),
 
1874
                                HA_CREATE_INFO *create_info __attribute__((unused)),
 
1875
                                HA_ALTER_INFO *alter_info __attribute__((unused)),
 
1876
                                HA_ALTER_FLAGS *alter_flags __attribute__((unused)))
 
1877
 {
 
1878
   return HA_ERR_UNSUPPORTED;
 
1879
 }
 
1880
 /**
 
1881
    Tell storage engine that changed frm file is now on disk and table
 
1882
    has been re-opened (post-alter)
 
1883
 
 
1884
    @param    thd               The thread handle
 
1885
    @param    table             The altered table, re-opened
 
1886
 */
 
1887
 virtual int alter_table_phase3(THD *thd __attribute__((unused)),
 
1888
                                TABLE *table __attribute__((unused)))
 
1889
 {
 
1890
   return HA_ERR_UNSUPPORTED;
 
1891
 }
 
1892
 
 
1893
  /**
 
1894
    use_hidden_primary_key() is called in case of an update/delete when
 
1895
    (table_flags() and HA_PRIMARY_KEY_REQUIRED_FOR_DELETE) is defined
 
1896
    but we don't have a primary key
 
1897
  */
 
1898
  virtual void use_hidden_primary_key();
 
1899
 
 
1900
  /**
 
1901
    Lock table.
 
1902
 
 
1903
    @param    thd                     Thread handle
 
1904
    @param    lock_type               HA_LOCK_IN_SHARE_MODE     (F_RDLCK)
 
1905
                                      HA_LOCK_IN_EXCLUSIVE_MODE (F_WRLCK)
 
1906
    @param    lock_timeout            -1 default timeout
 
1907
                                      0  no wait
 
1908
                                      >0 wait timeout in milliseconds.
 
1909
 
 
1910
   @note
 
1911
      lock_timeout >0 is not used by MySQL currently. If the storage
 
1912
      engine does not support NOWAIT (lock_timeout == 0) it should
 
1913
      return an error. But if it does not support WAIT X (lock_timeout
 
1914
      >0) it should treat it as lock_timeout == -1 and wait a default
 
1915
      (or even hard-coded) timeout.
 
1916
 
 
1917
    @retval HA_ERR_WRONG_COMMAND      Storage engine does not support
 
1918
                                      lock_table()
 
1919
    @retval HA_ERR_UNSUPPORTED        Storage engine does not support NOWAIT
 
1920
    @retval HA_ERR_LOCK_WAIT_TIMEOUT  Lock request timed out or
 
1921
                                      lock conflict with NOWAIT option
 
1922
    @retval HA_ERR_LOCK_DEADLOCK      Deadlock detected
 
1923
  */
 
1924
  virtual int lock_table(THD *thd         __attribute__((unused)),
 
1925
                         int lock_type    __attribute__((unused)),
 
1926
                         int lock_timeout __attribute__((unused)))
506
1927
  {
507
 
    return false;
 
1928
    return HA_ERR_WRONG_COMMAND;
508
1929
  }
509
1930
 
510
 
 
511
1931
protected:
512
1932
  /* Service methods for use by storage engines. */
513
 
  void ha_statistic_increment(uint64_t system_status_var::*offset) const;
514
 
  void **ha_data(Session *) const;
 
1933
  void ha_statistic_increment(ulong SSV::*offset) const;
 
1934
  void **ha_data(THD *) const;
 
1935
  THD *ha_thd(void) const;
 
1936
 
 
1937
  /**
 
1938
    Default rename_table() and delete_table() rename/delete files with a
 
1939
    given name and extensions from bas_ext().
 
1940
 
 
1941
    These methods can be overridden, but their default implementation
 
1942
    provide useful functionality.
 
1943
  */
 
1944
  virtual int rename_table(const char *from, const char *to);
 
1945
  /**
 
1946
    Delete a table in the engine. Called for base as well as temporary
 
1947
    tables.
 
1948
  */
 
1949
  virtual int delete_table(const char *name);
515
1950
 
516
1951
private:
517
1952
  /* Private helpers */
518
 
  inline void setTransactionReadWrite();
 
1953
  inline void mark_trx_read_write();
519
1954
private:
520
1955
  /*
521
1956
    Low-level primitives for storage engines.  These should be
523
1958
    the corresponding 'ha_*' method above.
524
1959
  */
525
1960
 
526
 
  virtual int open(const char *, int , uint32_t ) { assert(0); return -1; }
527
 
  virtual int doOpen(const identifier::Table &identifier, int mode, uint32_t test_if_locked);
528
 
  virtual int doStartIndexScan(uint32_t idx, bool)
 
1961
  virtual int open(const char *name, int mode, uint test_if_locked)=0;
 
1962
  virtual int index_init(uint idx,
 
1963
                         bool sorted __attribute__((unused)))
529
1964
  { active_index= idx; return 0; }
530
 
  virtual int doEndIndexScan() { active_index= MAX_KEY; return 0; }
 
1965
  virtual int index_end() { active_index= MAX_KEY; return 0; }
531
1966
  /**
532
 
    doStartTableScan() can be called two times without doEndTableScan() in between
 
1967
    rnd_init() can be called two times without rnd_end() in between
533
1968
    (it only makes sense if scan=1).
534
1969
    then the second call should prepare for the new table scan (e.g
535
1970
    if rnd_init allocates the cursor, second call should position it
536
1971
    to the start of the table, no need to deallocate and allocate it again
537
1972
  */
538
 
  virtual int doStartTableScan(bool scan) __attribute__ ((warn_unused_result)) = 0;
539
 
  virtual int doEndTableScan() { return 0; }
540
 
  virtual int doInsertRecord(unsigned char *)
541
 
  {
542
 
    return HA_ERR_WRONG_COMMAND;
543
 
  }
544
 
 
545
 
  virtual int doUpdateRecord(const unsigned char *, unsigned char *)
546
 
  {
547
 
    return HA_ERR_WRONG_COMMAND;
548
 
  }
549
 
 
550
 
  virtual int doDeleteRecord(const unsigned char *)
 
1973
  virtual int rnd_init(bool scan)= 0;
 
1974
  virtual int rnd_end() { return 0; }
 
1975
  virtual int write_row(uchar *buf __attribute__((unused)))
 
1976
  {
 
1977
    return HA_ERR_WRONG_COMMAND;
 
1978
  }
 
1979
 
 
1980
  virtual int update_row(const uchar *old_data __attribute__((unused)),
 
1981
                         uchar *new_data __attribute__((unused)))
 
1982
  {
 
1983
    return HA_ERR_WRONG_COMMAND;
 
1984
  }
 
1985
 
 
1986
  virtual int delete_row(const uchar *buf __attribute__((unused)))
551
1987
  {
552
1988
    return HA_ERR_WRONG_COMMAND;
553
1989
  }
557
1993
    by that statement.
558
1994
  */
559
1995
  virtual int reset() { return 0; }
 
1996
  virtual Table_flags table_flags(void) const= 0;
560
1997
 
561
1998
  /**
562
1999
    Is not invoked for non-transactional temporary tables.
563
2000
 
564
2001
    Tells the storage engine that we intend to read or write data
565
 
    from the table. This call is prefixed with a call to Cursor::store_lock()
566
 
    and is invoked only for those Cursor instances that stored the lock.
 
2002
    from the table. This call is prefixed with a call to handler::store_lock()
 
2003
    and is invoked only for those handler instances that stored the lock.
567
2004
 
568
2005
    Calls to rnd_init/index_init are prefixed with this call. When table
569
2006
    IO is complete, we call external_lock(F_UNLCK).
580
2017
    @return  non-0 in case of failure, 0 in case of success.
581
2018
    When lock_type is F_UNLCK, the return value is ignored.
582
2019
  */
583
 
  virtual int external_lock(Session *, int)
 
2020
  virtual int external_lock(THD *thd __attribute__((unused)),
 
2021
                            int lock_type __attribute__((unused)))
584
2022
  {
585
2023
    return 0;
586
2024
  }
587
 
  virtual void release_auto_increment(void) { return; }
 
2025
  virtual void release_auto_increment(void) { return; };
588
2026
  /** admin commands - called from mysql_admin_table */
589
 
  virtual int check(Session *)
 
2027
  virtual int check_for_upgrade(HA_CHECK_OPT *check_opt __attribute__((unused)))
 
2028
  { return 0; }
 
2029
  virtual int check(THD* thd __attribute__((unused)),
 
2030
                    HA_CHECK_OPT* check_opt __attribute__((unused)))
590
2031
  { return HA_ADMIN_NOT_IMPLEMENTED; }
591
2032
 
592
 
  virtual void start_bulk_insert(ha_rows)
 
2033
  /**
 
2034
     In this method check_opt can be modified
 
2035
     to specify CHECK option to use to call check()
 
2036
     upon the table.
 
2037
  */
 
2038
  virtual int repair(THD* thd __attribute__((unused)),
 
2039
                     HA_CHECK_OPT* check_opt __attribute__((unused)))
 
2040
  { return HA_ADMIN_NOT_IMPLEMENTED; }
 
2041
  virtual void start_bulk_insert(ha_rows rows __attribute__((unused)))
593
2042
  {}
594
2043
  virtual int end_bulk_insert(void) { return 0; }
595
 
  virtual int index_read(unsigned char *, const unsigned char *,
596
 
                         uint32_t, enum ha_rkey_function)
 
2044
  virtual int index_read(uchar * buf __attribute__((unused)),
 
2045
                         const uchar * key __attribute__((unused)),
 
2046
                         uint key_len __attribute__((unused)),
 
2047
                         enum ha_rkey_function find_flag __attribute__((unused)))
597
2048
   { return  HA_ERR_WRONG_COMMAND; }
598
 
  virtual int index_read_last(unsigned char *, const unsigned char *, uint32_t)
599
 
   { return (errno= HA_ERR_WRONG_COMMAND); }
 
2049
  virtual int index_read_last(uchar * buf __attribute__((unused)),
 
2050
                              const uchar * key __attribute__((unused)),
 
2051
                              uint key_len __attribute__((unused)))
 
2052
   { return (my_errno= HA_ERR_WRONG_COMMAND); }
 
2053
  /**
 
2054
    This method is similar to update_row, however the handler doesn't need
 
2055
    to execute the updates at this point in time. The handler can be certain
 
2056
    that another call to bulk_update_row will occur OR a call to
 
2057
    exec_bulk_update before the set of updates in this query is concluded.
 
2058
 
 
2059
    @param    old_data       Old record
 
2060
    @param    new_data       New record
 
2061
    @param    dup_key_found  Number of duplicate keys found
 
2062
 
 
2063
    @retval  0   Bulk delete used by handler
 
2064
    @retval  1   Bulk delete not used, normal operation used
 
2065
  */
 
2066
  virtual int bulk_update_row(const uchar *old_data __attribute__((unused)),
 
2067
                              uchar *new_data __attribute__((unused)),
 
2068
                              uint *dup_key_found __attribute__((unused)))
 
2069
  {
 
2070
    assert(false);
 
2071
    return HA_ERR_WRONG_COMMAND;
 
2072
  }
600
2073
  /**
601
2074
    This is called to delete all rows in a table
602
 
    If the Cursor don't support this, then this function will
 
2075
    If the handler don't support this, then this function will
603
2076
    return HA_ERR_WRONG_COMMAND and MySQL will delete the rows one
604
2077
    by one.
605
2078
  */
606
2079
  virtual int delete_all_rows(void)
607
 
  { return (errno=HA_ERR_WRONG_COMMAND); }
 
2080
  { return (my_errno=HA_ERR_WRONG_COMMAND); }
608
2081
  /**
609
2082
    Reset the auto-increment counter to the given value, i.e. the next row
610
2083
    inserted will get the given value. This is called e.g. after TRUNCATE
611
2084
    is emulated by doing a 'DELETE FROM t'. HA_ERR_WRONG_COMMAND is
612
2085
    returned by storage engines that don't support this operation.
613
2086
  */
614
 
  virtual int reset_auto_increment(uint64_t)
615
 
  { return HA_ERR_WRONG_COMMAND; }
616
 
 
617
 
  virtual int analyze(Session *)
618
 
  { return HA_ADMIN_NOT_IMPLEMENTED; }
619
 
 
620
 
  virtual int disable_indexes(uint32_t)
621
 
  { return HA_ERR_WRONG_COMMAND; }
622
 
 
623
 
  virtual int enable_indexes(uint32_t)
624
 
  { return HA_ERR_WRONG_COMMAND; }
625
 
 
626
 
  virtual int discard_or_import_tablespace(bool)
627
 
  { return (errno=HA_ERR_WRONG_COMMAND); }
628
 
 
629
 
  /* 
630
 
    @todo this is just for the HEAP engine, it should
631
 
    be removed at some point in the future (and
632
 
    no new engine should ever use it). Right
633
 
    now HEAP does rely on it, so we cannot remove it.
634
 
  */
 
2087
  virtual int reset_auto_increment(uint64_t value __attribute__((unused)))
 
2088
  { return HA_ERR_WRONG_COMMAND; }
 
2089
  virtual int optimize(THD* thd __attribute__((unused)),
 
2090
                       HA_CHECK_OPT* check_opt __attribute__((unused)))
 
2091
  { return HA_ADMIN_NOT_IMPLEMENTED; }
 
2092
  virtual int analyze(THD* thd __attribute__((unused)),
 
2093
                      HA_CHECK_OPT* check_opt __attribute__((unused)))
 
2094
  { return HA_ADMIN_NOT_IMPLEMENTED; }
 
2095
  virtual bool check_and_repair(THD *thd __attribute__((unused)))
 
2096
  { return true; }
 
2097
  virtual int disable_indexes(uint mode __attribute__((unused)))
 
2098
  { return HA_ERR_WRONG_COMMAND; }
 
2099
  virtual int enable_indexes(uint mode __attribute__((unused)))
 
2100
  { return HA_ERR_WRONG_COMMAND; }
 
2101
  virtual int discard_or_import_tablespace(bool discard __attribute__((unused)))
 
2102
  { return (my_errno=HA_ERR_WRONG_COMMAND); }
 
2103
  virtual void prepare_for_alter(void) { return; }
635
2104
  virtual void drop_table(const char *name);
 
2105
  virtual int create(const char *name __attribute__((unused)),
 
2106
                     TABLE *form __attribute__((unused)),
 
2107
                     HA_CREATE_INFO *info __attribute__((unused)))=0;
 
2108
 
 
2109
  virtual int create_handler_files(const char *name __attribute__((unused)),
 
2110
                                   const char *old_name __attribute__((unused)),
 
2111
                                   int action_flag __attribute__((unused)),
 
2112
                                   HA_CREATE_INFO *info __attribute__((unused)))
 
2113
  { return false; }
 
2114
};
 
2115
 
 
2116
 
 
2117
 
 
2118
/**
 
2119
  A Disk-Sweep MRR interface implementation
 
2120
 
 
2121
  This implementation makes range (and, in the future, 'ref') scans to read
 
2122
  table rows in disk sweeps. 
 
2123
  
 
2124
  Currently it is used by MyISAM and InnoDB. Potentially it can be used with
 
2125
  any table handler that has non-clustered indexes and on-disk rows.
 
2126
*/
 
2127
 
 
2128
class DsMrr_impl
 
2129
{
 
2130
public:
 
2131
  typedef void (handler::*range_check_toggle_func_t)(bool on);
 
2132
 
 
2133
  DsMrr_impl()
 
2134
    : h2(NULL) {};
 
2135
 
 
2136
  handler *h; /* The "owner" handler object. It is used for scanning the index */
 
2137
  TABLE *table; /* Always equal to h->table */
 
2138
private:
 
2139
  /*
 
2140
    Secondary handler object. It is used to retrieve full table rows by
 
2141
    calling rnd_pos().
 
2142
  */
 
2143
  handler *h2;
 
2144
 
 
2145
  /* Buffer to store rowids, or (rowid, range_id) pairs */
 
2146
  uchar *rowids_buf;
 
2147
  uchar *rowids_buf_cur;   /* Current position when reading/writing */
 
2148
  uchar *rowids_buf_last;  /* When reading: end of used buffer space */
 
2149
  uchar *rowids_buf_end;   /* End of the buffer */
 
2150
 
 
2151
  bool dsmrr_eof; /* true <=> We have reached EOF when reading index tuples */
 
2152
 
 
2153
  /* true <=> need range association, buffer holds {rowid, range_id} pairs */
 
2154
  bool is_mrr_assoc;
 
2155
 
 
2156
  bool use_default_impl; /* true <=> shortcut all calls to default MRR impl */
 
2157
public:
 
2158
  void init(handler *h_arg, TABLE *table_arg)
 
2159
  {
 
2160
    h= h_arg; 
 
2161
    table= table_arg;
 
2162
  }
 
2163
  int dsmrr_init(handler *h, KEY *key, RANGE_SEQ_IF *seq_funcs, 
 
2164
                 void *seq_init_param, uint n_ranges, uint mode, 
 
2165
                 HANDLER_BUFFER *buf);
 
2166
  void dsmrr_close();
 
2167
  int dsmrr_fill_buffer(handler *h);
 
2168
  int dsmrr_next(handler *h, char **range_info);
 
2169
 
 
2170
  int dsmrr_info(uint keyno, uint n_ranges, uint keys, uint *bufsz,
 
2171
                 uint *flags, COST_VECT *cost);
 
2172
 
 
2173
  ha_rows dsmrr_info_const(uint keyno, RANGE_SEQ_IF *seq, 
 
2174
                            void *seq_init_param, uint n_ranges, uint *bufsz,
 
2175
                            uint *flags, COST_VECT *cost);
 
2176
private:
 
2177
  bool key_uses_partial_cols(uint keyno);
 
2178
  bool choose_mrr_impl(uint keyno, ha_rows rows, uint *flags, uint *bufsz, 
 
2179
                       COST_VECT *cost);
 
2180
  bool get_disk_sweep_mrr_cost(uint keynr, ha_rows rows, uint flags, 
 
2181
                               uint *buffer_size, COST_VECT *cost);
636
2182
};
637
2183
 
638
2184
extern const char *ha_row_type[];
 
2185
extern const char *tx_isolation_names[];
 
2186
extern const char *binlog_format_names[];
 
2187
extern TYPELIB tx_isolation_typelib;
 
2188
extern TYPELIB myisam_stats_method_typelib;
 
2189
extern uint32_t total_ha, total_ha_2pc;
 
2190
 
 
2191
       /* Wrapper functions */
 
2192
#define ha_commit(thd) (ha_commit_trans((thd), true))
 
2193
#define ha_rollback(thd) (ha_rollback_trans((thd), true))
 
2194
 
 
2195
/* lookups */
 
2196
handlerton *ha_default_handlerton(THD *thd);
 
2197
plugin_ref ha_resolve_by_name(THD *thd, const LEX_STRING *name);
 
2198
plugin_ref ha_lock_engine(THD *thd, handlerton *hton);
 
2199
handlerton *ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type);
 
2200
handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc,
 
2201
                         handlerton *db_type);
 
2202
handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type,
 
2203
                          bool no_substitute, bool report_error);
 
2204
 
 
2205
 
 
2206
static inline enum legacy_db_type ha_legacy_type(const handlerton *db_type)
 
2207
{
 
2208
  return (db_type == NULL) ? DB_TYPE_UNKNOWN : db_type->db_type;
 
2209
}
 
2210
 
 
2211
static inline const char *ha_resolve_storage_engine_name(const handlerton *db_type)
 
2212
{
 
2213
  return db_type == NULL ? "UNKNOWN" : hton2plugin[db_type->slot]->name.str;
 
2214
}
 
2215
 
 
2216
static inline bool ha_check_storage_engine_flag(const handlerton *db_type, uint32_t flag)
 
2217
{
 
2218
  return db_type == NULL ? false : test(db_type->flags & flag);
 
2219
}
 
2220
 
 
2221
static inline bool ha_storage_engine_is_enabled(const handlerton *db_type)
 
2222
{
 
2223
  return (db_type && db_type->create) ?
 
2224
         (db_type->state == SHOW_OPTION_YES) : false;
 
2225
}
639
2226
 
640
2227
/* basic stuff */
641
 
void ha_init_errors(void);
642
 
 
643
 
class SortField;
644
 
SortField *make_unireg_sortorder(Order *order, uint32_t *length,
645
 
                                 SortField *sortorder);
646
 
int setup_order(Session *session, Item **ref_pointer_array, TableList *tables,
647
 
                List<Item> &fields, List <Item> &all_fields, Order *order);
648
 
int setup_group(Session *session, Item **ref_pointer_array, TableList *tables,
649
 
                List<Item> &fields, List<Item> &all_fields, Order *order,
650
 
                bool *hidden_group_fields);
651
 
bool fix_inner_refs(Session *session, List<Item> &all_fields, Select_Lex *select,
652
 
                    Item **ref_pointer_array);
653
 
 
654
 
bool handle_select(Session *session, LEX *lex, select_result *result,
655
 
                   uint64_t setup_tables_done_option);
656
 
void free_underlaid_joins(Session *session, Select_Lex *select);
657
 
 
658
 
bool handle_derived(LEX *lex, bool (*processor)(Session *session,
659
 
                                                      LEX *lex,
660
 
                                                      TableList *table));
661
 
bool derived_prepare(Session *session, LEX *lex, TableList *t);
662
 
bool derived_filling(Session *session, LEX *lex, TableList *t);
663
 
int prepare_create_field(CreateField *sql_field,
664
 
                         uint32_t *blob_columns,
665
 
                         int *timestamps, int *timestamps_with_niladic);
666
 
 
667
 
bool create_table(Session *session,
668
 
                  const identifier::Table &identifier,
669
 
                  HA_CREATE_INFO *create_info,
670
 
                  message::Table &table_proto,
671
 
                  AlterInfo *alter_info,
672
 
                  bool tmp_table, uint32_t select_field_count,
673
 
                  bool is_if_not_exists);
674
 
 
675
 
bool create_table_no_lock(Session *session,
676
 
                          const identifier::Table &identifier,
677
 
                          HA_CREATE_INFO *create_info,
678
 
                          message::Table &table_proto,
679
 
                          AlterInfo *alter_info,
680
 
                          bool tmp_table, uint32_t select_field_count,
681
 
                          bool is_if_not_exists);
682
 
 
683
 
bool create_like_table(Session* session,
684
 
                       identifier::Table::const_reference destination_identifier,
685
 
                       identifier::Table::const_reference source_identifier,
686
 
                       message::Table &create_table_proto,
687
 
                       bool is_if_not_exists,
688
 
                       bool is_engine_set);
689
 
 
690
 
bool rename_table(Session &session,
691
 
                        plugin::StorageEngine *base,
692
 
                        const identifier::Table &old_identifier,
693
 
                        const identifier::Table &new_identifier);
694
 
 
695
 
bool prepare_update(Session *session, TableList *table_list,
696
 
                          Item **conds, uint32_t order_num, Order *order);
697
 
int update_query(Session *session,TableList *tables,List<Item> &fields,
698
 
                 List<Item> &values,COND *conds,
699
 
                 uint32_t order_num, Order *order, ha_rows limit,
700
 
                 enum enum_duplicates handle_duplicates, bool ignore);
701
 
bool prepare_insert(Session *session, TableList *table_list, Table *table,
702
 
                          List<Item> &fields, List_item *values,
703
 
                          List<Item> &update_fields,
704
 
                          List<Item> &update_values, enum_duplicates duplic,
705
 
                          COND **where, bool select_insert,
706
 
                          bool check_fields, bool abort_on_warning);
707
 
bool insert_query(Session *session,TableList *table,List<Item> &fields,
708
 
                  List<List_item> &values, List<Item> &update_fields,
709
 
                  List<Item> &update_values, enum_duplicates flag,
710
 
                  bool ignore);
711
 
int check_that_all_fields_are_given_values(Session *session, Table *entry,
712
 
                                           TableList *table_list);
713
 
int prepare_delete(Session *session, TableList *table_list, Item **conds);
714
 
bool delete_query(Session *session, TableList *table_list, COND *conds,
715
 
                  SQL_LIST *order, ha_rows rows, uint64_t options,
716
 
                  bool reset_auto_increment);
717
 
bool truncate(Session& session, TableList *table_list);
718
 
TableShare *get_table_share(Session *session, TableList *table_list, char *key,
719
 
                             uint32_t key_length, uint32_t db_flags, int *error);
720
 
TableShare *get_cached_table_share(const char *db, const char *table_name);
721
 
bool reopen_name_locked_table(Session* session, TableList* table_list, bool link_in);
722
 
bool reopen_tables(Session *session,bool get_locks,bool in_refresh);
723
 
void close_handle_and_leave_table_as_lock(Table *table);
724
 
bool wait_for_tables(Session *session);
725
 
bool table_is_used(Table *table, bool wait_for_name_lock);
726
 
Table *drop_locked_tables(Session *session, const drizzled::identifier::Table &identifier);
727
 
void abort_locked_tables(Session *session, const drizzled::identifier::Table &identifier);
728
 
extern Field *not_found_field;
729
 
extern Field *view_ref_found;
730
 
 
731
 
Field *
732
 
find_field_in_tables(Session *session, Item_ident *item,
733
 
                     TableList *first_table, TableList *last_table,
734
 
                     Item **ref, find_item_error_report_type report_error,
735
 
                     bool register_tree_change);
736
 
Field *
737
 
find_field_in_table_ref(Session *session, TableList *table_list,
738
 
                        const char *name, uint32_t length,
739
 
                        const char *item_name, const char *db_name,
740
 
                        const char *table_name, Item **ref,
741
 
                        bool allow_rowid,
742
 
                        uint32_t *cached_field_index_ptr,
743
 
                        bool register_tree_change, TableList **actual_table);
744
 
Field *
745
 
find_field_in_table(Session *session, Table *table, const char *name, uint32_t length,
746
 
                    bool allow_rowid, uint32_t *cached_field_index_ptr);
747
 
 
748
 
} /* namespace drizzled */
749
 
 
750
 
#endif /* DRIZZLED_CURSOR_H */
 
2228
int ha_init_errors(void);
 
2229
int ha_init(void);
 
2230
int ha_end(void);
 
2231
int ha_initialize_handlerton(st_plugin_int *plugin);
 
2232
int ha_finalize_handlerton(st_plugin_int *plugin);
 
2233
 
 
2234
TYPELIB *ha_known_exts(void);
 
2235
void ha_close_connection(THD* thd);
 
2236
bool ha_flush_logs(handlerton *db_type);
 
2237
void ha_drop_database(char* path);
 
2238
int ha_create_table(THD *thd, const char *path,
 
2239
                    const char *db, const char *table_name,
 
2240
                    HA_CREATE_INFO *create_info,
 
2241
                    bool update_create_info);
 
2242
int ha_delete_table(THD *thd, handlerton *db_type, const char *path,
 
2243
                    const char *db, const char *alias, bool generate_warning);
 
2244
 
 
2245
/* statistics and info */
 
2246
bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat);
 
2247
 
 
2248
/* discovery */
 
2249
int ha_create_table_from_engine(THD* thd, const char *db, const char *name);
 
2250
int ha_discover(THD* thd, const char* dbname, const char* name,
 
2251
                uchar** frmblob, size_t* frmlen);
 
2252
int ha_find_files(THD *thd,const char *db,const char *path,
 
2253
                  const char *wild, bool dir, List<LEX_STRING>* files);
 
2254
int ha_table_exists_in_engine(THD* thd, const char* db, const char* name);
 
2255
 
 
2256
/* key cache */
 
2257
extern "C" int ha_init_key_cache(const char *name, KEY_CACHE *key_cache);
 
2258
int ha_resize_key_cache(KEY_CACHE *key_cache);
 
2259
int ha_change_key_cache_param(KEY_CACHE *key_cache);
 
2260
int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache);
 
2261
int ha_end_key_cache(KEY_CACHE *key_cache);
 
2262
 
 
2263
/* report to InnoDB that control passes to the client */
 
2264
int ha_release_temporary_latches(THD *thd);
 
2265
 
 
2266
/* transactions: interface to handlerton functions */
 
2267
int ha_start_consistent_snapshot(THD *thd);
 
2268
int ha_commit_or_rollback_by_xid(XID *xid, bool commit);
 
2269
int ha_commit_one_phase(THD *thd, bool all);
 
2270
int ha_rollback_trans(THD *thd, bool all);
 
2271
int ha_prepare(THD *thd);
 
2272
int ha_recover(HASH *commit_list);
 
2273
 
 
2274
/* transactions: these functions never call handlerton functions directly */
 
2275
int ha_commit_trans(THD *thd, bool all);
 
2276
int ha_autocommit_or_rollback(THD *thd, int error);
 
2277
int ha_enable_transaction(THD *thd, bool on);
 
2278
 
 
2279
/* savepoints */
 
2280
int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv);
 
2281
int ha_savepoint(THD *thd, SAVEPOINT *sv);
 
2282
int ha_release_savepoint(THD *thd, SAVEPOINT *sv);
 
2283
 
 
2284
/* these are called by storage engines */
 
2285
void trans_register_ha(THD *thd, bool all, handlerton *ht);
 
2286
 
 
2287
/*
 
2288
  Storage engine has to assume the transaction will end up with 2pc if
 
2289
   - there is more than one 2pc-capable storage engine available
 
2290
   - in the current transaction 2pc was not disabled yet
 
2291
*/
 
2292
#define trans_need_2pc(thd, all)                   ((total_ha_2pc > 1) && \
 
2293
        !((all ? &thd->transaction.all : &thd->transaction.stmt)->no_2pc))
 
2294
 
 
2295
#ifdef HAVE_NDB_BINLOG
 
2296
int ha_reset_logs(THD *thd);
 
2297
int ha_binlog_index_purge_file(THD *thd, const char *file);
 
2298
void ha_reset_slave(THD *thd);
 
2299
void ha_binlog_log_query(THD *thd, handlerton *db_type,
 
2300
                         enum_binlog_command binlog_command,
 
2301
                         const char *query, uint query_length,
 
2302
                         const char *db, const char *table_name);
 
2303
void ha_binlog_wait(THD *thd);
 
2304
int ha_binlog_end(THD *thd);
 
2305
#else
 
2306
#define ha_reset_logs(a) do {} while (0)
 
2307
#define ha_binlog_index_purge_file(a,b) do {} while (0)
 
2308
#define ha_reset_slave(a) do {} while (0)
 
2309
#define ha_binlog_log_query(a,b,c,d,e,f,g) do {} while (0)
 
2310
#define ha_binlog_wait(a) do {} while (0)
 
2311
#define ha_binlog_end(a)  do {} while (0)
 
2312
#endif