handler.cc 76.7 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 518
#endif
#ifdef HAVE_INNOBASE_DB
519
  if (have_innodb == SHOW_OPTION_YES)
520
    error|=innobase_end();
unknown's avatar
unknown committed
521 522 523 524
#endif
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
    error|=ndbcluster_end();
525
#endif
unknown's avatar
unknown committed
526 527 528 529
#ifdef HAVE_FEDERATED_DB
  if (have_federated_db == SHOW_OPTION_YES)
    error|= federated_db_end();
#endif
530
#if defined(HAVE_ARCHIVE_DB)
531 532
  if (have_archive_db == SHOW_OPTION_YES)
    error|= archive_db_end();
unknown's avatar
unknown committed
533 534 535 536
#endif
#ifdef HAVE_CSV_DB
  if (have_csv_db == SHOW_OPTION_YES)
    error|= tina_end();
unknown's avatar
unknown committed
537
#endif
538 539
  if (ha_finish_errors())
    error= 1;
unknown's avatar
unknown committed
540 541 542
  return error;
} /* ha_panic */

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

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

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

unknown's avatar
unknown committed
567 568 569 570 571 572 573 574 575
/*
  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.
576 577 578 579 580

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

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

589 590 591 592 593 594 595 596
  if (all)
  {
    trans= &thd->transaction.all;
    thd->server_status|= SERVER_STATUS_IN_TRANS;
  }
  else
    trans= &thd->transaction.stmt;

597
  for (ht=trans->ht; *ht; ht++)
unknown's avatar
unknown committed
598 599 600
    if (*ht == ht_arg)
      DBUG_VOID_RETURN;  /* already registered, return */

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

/*
  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);
627
      if ((*ht)->prepare)
628
      {
629 630 631 632 633 634 635 636 637 638 639 640
        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);
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659
      }
    }
  }
#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;
660
  my_xid xid= thd->transaction.xid_state.xid.get_my_xid();
661
  DBUG_ENTER("ha_commit_trans");
662

663
  if (thd->in_sub_stmt)
664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682
  {
    /*
      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);
  }
683 684 685
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
686 687 688 689 690
    if (is_real_trans && wait_if_global_read_lock(thd, 0, 0))
    {
      ha_rollback_trans(thd, all);
      DBUG_RETURN(1);
    }
691
    DBUG_EXECUTE_IF("crash_commit_before", abort(););
692 693 694 695 696

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

697 698 699 700 701 702 703 704
    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);
705
          error= 1;
706 707 708
        }
        statistic_increment(thd->status_var.ha_prepare_count,&LOCK_status);
      }
709
      DBUG_EXECUTE_IF("crash_commit_after_prepare", abort(););
unknown's avatar
unknown committed
710
      if (error || (is_real_trans && xid &&
711
                    (error= !(cookie= tc_log->log_xid(thd, xid)))))
712 713
      {
        ha_rollback_trans(thd, all);
714 715
        error= 1;
        goto end;
716
      }
717
      DBUG_EXECUTE_IF("crash_commit_after_log", abort(););
718
    }
719
    error=ha_commit_one_phase(thd, all) ? (cookie ? 2 : 1) : 0;
720
    DBUG_EXECUTE_IF("crash_commit_before_unlog", abort(););
721
    if (cookie)
unknown's avatar
unknown committed
722
      tc_log->unlog(cookie, xid);
723
    DBUG_EXECUTE_IF("crash_commit_after", abort(););
724 725 726
end:
    if (is_real_trans)
      start_waiting_global_read_lock(thd);
727 728 729 730 731
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

732 733 734 735
/*
  NOTE - this function does not care about global read lock.
  A caller should.
*/
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
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)
760
      thd->transaction.xid_state.xid.null();
761 762 763 764 765
    if (all)
    {
#ifdef HAVE_QUERY_CACHE
      if (thd->transaction.changed_tables)
        query_cache.invalidate(thd->transaction.changed_tables);
unknown's avatar
unknown committed
766
#endif
767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
      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");
782
  if (thd->in_sub_stmt)
783 784 785 786 787 788 789 790 791 792 793 794
  {
    /*
      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);
  }
795 796 797
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
798 799 800 801
    /* Close all cursors that can not survive ROLLBACK */
    if (is_real_trans)                          /* not a statement commit */
      thd->stmt_map.close_transient_cursors();

802 803 804 805 806 807 808 809 810 811 812 813 814 815
    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)
816
      thd->transaction.xid_state.xid.null();
817 818 819 820 821 822 823
    if (all)
    {
      thd->variables.tx_isolation=thd->session_tx_isolation;
      thd->transaction.cleanup();
    }
  }
#endif /* USING_TRANSACTIONS */
824 825 826
  if (all)
    thd->transaction_rollback_request= FALSE;

827 828 829 830 831 832 833 834 835
  /*
    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.
  */
836
  if (is_real_trans && thd->no_trans_update.all &&
837 838 839 840 841
      !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);
842 843
}

844
/*
unknown's avatar
unknown committed
845
  This is used to commit or rollback a single statement depending on the value
unknown's avatar
unknown committed
846 847 848 849 850
  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.
851 852
*/

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

unknown's avatar
unknown committed
869
    thd->variables.tx_isolation=thd->session_tx_isolation;
unknown's avatar
unknown committed
870 871 872 873 874
  }
#endif
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
875

unknown's avatar
unknown committed
876
int ha_commit_or_rollback_by_xid(XID *xid, bool commit)
877
{
878
  handlerton **types;
879 880
  int res= 1;

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

unknown's avatar
unknown committed
893

unknown's avatar
unknown committed
894 895 896 897 898 899 900 901 902 903
#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
904 905
    /* is_next_dig is set if next character is a number */
    bool is_next_dig= FALSE;
unknown's avatar
unknown committed
906 907
    if (i < XIDDATASIZE)
    {
unknown's avatar
unknown committed
908 909
      char ch= xid->data[i+1];
      is_next_dig= (ch >= '0' && ch <='9');
unknown's avatar
unknown committed
910
    }
unknown's avatar
unknown committed
911 912 913 914 915 916 917 918 919 920 921 922
    if (i == xid->gtrid_length)
    {
      *s++='\'';
      if (xid->bqual_length)
      {
        *s++='.';
        *s++='\'';
      }
    }
    if (c < 32 || c > 126)
    {
      *s++='\\';
unknown's avatar
unknown committed
923 924 925 926 927
      /*
        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
928 929 930 931 932
      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
933 934 935 936 937 938 939 940 941 942 943 944 945 946
    }
    else
    {
      if (c == '\'' || c == '\\')
        *s++='\\';
      *s++=c;
    }
  }
  *s++='\'';
  *s=0;
  return buf;
}
#endif

947 948
/*
  recover() step of xa
unknown's avatar
unknown committed
949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964

  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
965
*/
966
int ha_recover(HASH *commit_list)
967
{
unknown's avatar
unknown committed
968
  int len, got, found_foreign_xids=0, found_my_xids=0;
969
  handlerton **types;
970
  XID *list=0;
unknown's avatar
unknown committed
971
  bool dry_run=(commit_list==0 && tc_heuristic_recover==0);
972 973
  DBUG_ENTER("ha_recover");

unknown's avatar
unknown committed
974 975 976
  /* 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 */
977
  DBUG_ASSERT(dry_run || total_ha_2pc>(ulong)opt_bin_log);
unknown's avatar
unknown committed
978

979
  if (total_ha_2pc <= (ulong)opt_bin_log)
unknown's avatar
unknown committed
980 981
    DBUG_RETURN(0);

unknown's avatar
unknown committed
982 983 984
  if (commit_list)
    sql_print_information("Starting crash recovery...");

unknown's avatar
unknown committed
985 986 987 988 989
#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
990
  DBUG_ASSERT(total_ha_2pc == (ulong) opt_bin_log+1); // only InnoDB and binlog
unknown's avatar
unknown committed
991 992 993
  tc_heuristic_recover= TC_HEURISTIC_RECOVER_ROLLBACK; // forcing ROLLBACK
  dry_run=FALSE;
#endif
994

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

1005
  for (types= sys_table_types; *types; types++)
1006
  {
1007
    if ((*types)->state != SHOW_OPTION_YES || !(*types)->recover)
1008
      continue;
1009
    while ((got=(*(*types)->recover)(list, len)) > 0 )
1010
    {
unknown's avatar
unknown committed
1011
      sql_print_information("Found %d prepared transaction(s) in %s",
1012
                            got, (*types)->name);
1013 1014 1015 1016
      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
1017
        {
unknown's avatar
unknown committed
1018 1019 1020 1021
#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
1022
          xid_cache_insert(list+i, XA_PREPARED);
unknown's avatar
unknown committed
1023 1024 1025 1026 1027 1028
          found_foreign_xids++;
          continue;
        }
        if (dry_run)
        {
          found_my_xids++;
1029
          continue;
unknown's avatar
unknown committed
1030 1031
        }
        // recovery mode
1032
        if (commit_list ?
unknown's avatar
unknown committed
1033
            hash_search(commit_list, (byte *)&x, sizeof(x)) != 0 :
1034
            tc_heuristic_recover == TC_HEURISTIC_RECOVER_COMMIT)
unknown's avatar
unknown committed
1035 1036 1037 1038 1039
        {
#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
1040
          (*(*types)->commit_by_xid)(list+i);
unknown's avatar
unknown committed
1041
        }
1042
        else
unknown's avatar
unknown committed
1043 1044 1045 1046 1047
        {
#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
1048
          (*(*types)->rollback_by_xid)(list+i);
unknown's avatar
unknown committed
1049
        }
1050 1051 1052
      }
      if (got < len)
        break;
1053 1054
    }
  }
1055
  my_free((gptr)list, MYF(0));
unknown's avatar
unknown committed
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
  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
1069 1070
  if (commit_list)
    sql_print_information("Crash recovery finished.");
1071
  DBUG_RETURN(0);
1072
}
1073

unknown's avatar
unknown committed
1074
/*
1075
  return the list of XID's to a client, the same way SHOW commands do
unknown's avatar
unknown committed
1076

1077 1078 1079 1080
  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
1081
*/
1082
bool mysql_xa_recover(THD *thd)
unknown's avatar
unknown committed
1083
{
1084 1085
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
1086 1087
  int i=0;
  XID_STATE *xs;
1088 1089
  DBUG_ENTER("mysql_xa_recover");

1090 1091 1092
  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));
1093 1094 1095 1096 1097
  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
1098

1099
  pthread_mutex_lock(&LOCK_xid_cache);
unknown's avatar
unknown committed
1100
  while ((xs= (XID_STATE*)hash_element(&xid_cache, i++)))
1101
  {
1102
    if (xs->xa_state==XA_PREPARED)
1103
    {
1104 1105 1106 1107 1108 1109 1110
      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())
1111
      {
1112 1113
        pthread_mutex_unlock(&LOCK_xid_cache);
        DBUG_RETURN(1);
1114 1115
      }
    }
unknown's avatar
unknown committed
1116
  }
1117

1118
  pthread_mutex_unlock(&LOCK_xid_cache);
1119
  send_eof(thd);
1120
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1121
}
1122

1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
/*
  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
1143 1144
  if (opt_innodb)
    innobase_release_temporary_latches(thd);
1145 1146 1147 1148
#endif
  return 0;
}

1149

unknown's avatar
foo1  
unknown committed
1150
/*
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
  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;
}

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

1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
  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;
1182
    DBUG_ASSERT((*ht)->savepoint_set != 0);
1183 1184 1185 1186
    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;
1187
    }
1188 1189
    statistic_increment(thd->status_var.ha_savepoint_rollback_count,&LOCK_status);
    trans->no_2pc|=(*ht)->prepare == 0;
1190
  }
1191 1192 1193 1194 1195
  /*
    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
1196
  {
1197
    int err;
1198
    if ((err= (*(*ht)->rollback)(thd, !thd->in_sub_stmt)))
1199 1200 1201
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
unknown's avatar
unknown committed
1202
    }
1203 1204
    statistic_increment(thd->status_var.ha_rollback_count,&LOCK_status);
    *ht=0; // keep it conveniently zero-filled
1205
  }
unknown's avatar
unknown committed
1206 1207 1208
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
1209
/*
1210 1211 1212
  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
1213 1214
*/

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

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

  end_ht=ht+sv->nht;
  for (; ht < end_ht; ht++)
unknown's avatar
unknown committed
1254
  {
1255 1256 1257 1258 1259 1260 1261
    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
1262
    }
unknown's avatar
unknown committed
1263 1264 1265 1266
  }
  DBUG_RETURN(error);
}

1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278

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:
  */
1279 1280 1281
  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
               "This MySQL server does not support any "
               "consistent-read capable storage engine");
1282 1283 1284 1285
  return 0;
}


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

unknown's avatar
unknown committed
1302 1303 1304 1305
/*
  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
1306

1307 1308
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
1309
{
1310
  handler *file;
unknown's avatar
unknown committed
1311
  char tmp_path[FN_REFLEN];
1312 1313 1314 1315 1316 1317 1318 1319
  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;
1320 1321 1322

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

unknown's avatar
unknown committed
1326 1327 1328 1329
  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);
1330
    my_casedn_str(files_charset_info, tmp_path);
unknown's avatar
unknown committed
1331 1332
    path= tmp_path;
  }
1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350
  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;
1351
    thd->spcont= NULL;
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
    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
1370
  delete file;
1371
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1372
}
unknown's avatar
unknown committed
1373

unknown's avatar
unknown committed
1374 1375 1376
/****************************************************************************
** General handler functions
****************************************************************************/
unknown's avatar
unknown committed
1377 1378 1379 1380 1381 1382 1383 1384 1385
handler *handler::clone(MEM_ROOT *mem_root)
{
  handler *new_handler= get_new_handler(table, mem_root, table->s->db_type);
  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
1386 1387 1388 1389 1390 1391 1392

	/* 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;
1393
  DBUG_ENTER("handler::ha_open");
1394
  DBUG_PRINT("enter",("name: %s  db_type: %d  db_stat: %d  mode: %d  lock_test: %d",
unknown's avatar
unknown committed
1395 1396
                      name, table->s->db_type, table->db_stat, mode,
                      test_if_locked));
unknown's avatar
unknown committed
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413

  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
  {
1414
    if (table->s->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
unknown's avatar
unknown committed
1415
      table->db_stat|=HA_READ_ONLY;
1416 1417
    (void) extra(HA_EXTRA_NO_READCHECK);	// Not needed in SQL

1418 1419 1420
    DBUG_ASSERT(alloc_root_inited(&table->mem_root));

    if (!(ref= (byte*) alloc_root(&table->mem_root, ALIGN_SIZE(ref_length)*2)))
unknown's avatar
unknown committed
1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
    {
      close();
      error=HA_ERR_OUT_OF_MEM;
    }
    else
      dupp_ref=ref+ALIGN_SIZE(ref_length);
  }
  DBUG_RETURN(error);
}

1431 1432 1433 1434 1435
/*
  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
1436

1437
int handler::read_first_row(byte * buf, uint primary_key)
unknown's avatar
unknown committed
1438 1439
{
  register int error;
1440
  DBUG_ENTER("handler::read_first_row");
unknown's avatar
unknown committed
1441

1442
  statistic_increment(current_thd->status_var.ha_read_first_count,&LOCK_status);
1443 1444 1445 1446

  /*
    If there is very few deleted rows in the table, find the first row by
    scanning the table.
1447
    TODO remove the test for HA_READ_ORDER
1448
  */
1449 1450
  if (deleted < 10 || primary_key >= MAX_KEY ||
      !(index_flags(primary_key, 0, 0) & HA_READ_ORDER))
1451
  {
unknown's avatar
unknown committed
1452
    (void) ha_rnd_init(1);
1453
    while ((error= rnd_next(buf)) == HA_ERR_RECORD_DELETED) ;
unknown's avatar
unknown committed
1454
    (void) ha_rnd_end();
1455 1456 1457 1458
  }
  else
  {
    /* Find the first row through the primary key */
unknown's avatar
unknown committed
1459
    (void) ha_index_init(primary_key);
1460
    error=index_first(buf);
unknown's avatar
unknown committed
1461
    (void) ha_index_end();
1462
  }
unknown's avatar
unknown committed
1463 1464 1465
  DBUG_RETURN(error);
}

1466
/*
1467
  Generate the next auto-increment number based on increment and offset
unknown's avatar
unknown committed
1468

1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
  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);
}


1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505
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));
  }
}


1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
/*
  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
1534
                       (ulong) nr, variables->auto_increment_offset));
1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
    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);
}


1546
/*
1547 1548 1549 1550 1551 1552 1553
  Update the auto_increment field if necessary

  SYNOPSIS
     update_auto_increment()

  RETURN
    0	ok
unknown's avatar
unknown committed
1554 1555 1556 1557
    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
1558

1559 1560 1561 1562

  IMPLEMENTATION

    Updates columns with type NEXT_NUMBER if:
1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598

  - 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.
1599
*/
unknown's avatar
unknown committed
1600

unknown's avatar
unknown committed
1601
int handler::update_auto_increment()
unknown's avatar
unknown committed
1602
{
1603 1604 1605
  ulonglong nr;
  THD *thd= table->in_use;
  struct system_variables *variables= &thd->variables;
1606 1607
  bool external_auto_increment= 
       table->file->table_flags() & HA_EXTERNAL_AUTO_INCREMENT;
1608
  DBUG_ENTER("handler::update_auto_increment");
1609 1610 1611 1612 1613 1614 1615 1616

  /*
    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 ||
1617
      table->auto_increment_field_not_null &&
1618
      thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO)
1619
  {
1620
    /* Mark that we didn't generate a new value **/
1621
    auto_increment_column_changed=0;
1622
    adjust_next_insert_id_after_explicit_value(nr);
1623
    DBUG_RETURN(0);
1624
  }
1625
  if (external_auto_increment || !(nr= thd->next_insert_id))
1626
  {
1627
    if ((nr= get_auto_increment()) == ~(ulonglong) 0)
unknown's avatar
unknown committed
1628
      DBUG_RETURN(HA_ERR_AUTOINC_READ_FAILED);  // Mark failure
1629

1630
    if (!external_auto_increment && variables->auto_increment_increment != 1)
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
      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;

1645
  if (likely(!table->next_number_field->store((longlong) nr, TRUE)))
1646
    thd->insert_id((ulonglong) nr);
1647
  else
unknown's avatar
unknown committed
1648
  if (thd->killed != THD::KILL_BAD_DATA) /* did we fail strict mode? */
1649 1650 1651 1652 1653 1654 1655 1656 1657 1658
  {
    /*
      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
1659 1660
  else
    DBUG_RETURN(HA_ERR_AUTOINC_ERANGE);
1661 1662 1663 1664 1665 1666

  /*
    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
  */
1667
  if (!table->s->next_number_key_offset)
1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
  {
    /*
      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 */
1680
  auto_increment_column_changed=1;
unknown's avatar
unknown committed
1681
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1682 1683
}

1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694
/*
  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
1695
  {
1696
    thd->next_insert_id= thd->prev_insert_id;
unknown's avatar
unknown committed
1697 1698 1699 1700 1701 1702
    if (thd->next_insert_id == 0)
    {
      /* we didn't generate a value, engine will be called again */
      thd->clear_next_insert_id= 0;
    }
  }
1703 1704
}

unknown's avatar
unknown committed
1705

1706
ulonglong handler::get_auto_increment()
unknown's avatar
unknown committed
1707
{
1708
  ulonglong nr;
unknown's avatar
unknown committed
1709
  int error;
unknown's avatar
unknown committed
1710

unknown's avatar
unknown committed
1711
  (void) extra(HA_EXTRA_KEYREAD);
1712 1713
  index_init(table->s->next_number_index);
  if (!table->s->next_number_key_offset)
unknown's avatar
unknown committed
1714 1715 1716 1717 1718 1719
  {						// Autoincrement at key-start
    error=index_last(table->record[1]);
  }
  else
  {
    byte key[MAX_KEY_LENGTH];
1720
    key_copy(key, table->record[0],
1721 1722 1723 1724
             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
1725 1726
  }

unknown's avatar
unknown committed
1727 1728 1729
  if (error)
    nr=1;
  else
1730 1731
    nr= ((ulonglong) table->next_number_field->
         val_int_offset(table->s->rec_buff_length)+1);
unknown's avatar
unknown committed
1732
  index_end();
unknown's avatar
unknown committed
1733
  (void) extra(HA_EXTRA_NO_KEYREAD);
unknown's avatar
unknown committed
1734 1735 1736
  return nr;
}

1737 1738 1739 1740

/*
  Print error that we got from handler function

unknown's avatar
unknown committed
1741
  NOTE
1742 1743 1744 1745 1746
   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
1747 1748 1749

void handler::print_error(int error, myf errflag)
{
1750
  DBUG_ENTER("handler::print_error");
unknown's avatar
unknown committed
1751 1752 1753 1754
  DBUG_PRINT("enter",("error: %d",error));

  int textno=ER_GET_ERRNO;
  switch (error) {
1755 1756 1757
  case EACCES:
    textno=ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768
  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
1769
  case HA_ERR_WRONG_MRG_TABLE_DEF:
unknown's avatar
unknown committed
1770 1771 1772 1773 1774 1775 1776 1777 1778
    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];
1779
      String str(key,sizeof(key),system_charset_info);
1780 1781 1782 1783

      if (key_nr == MAX_KEY)
      {
	/* Key is unknown */
1784
	str.copy("", 0, system_charset_info);
1785
	key_nr= (uint) -1;
1786 1787
      }
      else
unknown's avatar
unknown committed
1788
      {
1789 1790 1791
	key_unpack(&str,table,(uint) key_nr);
	uint max_length=MYSQL_ERRMSG_SIZE-(uint) strlen(ER(ER_DUP_ENTRY));
	if (str.length() >= max_length)
1792
	{
1793
	    str.length(max_length-4);
1794
	    str.append(STRING_WITH_LEN("..."));
1795
	}
unknown's avatar
unknown committed
1796
      }
1797
      my_error(ER_DUP_ENTRY, MYF(0), str.c_ptr(), key_nr+1);
unknown's avatar
unknown committed
1798 1799 1800 1801 1802
      DBUG_VOID_RETURN;
    }
    textno=ER_DUP_KEY;
    break;
  }
1803
  case HA_ERR_NULL_IN_SPATIAL:
1804 1805
    my_error(ER_CANT_CREATE_GEOMETRY_OBJECT, MYF(0));
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1806 1807 1808 1809 1810 1811 1812 1813 1814
  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;
1815 1816 1817
  case HA_ERR_WRONG_IN_RECORD:
    textno= ER_CRASHED_ON_USAGE;
    break;
1818 1819 1820
  case HA_ERR_CRASHED_ON_USAGE:
    textno=ER_CRASHED_ON_USAGE;
    break;
1821 1822 1823
  case HA_ERR_NOT_A_TABLE:
    textno= error;
    break;
1824 1825 1826
  case HA_ERR_CRASHED_ON_REPAIR:
    textno=ER_CRASHED_ON_REPAIR;
    break;
unknown's avatar
unknown committed
1827
  case HA_ERR_OUT_OF_MEM:
1828 1829
    textno=ER_OUT_OF_RESOURCES;
    break;
unknown's avatar
unknown committed
1830 1831 1832 1833 1834 1835 1836 1837 1838 1839
  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:
1840
  case HA_ERR_INDEX_FILE_FULL:
1841
    textno=ER_RECORD_FILE_FULL;
1842
    break;
1843 1844 1845 1846 1847 1848
  case HA_ERR_LOCK_WAIT_TIMEOUT:
    textno=ER_LOCK_WAIT_TIMEOUT;
    break;
  case HA_ERR_LOCK_TABLE_FULL:
    textno=ER_LOCK_TABLE_FULL;
    break;
1849 1850 1851
  case HA_ERR_LOCK_DEADLOCK:
    textno=ER_LOCK_DEADLOCK;
    break;
1852 1853 1854
  case HA_ERR_READ_ONLY_TRANSACTION:
    textno=ER_READ_ONLY_TRANSACTION;
    break;
unknown's avatar
Merge  
unknown committed
1855 1856 1857 1858
  case HA_ERR_CANNOT_ADD_FOREIGN:
    textno=ER_CANNOT_ADD_FOREIGN;
    break;
  case HA_ERR_ROW_IS_REFERENCED:
1859 1860 1861 1862 1863 1864
  {
    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
1865
  case HA_ERR_NO_REFERENCED_ROW:
1866 1867 1868 1869 1870 1871
  {
    String str;
    get_error_message(error, &str);
    my_error(ER_NO_REFERENCED_ROW_2, MYF(0), str.c_ptr_safe());
    DBUG_VOID_RETURN;
  }
1872 1873 1874
  case HA_ERR_TABLE_DEF_CHANGED:
    textno=ER_TABLE_DEF_CHANGED;
    break;
1875 1876
  case HA_ERR_NO_SUCH_TABLE:
  {
unknown's avatar
unknown committed
1877 1878 1879 1880 1881
    /*
      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
    */
1882 1883
    char *db;
    char buff[FN_REFLEN];
1884
    uint length= dirname_part(buff,table->s->path);
1885 1886
    buff[length-1]=0;
    db=buff+dirname_length(buff);
1887
    my_error(ER_NO_SUCH_TABLE, MYF(0), db, table->alias);
1888 1889
    break;
  }
unknown's avatar
unknown committed
1890 1891 1892
  case HA_ERR_TABLE_NEEDS_UPGRADE:
    textno=ER_TABLE_NEEDS_UPGRADE;
    break;
1893 1894 1895
  case HA_ERR_TABLE_READONLY:
    textno= ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
1896 1897 1898 1899 1900 1901
  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
1902 1903
  default:
    {
1904 1905 1906
      /* The error was "unknown" to this function.
	 Ask handler if it has got a message for this error */
      bool temporary= FALSE;
1907 1908 1909
      String str;
      temporary= get_error_message(error, &str);
      if (!str.is_empty())
1910
      {
1911
	const char* engine= table_type();
1912
	if (temporary)
1913
	  my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(), engine);
1914
	else
1915
	  my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine);
1916
      }
1917
      else
1918
	my_error(ER_GET_ERRNO,errflag,error);
unknown's avatar
unknown committed
1919 1920 1921
      DBUG_VOID_RETURN;
    }
  }
1922
  my_error(textno, errflag, table->alias, error);
unknown's avatar
unknown committed
1923 1924 1925
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
1926

1927
/*
1928
   Return an error message specific to this handler
1929

1930
   SYNOPSIS
1931 1932
   error        error code previously returned by handler
   buf          Pointer to String where to add error message
unknown's avatar
unknown committed
1933

1934
   Returns true if this is a temporary error
1935 1936
 */

1937
bool handler::get_error_message(int error, String* buf)
1938
{
unknown's avatar
unknown committed
1939
  return FALSE;
1940 1941 1942
}


unknown's avatar
unknown committed
1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 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 1983 1984 1985 1986 1987
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;
        }
      }
    }
  }
  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;
      }
1988 1989 1990 1991
      if ((*field)->type() == MYSQL_TYPE_VAR_STRING)
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
unknown's avatar
unknown committed
1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
    }
  }
  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");

2005 2006 2007 2008 2009 2010 2011
  /*
    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
2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
    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
2050
/* Return key if error because of duplicated keys */
unknown's avatar
unknown committed
2051 2052 2053

uint handler::get_dup_key(int error)
{
2054
  DBUG_ENTER("handler::get_dup_key");
unknown's avatar
unknown committed
2055
  table->file->errkey  = (uint) -1;
2056 2057
  if (error == HA_ERR_FOUND_DUPP_KEY || error == HA_ERR_FOUND_DUPP_UNIQUE ||
      error == HA_ERR_NULL_IN_SPATIAL)
unknown's avatar
unknown committed
2058 2059 2060 2061
    info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
  DBUG_RETURN(table->file->errkey);
}

unknown's avatar
unknown committed
2062

2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075
/*
  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
2076
	didn't get any other errors than ENOENT
2077
    #   Error
2078 2079
*/

unknown's avatar
unknown committed
2080 2081
int handler::delete_table(const char *name)
{
2082 2083
  int error= 0;
  int enoent_or_zero= ENOENT;                   // Error if no file was deleted
2084
  char buff[FN_REFLEN];
2085

unknown's avatar
unknown committed
2086 2087
  for (const char **ext=bas_ext(); *ext ; ext++)
  {
2088 2089
    fn_format(buff, name, "", *ext, 2 | 4);
    if (my_delete_with_symlink(buff, MYF(0)))
unknown's avatar
unknown committed
2090
    {
2091
      if ((error= my_errno) != ENOENT)
unknown's avatar
unknown committed
2092 2093
	break;
    }
2094
    else
2095
      enoent_or_zero= 0;                        // No error for ENOENT
2096
    error= enoent_or_zero;
unknown's avatar
unknown committed
2097
  }
unknown's avatar
unknown committed
2098
  return error;
unknown's avatar
unknown committed
2099 2100 2101 2102 2103
}


int handler::rename_table(const char * from, const char * to)
{
unknown's avatar
unknown committed
2104 2105
  int error= 0;
  for (const char **ext= bas_ext(); *ext ; ext++)
unknown's avatar
unknown committed
2106
  {
unknown's avatar
unknown committed
2107 2108 2109 2110 2111 2112
    if (rename_file_ext(from, to, *ext))
    {
      if ((error=my_errno) != ENOENT)
	break;
      error= 0;
    }
unknown's avatar
unknown committed
2113
  }
unknown's avatar
unknown committed
2114
  return error;
unknown's avatar
unknown committed
2115 2116
}

unknown's avatar
unknown committed
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 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

/*
   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
2168
/*
2169 2170 2171 2172 2173 2174
  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.
2175
*/
unknown's avatar
unknown committed
2176

2177
int ha_enable_transaction(THD *thd, bool on)
2178 2179 2180
{
  int error=0;

2181 2182
  DBUG_ENTER("ha_enable_transaction");
  thd->transaction.on= on;
unknown's avatar
unknown committed
2183
  if (on)
2184 2185 2186 2187 2188 2189 2190
  {
    /*
      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.
    */
2191 2192
    if (!(error= ha_commit_stmt(thd)))
      error= end_trans(thd, COMMIT);
2193
  }
2194 2195 2196
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
2197 2198 2199 2200 2201
int handler::index_next_same(byte *buf, const byte *key, uint keylen)
{
  int error;
  if (!(error=index_next(buf)))
  {
unknown's avatar
unknown committed
2202
    if (key_cmp_if_same(table, key, active_index, keylen))
unknown's avatar
unknown committed
2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215
    {
      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
2216 2217 2218 2219
/*
  Initiates table-file and calls apropriate database-creator
  Returns 1 if something got wrong
*/
unknown's avatar
unknown committed
2220 2221 2222 2223 2224 2225

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
2226
  char name_buff[FN_REFLEN];
unknown's avatar
unknown committed
2227 2228
  DBUG_ENTER("ha_create_table");

2229
  if (openfrm(current_thd, name,"",0,(uint) READ_ALL, 0, &table))
unknown's avatar
unknown committed
2230 2231 2232 2233 2234
    DBUG_RETURN(1);
  if (update_create_info)
  {
    update_create_info_from_table(create_info, &table);
  }
unknown's avatar
unknown committed
2235 2236 2237 2238 2239
  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);
2240
    my_casedn_str(files_charset_info, name_buff);
unknown's avatar
unknown committed
2241 2242 2243
    name= name_buff;
  }

unknown's avatar
unknown committed
2244 2245
  error=table.file->create(name,&table,create_info);
  VOID(closefrm(&table));
unknown's avatar
unknown committed
2246
  if (error)
2247
    my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), name,error);
unknown's avatar
unknown committed
2248 2249 2250
  DBUG_RETURN(error != 0);
}

2251
/*
2252
  Try to discover table from engine and
2253
  if found, write the frm file to disk.
2254

2255
  RETURN VALUES:
2256
  -1 : Table did not exists
2257
   0 : Table created ok
2258
   > 0 : Error, table existed but could not be created
2259 2260 2261

*/

2262 2263 2264
int ha_create_table_from_engine(THD* thd,
				const char *db,
				const char *name)
2265
{
unknown's avatar
unknown committed
2266 2267 2268
  int error;
  const void *frmblob;
  uint frmlen;
2269 2270 2271 2272
  char path[FN_REFLEN];
  HA_CREATE_INFO create_info;
  TABLE table;
  DBUG_ENTER("ha_create_table_from_engine");
unknown's avatar
unknown committed
2273
  DBUG_PRINT("enter", ("name '%s'.'%s'", db, name));
2274 2275

  bzero((char*) &create_info,sizeof(create_info));
unknown's avatar
unknown committed
2276
  if ((error= ha_discover(thd, db, name, &frmblob, &frmlen)))
2277
  {
unknown's avatar
unknown committed
2278
    /* Table could not be discovered and thus not created */
2279
    DBUG_RETURN(error);
2280 2281
  }

unknown's avatar
unknown committed
2282
  /*
2283 2284
    Table exists in handler and could be discovered
    frmblob and frmlen are set, write the frm to disk
unknown's avatar
unknown committed
2285
  */
2286

2287 2288
  (void)strxnmov(path,FN_REFLEN,mysql_data_home,"/",db,"/",name,NullS);
  // Save the frm file
unknown's avatar
unknown committed
2289 2290 2291
  error= writefrm(path, frmblob, frmlen);
  my_free((char*) frmblob, MYF(0));
  if (error)
2292
    DBUG_RETURN(2);
2293

unknown's avatar
unknown committed
2294
  if (openfrm(thd, path,"",0,(uint) READ_ALL, 0, &table))
2295
    DBUG_RETURN(3);
2296

2297
  update_create_info_from_table(&create_info, &table);
2298
  create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE;
2299

2300 2301 2302 2303 2304
  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);
2305
  }
2306 2307 2308 2309
  error=table.file->create(path,&table,&create_info);
  VOID(closefrm(&table));

  DBUG_RETURN(error != 0);
2310 2311
}

2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329
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
2330

2331

unknown's avatar
unknown committed
2332
int ha_init_key_cache(const char *name, KEY_CACHE *key_cache)
unknown's avatar
unknown committed
2333
{
2334 2335
  DBUG_ENTER("ha_init_key_cache");

unknown's avatar
unknown committed
2336
  if (!key_cache->key_cache_inited)
2337 2338
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2339 2340 2341 2342
    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;
2343
    pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2344
    DBUG_RETURN(!init_key_cache(key_cache,
2345 2346
				tmp_block_size,
				tmp_buff_size,
unknown's avatar
unknown committed
2347
				division_limit, age_threshold));
2348
  }
2349
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2350 2351
}

2352 2353 2354

/* Resize key cache */

unknown's avatar
unknown committed
2355
int ha_resize_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
2356
{
2357 2358
  DBUG_ENTER("ha_resize_key_cache");

unknown's avatar
unknown committed
2359
  if (key_cache->key_cache_inited)
2360 2361
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2362 2363 2364 2365
    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;
2366
    pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2367 2368 2369
    DBUG_RETURN(!resize_key_cache(key_cache, tmp_block_size,
				  tmp_buff_size,
				  division_limit, age_threshold));
2370
  }
2371
  DBUG_RETURN(0);
2372 2373
}

2374 2375 2376

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

unknown's avatar
unknown committed
2377
int ha_change_key_cache_param(KEY_CACHE *key_cache)
2378
{
unknown's avatar
unknown committed
2379 2380 2381 2382 2383 2384 2385 2386
  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);
  }
2387 2388
  return 0;
}
unknown's avatar
unknown committed
2389

2390 2391
/* Free memory allocated by a key cache */

unknown's avatar
unknown committed
2392
int ha_end_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
2393
{
unknown's avatar
unknown committed
2394
  end_key_cache(key_cache, 1);		// Can never fail
2395
  return 0;
unknown's avatar
unknown committed
2396
}
unknown's avatar
unknown committed
2397

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

unknown's avatar
unknown committed
2400 2401
int ha_change_key_cache(KEY_CACHE *old_key_cache,
			KEY_CACHE *new_key_cache)
unknown's avatar
unknown committed
2402
{
2403 2404
  mi_change_key_cache(old_key_cache, new_key_cache);
  return 0;
unknown's avatar
unknown committed
2405
}
2406 2407


unknown's avatar
unknown committed
2408 2409
/*
  Try to discover one table from handler(s)
unknown's avatar
unknown committed
2410 2411

  RETURN
2412 2413 2414
   -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
2415 2416
*/

unknown's avatar
unknown committed
2417 2418
int ha_discover(THD *thd, const char *db, const char *name,
		const void **frmblob, uint *frmlen)
unknown's avatar
unknown committed
2419
{
2420
  int error= -1; // Table does not exist in any handler
unknown's avatar
unknown committed
2421
  DBUG_ENTER("ha_discover");
2422
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
2423 2424
  if (is_prefix(name,tmp_file_prefix)) /* skip temporary tables */
    DBUG_RETURN(error);
unknown's avatar
unknown committed
2425 2426
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
2427
    error= ndbcluster_discover(thd, db, name, frmblob, frmlen);
unknown's avatar
unknown committed
2428 2429
#endif
  if (!error)
2430
    statistic_increment(thd->status_var.ha_discover_count,&LOCK_status);
unknown's avatar
unknown committed
2431 2432 2433 2434
  DBUG_RETURN(error);
}


2435
/*
unknown's avatar
foo1  
unknown committed
2436 2437
  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
2438
  or any dropped tables that need to be removed from disk
2439 2440
*/

2441 2442
int
ha_find_files(THD *thd,const char *db,const char *path,
unknown's avatar
unknown committed
2443
	      const char *wild, bool dir, List<char> *files)
2444 2445
{
  int error= 0;
2446
  DBUG_ENTER("ha_find_files");
unknown's avatar
foo1  
unknown committed
2447
  DBUG_PRINT("enter", ("db: %s, path: %s, wild: %s, dir: %d",
2448
		       db, path, wild, dir));
2449 2450
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
unknown's avatar
unknown committed
2451
    error= ndbcluster_find_files(thd, db, path, wild, dir, files);
2452 2453 2454 2455
#endif
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
2456

2457 2458 2459 2460
/*
  Ask handler if the table exists in engine

  RETURN
2461 2462 2463
    HA_ERR_NO_SUCH_TABLE     Table does not exist
    HA_ERR_TABLE_EXIST       Table exists
    #                        Error code
2464 2465

 */
2466
int ha_table_exists_in_engine(THD* thd, const char* db, const char* name)
2467
{
2468
  int error= HA_ERR_NO_SUCH_TABLE;
2469
  DBUG_ENTER("ha_table_exists_in_engine");
2470 2471 2472
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
2473
    error= ndbcluster_table_exists_in_engine(thd, db, name);
2474
#endif
2475
  DBUG_PRINT("exit", ("error: %d", error));
2476 2477 2478 2479
  DBUG_RETURN(error);
}


unknown's avatar
unknown committed
2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 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
/*
  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);
}


2605 2606 2607 2608 2609 2610 2611 2612
/*
  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
unknown's avatar
foo1  
unknown committed
2613
    eq_range_arg	Set to 1 if start_key == end_key
2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626
    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
2627
			      bool eq_range_arg, bool sorted)
2628 2629 2630 2631
{
  int result;
  DBUG_ENTER("handler::read_range_first");

unknown's avatar
unknown committed
2632
  eq_range= eq_range_arg;
2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650
  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
2651
    DBUG_RETURN((result == HA_ERR_KEY_NOT_FOUND)
unknown's avatar
unknown committed
2652 2653
		? HA_ERR_END_OF_FILE
		: result);
2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673

  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
2674
int handler::read_range_next()
2675 2676 2677 2678 2679
{
  int result;
  DBUG_ENTER("handler::read_range_next");

  if (eq_range)
unknown's avatar
unknown committed
2680 2681 2682 2683 2684 2685 2686
  {
    /* 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]);
2687 2688 2689 2690 2691 2692 2693
  if (result)
    DBUG_RETURN(result);
  DBUG_RETURN(compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
}


/*
unknown's avatar
unknown committed
2694
  Compare if found key (in row) is over max-value
2695 2696 2697

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

2700
  NOTES
unknown's avatar
unknown committed
2701
    See key.cc::key_cmp() for details
2702 2703

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

2706 2707 2708 2709 2710 2711 2712
    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
2713
  int cmp;
2714 2715
  if (!range)
    return 0;					// No max range
unknown's avatar
unknown committed
2716 2717 2718 2719
  cmp= key_cmp(range_key_part, range->key, range->length);
  if (!cmp)
    cmp= key_compare_result_on_equal;
  return cmp;
2720
}
unknown's avatar
unknown committed
2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732

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;
}

2733

2734 2735 2736 2737 2738
/*
  Returns a list of all known extensions.

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

2740 2741
  NOTES
    No mutexes, worst case race is a minor surplus memory allocation
2742 2743
    We have to recreate the extension map if mysqld is restarted (for example
    within libmysqld)
2744 2745 2746 2747

  RETURN VALUE
    pointer		pointer to TYPELIB structure
*/
2748

2749 2750
TYPELIB *ha_known_exts(void)
{
2751
  MEM_ROOT *mem_root= current_thd->mem_root;
2752
  if (!known_extensions.type_names || mysys_usage_id != known_extensions_id)
2753
  {
2754
    handlerton **types;
2755 2756
    List<char> found_exts;
    List_iterator_fast<char> it(found_exts);
2757 2758 2759
    const char **ext, *old_ext;

    known_extensions_id= mysys_usage_id;
2760
    found_exts.push_back((char*) triggers_file_ext);
2761
    found_exts.push_back((char*) trigname_file_ext);
2762
    for (types= sys_table_types; *types; types++)
unknown's avatar
unknown committed
2763
    {
2764
      if ((*types)->state == SHOW_OPTION_YES)
2765
      {
2766 2767
	handler *file= get_new_handler(0, mem_root,
                                       (enum db_type) (*types)->db_type);
2768 2769
	for (ext= file->bas_ext(); *ext; ext++)
	{
2770 2771 2772
	  while ((old_ext= it++))
          {
	    if (!strcmp(old_ext, *ext))
2773
	      break;
2774 2775 2776
          }
	  if (!old_ext)
	    found_exts.push_back((char *) *ext);
2777 2778 2779 2780 2781 2782

	  it.rewind();
	}
	delete file;
      }
    }
2783 2784 2785
    ext= (const char **) my_once_alloc(sizeof(char *)*
                                       (found_exts.elements+1),
                                       MYF(MY_WME | MY_FAE));
unknown's avatar
foo1  
unknown committed
2786

2787
    DBUG_ASSERT(ext != 0);
2788 2789
    known_extensions.count= found_exts.elements;
    known_extensions.type_names= ext;
2790 2791 2792 2793

    while ((old_ext= it++))
      *ext++= old_ext;
    *ext= 0;
2794 2795 2796
  }
  return &known_extensions;
}