handler.cc 77.4 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2006 MySQL AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
unknown's avatar
unknown committed
5
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
6

unknown's avatar
unknown committed
7 8 9 10
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
unknown's avatar
unknown committed
11

unknown's avatar
unknown committed
12 13 14 15 16 17 18
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* Handler-calling-functions */

19
#ifdef USE_PRAGMA_IMPLEMENTATION
unknown's avatar
unknown committed
20 21 22 23 24 25 26
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include "ha_heap.h"
#include "ha_myisam.h"
#include "ha_myisammrg.h"
27 28 29 30 31 32


/*
  We have dummy hanldertons in case the handler has not been compiled
  in. This will be removed in 5.1.
*/
unknown's avatar
unknown committed
33 34
#ifdef HAVE_BERKELEY_DB
#include "ha_berkeley.h"
35
extern handlerton berkeley_hton;
36
#else
unknown's avatar
foo1  
unknown committed
37 38 39
handlerton berkeley_hton = { "BerkeleyDB", SHOW_OPTION_NO,
  "Supports transactions and page-level locking", DB_TYPE_BERKELEY_DB, NULL,
  0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
40
  NULL, NULL, HTON_NO_FLAGS };
unknown's avatar
unknown committed
41
#endif
42 43
#ifdef HAVE_BLACKHOLE_DB
#include "ha_blackhole.h"
44
extern handlerton blackhole_hton;
45 46 47
#else
handlerton blackhole_hton = { "BLACKHOLE", SHOW_OPTION_NO,
  "/dev/null storage engine (anything you write to it disappears)",
unknown's avatar
foo1  
unknown committed
48 49
  DB_TYPE_BLACKHOLE_DB, NULL, 0, 0, NULL, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
50
  HTON_NO_FLAGS };
51
#endif
52 53
#ifdef HAVE_EXAMPLE_DB
#include "examples/ha_example.h"
54
extern handlerton example_hton;
55 56
#else
handlerton example_hton = { "EXAMPLE", SHOW_OPTION_NO,
unknown's avatar
foo1  
unknown committed
57 58 59
  "Example storage engine",
  DB_TYPE_EXAMPLE_DB, NULL, 0, 0, NULL, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
60
  HTON_NO_FLAGS };
61
#endif
62
#if defined(HAVE_ARCHIVE_DB)
63
#include "ha_archive.h"
64
extern handlerton archive_hton;
65 66
#else
handlerton archive_hton = { "ARCHIVE", SHOW_OPTION_NO,
unknown's avatar
foo1  
unknown committed
67 68
  "Archive storage engine", DB_TYPE_ARCHIVE_DB, NULL, 0, 0, NULL, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
69
  HTON_NO_FLAGS };
70
#endif
71 72
#ifdef HAVE_CSV_DB
#include "examples/ha_tina.h"
73
extern handlerton tina_hton;
74
#else
unknown's avatar
foo1  
unknown committed
75 76 77
handlerton tina_hton = { "CSV", SHOW_OPTION_NO, "CSV storage engine",
  DB_TYPE_CSV_DB, NULL, 0, 0, NULL, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
78
  HTON_NO_FLAGS };
79
#endif
80
#ifdef HAVE_INNOBASE_DB
81
#include "ha_innodb.h"
82
extern handlerton innobase_hton;
83 84
#else
handlerton innobase_hton = { "InnoDB", SHOW_OPTION_NO,
unknown's avatar
foo1  
unknown committed
85 86 87
  "Supports transactions, row-level locking, and foreign keys",
  DB_TYPE_INNODB, NULL, 0, 0, NULL, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
88
  HTON_NO_FLAGS };
89
#endif
unknown's avatar
unknown committed
90 91
#ifdef HAVE_NDBCLUSTER_DB
#include "ha_ndbcluster.h"
92
extern handlerton ndbcluster_hton;
93 94
#else
handlerton ndbcluster_hton = { "ndbcluster", SHOW_OPTION_NO,
unknown's avatar
foo1  
unknown committed
95 96 97
  "Clustered, fault-tolerant, memory-based tables",
  DB_TYPE_NDBCLUSTER, NULL, 0, 0, NULL, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
98
  HTON_NO_FLAGS };
unknown's avatar
unknown committed
99
#endif
100 101
#ifdef HAVE_FEDERATED_DB
#include "ha_federated.h"
102
extern handlerton federated_hton;
103
#else
unknown's avatar
foo1  
unknown committed
104 105 106
handlerton federated_hton = { "FEDERATED", SHOW_OPTION_NO,
  "Federated MySQL storage engine", DB_TYPE_FEDERATED_DB, NULL, 0, 0, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
107
  HTON_NO_FLAGS };
108
#endif
unknown's avatar
unknown committed
109 110 111
#include <myisampack.h>
#include <errno.h>

112 113 114
extern handlerton myisam_hton;
extern handlerton myisammrg_hton;
extern handlerton heap_hton;
115
extern handlerton binlog_hton;
116

117 118 119
/*
  Obsolete
*/
unknown's avatar
foo1  
unknown committed
120 121
handlerton isam_hton = { "ISAM", SHOW_OPTION_NO, "Obsolete storage engine",
  DB_TYPE_ISAM, NULL, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
122 123
  NULL, NULL, NULL, NULL, NULL, NULL, HTON_NO_FLAGS };

unknown's avatar
unknown committed
124 125 126 127 128 129
/* number of entries in handlertons[] */
ulong total_ha;
/* number of storage engines (from handlertons[]) that support 2pc */
ulong total_ha_2pc;
/* size of savepoint storage area (see ha_init) */
ulong savepoint_alloc_size;
130

131
/*
132
  This array is used for processing compiled in engines.
133
*/
134
handlerton *sys_table_types[]=
unknown's avatar
unknown committed
135
{
136 137 138 139 140 141 142 143 144 145 146
  &myisam_hton,
  &heap_hton,
  &innobase_hton,
  &berkeley_hton,
  &blackhole_hton,
  &example_hton,
  &archive_hton,
  &tina_hton,
  &ndbcluster_hton,
  &federated_hton,
  &myisammrg_hton,
147 148
  &binlog_hton,
  &isam_hton,
149
  NULL
150 151 152 153
};

struct show_table_alias_st sys_table_aliases[]=
{
154 155 156 157 158 159
  {"INNOBASE",	"InnoDB"},
  {"NDB", "NDBCLUSTER"},
  {"BDB", "BERKELEYDB"},
  {"HEAP", "MEMORY"},
  {"MERGE", "MRG_MYISAM"},
  {NullS, NullS}
unknown's avatar
unknown committed
160
};
161

unknown's avatar
unknown committed
162
const char *ha_row_type[] = {
163
  "", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT", "?","?","?"
unknown's avatar
unknown committed
164 165
};

unknown's avatar
unknown committed
166
const char *tx_isolation_names[] =
167 168 169
{ "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",
  NullS};
TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
170
			       tx_isolation_names, NULL};
unknown's avatar
unknown committed
171

172
static TYPELIB known_extensions= {0,"known_exts", NULL, NULL};
173
uint known_extensions_id= 0;
174

175 176
enum db_type ha_resolve_by_name(const char *name, uint namelen)
{
177
  THD *thd= current_thd;
178
  show_table_alias_st *table_alias;
179
  handlerton **types;
180

181
  if (thd && !my_strnncoll(&my_charset_latin1,
182 183
                           (const uchar *)name, namelen,
                           (const uchar *)"DEFAULT", 7))
184
    return (enum db_type) thd->variables.table_type;
unknown's avatar
unknown committed
185

186
retest:
187
  for (types= sys_table_types; *types; types++)
188
  {
189
    if (!my_strnncoll(&my_charset_latin1,
190 191
                      (const uchar *)name, namelen,
                      (const uchar *)(*types)->name, strlen((*types)->name)))
192
      return (enum db_type) (*types)->db_type;
193
  }
194 195

  /*
196
    We check for the historical aliases.
197 198 199
  */
  for (table_alias= sys_table_aliases; table_alias->type; table_alias++)
  {
200
    if (!my_strnncoll(&my_charset_latin1,
201 202 203
                      (const uchar *)name, namelen,
                      (const uchar *)table_alias->alias,
                      strlen(table_alias->alias)))
204
    {
205 206
      name= table_alias->type;
      namelen= strlen(name);
207 208
      goto retest;
    }
209
  }
210

211 212
  return DB_TYPE_UNKNOWN;
}
unknown's avatar
unknown committed
213 214


unknown's avatar
unknown committed
215
const char *ha_get_storage_engine(enum db_type db_type)
216
{
217 218
  handlerton **types;
  for (types= sys_table_types; *types; types++)
219
  {
220 221
    if (db_type == (*types)->db_type)
      return (*types)->name;
222
  }
unknown's avatar
unknown committed
223
  return "*NONE*";
224 225
}

unknown's avatar
unknown committed
226

227 228
bool ha_check_storage_engine_flag(enum db_type db_type, uint32 flag)
{
229 230
  handlerton **types;
  for (types= sys_table_types; *types; types++)
231
  {
232
    if (db_type == (*types)->db_type)
unknown's avatar
unknown committed
233
      return test((*types)->flags & flag);
234
  }
unknown's avatar
unknown committed
235
  return FALSE;                                 // No matching engine
236 237
}

unknown's avatar
unknown committed
238

239
my_bool ha_storage_engine_is_enabled(enum db_type database_type)
unknown's avatar
unknown committed
240
{
241 242
  handlerton **types;
  for (types= sys_table_types; *types; types++)
243
  {
244 245
    if ((database_type == (*types)->db_type) &&
	((*types)->state == SHOW_OPTION_YES))
246
      return TRUE;
247
  }
248 249 250 251
  return FALSE;
}


252
/* Use other database handler if databasehandler is not compiled in */
unknown's avatar
unknown committed
253

254 255
enum db_type ha_checktype(THD *thd, enum db_type database_type,
                          bool no_substitute, bool report_error)
unknown's avatar
unknown committed
256
{
257 258
  if (ha_storage_engine_is_enabled(database_type))
    return database_type;
259

260 261 262 263 264 265 266 267 268 269
  if (no_substitute)
  {
    if (report_error)
    {
      const char *engine_name= ha_get_storage_engine(database_type);
      my_error(ER_FEATURE_DISABLED,MYF(0),engine_name,engine_name);
    }
    return DB_TYPE_UNKNOWN;
  }

unknown's avatar
unknown committed
270 271 272
  switch (database_type) {
#ifndef NO_HASH
  case DB_TYPE_HASH:
273
    return (database_type);
274
#endif
275 276
  case DB_TYPE_MRG_ISAM:
    return (DB_TYPE_MRG_MYISAM);
unknown's avatar
unknown committed
277 278 279
  default:
    break;
  }
unknown's avatar
foo1  
unknown committed
280

281 282
  return ((enum db_type) thd->variables.table_type != DB_TYPE_UNKNOWN ?
          (enum db_type) thd->variables.table_type :
283 284 285 286
          ((enum db_type) global_system_variables.table_type !=
           DB_TYPE_UNKNOWN ?
           (enum db_type) global_system_variables.table_type : DB_TYPE_MYISAM)
          );
unknown's avatar
unknown committed
287 288 289
} /* ha_checktype */


290
handler *get_new_handler(TABLE *table, MEM_ROOT *alloc, enum db_type db_type)
unknown's avatar
unknown committed
291 292 293
{
  switch (db_type) {
#ifndef NO_HASH
294
  case DB_TYPE_HASH:
295
    return new (alloc) ha_hash(table);
unknown's avatar
unknown committed
296
#endif
297
  case DB_TYPE_MRG_MYISAM:
298
  case DB_TYPE_MRG_ISAM:
299 300 301
    if (have_merge_db == SHOW_OPTION_YES)
      return new (alloc) ha_myisammrg(table);
    return NULL;
unknown's avatar
unknown committed
302 303
#ifdef HAVE_BERKELEY_DB
  case DB_TYPE_BERKELEY_DB:
304 305 306
    if (have_berkeley_db == SHOW_OPTION_YES)
      return new (alloc) ha_berkeley(table);
    return NULL;
307 308
#endif
#ifdef HAVE_INNOBASE_DB
309
  case DB_TYPE_INNODB:
310 311 312
    if (have_innodb == SHOW_OPTION_YES)
      return new (alloc) ha_innobase(table);
    return NULL;
313 314 315
#endif
#ifdef HAVE_EXAMPLE_DB
  case DB_TYPE_EXAMPLE_DB:
316 317 318
    if (have_example_db == SHOW_OPTION_YES)
      return new (alloc) ha_example(table);
    return NULL;
319
#endif
320
#if defined(HAVE_ARCHIVE_DB)
321
  case DB_TYPE_ARCHIVE_DB:
322 323 324
    if (have_archive_db == SHOW_OPTION_YES)
      return new (alloc) ha_archive(table);
    return NULL;
unknown's avatar
Merge  
unknown committed
325
#endif
326 327
#ifdef HAVE_BLACKHOLE_DB
  case DB_TYPE_BLACKHOLE_DB:
328 329 330
    if (have_blackhole_db == SHOW_OPTION_YES)
      return new (alloc) ha_blackhole(table);
    return NULL;
331
#endif
332 333
#ifdef HAVE_FEDERATED_DB
  case DB_TYPE_FEDERATED_DB:
334 335 336
    if (have_federated_db == SHOW_OPTION_YES)
      return new (alloc) ha_federated(table);
    return NULL;
337
#endif
338 339
#ifdef HAVE_CSV_DB
  case DB_TYPE_CSV_DB:
340 341 342
    if (have_csv_db == SHOW_OPTION_YES)
      return new (alloc) ha_tina(table);
    return NULL;
343
#endif
unknown's avatar
unknown committed
344 345
#ifdef HAVE_NDBCLUSTER_DB
  case DB_TYPE_NDBCLUSTER:
346 347 348
    if (have_ndbcluster == SHOW_OPTION_YES)
      return new (alloc) ha_ndbcluster(table);
    return NULL;
unknown's avatar
unknown committed
349 350
#endif
  case DB_TYPE_HEAP:
351
    return new (alloc) ha_heap(table);
unknown's avatar
unknown committed
352
  default:					// should never happen
353 354 355 356
  {
    enum db_type def=(enum db_type) current_thd->variables.table_type;
    /* Try first with 'default table type' */
    if (db_type != def)
357
      return get_new_handler(table, alloc, def);
358 359 360
  }
  /* Fall back to MyISAM */
  case DB_TYPE_MYISAM:
361
    return new (alloc) ha_myisam(table);
unknown's avatar
unknown committed
362 363 364
  }
}

365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
/*
  Register handler error messages for use with my_error().

  SYNOPSIS
    ha_init_errors()

  RETURN
    0           OK
    != 0        Error
*/

static int ha_init_errors(void)
{
#define SETMSG(nr, msg) errmsgs[(nr) - HA_ERR_FIRST]= (msg)
  const char    **errmsgs;

  /* Allocate a pointer array for the error message strings. */
  /* Zerofill it to avoid uninitialized gaps. */
  if (! (errmsgs= (const char**) my_malloc(HA_ERR_ERRORS * sizeof(char*),
                                           MYF(MY_WME | MY_ZEROFILL))))
    return 1;

  /* Set the dedicated error messages. */
  SETMSG(HA_ERR_KEY_NOT_FOUND,          ER(ER_KEY_NOT_FOUND));
  SETMSG(HA_ERR_FOUND_DUPP_KEY,         ER(ER_DUP_KEY));
  SETMSG(HA_ERR_RECORD_CHANGED,         "Update wich is recoverable");
  SETMSG(HA_ERR_WRONG_INDEX,            "Wrong index given to function");
  SETMSG(HA_ERR_CRASHED,                ER(ER_NOT_KEYFILE));
  SETMSG(HA_ERR_WRONG_IN_RECORD,        ER(ER_CRASHED_ON_USAGE));
  SETMSG(HA_ERR_OUT_OF_MEM,             "Table handler out of memory");
  SETMSG(HA_ERR_NOT_A_TABLE,            "Incorrect file format '%.64s'");
  SETMSG(HA_ERR_WRONG_COMMAND,          "Command not supported");
  SETMSG(HA_ERR_OLD_FILE,               ER(ER_OLD_KEYFILE));
  SETMSG(HA_ERR_NO_ACTIVE_RECORD,       "No record read in update");
  SETMSG(HA_ERR_RECORD_DELETED,         "Intern record deleted");
  SETMSG(HA_ERR_RECORD_FILE_FULL,       ER(ER_RECORD_FILE_FULL));
  SETMSG(HA_ERR_INDEX_FILE_FULL,        "No more room in index file '%.64s'");
  SETMSG(HA_ERR_END_OF_FILE,            "End in next/prev/first/last");
  SETMSG(HA_ERR_UNSUPPORTED,            ER(ER_ILLEGAL_HA));
  SETMSG(HA_ERR_TO_BIG_ROW,             "Too big row");
  SETMSG(HA_WRONG_CREATE_OPTION,        "Wrong create option");
  SETMSG(HA_ERR_FOUND_DUPP_UNIQUE,      ER(ER_DUP_UNIQUE));
  SETMSG(HA_ERR_UNKNOWN_CHARSET,        "Can't open charset");
  SETMSG(HA_ERR_WRONG_MRG_TABLE_DEF,    ER(ER_WRONG_MRG_TABLE));
  SETMSG(HA_ERR_CRASHED_ON_REPAIR,      ER(ER_CRASHED_ON_REPAIR));
  SETMSG(HA_ERR_CRASHED_ON_USAGE,       ER(ER_CRASHED_ON_USAGE));
  SETMSG(HA_ERR_LOCK_WAIT_TIMEOUT,      ER(ER_LOCK_WAIT_TIMEOUT));
  SETMSG(HA_ERR_LOCK_TABLE_FULL,        ER(ER_LOCK_TABLE_FULL));
  SETMSG(HA_ERR_READ_ONLY_TRANSACTION,  ER(ER_READ_ONLY_TRANSACTION));
  SETMSG(HA_ERR_LOCK_DEADLOCK,          ER(ER_LOCK_DEADLOCK));
  SETMSG(HA_ERR_CANNOT_ADD_FOREIGN,     ER(ER_CANNOT_ADD_FOREIGN));
416 417
  SETMSG(HA_ERR_NO_REFERENCED_ROW,      ER(ER_NO_REFERENCED_ROW_2));
  SETMSG(HA_ERR_ROW_IS_REFERENCED,      ER(ER_ROW_IS_REFERENCED_2));
418 419 420 421 422
  SETMSG(HA_ERR_NO_SAVEPOINT,           "No savepoint with that name");
  SETMSG(HA_ERR_NON_UNIQUE_BLOCK_SIZE,  "Non unique key block size");
  SETMSG(HA_ERR_NO_SUCH_TABLE,          "No such table: '%.64s'");
  SETMSG(HA_ERR_TABLE_EXIST,            ER(ER_TABLE_EXISTS_ERROR));
  SETMSG(HA_ERR_NO_CONNECTION,          "Could not connect to storage engine");
423
  SETMSG(HA_ERR_TABLE_DEF_CHANGED,      ER(ER_TABLE_DEF_CHANGED));
unknown's avatar
unknown committed
424
  SETMSG(HA_ERR_TABLE_NEEDS_UPGRADE,    ER(ER_TABLE_NEEDS_UPGRADE));
425
  SETMSG(HA_ERR_TABLE_READONLY,         ER(ER_OPEN_AS_READONLY));
unknown's avatar
unknown committed
426 427
  SETMSG(HA_ERR_AUTOINC_READ_FAILED,    ER(ER_AUTOINC_READ_FAILED));
  SETMSG(HA_ERR_AUTOINC_ERANGE,         ER(ER_WARN_DATA_OUT_OF_RANGE));
428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454

  /* Register the error messages for use with my_error(). */
  return my_error_register(errmsgs, HA_ERR_FIRST, HA_ERR_LAST);
}


/*
  Unregister handler error messages.

  SYNOPSIS
    ha_finish_errors()

  RETURN
    0           OK
    != 0        Error
*/

static int ha_finish_errors(void)
{
  const char    **errmsgs;

  /* Allocate a pointer array for the error message strings. */
  if (! (errmsgs= my_error_unregister(HA_ERR_FIRST, HA_ERR_LAST)))
    return 1;
  my_free((gptr) errmsgs, MYF(0));
  return 0;
}
unknown's avatar
unknown committed
455

456

457 458 459 460 461 462 463 464 465
static inline void ha_was_inited_ok(handlerton **ht)
{
  uint tmp= (*ht)->savepoint_offset;
  (*ht)->savepoint_offset= savepoint_alloc_size;
  savepoint_alloc_size+= tmp;
  (*ht)->slot= total_ha++;
  if ((*ht)->prepare)
    total_ha_2pc++;
}
466

unknown's avatar
unknown committed
467 468
int ha_init()
{
469
  int error= 0;
470
  handlerton **types;
471 472
  total_ha= savepoint_alloc_size= 0;

473 474
  if (ha_init_errors())
    return 1;
unknown's avatar
unknown committed
475

476
  /*
477
    We now initialize everything here.
478
  */
479
  for (types= sys_table_types; *types; types++)
480
  {
481
    if (!(*types)->init || !(*types)->init())
unknown's avatar
foo1  
unknown committed
482
      ha_was_inited_ok(types);
unknown's avatar
unknown committed
483
    else
484
      (*types)->state= SHOW_OPTION_DISABLED;
485
  }
486

487
  DBUG_ASSERT(total_ha < MAX_HA);
488 489 490 491 492 493
  /*
    Check if there is a transaction-capable storage engine besides the
    binary log (which is considered a transaction-capable storage engine in
    counting total_ha)
  */
  opt_using_transactions= total_ha>(ulong)opt_bin_log;
494
  savepoint_alloc_size+= sizeof(SAVEPOINT);
495
  return error;
unknown's avatar
unknown committed
496 497 498 499 500 501 502 503 504 505 506
}

	/* close, flush or restart databases */
	/* Ignore this for other databases than ours */

int ha_panic(enum ha_panic_function flag)
{
  int error=0;
#ifndef NO_HASH
  error|=h_panic(flag);			/* fix hash */
#endif
507 508
#ifdef HAVE_ISAM
  error|=mrg_panic(flag);
unknown's avatar
unknown committed
509
  error|=nisam_panic(flag);
510 511
#endif
  error|=heap_panic(flag);
unknown's avatar
unknown committed
512 513 514
  error|=mi_panic(flag);
  error|=myrg_panic(flag);
#ifdef HAVE_BERKELEY_DB
515
  if (have_berkeley_db == SHOW_OPTION_YES)
unknown's avatar
unknown committed
516
    error|=berkeley_end();
517
#endif
518 519 520 521
#ifdef HAVE_BLACKHOLE_DB
  if (have_blackhole_db == SHOW_OPTION_YES)
    error|= blackhole_db_end();
#endif
522
#ifdef HAVE_INNOBASE_DB
523
  if (have_innodb == SHOW_OPTION_YES)
524
    error|=innobase_end();
unknown's avatar
unknown committed
525 526 527 528
#endif
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
    error|=ndbcluster_end();
529
#endif
unknown's avatar
unknown committed
530 531 532 533
#ifdef HAVE_FEDERATED_DB
  if (have_federated_db == SHOW_OPTION_YES)
    error|= federated_db_end();
#endif
534
#if defined(HAVE_ARCHIVE_DB)
535 536
  if (have_archive_db == SHOW_OPTION_YES)
    error|= archive_db_end();
unknown's avatar
unknown committed
537 538 539 540
#endif
#ifdef HAVE_CSV_DB
  if (have_csv_db == SHOW_OPTION_YES)
    error|= tina_end();
unknown's avatar
unknown committed
541
#endif
542 543
  if (ha_finish_errors())
    error= 1;
unknown's avatar
unknown committed
544 545 546
  return error;
} /* ha_panic */

547 548 549
void ha_drop_database(char* path)
{
#ifdef HAVE_INNOBASE_DB
550
  if (have_innodb == SHOW_OPTION_YES)
551 552
    innobase_drop_database(path);
#endif
unknown's avatar
unknown committed
553 554 555 556
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
    ndbcluster_drop_database(path);
#endif
557
}
unknown's avatar
unknown committed
558

559
/* don't bother to rollback here, it's done already */
560 561
void ha_close_connection(THD* thd)
{
562 563 564 565
  handlerton **types;
  for (types= sys_table_types; *types; types++)
    if (thd->ha_data[(*types)->slot])
      (*types)->close_connection(thd);
566 567 568 569 570
}

/* ========================================================================
 ======================= TRANSACTIONS ===================================*/

unknown's avatar
unknown committed
571 572 573 574 575 576 577 578 579
/*
  Register a storage engine for a transaction

  DESCRIPTION
    Every storage engine MUST call this function when it starts
    a transaction or a statement (that is it must be called both for the
    "beginning of transaction" and "beginning of statement").
    Only storage engines registered for the transaction/statement
    will know when to commit/rollback it.
580 581 582 583 584

  NOTE
    trans_register_ha is idempotent - storage engine may register many
    times per transaction.

unknown's avatar
unknown committed
585
*/
586 587 588
void trans_register_ha(THD *thd, bool all, handlerton *ht_arg)
{
  THD_TRANS *trans;
589
  handlerton **ht;
unknown's avatar
unknown committed
590 591 592
  DBUG_ENTER("trans_register_ha");
  DBUG_PRINT("enter",("%s", all ? "all" : "stmt"));

593 594 595 596 597 598 599 600
  if (all)
  {
    trans= &thd->transaction.all;
    thd->server_status|= SERVER_STATUS_IN_TRANS;
  }
  else
    trans= &thd->transaction.stmt;

601
  for (ht=trans->ht; *ht; ht++)
unknown's avatar
unknown committed
602 603 604
    if (*ht == ht_arg)
      DBUG_VOID_RETURN;  /* already registered, return */

605
  trans->ht[trans->nht++]=ht_arg;
606
  DBUG_ASSERT(*ht == ht_arg);
607
  trans->no_2pc|=(ht_arg->prepare==0);
608 609
  if (thd->transaction.xid_state.xid.is_null())
    thd->transaction.xid_state.xid.set(thd->query_id);
unknown's avatar
unknown committed
610
  DBUG_VOID_RETURN;
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
}

/*
  RETURN
      0  - ok
      1  - error, transaction was rolled back
*/
int ha_prepare(THD *thd)
{
  int error=0, all=1;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
  handlerton **ht=trans->ht;
  DBUG_ENTER("ha_prepare");
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
    for (; *ht; ht++)
    {
      int err;
      statistic_increment(thd->status_var.ha_prepare_count,&LOCK_status);
631
      if ((*ht)->prepare)
632
      {
633 634 635 636 637 638 639 640 641 642 643 644
        if ((err= (*(*ht)->prepare)(thd, all)))
        {
          my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
          ha_rollback_trans(thd, all);
          error=1;
          break;
        }
      }
      else
      {
        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                            ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA), (*ht)->name);
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
      }
    }
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

/*
  RETURN
      0  - ok
      1  - transaction was rolled back
      2  - error during commit, data may be inconsistent
*/
int ha_commit_trans(THD *thd, bool all)
{
  int error= 0, cookie= 0;
  THD_TRANS *trans= all ? &thd->transaction.all : &thd->transaction.stmt;
  bool is_real_trans= all || thd->transaction.all.nht == 0;
  handlerton **ht= trans->ht;
664
  my_xid xid= thd->transaction.xid_state.xid.get_my_xid();
665
  DBUG_ENTER("ha_commit_trans");
666

667
  if (thd->in_sub_stmt)
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
  {
    /*
      Since we don't support nested statement transactions in 5.0,
      we can't commit or rollback stmt transactions while we are inside
      stored functions or triggers. So we simply do nothing now.
      TODO: This should be fixed in later ( >= 5.1) releases.
    */
    if (!all)
      DBUG_RETURN(0);
    /*
      We assume that all statements which commit or rollback main transaction
      are prohibited inside of stored functions or triggers. So they should
      bail out with error even before ha_commit_trans() call. To be 100% safe
      let us throw error in non-debug builds.
    */
    DBUG_ASSERT(0);
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(2);
  }
687 688 689
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
690 691 692 693 694
    if (is_real_trans && wait_if_global_read_lock(thd, 0, 0))
    {
      ha_rollback_trans(thd, all);
      DBUG_RETURN(1);
    }
695
    DBUG_EXECUTE_IF("crash_commit_before", abort(););
696 697 698 699 700

    /* Close all cursors that can not survive COMMIT */
    if (is_real_trans)                          /* not a statement commit */
      thd->stmt_map.close_transient_cursors();

701 702 703 704 705 706 707 708
    if (!trans->no_2pc && trans->nht > 1)
    {
      for (; *ht && !error; ht++)
      {
        int err;
        if ((err= (*(*ht)->prepare)(thd, all)))
        {
          my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
709
          error= 1;
710 711 712
        }
        statistic_increment(thd->status_var.ha_prepare_count,&LOCK_status);
      }
713
      DBUG_EXECUTE_IF("crash_commit_after_prepare", abort(););
unknown's avatar
unknown committed
714
      if (error || (is_real_trans && xid &&
715
                    (error= !(cookie= tc_log->log_xid(thd, xid)))))
716 717
      {
        ha_rollback_trans(thd, all);
718 719
        error= 1;
        goto end;
720
      }
721
      DBUG_EXECUTE_IF("crash_commit_after_log", abort(););
722
    }
723
    error=ha_commit_one_phase(thd, all) ? (cookie ? 2 : 1) : 0;
724
    DBUG_EXECUTE_IF("crash_commit_before_unlog", abort(););
725
    if (cookie)
unknown's avatar
unknown committed
726
      tc_log->unlog(cookie, xid);
727
    DBUG_EXECUTE_IF("crash_commit_after", abort(););
728 729 730
end:
    if (is_real_trans)
      start_waiting_global_read_lock(thd);
731 732 733 734 735
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

736 737 738 739
/*
  NOTE - this function does not care about global read lock.
  A caller should.
*/
740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
int ha_commit_one_phase(THD *thd, bool all)
{
  int error=0;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
  bool is_real_trans=all || thd->transaction.all.nht == 0;
  handlerton **ht=trans->ht;
  DBUG_ENTER("ha_commit_one_phase");
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
    for (ht=trans->ht; *ht; ht++)
    {
      int err;
      if ((err= (*(*ht)->commit)(thd, all)))
      {
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
        error=1;
      }
      statistic_increment(thd->status_var.ha_commit_count,&LOCK_status);
      *ht= 0;
    }
    trans->nht=0;
    trans->no_2pc=0;
    if (is_real_trans)
764
      thd->transaction.xid_state.xid.null();
765 766 767 768 769
    if (all)
    {
#ifdef HAVE_QUERY_CACHE
      if (thd->transaction.changed_tables)
        query_cache.invalidate(thd->transaction.changed_tables);
unknown's avatar
unknown committed
770
#endif
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785
      thd->variables.tx_isolation=thd->session_tx_isolation;
      thd->transaction.cleanup();
    }
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}


int ha_rollback_trans(THD *thd, bool all)
{
  int error=0;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
  bool is_real_trans=all || thd->transaction.all.nht == 0;
  DBUG_ENTER("ha_rollback_trans");
786
  if (thd->in_sub_stmt)
787 788 789 790 791 792 793 794 795 796 797 798
  {
    /*
      If we are inside stored function or trigger we should not commit or
      rollback current statement transaction. See comment in ha_commit_trans()
      call for more information.
    */
    if (!all)
      DBUG_RETURN(0);
    DBUG_ASSERT(0);
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
799 800 801
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
802 803 804 805
    /* Close all cursors that can not survive ROLLBACK */
    if (is_real_trans)                          /* not a statement commit */
      thd->stmt_map.close_transient_cursors();

806 807 808 809 810 811 812 813 814 815 816 817 818 819
    for (handlerton **ht=trans->ht; *ht; ht++)
    {
      int err;
      if ((err= (*(*ht)->rollback)(thd, all)))
      { // cannot happen
        my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
        error=1;
      }
      statistic_increment(thd->status_var.ha_rollback_count,&LOCK_status);
      *ht= 0;
    }
    trans->nht=0;
    trans->no_2pc=0;
    if (is_real_trans)
820
      thd->transaction.xid_state.xid.null();
821 822 823 824 825 826 827
    if (all)
    {
      thd->variables.tx_isolation=thd->session_tx_isolation;
      thd->transaction.cleanup();
    }
  }
#endif /* USING_TRANSACTIONS */
828 829 830
  if (all)
    thd->transaction_rollback_request= FALSE;

831 832 833 834 835 836 837 838 839
  /*
    If a non-transactional table was updated, warn; don't warn if this is a
    slave thread (because when a slave thread executes a ROLLBACK, it has
    been read from the binary log, so it's 100% sure and normal to produce
    error ER_WARNING_NOT_COMPLETE_ROLLBACK. If we sent the warning to the
    slave SQL thread, it would not stop the thread but just be printed in
    the error log; but we don't want users to wonder why they have this
    message in the error log, so we don't send it.
  */
unknown's avatar
unknown committed
840
  if (is_real_trans && thd->transaction.all.modified_non_trans_table &&
841 842 843 844 845
      !thd->slave_thread)
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                 ER_WARNING_NOT_COMPLETE_ROLLBACK,
                 ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
  DBUG_RETURN(error);
846 847
}

848
/*
unknown's avatar
unknown committed
849
  This is used to commit or rollback a single statement depending on the value
unknown's avatar
unknown committed
850 851 852 853 854
  of error. Note that if the autocommit is on, then the following call inside
  InnoDB will commit or rollback the whole transaction (= the statement). The
  autocommit mechanism built into InnoDB is based on counting locks, but if
  the user has used LOCK TABLES then that mechanism does not know to do the
  commit.
855 856
*/

unknown's avatar
unknown committed
857 858 859
int ha_autocommit_or_rollback(THD *thd, int error)
{
  DBUG_ENTER("ha_autocommit_or_rollback");
860
#ifdef USING_TRANSACTIONS
861
  if (thd->transaction.stmt.nht)
unknown's avatar
unknown committed
862
  {
863 864 865 866 867
    if (!error)
    {
      if (ha_commit_stmt(thd))
	error=1;
    }
868 869
    else if (thd->transaction_rollback_request && !thd->in_sub_stmt)
      (void) ha_rollback(thd);
870 871
    else
      (void) ha_rollback_stmt(thd);
unknown's avatar
unknown committed
872

unknown's avatar
unknown committed
873
    thd->variables.tx_isolation=thd->session_tx_isolation;
unknown's avatar
unknown committed
874 875 876 877 878
  }
#endif
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
879

unknown's avatar
unknown committed
880
int ha_commit_or_rollback_by_xid(XID *xid, bool commit)
881
{
882
  handlerton **types;
883 884
  int res= 1;

885
  for (types= sys_table_types; *types; types++)
unknown's avatar
unknown committed
886
  {
887
    if ((*types)->state == SHOW_OPTION_YES && (*types)->recover)
unknown's avatar
unknown committed
888 889
    {
      if ((*(commit ? (*types)->commit_by_xid :
890 891
             (*types)->rollback_by_xid))(xid))
        res= 0;
unknown's avatar
unknown committed
892 893
    }
  }
894 895
  return res;
}
unknown's avatar
unknown committed
896

unknown's avatar
unknown committed
897

unknown's avatar
unknown committed
898 899 900 901 902 903 904 905 906 907
#ifndef DBUG_OFF
/* this does not need to be multi-byte safe or anything */
static char* xid_to_str(char *buf, XID *xid)
{
  int i;
  char *s=buf;
  *s++='\'';
  for (i=0; i < xid->gtrid_length+xid->bqual_length; i++)
  {
    uchar c=(uchar)xid->data[i];
unknown's avatar
unknown committed
908 909
    /* is_next_dig is set if next character is a number */
    bool is_next_dig= FALSE;
unknown's avatar
unknown committed
910 911
    if (i < XIDDATASIZE)
    {
unknown's avatar
unknown committed
912 913
      char ch= xid->data[i+1];
      is_next_dig= (ch >= '0' && ch <='9');
unknown's avatar
unknown committed
914
    }
unknown's avatar
unknown committed
915 916 917 918 919 920 921 922 923 924 925 926
    if (i == xid->gtrid_length)
    {
      *s++='\'';
      if (xid->bqual_length)
      {
        *s++='.';
        *s++='\'';
      }
    }
    if (c < 32 || c > 126)
    {
      *s++='\\';
unknown's avatar
unknown committed
927 928 929 930 931
      /*
        If next character is a number, write current character with
        3 octal numbers to ensure that the next number is not seen
        as part of the octal number
      */
unknown's avatar
unknown committed
932 933 934 935 936
      if (c > 077 || is_next_dig)
        *s++=_dig_vec_lower[c >> 6];
      if (c > 007 || is_next_dig)
        *s++=_dig_vec_lower[(c >> 3) & 7];
      *s++=_dig_vec_lower[c & 7];
unknown's avatar
unknown committed
937 938 939 940 941 942 943 944 945 946 947 948 949 950
    }
    else
    {
      if (c == '\'' || c == '\\')
        *s++='\\';
      *s++=c;
    }
  }
  *s++='\'';
  *s=0;
  return buf;
}
#endif

951 952
/*
  recover() step of xa
unknown's avatar
unknown committed
953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968

  NOTE
   there are three modes of operation:

   - automatic recover after a crash
     in this case commit_list != 0, tc_heuristic_recover==0
     all xids from commit_list are committed, others are rolled back

   - manual (heuristic) recover
     in this case commit_list==0, tc_heuristic_recover != 0
     DBA has explicitly specified that all prepared transactions should
     be committed (or rolled back).

   - no recovery (MySQL did not detect a crash)
     in this case commit_list==0, tc_heuristic_recover == 0
     there should be no prepared transactions in this case.
unknown's avatar
unknown committed
969
*/
970
int ha_recover(HASH *commit_list)
971
{
unknown's avatar
unknown committed
972
  int len, got, found_foreign_xids=0, found_my_xids=0;
973
  handlerton **types;
974
  XID *list=0;
unknown's avatar
unknown committed
975
  bool dry_run=(commit_list==0 && tc_heuristic_recover==0);
976 977
  DBUG_ENTER("ha_recover");

unknown's avatar
unknown committed
978 979 980
  /* commit_list and tc_heuristic_recover cannot be set both */
  DBUG_ASSERT(commit_list==0 || tc_heuristic_recover==0);
  /* if either is set, total_ha_2pc must be set too */
981
  DBUG_ASSERT(dry_run || total_ha_2pc>(ulong)opt_bin_log);
unknown's avatar
unknown committed
982

983
  if (total_ha_2pc <= (ulong)opt_bin_log)
unknown's avatar
unknown committed
984 985
    DBUG_RETURN(0);

unknown's avatar
unknown committed
986 987 988
  if (commit_list)
    sql_print_information("Starting crash recovery...");

unknown's avatar
unknown committed
989 990 991 992 993
#ifndef WILL_BE_DELETED_LATER
  /*
    for now, only InnoDB supports 2pc. It means we can always safely
    rollback all pending transactions, without risking inconsistent data
  */
unknown's avatar
unknown committed
994
  DBUG_ASSERT(total_ha_2pc == (ulong) opt_bin_log+1); // only InnoDB and binlog
unknown's avatar
unknown committed
995 996 997
  tc_heuristic_recover= TC_HEURISTIC_RECOVER_ROLLBACK; // forcing ROLLBACK
  dry_run=FALSE;
#endif
998

999
  for (len= MAX_XID_LIST_SIZE ; list==0 && len > MIN_XID_LIST_SIZE; len/=2)
1000
  {
1001 1002 1003 1004
    list=(XID *)my_malloc(len*sizeof(XID), MYF(0));
  }
  if (!list)
  {
unknown's avatar
unknown committed
1005
    sql_print_error(ER(ER_OUTOFMEMORY), len*sizeof(XID));
1006 1007 1008
    DBUG_RETURN(1);
  }

1009
  for (types= sys_table_types; *types; types++)
1010
  {
1011
    if ((*types)->state != SHOW_OPTION_YES || !(*types)->recover)
1012
      continue;
1013
    while ((got=(*(*types)->recover)(list, len)) > 0 )
1014
    {
unknown's avatar
unknown committed
1015
      sql_print_information("Found %d prepared transaction(s) in %s",
1016
                            got, (*types)->name);
1017 1018 1019 1020
      for (int i=0; i < got; i ++)
      {
        my_xid x=list[i].get_my_xid();
        if (!x) // not "mine" - that is generated by external TM
unknown's avatar
unknown committed
1021
        {
unknown's avatar
unknown committed
1022 1023 1024 1025
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
          sql_print_information("ignore xid %s", xid_to_str(buf, list+i));
#endif
1026
          xid_cache_insert(list+i, XA_PREPARED);
unknown's avatar
unknown committed
1027 1028 1029 1030 1031 1032
          found_foreign_xids++;
          continue;
        }
        if (dry_run)
        {
          found_my_xids++;
1033
          continue;
unknown's avatar
unknown committed
1034 1035
        }
        // recovery mode
1036
        if (commit_list ?
unknown's avatar
unknown committed
1037
            hash_search(commit_list, (byte *)&x, sizeof(x)) != 0 :
1038
            tc_heuristic_recover == TC_HEURISTIC_RECOVER_COMMIT)
unknown's avatar
unknown committed
1039 1040 1041 1042 1043
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
          sql_print_information("commit xid %s", xid_to_str(buf, list+i));
#endif
1044
          (*(*types)->commit_by_xid)(list+i);
unknown's avatar
unknown committed
1045
        }
1046
        else
unknown's avatar
unknown committed
1047 1048 1049 1050 1051
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
          sql_print_information("rollback xid %s", xid_to_str(buf, list+i));
#endif
1052
          (*(*types)->rollback_by_xid)(list+i);
unknown's avatar
unknown committed
1053
        }
1054 1055 1056
      }
      if (got < len)
        break;
1057 1058
    }
  }
1059
  my_free((gptr)list, MYF(0));
unknown's avatar
unknown committed
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
  if (found_foreign_xids)
    sql_print_warning("Found %d prepared XA transactions", found_foreign_xids);
  if (dry_run && found_my_xids)
  {
    sql_print_error("Found %d prepared transactions! It means that mysqld was "
                    "not shut down properly last time and critical recovery "
                    "information (last binlog or %s file) was manually deleted "
                    "after a crash. You have to start mysqld with "
                    "--tc-heuristic-recover switch to commit or rollback "
                    "pending transactions.",
                    found_my_xids, opt_tc_log_file);
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
1073 1074
  if (commit_list)
    sql_print_information("Crash recovery finished.");
1075
  DBUG_RETURN(0);
1076
}
1077

unknown's avatar
unknown committed
1078
/*
1079
  return the list of XID's to a client, the same way SHOW commands do
unknown's avatar
unknown committed
1080

1081 1082 1083 1084
  NOTE
    I didn't find in XA specs that an RM cannot return the same XID twice,
    so mysql_xa_recover does not filter XID's to ensure uniqueness.
    It can be easily fixed later, if necessary.
unknown's avatar
unknown committed
1085
*/
1086
bool mysql_xa_recover(THD *thd)
unknown's avatar
unknown committed
1087
{
1088 1089
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
1090 1091
  int i=0;
  XID_STATE *xs;
1092 1093
  DBUG_ENTER("mysql_xa_recover");

1094 1095 1096
  field_list.push_back(new Item_int("formatID", 0, MY_INT32_NUM_DECIMAL_DIGITS));
  field_list.push_back(new Item_int("gtrid_length", 0, MY_INT32_NUM_DECIMAL_DIGITS));
  field_list.push_back(new Item_int("bqual_length", 0, MY_INT32_NUM_DECIMAL_DIGITS));
1097 1098 1099 1100 1101
  field_list.push_back(new Item_empty_string("data",XIDDATASIZE));

  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
    DBUG_RETURN(1);
unknown's avatar
unknown committed
1102

1103
  pthread_mutex_lock(&LOCK_xid_cache);
unknown's avatar
unknown committed
1104
  while ((xs= (XID_STATE*)hash_element(&xid_cache, i++)))
1105
  {
1106
    if (xs->xa_state==XA_PREPARED)
1107
    {
1108 1109 1110 1111 1112 1113 1114
      protocol->prepare_for_resend();
      protocol->store_longlong((longlong)xs->xid.formatID, FALSE);
      protocol->store_longlong((longlong)xs->xid.gtrid_length, FALSE);
      protocol->store_longlong((longlong)xs->xid.bqual_length, FALSE);
      protocol->store(xs->xid.data, xs->xid.gtrid_length+xs->xid.bqual_length,
                      &my_charset_bin);
      if (protocol->write())
1115
      {
1116 1117
        pthread_mutex_unlock(&LOCK_xid_cache);
        DBUG_RETURN(1);
1118 1119
      }
    }
unknown's avatar
unknown committed
1120
  }
1121

1122
  pthread_mutex_unlock(&LOCK_xid_cache);
1123
  send_eof(thd);
1124
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1125
}
1126

1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
/*
  This function should be called when MySQL sends rows of a SELECT result set
  or the EOF mark to the client. It releases a possible adaptive hash index
  S-latch held by thd in InnoDB and also releases a possible InnoDB query
  FIFO ticket to enter InnoDB. To save CPU time, InnoDB allows a thd to
  keep them over several calls of the InnoDB handler interface when a join
  is executed. But when we let the control to pass to the client they have
  to be released because if the application program uses mysql_use_result(),
  it may deadlock on the S-latch if the application on another connection
  performs another SQL query. In MySQL-4.1 this is even more important because
  there a connection can have several SELECT queries open at the same time.

  arguments:
  thd:           the thread handle of the current connection
  return value:  always 0
*/

int ha_release_temporary_latches(THD *thd)
{
#ifdef HAVE_INNOBASE_DB
1147 1148
  if (opt_innodb)
    innobase_release_temporary_latches(thd);
1149 1150 1151 1152
#endif
  return 0;
}

1153

unknown's avatar
foo1  
unknown committed
1154
/*
1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167
  Export statistics for different engines. Currently we use it only for
  InnoDB.
*/

int ha_update_statistics()
{
#ifdef HAVE_INNOBASE_DB
  if (opt_innodb)
    innodb_export_status();
#endif
  return 0;
}

1168
int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1169 1170
{
  int error=0;
1171 1172
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
1173 1174
  handlerton **ht=trans->ht, **end_ht;
  DBUG_ENTER("ha_rollback_to_savepoint");
1175

1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
  trans->nht=sv->nht;
  trans->no_2pc=0;
  end_ht=ht+sv->nht;
  /*
    rolling back to savepoint in all storage engines that were part of the
    transaction when the savepoint was set
  */
  for (; ht < end_ht; ht++)
  {
    int err;
1186
    DBUG_ASSERT((*ht)->savepoint_set != 0);
1187 1188 1189 1190
    if ((err= (*(*ht)->savepoint_rollback)(thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
1191
    }
1192 1193
    statistic_increment(thd->status_var.ha_savepoint_rollback_count,&LOCK_status);
    trans->no_2pc|=(*ht)->prepare == 0;
1194
  }
1195 1196 1197 1198 1199
  /*
    rolling back the transaction in all storage engines that were not part of
    the transaction when the savepoint was set
  */
  for (; *ht ; ht++)
unknown's avatar
unknown committed
1200
  {
1201
    int err;
1202
    if ((err= (*(*ht)->rollback)(thd, !thd->in_sub_stmt)))
1203 1204 1205
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
unknown's avatar
unknown committed
1206
    }
1207 1208
    statistic_increment(thd->status_var.ha_rollback_count,&LOCK_status);
    *ht=0; // keep it conveniently zero-filled
1209
  }
unknown's avatar
unknown committed
1210 1211 1212
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
1213
/*
1214 1215 1216
  note, that according to the sql standard (ISO/IEC 9075-2:2003)
  section "4.33.4 SQL-statements and transaction states",
  SAVEPOINT is *not* transaction-initiating SQL-statement
unknown's avatar
unknown committed
1217 1218
*/

1219
int ha_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1220 1221
{
  int error=0;
1222 1223
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
1224 1225
  handlerton **ht=trans->ht;
  DBUG_ENTER("ha_savepoint");
unknown's avatar
unknown committed
1226
#ifdef USING_TRANSACTIONS
1227
  for (; *ht; ht++)
unknown's avatar
unknown committed
1228
  {
1229 1230
    int err;
    if (! (*ht)->savepoint_set)
unknown's avatar
unknown committed
1231
    {
1232
      my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "SAVEPOINT");
unknown's avatar
unknown committed
1233
      error=1;
1234
      break;
unknown's avatar
unknown committed
1235
    }
1236 1237 1238
    if ((err= (*(*ht)->savepoint_set)(thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
    { // cannot happen
      my_error(ER_GET_ERRNO, MYF(0), err);
unknown's avatar
unknown committed
1239 1240
      error=1;
    }
1241
    statistic_increment(thd->status_var.ha_savepoint_count,&LOCK_status);
unknown's avatar
unknown committed
1242
  }
1243
  sv->nht=trans->nht;
unknown's avatar
unknown committed
1244 1245 1246 1247
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

1248
int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1249 1250
{
  int error=0;
1251 1252 1253
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
  handlerton **ht=trans->ht, **end_ht;
1254 1255 1256 1257
  DBUG_ENTER("ha_release_savepoint");

  end_ht=ht+sv->nht;
  for (; ht < end_ht; ht++)
unknown's avatar
unknown committed
1258
  {
1259 1260 1261 1262 1263 1264 1265
    int err;
    if (!(*ht)->savepoint_release)
      continue;
    if ((err= (*(*ht)->savepoint_release)(thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
    { // cannot happen
      my_error(ER_GET_ERRNO, MYF(0), err);
      error=1;
unknown's avatar
unknown committed
1266
    }
unknown's avatar
unknown committed
1267 1268 1269 1270
  }
  DBUG_RETURN(error);
}

1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282

int ha_start_consistent_snapshot(THD *thd)
{
#ifdef HAVE_INNOBASE_DB
  if ((have_innodb == SHOW_OPTION_YES) &&
      !innobase_start_trx_and_assign_read_view(thd))
    return 0;
#endif
  /*
    Same idea as when one wants to CREATE TABLE in one engine which does not
    exist:
  */
1283 1284 1285
  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
               "This MySQL server does not support any "
               "consistent-read capable storage engine");
1286 1287 1288 1289
  return 0;
}


unknown's avatar
unknown committed
1290 1291 1292 1293
bool ha_flush_logs()
{
  bool result=0;
#ifdef HAVE_BERKELEY_DB
1294
  if ((have_berkeley_db == SHOW_OPTION_YES) &&
1295
      berkeley_flush_logs())
unknown's avatar
unknown committed
1296
    result=1;
1297 1298
#endif
#ifdef HAVE_INNOBASE_DB
1299
  if ((have_innodb == SHOW_OPTION_YES) &&
1300
      innobase_flush_logs())
1301
    result=1;
unknown's avatar
unknown committed
1302 1303 1304 1305
#endif
  return result;
}

unknown's avatar
unknown committed
1306 1307 1308 1309
/*
  This should return ENOENT if the file doesn't exists.
  The .frm file will be deleted only if we return 0 or ENOENT
*/
unknown's avatar
unknown committed
1310

1311 1312
int ha_delete_table(THD *thd, enum db_type table_type, const char *path,
                    const char *alias, bool generate_warning)
unknown's avatar
unknown committed
1313
{
1314
  handler *file;
unknown's avatar
unknown committed
1315
  char tmp_path[FN_REFLEN];
1316 1317 1318 1319 1320 1321 1322 1323
  int error;
  TABLE dummy_table;
  TABLE_SHARE dummy_share;
  DBUG_ENTER("ha_delete_table");

  bzero((char*) &dummy_table, sizeof(dummy_table));
  bzero((char*) &dummy_share, sizeof(dummy_share));
  dummy_table.s= &dummy_share;
1324 1325 1326

  /* DB_TYPE_UNKNOWN is used in ALTER TABLE when renaming only .frm files */
  if (table_type == DB_TYPE_UNKNOWN ||
1327
      ! (file=get_new_handler(&dummy_table, thd->mem_root, table_type)))
1328
    DBUG_RETURN(ENOENT);
1329

unknown's avatar
unknown committed
1330 1331 1332 1333
  if (lower_case_table_names == 2 && !(file->table_flags() & HA_FILE_BASED))
  {
    /* Ensure that table handler get path in lower case */
    strmov(tmp_path, path);
1334
    my_casedn_str(files_charset_info, tmp_path);
unknown's avatar
unknown committed
1335 1336
    path= tmp_path;
  }
1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354
  if ((error= file->delete_table(path)) && generate_warning)
  {
    /*
      Because file->print_error() use my_error() to generate the error message
      we must store the error state in thd, reset it and restore it to
      be able to get hold of the error message.
      (We should in the future either rewrite handler::print_error() or make
      a nice method of this.
    */
    bool query_error= thd->query_error;
    sp_rcontext *spcont= thd->spcont;
    SELECT_LEX *current_select= thd->lex->current_select;
    char buff[sizeof(thd->net.last_error)];
    char new_error[sizeof(thd->net.last_error)];
    int last_errno= thd->net.last_errno;

    strmake(buff, thd->net.last_error, sizeof(buff)-1);
    thd->query_error= 0;
1355
    thd->spcont= NULL;
1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373
    thd->lex->current_select= 0;
    thd->net.last_error[0]= 0;

    /* Fill up strucutures that print_error may need */
    dummy_table.s->path= path;
    dummy_table.alias= alias;

    file->print_error(error, 0);
    strmake(new_error, thd->net.last_error, sizeof(buff)-1);

    /* restore thd */
    thd->query_error= query_error;
    thd->spcont= spcont;
    thd->lex->current_select= current_select;
    thd->net.last_errno= last_errno;
    strmake(thd->net.last_error, buff, sizeof(buff)-1);
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, error, new_error);
  }
unknown's avatar
unknown committed
1374
  delete file;
1375
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1376
}
unknown's avatar
unknown committed
1377

unknown's avatar
unknown committed
1378 1379 1380
/****************************************************************************
** General handler functions
****************************************************************************/
unknown's avatar
unknown committed
1381 1382 1383
handler *handler::clone(MEM_ROOT *mem_root)
{
  handler *new_handler= get_new_handler(table, mem_root, table->s->db_type);
1384 1385 1386 1387 1388 1389 1390
  /*
    Allocate handler->ref here because otherwise ha_open will allocate it
    on this->table->mem_root and we will not be able to reclaim that memory 
    when the clone handler object is destroyed.
  */
  if (!(new_handler->ref= (byte*) alloc_root(mem_root, ALIGN_SIZE(ref_length)*2)))
    return NULL;
unknown's avatar
unknown committed
1391 1392 1393 1394 1395 1396
  if (new_handler && !new_handler->ha_open(table->s->path, table->db_stat,
                                           HA_OPEN_IGNORE_IF_LOCKED))
    return new_handler;
  return NULL;
}

unknown's avatar
unknown committed
1397 1398 1399 1400 1401 1402 1403

	/* Open database-handler. Try O_RDONLY if can't open as O_RDWR */
	/* Don't wait for locks if not HA_OPEN_WAIT_IF_LOCKED is set */

int handler::ha_open(const char *name, int mode, int test_if_locked)
{
  int error;
1404
  DBUG_ENTER("handler::ha_open");
1405
  DBUG_PRINT("enter",("name: %s  db_type: %d  db_stat: %d  mode: %d  lock_test: %d",
unknown's avatar
unknown committed
1406 1407
                      name, table->s->db_type, table->db_stat, mode,
                      test_if_locked));
unknown's avatar
unknown committed
1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424

  if ((error=open(name,mode,test_if_locked)))
  {
    if ((error == EACCES || error == EROFS) && mode == O_RDWR &&
	(table->db_stat & HA_TRY_READ_ONLY))
    {
      table->db_stat|=HA_READ_ONLY;
      error=open(name,O_RDONLY,test_if_locked);
    }
  }
  if (error)
  {
    my_errno=error;			/* Safeguard */
    DBUG_PRINT("error",("error: %d  errno: %d",error,errno));
  }
  else
  {
1425
    if (table->s->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
unknown's avatar
unknown committed
1426
      table->db_stat|=HA_READ_ONLY;
1427 1428
    (void) extra(HA_EXTRA_NO_READCHECK);	// Not needed in SQL

1429
    DBUG_ASSERT(alloc_root_inited(&table->mem_root));
1430 1431 1432
    /* ref is already allocated for us if we're called from handler::clone() */
    if (!ref && !(ref= (byte*) alloc_root(&table->mem_root, 
                                          ALIGN_SIZE(ref_length)*2)))
unknown's avatar
unknown committed
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
    {
      close();
      error=HA_ERR_OUT_OF_MEM;
    }
    else
      dupp_ref=ref+ALIGN_SIZE(ref_length);
  }
  DBUG_RETURN(error);
}

1443 1444 1445 1446 1447
/*
  Read first row (only) from a table
  This is never called for InnoDB or BDB tables, as these table types
  has the HA_NOT_EXACT_COUNT set.
*/
unknown's avatar
unknown committed
1448

1449
int handler::read_first_row(byte * buf, uint primary_key)
unknown's avatar
unknown committed
1450 1451
{
  register int error;
1452
  DBUG_ENTER("handler::read_first_row");
unknown's avatar
unknown committed
1453

1454
  statistic_increment(current_thd->status_var.ha_read_first_count,&LOCK_status);
1455 1456 1457 1458

  /*
    If there is very few deleted rows in the table, find the first row by
    scanning the table.
1459
    TODO remove the test for HA_READ_ORDER
1460
  */
1461 1462
  if (deleted < 10 || primary_key >= MAX_KEY ||
      !(index_flags(primary_key, 0, 0) & HA_READ_ORDER))
1463
  {
unknown's avatar
unknown committed
1464
    (void) ha_rnd_init(1);
1465
    while ((error= rnd_next(buf)) == HA_ERR_RECORD_DELETED) ;
unknown's avatar
unknown committed
1466
    (void) ha_rnd_end();
1467 1468 1469 1470
  }
  else
  {
    /* Find the first row through the primary key */
unknown's avatar
unknown committed
1471
    (void) ha_index_init(primary_key);
1472
    error=index_first(buf);
unknown's avatar
unknown committed
1473
    (void) ha_index_end();
1474
  }
unknown's avatar
unknown committed
1475 1476 1477
  DBUG_RETURN(error);
}

1478
/*
1479
  Generate the next auto-increment number based on increment and offset
unknown's avatar
unknown committed
1480

1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497
  In most cases increment= offset= 1, in which case we get:
  1,2,3,4,5,...
  If increment=10 and offset=5 and previous number is 1, we get:
  1,5,15,25,35,...
*/

inline ulonglong
next_insert_id(ulonglong nr,struct system_variables *variables)
{
  nr= (((nr+ variables->auto_increment_increment -
         variables->auto_increment_offset)) /
       (ulonglong) variables->auto_increment_increment);
  return (nr* (ulonglong) variables->auto_increment_increment +
          variables->auto_increment_offset);
}


1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
void handler::adjust_next_insert_id_after_explicit_value(ulonglong nr)
{
  /*
    If we have set THD::next_insert_id previously and plan to insert an
    explicitely-specified value larger than this, we need to increase
    THD::next_insert_id to be greater than the explicit value.
  */
  THD *thd= table->in_use;
  if (thd->clear_next_insert_id && (nr >= thd->next_insert_id))
  {
    if (thd->variables.auto_increment_increment != 1)
      nr= next_insert_id(nr, &thd->variables);
    else
      nr++;
    thd->next_insert_id= nr;
    DBUG_PRINT("info",("next_insert_id: %lu", (ulong) nr));
  }
}


1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
/*
  Computes the largest number X:
  - smaller than or equal to "nr"
  - of the form: auto_increment_offset + N * auto_increment_increment
  where N>=0.

  SYNOPSIS
    prev_insert_id
      nr            Number to "round down"
      variables     variables struct containing auto_increment_increment and
                    auto_increment_offset

  RETURN
    The number X if it exists, "nr" otherwise.
*/

inline ulonglong
prev_insert_id(ulonglong nr, struct system_variables *variables)
{
  if (unlikely(nr < variables->auto_increment_offset))
  {
    /*
      There's nothing good we can do here. That is a pathological case, where
      the offset is larger than the column's max possible value, i.e. not even
      the first sequence value may be inserted. User will receive warning.
    */
    DBUG_PRINT("info",("auto_increment: nr: %lu cannot honour "
                       "auto_increment_offset: %lu",
unknown's avatar
unknown committed
1546
                       (ulong) nr, variables->auto_increment_offset));
1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557
    return nr;
  }
  if (variables->auto_increment_increment == 1)
    return nr; // optimization of the formula below
  nr= (((nr - variables->auto_increment_offset)) /
       (ulonglong) variables->auto_increment_increment);
  return (nr * (ulonglong) variables->auto_increment_increment +
          variables->auto_increment_offset);
}


1558
/*
1559 1560 1561 1562 1563 1564 1565
  Update the auto_increment field if necessary

  SYNOPSIS
     update_auto_increment()

  RETURN
    0	ok
unknown's avatar
unknown committed
1566 1567 1568 1569
    HA_ERR_AUTOINC_READ_FAILED
     	get_auto_increment() was called and returned ~(ulonglong) 0
    HA_ERR_AUTOINC_ERANGE
        storing value in field caused strict mode failure.
unknown's avatar
foo1  
unknown committed
1570

1571 1572 1573 1574

  IMPLEMENTATION

    Updates columns with type NEXT_NUMBER if:
1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610

  - If column value is set to NULL (in which case
    auto_increment_field_not_null is 0)
  - If column is set to 0 and (sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO) is not
    set. In the future we will only set NEXT_NUMBER fields if one sets them
    to NULL (or they are not included in the insert list).


  There are two different cases when the above is true:

  - thd->next_insert_id == 0  (This is the normal case)
    In this case we set the set the column for the first row to the value
    next_insert_id(get_auto_increment(column))) which is normally
    max-used-column-value +1.

    We call get_auto_increment() only for the first row in a multi-row
    statement. For the following rows we generate new numbers based on the
    last used number.

  - thd->next_insert_id != 0.  This happens when we have read a statement
    from the binary log or when one has used SET LAST_INSERT_ID=#.

    In this case we will set the column to the value of next_insert_id.
    The next row will be given the id
    next_insert_id(next_insert_id)

    The idea is that generated auto_increment values are predictable and
    independent of the column values in the table.  This is needed to be
    able to replicate into a table that already has rows with a higher
    auto-increment value than the one that is inserted.

    After we have already generated an auto-increment number and the user
    inserts a column with a higher value than the last used one, we will
    start counting from the inserted value.

    thd->next_insert_id is cleared after it's been used for a statement.
1611
*/
unknown's avatar
unknown committed
1612

unknown's avatar
unknown committed
1613
int handler::update_auto_increment()
unknown's avatar
unknown committed
1614
{
1615 1616 1617
  ulonglong nr;
  THD *thd= table->in_use;
  struct system_variables *variables= &thd->variables;
1618 1619
  bool external_auto_increment= 
       table->file->table_flags() & HA_EXTERNAL_AUTO_INCREMENT;
1620
  DBUG_ENTER("handler::update_auto_increment");
1621 1622 1623 1624 1625 1626 1627 1628

  /*
    We must save the previous value to be able to restore it if the
    row was not inserted
  */
  thd->prev_insert_id= thd->next_insert_id;

  if ((nr= table->next_number_field->val_int()) != 0 ||
1629
      table->auto_increment_field_not_null &&
1630
      thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO)
1631
  {
1632
    /* Mark that we didn't generate a new value **/
1633
    auto_increment_column_changed=0;
1634
    adjust_next_insert_id_after_explicit_value(nr);
1635
    DBUG_RETURN(0);
1636
  }
1637
  if (external_auto_increment || !(nr= thd->next_insert_id))
1638
  {
1639
    if ((nr= get_auto_increment()) == ~(ulonglong) 0)
unknown's avatar
unknown committed
1640
      DBUG_RETURN(HA_ERR_AUTOINC_READ_FAILED);  // Mark failure
1641

1642
    if (!external_auto_increment && variables->auto_increment_increment != 1)
1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656
      nr= next_insert_id(nr-1, variables);
    /*
      Update next row based on the found value. This way we don't have to
      call the handler for every generated auto-increment value on a
      multi-row statement
    */
    thd->next_insert_id= nr;
  }

  DBUG_PRINT("info",("auto_increment: %lu", (ulong) nr));

  /* Mark that we should clear next_insert_id before next stmt */
  thd->clear_next_insert_id= 1;

1657
  if (likely(!table->next_number_field->store((longlong) nr, TRUE)))
1658
    thd->insert_id((ulonglong) nr);
1659
  else
unknown's avatar
unknown committed
1660
  if (thd->killed != THD::KILL_BAD_DATA) /* did we fail strict mode? */
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
  {
    /*
      overflow of the field; we'll use the max value, however we try to
      decrease it to honour auto_increment_* variables:
    */
    nr= prev_insert_id(table->next_number_field->val_int(), variables);
    thd->insert_id(nr);
    if (unlikely(table->next_number_field->store((longlong) nr, TRUE)))
      thd->insert_id(nr= table->next_number_field->val_int());
  }
unknown's avatar
unknown committed
1671 1672
  else
    DBUG_RETURN(HA_ERR_AUTOINC_ERANGE);
1673 1674 1675 1676 1677 1678

  /*
    We can't set next_insert_id if the auto-increment key is not the
    first key part, as there is no guarantee that the first parts will be in
    sequence
  */
1679
  if (!table->s->next_number_key_offset)
1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
  {
    /*
      Set next insert id to point to next auto-increment value to be able to
      handle multi-row statements
      This works even if auto_increment_increment > 1
    */
    thd->next_insert_id= next_insert_id(nr, variables);
  }
  else
    thd->next_insert_id= 0;

  /* Mark that we generated a new value */
1692
  auto_increment_column_changed=1;
unknown's avatar
unknown committed
1693
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1694 1695
}

1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706
/*
  restore_auto_increment

  In case of error on write, we restore the last used next_insert_id value
  because the previous value was not used.
*/

void handler::restore_auto_increment()
{
  THD *thd= table->in_use;
  if (thd->next_insert_id)
unknown's avatar
unknown committed
1707
  {
1708
    thd->next_insert_id= thd->prev_insert_id;
unknown's avatar
unknown committed
1709 1710 1711 1712 1713 1714
    if (thd->next_insert_id == 0)
    {
      /* we didn't generate a value, engine will be called again */
      thd->clear_next_insert_id= 0;
    }
  }
1715 1716
}

unknown's avatar
unknown committed
1717

1718
ulonglong handler::get_auto_increment()
unknown's avatar
unknown committed
1719
{
1720
  ulonglong nr;
unknown's avatar
unknown committed
1721
  int error;
unknown's avatar
unknown committed
1722

unknown's avatar
unknown committed
1723
  (void) extra(HA_EXTRA_KEYREAD);
1724 1725
  index_init(table->s->next_number_index);
  if (!table->s->next_number_key_offset)
unknown's avatar
unknown committed
1726 1727 1728 1729 1730 1731
  {						// Autoincrement at key-start
    error=index_last(table->record[1]);
  }
  else
  {
    byte key[MAX_KEY_LENGTH];
1732
    key_copy(key, table->record[0],
1733 1734 1735 1736
             table->key_info + table->s->next_number_index,
             table->s->next_number_key_offset);
    error= index_read(table->record[1], key, table->s->next_number_key_offset,
                      HA_READ_PREFIX_LAST);
unknown's avatar
unknown committed
1737 1738
  }

unknown's avatar
unknown committed
1739 1740 1741
  if (error)
    nr=1;
  else
1742 1743
    nr= ((ulonglong) table->next_number_field->
         val_int_offset(table->s->rec_buff_length)+1);
unknown's avatar
unknown committed
1744
  index_end();
unknown's avatar
unknown committed
1745
  (void) extra(HA_EXTRA_NO_KEYREAD);
unknown's avatar
unknown committed
1746 1747 1748
  return nr;
}

1749 1750 1751 1752

/*
  Print error that we got from handler function

unknown's avatar
unknown committed
1753
  NOTE
1754 1755 1756 1757 1758
   In case of delete table it's only safe to use the following parts of
   the 'table' structure:
     table->s->path
     table->alias
*/
unknown's avatar
unknown committed
1759 1760 1761

void handler::print_error(int error, myf errflag)
{
1762
  DBUG_ENTER("handler::print_error");
unknown's avatar
unknown committed
1763 1764 1765 1766
  DBUG_PRINT("enter",("error: %d",error));

  int textno=ER_GET_ERRNO;
  switch (error) {
1767 1768 1769
  case EACCES:
    textno=ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780
  case EAGAIN:
    textno=ER_FILE_USED;
    break;
  case ENOENT:
    textno=ER_FILE_NOT_FOUND;
    break;
  case HA_ERR_KEY_NOT_FOUND:
  case HA_ERR_NO_ACTIVE_RECORD:
  case HA_ERR_END_OF_FILE:
    textno=ER_KEY_NOT_FOUND;
    break;
unknown's avatar
unknown committed
1781
  case HA_ERR_WRONG_MRG_TABLE_DEF:
unknown's avatar
unknown committed
1782 1783 1784 1785 1786 1787 1788 1789 1790
    textno=ER_WRONG_MRG_TABLE;
    break;
  case HA_ERR_FOUND_DUPP_KEY:
  {
    uint key_nr=get_dup_key(error);
    if ((int) key_nr >= 0)
    {
      /* Write the dupplicated key in the error message */
      char key[MAX_KEY_LENGTH];
1791
      String str(key,sizeof(key),system_charset_info);
1792 1793 1794 1795

      if (key_nr == MAX_KEY)
      {
	/* Key is unknown */
1796
	str.copy("", 0, system_charset_info);
1797
	key_nr= (uint) -1;
1798 1799
      }
      else
unknown's avatar
unknown committed
1800
      {
1801 1802 1803
	key_unpack(&str,table,(uint) key_nr);
	uint max_length=MYSQL_ERRMSG_SIZE-(uint) strlen(ER(ER_DUP_ENTRY));
	if (str.length() >= max_length)
1804
	{
1805
	    str.length(max_length-4);
1806
	    str.append(STRING_WITH_LEN("..."));
1807
	}
unknown's avatar
unknown committed
1808
      }
1809
      my_error(ER_DUP_ENTRY, MYF(0), str.c_ptr(), key_nr+1);
unknown's avatar
unknown committed
1810 1811 1812 1813 1814
      DBUG_VOID_RETURN;
    }
    textno=ER_DUP_KEY;
    break;
  }
1815
  case HA_ERR_NULL_IN_SPATIAL:
1816 1817
    my_error(ER_CANT_CREATE_GEOMETRY_OBJECT, MYF(0));
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1818 1819 1820 1821 1822 1823 1824 1825 1826
  case HA_ERR_FOUND_DUPP_UNIQUE:
    textno=ER_DUP_UNIQUE;
    break;
  case HA_ERR_RECORD_CHANGED:
    textno=ER_CHECKREAD;
    break;
  case HA_ERR_CRASHED:
    textno=ER_NOT_KEYFILE;
    break;
1827 1828 1829
  case HA_ERR_WRONG_IN_RECORD:
    textno= ER_CRASHED_ON_USAGE;
    break;
1830 1831 1832
  case HA_ERR_CRASHED_ON_USAGE:
    textno=ER_CRASHED_ON_USAGE;
    break;
1833 1834 1835
  case HA_ERR_NOT_A_TABLE:
    textno= error;
    break;
1836 1837 1838
  case HA_ERR_CRASHED_ON_REPAIR:
    textno=ER_CRASHED_ON_REPAIR;
    break;
unknown's avatar
unknown committed
1839
  case HA_ERR_OUT_OF_MEM:
1840 1841
    textno=ER_OUT_OF_RESOURCES;
    break;
unknown's avatar
unknown committed
1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
  case HA_ERR_WRONG_COMMAND:
    textno=ER_ILLEGAL_HA;
    break;
  case HA_ERR_OLD_FILE:
    textno=ER_OLD_KEYFILE;
    break;
  case HA_ERR_UNSUPPORTED:
    textno=ER_UNSUPPORTED_EXTENSION;
    break;
  case HA_ERR_RECORD_FILE_FULL:
1852
  case HA_ERR_INDEX_FILE_FULL:
1853
    textno=ER_RECORD_FILE_FULL;
1854
    break;
1855 1856 1857 1858 1859 1860
  case HA_ERR_LOCK_WAIT_TIMEOUT:
    textno=ER_LOCK_WAIT_TIMEOUT;
    break;
  case HA_ERR_LOCK_TABLE_FULL:
    textno=ER_LOCK_TABLE_FULL;
    break;
1861 1862 1863
  case HA_ERR_LOCK_DEADLOCK:
    textno=ER_LOCK_DEADLOCK;
    break;
1864 1865 1866
  case HA_ERR_READ_ONLY_TRANSACTION:
    textno=ER_READ_ONLY_TRANSACTION;
    break;
unknown's avatar
Merge  
unknown committed
1867 1868 1869 1870
  case HA_ERR_CANNOT_ADD_FOREIGN:
    textno=ER_CANNOT_ADD_FOREIGN;
    break;
  case HA_ERR_ROW_IS_REFERENCED:
1871 1872 1873 1874 1875 1876
  {
    String str;
    get_error_message(error, &str);
    my_error(ER_ROW_IS_REFERENCED_2, MYF(0), str.c_ptr_safe());
    DBUG_VOID_RETURN;
  }
unknown's avatar
Merge  
unknown committed
1877
  case HA_ERR_NO_REFERENCED_ROW:
1878 1879 1880 1881 1882 1883
  {
    String str;
    get_error_message(error, &str);
    my_error(ER_NO_REFERENCED_ROW_2, MYF(0), str.c_ptr_safe());
    DBUG_VOID_RETURN;
  }
1884 1885 1886
  case HA_ERR_TABLE_DEF_CHANGED:
    textno=ER_TABLE_DEF_CHANGED;
    break;
1887 1888
  case HA_ERR_NO_SUCH_TABLE:
  {
unknown's avatar
unknown committed
1889 1890 1891 1892 1893
    /*
      We have to use path to find database name instead of using
      table->table_cache_key because if the table didn't exist, then
      table_cache_key was not set up
    */
1894 1895
    char *db;
    char buff[FN_REFLEN];
1896
    uint length= dirname_part(buff,table->s->path);
1897 1898
    buff[length-1]=0;
    db=buff+dirname_length(buff);
1899
    my_error(ER_NO_SUCH_TABLE, MYF(0), db, table->alias);
1900 1901
    break;
  }
unknown's avatar
unknown committed
1902 1903 1904
  case HA_ERR_TABLE_NEEDS_UPGRADE:
    textno=ER_TABLE_NEEDS_UPGRADE;
    break;
1905 1906 1907
  case HA_ERR_TABLE_READONLY:
    textno= ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
1908 1909 1910 1911 1912 1913
  case HA_ERR_AUTOINC_READ_FAILED:
    textno= ER_AUTOINC_READ_FAILED;
    break;
  case HA_ERR_AUTOINC_ERANGE:
    textno= ER_WARN_DATA_OUT_OF_RANGE;
    break;
unknown's avatar
unknown committed
1914 1915
  default:
    {
1916 1917 1918
      /* The error was "unknown" to this function.
	 Ask handler if it has got a message for this error */
      bool temporary= FALSE;
1919 1920 1921
      String str;
      temporary= get_error_message(error, &str);
      if (!str.is_empty())
1922
      {
1923
	const char* engine= table_type();
1924
	if (temporary)
1925
	  my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(), engine);
1926
	else
1927
	  my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine);
1928
      }
1929
      else
1930
	my_error(ER_GET_ERRNO,errflag,error);
unknown's avatar
unknown committed
1931 1932 1933
      DBUG_VOID_RETURN;
    }
  }
1934
  my_error(textno, errflag, table->alias, error);
unknown's avatar
unknown committed
1935 1936 1937
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
1938

1939
/*
1940
   Return an error message specific to this handler
1941

1942
   SYNOPSIS
1943 1944
   error        error code previously returned by handler
   buf          Pointer to String where to add error message
unknown's avatar
unknown committed
1945

1946
   Returns true if this is a temporary error
1947 1948
 */

1949
bool handler::get_error_message(int error, String* buf)
1950
{
unknown's avatar
unknown committed
1951
  return FALSE;
1952 1953 1954
}


unknown's avatar
unknown committed
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982
int handler::ha_check_for_upgrade(HA_CHECK_OPT *check_opt)
{
  KEY *keyinfo, *keyend;
  KEY_PART_INFO *keypart, *keypartend;

  if (!table->s->mysql_version)
  {
    /* check for blob-in-key error */
    keyinfo= table->key_info;
    keyend= table->key_info + table->s->keys;
    for (; keyinfo < keyend; keyinfo++)
    {
      keypart= keyinfo->key_part;
      keypartend= keypart + keyinfo->key_parts;
      for (; keypart < keypartend; keypart++)
      {
        if (!keypart->fieldnr)
          continue;
        Field *field= table->field[keypart->fieldnr-1];
        if (field->type() == FIELD_TYPE_BLOB)
        {
          if (check_opt->sql_flags & TT_FOR_UPGRADE)
            check_opt->flags= T_MEDIUM;
          return HA_ADMIN_NEEDS_CHECK;
        }
      }
    }
  }
1983 1984
  if (table->s->frm_version != FRM_VER_TRUE_VARCHAR)
    return HA_ADMIN_NEEDS_ALTER;
unknown's avatar
unknown committed
1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
  return check_for_upgrade(check_opt);
}


int handler::check_old_types()
{
  Field** field;

  if (!table->s->mysql_version)
  {
    /* check for bad DECIMAL field */
    for (field= table->field; (*field); field++)
    {
      if ((*field)->type() == FIELD_TYPE_NEWDECIMAL)
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
2002 2003 2004 2005
      if ((*field)->type() == MYSQL_TYPE_VAR_STRING)
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
unknown's avatar
unknown committed
2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018
    }
  }
  return 0;
}


static bool update_frm_version(TABLE *table, bool needs_lock)
{
  char path[FN_REFLEN];
  File file;
  int result= 1;
  DBUG_ENTER("update_frm_version");

2019 2020 2021 2022 2023 2024 2025
  /*
    No need to update frm version in case table was created or checked
    by server with the same version. This also ensures that we do not
    update frm version for temporary tables as this code doesn't support
    temporary tables.
  */
  if (table->s->mysql_version == MYSQL_VERSION_ID)
unknown's avatar
unknown committed
2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063
    DBUG_RETURN(0);

  strxnmov(path, sizeof(path)-1, mysql_data_home, "/", table->s->db, "/",
           table->s->table_name, reg_ext, NullS);
  if (!unpack_filename(path, path))
    DBUG_RETURN(1);

  if (needs_lock)
    pthread_mutex_lock(&LOCK_open);

  if ((file= my_open(path, O_RDWR|O_BINARY, MYF(MY_WME))) >= 0)
  {
    uchar version[4];
    char *key= table->s->table_cache_key;
    uint key_length= table->s->key_length;
    TABLE *entry;
    HASH_SEARCH_STATE state;

    int4store(version, MYSQL_VERSION_ID);

    if ((result= my_pwrite(file,(byte*) version,4,51L,MYF_RW)))
      goto err;

    for (entry=(TABLE*) hash_first(&open_cache,(byte*) key,key_length, &state);
         entry;
         entry= (TABLE*) hash_next(&open_cache,(byte*) key,key_length, &state))
      entry->s->mysql_version= MYSQL_VERSION_ID;
  }
err:
  if (file >= 0)
    VOID(my_close(file,MYF(MY_WME)));
  if (needs_lock)
    pthread_mutex_unlock(&LOCK_open);
  DBUG_RETURN(result);
}



unknown's avatar
unknown committed
2064
/* Return key if error because of duplicated keys */
unknown's avatar
unknown committed
2065 2066 2067

uint handler::get_dup_key(int error)
{
2068
  DBUG_ENTER("handler::get_dup_key");
unknown's avatar
unknown committed
2069
  table->file->errkey  = (uint) -1;
2070 2071
  if (error == HA_ERR_FOUND_DUPP_KEY || error == HA_ERR_FOUND_DUPP_UNIQUE ||
      error == HA_ERR_NULL_IN_SPATIAL)
unknown's avatar
unknown committed
2072 2073 2074 2075
    info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
  DBUG_RETURN(table->file->errkey);
}

unknown's avatar
unknown committed
2076

2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
/*
  Delete all files with extension from bas_ext()

  SYNOPSIS
    delete_table()
    name		Base name of table

  NOTES
    We assume that the handler may return more extensions than
    was actually used for the file.

  RETURN
    0   If we successfully deleted at least one file from base_ext and
unknown's avatar
unknown committed
2090
	didn't get any other errors than ENOENT
2091
    #   Error
2092 2093
*/

unknown's avatar
unknown committed
2094 2095
int handler::delete_table(const char *name)
{
2096 2097
  int error= 0;
  int enoent_or_zero= ENOENT;                   // Error if no file was deleted
2098
  char buff[FN_REFLEN];
2099

unknown's avatar
unknown committed
2100 2101
  for (const char **ext=bas_ext(); *ext ; ext++)
  {
2102 2103
    fn_format(buff, name, "", *ext, 2 | 4);
    if (my_delete_with_symlink(buff, MYF(0)))
unknown's avatar
unknown committed
2104
    {
2105
      if ((error= my_errno) != ENOENT)
unknown's avatar
unknown committed
2106 2107
	break;
    }
2108
    else
2109
      enoent_or_zero= 0;                        // No error for ENOENT
2110
    error= enoent_or_zero;
unknown's avatar
unknown committed
2111
  }
unknown's avatar
unknown committed
2112
  return error;
unknown's avatar
unknown committed
2113 2114 2115 2116 2117
}


int handler::rename_table(const char * from, const char * to)
{
unknown's avatar
unknown committed
2118 2119
  int error= 0;
  for (const char **ext= bas_ext(); *ext ; ext++)
unknown's avatar
unknown committed
2120
  {
unknown's avatar
unknown committed
2121 2122 2123 2124 2125 2126
    if (rename_file_ext(from, to, *ext))
    {
      if ((error=my_errno) != ENOENT)
	break;
      error= 0;
    }
unknown's avatar
unknown committed
2127
  }
unknown's avatar
unknown committed
2128
  return error;
unknown's avatar
unknown committed
2129 2130
}

unknown's avatar
unknown committed
2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181

/*
   Performs checks upon the table.

   SYNOPSIS
   check()
   thd                thread doing CHECK TABLE operation
   check_opt          options from the parser

   NOTES

   RETURN
   HA_ADMIN_OK                 Successful upgrade
   HA_ADMIN_NEEDS_UPGRADE      Table has structures requiring upgrade
   HA_ADMIN_NEEDS_ALTER        Table has structures requiring ALTER TABLE
   HA_ADMIN_NOT_IMPLEMENTED
*/

int handler::ha_check(THD *thd, HA_CHECK_OPT *check_opt)
{
  int error;

  if ((table->s->mysql_version >= MYSQL_VERSION_ID) &&
      (check_opt->sql_flags & TT_FOR_UPGRADE))
    return 0;

  if (table->s->mysql_version < MYSQL_VERSION_ID)
  {
    if ((error= check_old_types()))
      return error;
    error= ha_check_for_upgrade(check_opt);
    if (error && (error != HA_ADMIN_NEEDS_CHECK))
      return error;
    if (!error && (check_opt->sql_flags & TT_FOR_UPGRADE))
      return 0;
  }
  if ((error= check(thd, check_opt)))
    return error;
  return update_frm_version(table, 0);
}


int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
{
  int result;
  if ((result= repair(thd, check_opt)))
    return result;
  return update_frm_version(table, 0);
}


unknown's avatar
unknown committed
2182
/*
2183 2184 2185 2186 2187 2188
  Tell the storage engine that it is allowed to "disable transaction" in the
  handler. It is a hint that ACID is not required - it is used in NDB for
  ALTER TABLE, for example, when data are copied to temporary table.
  A storage engine may treat this hint any way it likes. NDB for example
  starts to commit every now and then automatically.
  This hint can be safely ignored.
2189
*/
unknown's avatar
unknown committed
2190

2191
int ha_enable_transaction(THD *thd, bool on)
2192 2193 2194
{
  int error=0;

2195 2196
  DBUG_ENTER("ha_enable_transaction");
  thd->transaction.on= on;
unknown's avatar
unknown committed
2197
  if (on)
2198 2199 2200 2201 2202 2203 2204
  {
    /*
      Now all storage engines should have transaction handling enabled.
      But some may have it enabled all the time - "disabling" transactions
      is an optimization hint that storage engine is free to ignore.
      So, let's commit an open transaction (if any) now.
    */
2205 2206
    if (!(error= ha_commit_stmt(thd)))
      error= end_trans(thd, COMMIT);
2207
  }
2208 2209 2210
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
2211 2212 2213 2214 2215
int handler::index_next_same(byte *buf, const byte *key, uint keylen)
{
  int error;
  if (!(error=index_next(buf)))
  {
unknown's avatar
unknown committed
2216
    if (key_cmp_if_same(table, key, active_index, keylen))
unknown's avatar
unknown committed
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229
    {
      table->status=STATUS_NOT_FOUND;
      error=HA_ERR_END_OF_FILE;
    }
  }
  return error;
}


/****************************************************************************
** Some general functions that isn't in the handler class
****************************************************************************/

unknown's avatar
unknown committed
2230 2231 2232 2233
/*
  Initiates table-file and calls apropriate database-creator
  Returns 1 if something got wrong
*/
unknown's avatar
unknown committed
2234 2235 2236 2237 2238 2239

int ha_create_table(const char *name, HA_CREATE_INFO *create_info,
		    bool update_create_info)
{
  int error;
  TABLE table;
unknown's avatar
unknown committed
2240
  char name_buff[FN_REFLEN];
unknown's avatar
unknown committed
2241 2242
  DBUG_ENTER("ha_create_table");

2243
  if (openfrm(current_thd, name,"",0,(uint) READ_ALL, 0, &table))
unknown's avatar
unknown committed
2244 2245 2246 2247 2248
    DBUG_RETURN(1);
  if (update_create_info)
  {
    update_create_info_from_table(create_info, &table);
  }
unknown's avatar
unknown committed
2249 2250 2251 2252 2253
  if (lower_case_table_names == 2 &&
      !(table.file->table_flags() & HA_FILE_BASED))
  {
    /* Ensure that handler gets name in lower case */
    strmov(name_buff, name);
2254
    my_casedn_str(files_charset_info, name_buff);
unknown's avatar
unknown committed
2255 2256 2257
    name= name_buff;
  }

unknown's avatar
unknown committed
2258 2259
  error=table.file->create(name,&table,create_info);
  VOID(closefrm(&table));
unknown's avatar
unknown committed
2260
  if (error)
2261
    my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), name,error);
unknown's avatar
unknown committed
2262 2263 2264
  DBUG_RETURN(error != 0);
}

2265
/*
2266
  Try to discover table from engine and
2267
  if found, write the frm file to disk.
2268

2269
  RETURN VALUES:
2270
  -1 : Table did not exists
2271
   0 : Table created ok
2272
   > 0 : Error, table existed but could not be created
2273 2274 2275

*/

2276 2277 2278
int ha_create_table_from_engine(THD* thd,
				const char *db,
				const char *name)
2279
{
unknown's avatar
unknown committed
2280 2281 2282
  int error;
  const void *frmblob;
  uint frmlen;
2283 2284 2285 2286
  char path[FN_REFLEN];
  HA_CREATE_INFO create_info;
  TABLE table;
  DBUG_ENTER("ha_create_table_from_engine");
unknown's avatar
unknown committed
2287
  DBUG_PRINT("enter", ("name '%s'.'%s'", db, name));
2288 2289

  bzero((char*) &create_info,sizeof(create_info));
unknown's avatar
unknown committed
2290
  if ((error= ha_discover(thd, db, name, &frmblob, &frmlen)))
2291
  {
unknown's avatar
unknown committed
2292
    /* Table could not be discovered and thus not created */
2293
    DBUG_RETURN(error);
2294 2295
  }

unknown's avatar
unknown committed
2296
  /*
2297 2298
    Table exists in handler and could be discovered
    frmblob and frmlen are set, write the frm to disk
unknown's avatar
unknown committed
2299
  */
2300

2301 2302
  (void)strxnmov(path,FN_REFLEN,mysql_data_home,"/",db,"/",name,NullS);
  // Save the frm file
unknown's avatar
unknown committed
2303 2304 2305
  error= writefrm(path, frmblob, frmlen);
  my_free((char*) frmblob, MYF(0));
  if (error)
2306
    DBUG_RETURN(2);
2307

unknown's avatar
unknown committed
2308
  if (openfrm(thd, path,"",0,(uint) READ_ALL, 0, &table))
2309
    DBUG_RETURN(3);
2310

2311
  update_create_info_from_table(&create_info, &table);
2312
  create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE;
2313

2314 2315 2316 2317 2318
  if (lower_case_table_names == 2 &&
      !(table.file->table_flags() & HA_FILE_BASED))
  {
    /* Ensure that handler gets name in lower case */
    my_casedn_str(files_charset_info, path);
2319
  }
2320 2321 2322 2323
  error=table.file->create(path,&table,&create_info);
  VOID(closefrm(&table));

  DBUG_RETURN(error != 0);
2324 2325
}

2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343
void st_ha_check_opt::init()
{
  flags= sql_flags= 0;
  sort_buffer_size = current_thd->variables.myisam_sort_buff_size;
}


/*****************************************************************************
  Key cache handling.

  This code is only relevant for ISAM/MyISAM tables

  key_cache->cache may be 0 only in the case where a key cache is not
  initialized or when we where not able to init the key cache in a previous
  call to ha_init_key_cache() (probably out of memory)
*****************************************************************************/

/* Init a key cache if it has not been initied before */
unknown's avatar
unknown committed
2344

2345

unknown's avatar
unknown committed
2346
int ha_init_key_cache(const char *name, KEY_CACHE *key_cache)
unknown's avatar
unknown committed
2347
{
2348 2349
  DBUG_ENTER("ha_init_key_cache");

unknown's avatar
unknown committed
2350
  if (!key_cache->key_cache_inited)
2351 2352
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2353 2354 2355 2356
    long tmp_buff_size= (long) key_cache->param_buff_size;
    long tmp_block_size= (long) key_cache->param_block_size;
    uint division_limit= key_cache->param_division_limit;
    uint age_threshold=  key_cache->param_age_threshold;
2357
    pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2358
    DBUG_RETURN(!init_key_cache(key_cache,
2359 2360
				tmp_block_size,
				tmp_buff_size,
unknown's avatar
unknown committed
2361
				division_limit, age_threshold));
2362
  }
2363
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2364 2365
}

2366 2367 2368

/* Resize key cache */

unknown's avatar
unknown committed
2369
int ha_resize_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
2370
{
2371 2372
  DBUG_ENTER("ha_resize_key_cache");

unknown's avatar
unknown committed
2373
  if (key_cache->key_cache_inited)
2374 2375
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2376 2377 2378 2379
    long tmp_buff_size= (long) key_cache->param_buff_size;
    long tmp_block_size= (long) key_cache->param_block_size;
    uint division_limit= key_cache->param_division_limit;
    uint age_threshold=  key_cache->param_age_threshold;
2380
    pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2381 2382 2383
    DBUG_RETURN(!resize_key_cache(key_cache, tmp_block_size,
				  tmp_buff_size,
				  division_limit, age_threshold));
2384
  }
2385
  DBUG_RETURN(0);
2386 2387
}

2388 2389 2390

/* Change parameters for key cache (like size) */

unknown's avatar
unknown committed
2391
int ha_change_key_cache_param(KEY_CACHE *key_cache)
2392
{
unknown's avatar
unknown committed
2393 2394 2395 2396 2397 2398 2399 2400
  if (key_cache->key_cache_inited)
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
    uint division_limit= key_cache->param_division_limit;
    uint age_threshold=  key_cache->param_age_threshold;
    pthread_mutex_unlock(&LOCK_global_system_variables);
    change_key_cache_param(key_cache, division_limit, age_threshold);
  }
2401 2402
  return 0;
}
unknown's avatar
unknown committed
2403

2404 2405
/* Free memory allocated by a key cache */

unknown's avatar
unknown committed
2406
int ha_end_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
2407
{
unknown's avatar
unknown committed
2408
  end_key_cache(key_cache, 1);		// Can never fail
2409
  return 0;
unknown's avatar
unknown committed
2410
}
unknown's avatar
unknown committed
2411

2412
/* Move all tables from one key cache to another one */
unknown's avatar
unknown committed
2413

unknown's avatar
unknown committed
2414 2415
int ha_change_key_cache(KEY_CACHE *old_key_cache,
			KEY_CACHE *new_key_cache)
unknown's avatar
unknown committed
2416
{
2417 2418
  mi_change_key_cache(old_key_cache, new_key_cache);
  return 0;
unknown's avatar
unknown committed
2419
}
2420 2421


unknown's avatar
unknown committed
2422 2423
/*
  Try to discover one table from handler(s)
unknown's avatar
unknown committed
2424 2425

  RETURN
2426 2427 2428
   -1  : Table did not exists
    0  : OK. In this case *frmblob and *frmlen are set
    >0 : error.  frmblob and frmlen may not be set
unknown's avatar
unknown committed
2429 2430
*/

unknown's avatar
unknown committed
2431 2432
int ha_discover(THD *thd, const char *db, const char *name,
		const void **frmblob, uint *frmlen)
unknown's avatar
unknown committed
2433
{
2434
  int error= -1; // Table does not exist in any handler
unknown's avatar
unknown committed
2435
  DBUG_ENTER("ha_discover");
2436
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
2437 2438
  if (is_prefix(name,tmp_file_prefix)) /* skip temporary tables */
    DBUG_RETURN(error);
unknown's avatar
unknown committed
2439 2440
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
2441
    error= ndbcluster_discover(thd, db, name, frmblob, frmlen);
unknown's avatar
unknown committed
2442 2443
#endif
  if (!error)
2444
    statistic_increment(thd->status_var.ha_discover_count,&LOCK_status);
unknown's avatar
unknown committed
2445 2446 2447 2448
  DBUG_RETURN(error);
}


2449
/*
unknown's avatar
foo1  
unknown committed
2450 2451
  Call this function in order to give the handler the possiblity
  to ask engine if there are any new tables that should be written to disk
2452
  or any dropped tables that need to be removed from disk
2453 2454
*/

2455 2456
int
ha_find_files(THD *thd,const char *db,const char *path,
unknown's avatar
unknown committed
2457
	      const char *wild, bool dir, List<char> *files)
2458 2459
{
  int error= 0;
2460
  DBUG_ENTER("ha_find_files");
unknown's avatar
foo1  
unknown committed
2461
  DBUG_PRINT("enter", ("db: %s, path: %s, wild: %s, dir: %d",
2462
		       db, path, wild, dir));
2463 2464
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
unknown's avatar
unknown committed
2465
    error= ndbcluster_find_files(thd, db, path, wild, dir, files);
2466 2467 2468 2469
#endif
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
2470

2471 2472 2473 2474
/*
  Ask handler if the table exists in engine

  RETURN
2475 2476 2477
    HA_ERR_NO_SUCH_TABLE     Table does not exist
    HA_ERR_TABLE_EXIST       Table exists
    #                        Error code
2478 2479

 */
2480
int ha_table_exists_in_engine(THD* thd, const char* db, const char* name)
2481
{
2482
  int error= HA_ERR_NO_SUCH_TABLE;
2483
  DBUG_ENTER("ha_table_exists_in_engine");
2484 2485 2486
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
2487
    error= ndbcluster_table_exists_in_engine(thd, db, name);
2488
#endif
2489
  DBUG_PRINT("exit", ("error: %d", error));
2490 2491 2492 2493
  DBUG_RETURN(error);
}


unknown's avatar
unknown committed
2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618
/*
  Read the first row of a multi-range set.

  SYNOPSIS
    read_multi_range_first()
    found_range_p       Returns a pointer to the element in 'ranges' that
                        corresponds to the returned row.
    ranges              An array of KEY_MULTI_RANGE range descriptions.
    range_count         Number of ranges in 'ranges'.
    sorted		If result should be sorted per key.
    buffer              A HANDLER_BUFFER for internal handler usage.

  NOTES
    Record is read into table->record[0].
    *found_range_p returns a valid value only if read_multi_range_first()
    returns 0.
    Sorting is done within each range. If you want an overall sort, enter
    'ranges' with sorted ranges.

  RETURN
    0			OK, found a row
    HA_ERR_END_OF_FILE	No rows in range
    #			Error code
*/

int handler::read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
                                    KEY_MULTI_RANGE *ranges, uint range_count,
                                    bool sorted, HANDLER_BUFFER *buffer)
{
  int result= HA_ERR_END_OF_FILE;
  DBUG_ENTER("handler::read_multi_range_first");
  multi_range_sorted= sorted;
  multi_range_buffer= buffer;

  for (multi_range_curr= ranges, multi_range_end= ranges + range_count;
       multi_range_curr < multi_range_end;
       multi_range_curr++)
  {
    result= read_range_first(multi_range_curr->start_key.length ?
                             &multi_range_curr->start_key : 0,
                             multi_range_curr->end_key.length ?
                             &multi_range_curr->end_key : 0,
                             test(multi_range_curr->range_flag & EQ_RANGE),
                             multi_range_sorted);
    if (result != HA_ERR_END_OF_FILE)
      break;
  }

  *found_range_p= multi_range_curr;
  DBUG_PRINT("exit",("result %d", result));
  DBUG_RETURN(result);
}


/*
  Read the next row of a multi-range set.

  SYNOPSIS
    read_multi_range_next()
    found_range_p       Returns a pointer to the element in 'ranges' that
                        corresponds to the returned row.

  NOTES
    Record is read into table->record[0].
    *found_range_p returns a valid value only if read_multi_range_next()
    returns 0.

  RETURN
    0			OK, found a row
    HA_ERR_END_OF_FILE	No (more) rows in range
    #			Error code
*/

int handler::read_multi_range_next(KEY_MULTI_RANGE **found_range_p)
{
  int result;
  DBUG_ENTER("handler::read_multi_range_next");

  /* We should not be called after the last call returned EOF. */
  DBUG_ASSERT(multi_range_curr < multi_range_end);

  do
  {
    /* Save a call if there can be only one row in range. */
    if (multi_range_curr->range_flag != (UNIQUE_RANGE | EQ_RANGE))
    {
      result= read_range_next();

      /* On success or non-EOF errors jump to the end. */
      if (result != HA_ERR_END_OF_FILE)
        break;
    }
    else
    {
      /*
        We need to set this for the last range only, but checking this
        condition is more expensive than just setting the result code.
      */
      result= HA_ERR_END_OF_FILE;
    }

    /* Try the next range(s) until one matches a record. */
    for (multi_range_curr++;
         multi_range_curr < multi_range_end;
         multi_range_curr++)
    {
      result= read_range_first(multi_range_curr->start_key.length ?
                               &multi_range_curr->start_key : 0,
                               multi_range_curr->end_key.length ?
                               &multi_range_curr->end_key : 0,
                               test(multi_range_curr->range_flag & EQ_RANGE),
                               multi_range_sorted);
      if (result != HA_ERR_END_OF_FILE)
        break;
    }
  }
  while ((result == HA_ERR_END_OF_FILE) &&
         (multi_range_curr < multi_range_end));

  *found_range_p= multi_range_curr;
  DBUG_PRINT("exit",("handler::read_multi_range_next: result %d", result));
  DBUG_RETURN(result);
}


2619 2620 2621 2622 2623 2624 2625 2626
/*
  Read first row between two ranges.
  Store ranges for future calls to read_range_next

  SYNOPSIS
    read_range_first()
    start_key		Start key. Is 0 if no min range
    end_key		End key.  Is 0 if no max range
2627 2628
    eq_range_arg	Set to 1 if start_key == end_key and the range endpoints
                        will not change during query execution.
2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641
    sorted		Set to 1 if result should be sorted per key

  NOTES
    Record is read into table->record[0]

  RETURN
    0			Found row
    HA_ERR_END_OF_FILE	No rows in range
    #			Error code
*/

int handler::read_range_first(const key_range *start_key,
			      const key_range *end_key,
unknown's avatar
unknown committed
2642
			      bool eq_range_arg, bool sorted)
2643 2644 2645 2646
{
  int result;
  DBUG_ENTER("handler::read_range_first");

unknown's avatar
unknown committed
2647
  eq_range= eq_range_arg;
2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665
  end_range= 0;
  if (end_key)
  {
    end_range= &save_end_range;
    save_end_range= *end_key;
    key_compare_result_on_equal= ((end_key->flag == HA_READ_BEFORE_KEY) ? 1 :
				  (end_key->flag == HA_READ_AFTER_KEY) ? -1 : 0);
  }
  range_key_part= table->key_info[active_index].key_part;

  if (!start_key)			// Read first record
    result= index_first(table->record[0]);
  else
    result= index_read(table->record[0],
		       start_key->key,
		       start_key->length,
		       start_key->flag);
  if (result)
unknown's avatar
foo1  
unknown committed
2666
    DBUG_RETURN((result == HA_ERR_KEY_NOT_FOUND)
unknown's avatar
unknown committed
2667 2668
		? HA_ERR_END_OF_FILE
		: result);
2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688

  DBUG_RETURN (compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
}


/*
  Read next row between two ranges.

  SYNOPSIS
    read_range_next()

  NOTES
    Record is read into table->record[0]

  RETURN
    0			Found row
    HA_ERR_END_OF_FILE	No rows in range
    #			Error code
*/

unknown's avatar
unknown committed
2689
int handler::read_range_next()
2690 2691 2692 2693 2694
{
  int result;
  DBUG_ENTER("handler::read_range_next");

  if (eq_range)
unknown's avatar
unknown committed
2695 2696 2697 2698 2699 2700 2701
  {
    /* We trust that index_next_same always gives a row in range */
    DBUG_RETURN(index_next_same(table->record[0],
                                end_range->key,
                                end_range->length));
  }
  result= index_next(table->record[0]);
2702 2703 2704 2705 2706 2707 2708
  if (result)
    DBUG_RETURN(result);
  DBUG_RETURN(compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
}


/*
unknown's avatar
unknown committed
2709
  Compare if found key (in row) is over max-value
2710 2711 2712

  SYNOPSIS
    compare_key
unknown's avatar
unknown committed
2713
    range		range to compare to row. May be 0 for no range
unknown's avatar
foo1  
unknown committed
2714

2715
  NOTES
unknown's avatar
unknown committed
2716
    See key.cc::key_cmp() for details
2717 2718

  RETURN
unknown's avatar
unknown committed
2719 2720
    The return value is SIGN(key_in_row - range_key):

2721 2722 2723 2724 2725 2726 2727
    0			Key is equal to range or 'range' == 0 (no range)
   -1			Key is less than range
    1			Key is larger than range
*/

int handler::compare_key(key_range *range)
{
unknown's avatar
unknown committed
2728
  int cmp;
2729 2730
  if (!range)
    return 0;					// No max range
unknown's avatar
unknown committed
2731 2732 2733 2734
  cmp= key_cmp(range_key_part, range->key, range->length);
  if (!cmp)
    cmp= key_compare_result_on_equal;
  return cmp;
2735
}
unknown's avatar
unknown committed
2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747

int handler::index_read_idx(byte * buf, uint index, const byte * key,
			     uint key_len, enum ha_rkey_function find_flag)
{
  int error= ha_index_init(index);
  if (!error)
    error= index_read(buf, key, key_len, find_flag);
  if (!error)
    error= ha_index_end();
  return error;
}

2748

2749 2750 2751 2752 2753
/*
  Returns a list of all known extensions.

  SYNOPSIS
    ha_known_exts()
unknown's avatar
foo1  
unknown committed
2754

2755 2756
  NOTES
    No mutexes, worst case race is a minor surplus memory allocation
2757 2758
    We have to recreate the extension map if mysqld is restarted (for example
    within libmysqld)
2759 2760 2761 2762

  RETURN VALUE
    pointer		pointer to TYPELIB structure
*/
2763

2764 2765
TYPELIB *ha_known_exts(void)
{
2766
  MEM_ROOT *mem_root= current_thd->mem_root;
2767
  if (!known_extensions.type_names || mysys_usage_id != known_extensions_id)
2768
  {
2769
    handlerton **types;
2770 2771
    List<char> found_exts;
    List_iterator_fast<char> it(found_exts);
2772 2773 2774
    const char **ext, *old_ext;

    known_extensions_id= mysys_usage_id;
2775
    found_exts.push_back((char*) triggers_file_ext);
2776
    found_exts.push_back((char*) trigname_file_ext);
2777
    for (types= sys_table_types; *types; types++)
unknown's avatar
unknown committed
2778
    {
2779
      if ((*types)->state == SHOW_OPTION_YES)
2780
      {
2781 2782
	handler *file= get_new_handler(0, mem_root,
                                       (enum db_type) (*types)->db_type);
2783 2784
	for (ext= file->bas_ext(); *ext; ext++)
	{
2785 2786 2787
	  while ((old_ext= it++))
          {
	    if (!strcmp(old_ext, *ext))
2788
	      break;
2789 2790 2791
          }
	  if (!old_ext)
	    found_exts.push_back((char *) *ext);
2792 2793 2794 2795 2796 2797

	  it.rewind();
	}
	delete file;
      }
    }
2798 2799 2800
    ext= (const char **) my_once_alloc(sizeof(char *)*
                                       (found_exts.elements+1),
                                       MYF(MY_WME | MY_FAE));
unknown's avatar
foo1  
unknown committed
2801

2802
    DBUG_ASSERT(ext != 0);
2803 2804
    known_extensions.count= found_exts.elements;
    known_extensions.type_names= ext;
2805 2806 2807 2808

    while ((old_ext= it++))
      *ext++= old_ext;
    *ext= 0;
2809 2810 2811
  }
  return &known_extensions;
}