handler.cc 111 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
   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 */

16
/** @file handler.cc
unknown's avatar
unknown committed
17

18 19 20
    @brief
  Handler-calling-functions
*/
unknown's avatar
unknown committed
21

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

#include "mysql_priv.h"
27
#include "rpl_filter.h"
28 29


30 31
#include <myisampack.h>
#include <errno.h>
32

33 34
#ifdef WITH_PARTITION_STORAGE_ENGINE
#include "ha_partition.h"
35
#endif
36

37 38 39 40 41
/*
  While we have legacy_db_type, we have this array to
  check for dups and to find handlerton from legacy_db_type.
  Remove when legacy_db_type is finally gone
*/
unknown's avatar
unknown committed
42
st_plugin_int *hton2plugin[MAX_HA];
unknown's avatar
unknown committed
43

44
static handlerton *installed_htons[128];
45

unknown's avatar
unknown committed
46 47
#define BITMAP_STACKBUF_SIZE (128/8)

unknown's avatar
unknown committed
48
KEY_CREATE_INFO default_key_create_info= { HA_KEY_ALG_UNDEF, 0, {NullS,0} };
49

unknown's avatar
unknown committed
50
/* number of entries in handlertons[] */
unknown's avatar
unknown committed
51
ulong total_ha= 0;
unknown's avatar
unknown committed
52
/* number of storage engines (from handlertons[]) that support 2pc */
unknown's avatar
unknown committed
53
ulong total_ha_2pc= 0;
unknown's avatar
unknown committed
54
/* size of savepoint storage area (see ha_init) */
unknown's avatar
unknown committed
55
ulong savepoint_alloc_size= 0;
56

unknown's avatar
unknown committed
57
static const LEX_STRING sys_table_aliases[]=
58
{
unknown's avatar
unknown committed
59 60 61
  { C_STRING_WITH_LEN("INNOBASE") },  { C_STRING_WITH_LEN("INNODB") },
  { C_STRING_WITH_LEN("NDB") },       { C_STRING_WITH_LEN("NDBCLUSTER") },
  { C_STRING_WITH_LEN("HEAP") },      { C_STRING_WITH_LEN("MEMORY") },
62
  { C_STRING_WITH_LEN("MERGE") },     { C_STRING_WITH_LEN("MRG_MYISAM") },
unknown's avatar
unknown committed
63
  {NullS, 0}
unknown's avatar
unknown committed
64
};
65

unknown's avatar
unknown committed
66
const char *ha_row_type[] = {
67
  "", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT", "?","?","?"
unknown's avatar
unknown committed
68 69
};

unknown's avatar
unknown committed
70
const char *tx_isolation_names[] =
71 72 73
{ "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",
  NullS};
TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
74
			       tx_isolation_names, NULL};
unknown's avatar
unknown committed
75

76
static TYPELIB known_extensions= {0,"known_exts", NULL, NULL};
77
uint known_extensions_id= 0;
78

unknown's avatar
unknown committed
79

unknown's avatar
unknown committed
80 81 82 83 84 85 86 87 88

static plugin_ref ha_default_plugin(THD *thd)
{
  if (thd->variables.table_plugin)
    return thd->variables.table_plugin;
  return my_plugin_lock(thd, &global_system_variables.table_plugin);
}


89
/** @brief
unknown's avatar
unknown committed
90
  Return the default storage engine handlerton for thread
91

unknown's avatar
unknown committed
92 93 94
  SYNOPSIS
    ha_default_handlerton(thd)
    thd         current thread
95

unknown's avatar
unknown committed
96 97 98 99
  RETURN
    pointer to handlerton
*/
handlerton *ha_default_handlerton(THD *thd)
100
{
unknown's avatar
unknown committed
101 102 103 104 105
  plugin_ref plugin= ha_default_plugin(thd);
  DBUG_ASSERT(plugin);
  handlerton *hton= plugin_data(plugin, handlerton*);
  DBUG_ASSERT(hton);
  return hton;
unknown's avatar
unknown committed
106 107 108
}


109
/** @brief
unknown's avatar
unknown committed
110 111 112 113 114 115 116 117
  Return the storage engine handlerton for the supplied name
  
  SYNOPSIS
    ha_resolve_by_name(thd, name)
    thd         current thread
    name        name of storage engine
  
  RETURN
unknown's avatar
unknown committed
118
    pointer to storage engine plugin handle
unknown's avatar
unknown committed
119
*/
unknown's avatar
unknown committed
120
plugin_ref ha_resolve_by_name(THD *thd, const LEX_STRING *name)
unknown's avatar
unknown committed
121 122
{
  const LEX_STRING *table_alias;
unknown's avatar
unknown committed
123
  plugin_ref plugin;
124

unknown's avatar
unknown committed
125 126 127
redo:
  /* my_strnncoll is a macro and gcc doesn't do early expansion of macro */
  if (thd && !my_charset_latin1.coll->strnncoll(&my_charset_latin1,
unknown's avatar
unknown committed
128
                           (const uchar *)name->str, name->length,
unknown's avatar
unknown committed
129
                           (const uchar *)STRING_WITH_LEN("DEFAULT"), 0))
unknown's avatar
unknown committed
130
    return ha_default_plugin(thd);
unknown's avatar
unknown committed
131

unknown's avatar
unknown committed
132
  if ((plugin= my_plugin_lock_by_name(thd, name, MYSQL_STORAGE_ENGINE_PLUGIN)))
133
  {
unknown's avatar
unknown committed
134
    handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
135
    if (!(hton->flags & HTON_NOT_USER_SELECTABLE))
unknown's avatar
unknown committed
136 137 138 139 140 141
      return plugin;
      
    /*
      unlocking plugin immediately after locking is relatively low cost.
    */
    plugin_unlock(thd, plugin);
142
  }
unknown's avatar
unknown committed
143

144
  /*
145
    We check for the historical aliases.
146
  */
unknown's avatar
unknown committed
147
  for (table_alias= sys_table_aliases; table_alias->str; table_alias+= 2)
148
  {
149
    if (!my_strnncoll(&my_charset_latin1,
unknown's avatar
unknown committed
150
                      (const uchar *)name->str, name->length,
unknown's avatar
unknown committed
151 152 153 154 155
                      (const uchar *)table_alias->str, table_alias->length))
    {
      name= table_alias + 1;
      goto redo;
    }
156
  }
157

unknown's avatar
unknown committed
158
  return NULL;
159
}
unknown's avatar
unknown committed
160 161


unknown's avatar
unknown committed
162
plugin_ref ha_lock_engine(THD *thd, handlerton *hton)
163
{
unknown's avatar
unknown committed
164 165 166 167
  if (hton)
  {
    st_plugin_int **plugin= hton2plugin + hton->slot;
    
unknown's avatar
unknown committed
168
#ifdef DBUG_OFF
unknown's avatar
unknown committed
169 170 171 172
    return my_plugin_lock(thd, plugin);
#else
    return my_plugin_lock(thd, &plugin);
#endif
173
  }
unknown's avatar
unknown committed
174
  return NULL;
175 176
}

unknown's avatar
unknown committed
177

unknown's avatar
unknown committed
178
#ifdef NOT_USED
179
static handler *create_default(TABLE_SHARE *table, MEM_ROOT *mem_root)
unknown's avatar
unknown committed
180
{
unknown's avatar
unknown committed
181
  handlerton *hton= ha_default_handlerton(current_thd);
182
  return (hton && hton->create) ? hton->create(hton, table, mem_root) : NULL;
unknown's avatar
unknown committed
183
}
unknown's avatar
unknown committed
184
#endif
unknown's avatar
unknown committed
185 186 187 188


handlerton *ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type)
{
unknown's avatar
unknown committed
189
  plugin_ref plugin;
190
  switch (db_type) {
unknown's avatar
unknown committed
191
  case DB_TYPE_DEFAULT:
unknown's avatar
unknown committed
192
    return ha_default_handlerton(thd);
unknown's avatar
unknown committed
193
  default:
unknown's avatar
unknown committed
194 195 196 197 198
    if (db_type > DB_TYPE_UNKNOWN && db_type < DB_TYPE_DEFAULT &&
        (plugin= ha_lock_engine(thd, installed_htons[db_type])))
      return plugin_data(plugin, handlerton*);
    /* fall through */
  case DB_TYPE_UNKNOWN:
unknown's avatar
unknown committed
199
    return NULL;
200
  }
201 202 203
}


204 205 206
/** @brief
  Use other database handler if databasehandler is not compiled in
*/
unknown's avatar
unknown committed
207
handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type,
208
                          bool no_substitute, bool report_error)
unknown's avatar
unknown committed
209
{
unknown's avatar
unknown committed
210 211 212 213
  handlerton *hton= ha_resolve_by_legacy_type(thd, database_type);
  if (ha_storage_engine_is_enabled(hton))
    return hton;

214 215 216 217
  if (no_substitute)
  {
    if (report_error)
    {
unknown's avatar
unknown committed
218
      const char *engine_name= ha_resolve_storage_engine_name(hton);
219 220
      my_error(ER_FEATURE_DISABLED,MYF(0),engine_name,engine_name);
    }
unknown's avatar
unknown committed
221
    return NULL;
222 223
  }

unknown's avatar
unknown committed
224 225 226
  switch (database_type) {
#ifndef NO_HASH
  case DB_TYPE_HASH:
unknown's avatar
unknown committed
227
    return ha_resolve_by_legacy_type(thd, DB_TYPE_HASH);
228
#endif
229
  case DB_TYPE_MRG_ISAM:
unknown's avatar
unknown committed
230
    return ha_resolve_by_legacy_type(thd, DB_TYPE_MRG_MYISAM);
unknown's avatar
unknown committed
231 232 233
  default:
    break;
  }
unknown's avatar
unknown committed
234

unknown's avatar
unknown committed
235
  return ha_default_handlerton(thd);
unknown's avatar
unknown committed
236 237 238
} /* ha_checktype */


unknown's avatar
unknown committed
239
handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc,
unknown's avatar
unknown committed
240
                         handlerton *db_type)
unknown's avatar
unknown committed
241
{
242 243 244
  handler *file;
  DBUG_ENTER("get_new_handler");
  DBUG_PRINT("enter", ("alloc: 0x%lx", (long) alloc));
245

246
  if (db_type && db_type->state == SHOW_OPTION_YES && db_type->create)
247
  {
248
    if ((file= db_type->create(db_type, share, alloc)))
249 250
      file->init();
    DBUG_RETURN(file);
251
  }
252 253 254 255 256
  /*
    Try the default table type
    Here the call to current_thd() is ok as we call this function a lot of
    times but we enter this branch very seldom.
  */
unknown's avatar
unknown committed
257
  DBUG_RETURN(get_new_handler(share, alloc, ha_default_handlerton(current_thd)));
unknown's avatar
unknown committed
258 259
}

260

261
#ifdef WITH_PARTITION_STORAGE_ENGINE
262 263 264 265
handler *get_ha_partition(partition_info *part_info)
{
  ha_partition *partition;
  DBUG_ENTER("get_ha_partition");
266
  if ((partition= new ha_partition(partition_hton, part_info)))
267
  {
268
    if (partition->initialise_partition(current_thd->mem_root))
269 270 271 272
    {
      delete partition;
      partition= 0;
    }
273 274
    else
      partition->init();
275 276 277 278 279 280 281 282 283 284
  }
  else
  {
    my_error(ER_OUTOFMEMORY, MYF(0), sizeof(ha_partition));
  }
  DBUG_RETURN(((handler*) partition));
}
#endif


285
/** @brief
286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
  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));
335 336
  SETMSG(HA_ERR_NO_REFERENCED_ROW,      ER(ER_NO_REFERENCED_ROW_2));
  SETMSG(HA_ERR_ROW_IS_REFERENCED,      ER(ER_ROW_IS_REFERENCED_2));
337 338 339 340 341
  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");
342
  SETMSG(HA_ERR_TABLE_DEF_CHANGED,      ER(ER_TABLE_DEF_CHANGED));
343
  SETMSG(HA_ERR_FOREIGN_DUPLICATE_KEY,  "FK constraint would lead to duplicate key");
unknown's avatar
unknown committed
344
  SETMSG(HA_ERR_TABLE_NEEDS_UPGRADE,    ER(ER_TABLE_NEEDS_UPGRADE));
345
  SETMSG(HA_ERR_TABLE_READONLY,         ER(ER_OPEN_AS_READONLY));
unknown's avatar
unknown committed
346 347
  SETMSG(HA_ERR_AUTOINC_READ_FAILED,    ER(ER_AUTOINC_READ_FAILED));
  SETMSG(HA_ERR_AUTOINC_ERANGE,         ER(ER_WARN_DATA_OUT_OF_RANGE));
348 349 350 351 352 353

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


354
/** @brief
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
  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;
371
  my_free((uchar*) errmsgs, MYF(0));
372 373
  return 0;
}
unknown's avatar
unknown committed
374

375

unknown's avatar
unknown committed
376
int ha_finalize_handlerton(st_plugin_int *plugin)
377
{
unknown's avatar
unknown committed
378
  handlerton *hton= (handlerton *)plugin->data;
unknown's avatar
unknown committed
379 380 381 382 383 384 385 386 387 388 389 390
  DBUG_ENTER("ha_finalize_handlerton");

  switch (hton->state)
  {
  case SHOW_OPTION_NO:
  case SHOW_OPTION_DISABLED:
    break;
  case SHOW_OPTION_YES:
    if (installed_htons[hton->db_type] == hton)
      installed_htons[hton->db_type]= NULL;
    break;
  };
391

unknown's avatar
unknown committed
392 393 394
  if (hton->panic)
    hton->panic(hton, HA_PANIC_CLOSE);

395 396 397 398 399 400 401 402 403 404 405 406 407 408
  if (plugin->plugin->deinit)
  {
    /*
      Today we have no defined/special behavior for uninstalling
      engine plugins.
    */
    DBUG_PRINT("info", ("Deinitializing plugin: '%s'", plugin->name.str));
    if (plugin->plugin->deinit(NULL))
    {
      DBUG_PRINT("warning", ("Plugin '%s' deinit function returned error.",
                             plugin->name.str));
    }
  }

409
  my_free((uchar*)hton, MYF(0));
410

unknown's avatar
unknown committed
411
  DBUG_RETURN(0);
412
}
413

unknown's avatar
unknown committed
414

unknown's avatar
unknown committed
415
int ha_initialize_handlerton(st_plugin_int *plugin)
unknown's avatar
unknown committed
416
{
417
  handlerton *hton;
unknown's avatar
unknown committed
418
  DBUG_ENTER("ha_initialize_handlerton");
419
  DBUG_PRINT("plugin", ("initialize plugin: '%s'", plugin->name.str));
unknown's avatar
unknown committed
420

421 422 423
  hton= (handlerton *)my_malloc(sizeof(handlerton),
                                MYF(MY_WME | MY_ZEROFILL));
  /* Historical Requirement */
unknown's avatar
unknown committed
424
  plugin->data= hton; // shortcut for the future
425 426 427 428 429 430 431 432 433
  if (plugin->plugin->init)
  {
    if (plugin->plugin->init(hton))
    {
      sql_print_error("Plugin '%s' init function returned error.",
                      plugin->name.str);
      goto err;
    }
  }
unknown's avatar
unknown committed
434

unknown's avatar
unknown committed
435 436 437 438
  /*
    the switch below and hton->state should be removed when
    command-line options for plugins will be implemented
  */
unknown's avatar
unknown committed
439
  switch (hton->state) {
unknown's avatar
unknown committed
440 441 442 443
  case SHOW_OPTION_NO:
    break;
  case SHOW_OPTION_YES:
    {
unknown's avatar
unknown committed
444
      uint tmp;
unknown's avatar
unknown committed
445
      /* now check the db_type for conflict */
unknown's avatar
unknown committed
446
      if (hton->db_type <= DB_TYPE_UNKNOWN ||
unknown's avatar
unknown committed
447 448 449 450
          hton->db_type >= DB_TYPE_DEFAULT ||
          installed_htons[hton->db_type])
      {
        int idx= (int) DB_TYPE_FIRST_DYNAMIC;
unknown's avatar
unknown committed
451

unknown's avatar
unknown committed
452 453 454 455 456 457 458 459 460 461
        while (idx < (int) DB_TYPE_DEFAULT && installed_htons[idx])
          idx++;

        if (idx == (int) DB_TYPE_DEFAULT)
        {
          sql_print_warning("Too many storage engines!");
          DBUG_RETURN(1);
        }
        if (hton->db_type != DB_TYPE_UNKNOWN)
          sql_print_warning("Storage engine '%s' has conflicting typecode. "
unknown's avatar
unknown committed
462
                            "Assigning value %d.", plugin->plugin->name, idx);
unknown's avatar
unknown committed
463 464 465
        hton->db_type= (enum legacy_db_type) idx;
      }
      installed_htons[hton->db_type]= hton;
unknown's avatar
unknown committed
466
      tmp= hton->savepoint_offset;
unknown's avatar
unknown committed
467 468 469
      hton->savepoint_offset= savepoint_alloc_size;
      savepoint_alloc_size+= tmp;
      hton->slot= total_ha++;
unknown's avatar
unknown committed
470
      hton2plugin[hton->slot]=plugin;
unknown's avatar
unknown committed
471 472
      if (hton->prepare)
        total_ha_2pc++;
unknown's avatar
unknown committed
473 474 475 476 477 478 479
      break;
    }
    /* fall through */
  default:
    hton->state= SHOW_OPTION_DISABLED;
    break;
  }
480 481
  
  /* 
482 483 484
    This is entirely for legacy. We will create a new "disk based" hton and a 
    "memory" hton which will be configurable longterm. We should be able to 
    remove partition and myisammrg.
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499
  */
  switch (hton->db_type) {
  case DB_TYPE_HEAP:
    heap_hton= hton;
    break;
  case DB_TYPE_MYISAM:
    myisam_hton= hton;
    break;
  case DB_TYPE_PARTITION_DB:
    partition_hton= hton;
    break;
  default:
    break;
  };

unknown's avatar
unknown committed
500
  DBUG_RETURN(0);
501 502
err:
  DBUG_RETURN(1);
unknown's avatar
unknown committed
503 504
}

unknown's avatar
unknown committed
505 506
int ha_init()
{
507
  int error= 0;
unknown's avatar
unknown committed
508 509
  DBUG_ENTER("ha_init");

510
  if (ha_init_errors())
unknown's avatar
unknown committed
511
    DBUG_RETURN(1);
unknown's avatar
unknown committed
512

513
  DBUG_ASSERT(total_ha < MAX_HA);
514 515 516 517 518 519
  /*
    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;
520
  savepoint_alloc_size+= sizeof(SAVEPOINT);
unknown's avatar
unknown committed
521
  DBUG_RETURN(error);
unknown's avatar
unknown committed
522 523
}

524
int ha_end()
unknown's avatar
unknown committed
525
{
526 527
  int error= 0;
  DBUG_ENTER("ha_end");
unknown's avatar
unknown committed
528

unknown's avatar
unknown committed
529

530 531 532 533 534 535 536
  /* 
    This should be eventualy based  on the graceful shutdown flag.
    So if flag is equal to HA_PANIC_CLOSE, the deallocate
    the errors.
  */
  if (ha_finish_errors())
    error= 1;
unknown's avatar
unknown committed
537

538 539
  DBUG_RETURN(error);
}
unknown's avatar
unknown committed
540

unknown's avatar
unknown committed
541
static my_bool dropdb_handlerton(THD *unused1, plugin_ref plugin,
unknown's avatar
unknown committed
542 543
                                 void *path)
{
unknown's avatar
unknown committed
544
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
545
  if (hton->state == SHOW_OPTION_YES && hton->drop_database)
546
    hton->drop_database(hton, (char *)path);
unknown's avatar
unknown committed
547 548 549 550
  return FALSE;
}


551 552
void ha_drop_database(char* path)
{
unknown's avatar
unknown committed
553 554
  plugin_foreach(NULL, dropdb_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, path);
}
555

unknown's avatar
unknown committed
556

unknown's avatar
unknown committed
557
static my_bool closecon_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
558 559
                                   void *unused)
{
unknown's avatar
unknown committed
560
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
561 562 563 564
  /*
    there's no need to rollback here as all transactions must
    be rolled back already
  */
unknown's avatar
unknown committed
565 566
  if (hton->state == SHOW_OPTION_YES && hton->close_connection &&
      thd->ha_data[hton->slot])
567
    hton->close_connection(hton, thd);
unknown's avatar
unknown committed
568
  return FALSE;
569
}
unknown's avatar
unknown committed
570

unknown's avatar
unknown committed
571

572 573 574
/** @brief
  don't bother to rollback here, it's done already
*/
575 576
void ha_close_connection(THD* thd)
{
unknown's avatar
unknown committed
577
  plugin_foreach(thd, closecon_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, 0);
578 579 580 581 582
}

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

583
/** @brief
unknown's avatar
unknown committed
584 585 586 587 588 589 590 591
  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.
592 593 594 595 596

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

unknown's avatar
unknown committed
597
*/
598 599 600
void trans_register_ha(THD *thd, bool all, handlerton *ht_arg)
{
  THD_TRANS *trans;
601
  handlerton **ht;
unknown's avatar
unknown committed
602 603 604
  DBUG_ENTER("trans_register_ha");
  DBUG_PRINT("enter",("%s", all ? "all" : "stmt"));

605 606 607 608 609 610 611 612
  if (all)
  {
    trans= &thd->transaction.all;
    thd->server_status|= SERVER_STATUS_IN_TRANS;
  }
  else
    trans= &thd->transaction.stmt;

613
  for (ht=trans->ht; *ht; ht++)
unknown's avatar
unknown committed
614 615 616
    if (*ht == ht_arg)
      DBUG_VOID_RETURN;  /* already registered, return */

617
  trans->ht[trans->nht++]=ht_arg;
618
  DBUG_ASSERT(*ht == ht_arg);
619
  trans->no_2pc|=(ht_arg->prepare==0);
620 621
  if (thd->transaction.xid_state.xid.is_null())
    thd->transaction.xid_state.xid.set(thd->query_id);
unknown's avatar
unknown committed
622
  DBUG_VOID_RETURN;
623 624
}

625
/** @brief
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641
  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;
642
      status_var_increment(thd->status_var.ha_prepare_count);
643
      if ((*ht)->prepare)
644
      {
645
        if ((err= (*(*ht)->prepare)(*ht, thd, all)))
646 647 648 649 650 651 652 653 654 655
        {
          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,
unknown's avatar
unknown committed
656
                            ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
unknown's avatar
unknown committed
657
                            ha_resolve_storage_engine_name(*ht));
658 659 660 661 662 663 664
      }
    }
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

665
/** @brief
666 667 668 669 670 671 672 673 674 675 676
  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;
677
  my_xid xid= thd->transaction.xid_state.xid.get_my_xid();
678
  DBUG_ENTER("ha_commit_trans");
679

680
  if (thd->in_sub_stmt)
681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699
  {
    /*
      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);
  }
700 701 702
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
703 704 705 706 707
    if (is_real_trans && wait_if_global_read_lock(thd, 0, 0))
    {
      ha_rollback_trans(thd, all);
      DBUG_RETURN(1);
    }
unknown's avatar
unknown committed
708

unknown's avatar
unknown committed
709 710 711 712 713
    if (   is_real_trans
        && opt_readonly
        && ! (thd->security_ctx->master_access & SUPER_ACL)
        && ! thd->slave_thread
       )
unknown's avatar
unknown committed
714 715 716 717 718 719 720
    {
      my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
      ha_rollback_trans(thd, all);
      error= 1;
      goto end;
    }

721
    DBUG_EXECUTE_IF("crash_commit_before", abort(););
722 723 724 725 726

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

727 728 729 730 731
    if (!trans->no_2pc && trans->nht > 1)
    {
      for (; *ht && !error; ht++)
      {
        int err;
732
        if ((err= (*(*ht)->prepare)(*ht, thd, all)))
733 734
        {
          my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
735
          error= 1;
736
        }
737
        status_var_increment(thd->status_var.ha_prepare_count);
738
      }
739
      DBUG_EXECUTE_IF("crash_commit_after_prepare", abort(););
unknown's avatar
unknown committed
740
      if (error || (is_real_trans && xid &&
741
                    (error= !(cookie= tc_log->log_xid(thd, xid)))))
742 743
      {
        ha_rollback_trans(thd, all);
744 745
        error= 1;
        goto end;
746
      }
747
      DBUG_EXECUTE_IF("crash_commit_after_log", abort(););
748
    }
749
    error=ha_commit_one_phase(thd, all) ? (cookie ? 2 : 1) : 0;
750
    DBUG_EXECUTE_IF("crash_commit_before_unlog", abort(););
751
    if (cookie)
unknown's avatar
unknown committed
752
      tc_log->unlog(cookie, xid);
753
    DBUG_EXECUTE_IF("crash_commit_after", abort(););
754 755 756
end:
    if (is_real_trans)
      start_waiting_global_read_lock(thd);
757 758 759 760 761
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

762
/** @brief
763 764 765
  NOTE - this function does not care about global read lock.
  A caller should.
*/
766 767 768 769 770 771 772 773 774 775 776 777 778
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;
779
      if ((err= (*(*ht)->commit)(*ht, thd, all)))
780 781 782 783
      {
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
        error=1;
      }
784
      status_var_increment(thd->status_var.ha_commit_count);
785 786 787 788 789
      *ht= 0;
    }
    trans->nht=0;
    trans->no_2pc=0;
    if (is_real_trans)
790
      thd->transaction.xid_state.xid.null();
791 792 793 794 795
    if (all)
    {
#ifdef HAVE_QUERY_CACHE
      if (thd->transaction.changed_tables)
        query_cache.invalidate(thd->transaction.changed_tables);
unknown's avatar
unknown committed
796
#endif
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811
      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");
812
  if (thd->in_sub_stmt)
813 814 815 816 817 818 819 820 821 822 823 824
  {
    /*
      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);
  }
825 826 827
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
828 829 830 831
    /* Close all cursors that can not survive ROLLBACK */
    if (is_real_trans)                          /* not a statement commit */
      thd->stmt_map.close_transient_cursors();

832 833 834
    for (handlerton **ht=trans->ht; *ht; ht++)
    {
      int err;
835
      if ((err= (*(*ht)->rollback)(*ht, thd, all)))
836 837 838 839
      { // cannot happen
        my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
        error=1;
      }
840
      status_var_increment(thd->status_var.ha_rollback_count);
841 842 843 844 845
      *ht= 0;
    }
    trans->nht=0;
    trans->no_2pc=0;
    if (is_real_trans)
846
      thd->transaction.xid_state.xid.null();
847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
    if (all)
    {
      thd->variables.tx_isolation=thd->session_tx_isolation;
      thd->transaction.cleanup();
    }
  }
#endif /* USING_TRANSACTIONS */
  /*
    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.
  */
863
  if (is_real_trans && thd->no_trans_update.all &&
unknown's avatar
unknown committed
864
      !thd->slave_thread && thd->killed != THD::KILL_CONNECTION)
865 866 867 868
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                 ER_WARNING_NOT_COMPLETE_ROLLBACK,
                 ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
  DBUG_RETURN(error);
869 870
}

871
/** @brief
unknown's avatar
unknown committed
872
  This is used to commit or rollback a single statement depending on the value
unknown's avatar
unknown committed
873 874 875 876 877
  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.
878
*/
unknown's avatar
unknown committed
879 880 881
int ha_autocommit_or_rollback(THD *thd, int error)
{
  DBUG_ENTER("ha_autocommit_or_rollback");
882
#ifdef USING_TRANSACTIONS
883
  if (thd->transaction.stmt.nht)
unknown's avatar
unknown committed
884
  {
885 886 887 888 889 890 891
    if (!error)
    {
      if (ha_commit_stmt(thd))
	error=1;
    }
    else
      (void) ha_rollback_stmt(thd);
unknown's avatar
unknown committed
892

unknown's avatar
unknown committed
893
    thd->variables.tx_isolation=thd->session_tx_isolation;
unknown's avatar
unknown committed
894 895 896 897 898
  }
#endif
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
899

unknown's avatar
unknown committed
900 901 902 903 904
struct xahton_st {
  XID *xid;
  int result;
};

unknown's avatar
unknown committed
905
static my_bool xacommit_handlerton(THD *unused1, plugin_ref plugin,
unknown's avatar
unknown committed
906
                                   void *arg)
907
{
unknown's avatar
unknown committed
908
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
909 910
  if (hton->state == SHOW_OPTION_YES && hton->recover)
  {
911
    hton->commit_by_xid(hton, ((struct xahton_st *)arg)->xid);
unknown's avatar
unknown committed
912 913 914 915
    ((struct xahton_st *)arg)->result= 0;
  }
  return FALSE;
}
916

unknown's avatar
unknown committed
917
static my_bool xarollback_handlerton(THD *unused1, plugin_ref plugin,
unknown's avatar
unknown committed
918 919
                                     void *arg)
{
unknown's avatar
unknown committed
920
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
921
  if (hton->state == SHOW_OPTION_YES && hton->recover)
unknown's avatar
unknown committed
922
  {
923
    hton->rollback_by_xid(hton, ((struct xahton_st *)arg)->xid);
unknown's avatar
unknown committed
924
    ((struct xahton_st *)arg)->result= 0;
unknown's avatar
unknown committed
925
  }
unknown's avatar
unknown committed
926 927 928 929 930 931 932 933 934
  return FALSE;
}


int ha_commit_or_rollback_by_xid(XID *xid, bool commit)
{
  struct xahton_st xaop;
  xaop.xid= xid;
  xaop.result= 1;
unknown's avatar
unknown committed
935

unknown's avatar
unknown committed
936 937 938 939
  plugin_foreach(NULL, commit ? xacommit_handlerton : xarollback_handlerton,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &xaop);

  return xaop.result;
940
}
unknown's avatar
unknown committed
941

unknown's avatar
unknown committed
942

unknown's avatar
unknown committed
943 944 945 946 947 948 949 950 951 952
#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
953 954
    /* is_next_dig is set if next character is a number */
    bool is_next_dig= FALSE;
unknown's avatar
unknown committed
955 956
    if (i < XIDDATASIZE)
    {
unknown's avatar
unknown committed
957 958
      char ch= xid->data[i+1];
      is_next_dig= (ch >= '0' && ch <='9');
unknown's avatar
unknown committed
959
    }
unknown's avatar
unknown committed
960 961 962 963 964 965 966 967 968 969 970 971
    if (i == xid->gtrid_length)
    {
      *s++='\'';
      if (xid->bqual_length)
      {
        *s++='.';
        *s++='\'';
      }
    }
    if (c < 32 || c > 126)
    {
      *s++='\\';
unknown's avatar
unknown committed
972 973 974 975 976
      /*
        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
977 978 979 980 981
      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
982 983 984 985 986 987 988 989 990 991 992 993 994 995
    }
    else
    {
      if (c == '\'' || c == '\\')
        *s++='\\';
      *s++=c;
    }
  }
  *s++='\'';
  *s=0;
  return buf;
}
#endif

996
/** @brief
997
  recover() step of xa
unknown's avatar
unknown committed
998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013

  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
1014
*/
unknown's avatar
unknown committed
1015 1016 1017 1018 1019 1020 1021
struct xarecover_st
{
  int len, found_foreign_xids, found_my_xids;
  XID *list;
  HASH *commit_list;
  bool dry_run;
};
1022

unknown's avatar
unknown committed
1023
static my_bool xarecover_handlerton(THD *unused, plugin_ref plugin,
unknown's avatar
unknown committed
1024 1025
                                    void *arg)
{
unknown's avatar
unknown committed
1026
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
1027 1028
  struct xarecover_st *info= (struct xarecover_st *) arg;
  int got;
unknown's avatar
unknown committed
1029

unknown's avatar
unknown committed
1030
  if (hton->state == SHOW_OPTION_YES && hton->recover)
1031
  {
1032
    while ((got= hton->recover(hton, info->list, info->len)) > 0 )
1033
    {
unknown's avatar
unknown committed
1034
      sql_print_information("Found %d prepared transaction(s) in %s",
unknown's avatar
unknown committed
1035
                            got, ha_resolve_storage_engine_name(hton));
1036 1037
      for (int i=0; i < got; i ++)
      {
unknown's avatar
unknown committed
1038
        my_xid x=info->list[i].get_my_xid();
1039
        if (!x) // not "mine" - that is generated by external TM
unknown's avatar
unknown committed
1040
        {
unknown's avatar
unknown committed
1041 1042
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
unknown's avatar
unknown committed
1043
          sql_print_information("ignore xid %s", xid_to_str(buf, info->list+i));
unknown's avatar
unknown committed
1044
#endif
unknown's avatar
unknown committed
1045 1046
          xid_cache_insert(info->list+i, XA_PREPARED);
          info->found_foreign_xids++;
unknown's avatar
unknown committed
1047 1048
          continue;
        }
unknown's avatar
unknown committed
1049
        if (info->dry_run)
unknown's avatar
unknown committed
1050
        {
unknown's avatar
unknown committed
1051
          info->found_my_xids++;
1052
          continue;
unknown's avatar
unknown committed
1053 1054
        }
        // recovery mode
unknown's avatar
unknown committed
1055
        if (info->commit_list ?
1056
            hash_search(info->commit_list, (uchar *)&x, sizeof(x)) != 0 :
1057
            tc_heuristic_recover == TC_HEURISTIC_RECOVER_COMMIT)
unknown's avatar
unknown committed
1058 1059 1060
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
unknown's avatar
unknown committed
1061
          sql_print_information("commit xid %s", xid_to_str(buf, info->list+i));
unknown's avatar
unknown committed
1062
#endif
1063
          hton->commit_by_xid(hton, info->list+i);
unknown's avatar
unknown committed
1064
        }
1065
        else
unknown's avatar
unknown committed
1066 1067 1068
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
unknown's avatar
unknown committed
1069 1070
          sql_print_information("rollback xid %s",
                                xid_to_str(buf, info->list+i));
unknown's avatar
unknown committed
1071
#endif
1072
          hton->rollback_by_xid(hton, info->list+i);
unknown's avatar
unknown committed
1073
        }
1074
      }
unknown's avatar
unknown committed
1075
      if (got < info->len)
1076
        break;
1077 1078
    }
  }
unknown's avatar
unknown committed
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
  return FALSE;
}

int ha_recover(HASH *commit_list)
{
  struct xarecover_st info;
  DBUG_ENTER("ha_recover");
  info.found_foreign_xids= info.found_my_xids= 0;
  info.commit_list= commit_list;
  info.dry_run= (info.commit_list==0 && tc_heuristic_recover==0);
  info.list= NULL;

  /* commit_list and tc_heuristic_recover cannot be set both */
  DBUG_ASSERT(info.commit_list==0 || tc_heuristic_recover==0);
  /* if either is set, total_ha_2pc must be set too */
  DBUG_ASSERT(info.dry_run || total_ha_2pc>(ulong)opt_bin_log);

  if (total_ha_2pc <= (ulong)opt_bin_log)
    DBUG_RETURN(0);

  if (info.commit_list)
    sql_print_information("Starting crash recovery...");

#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
  */
  DBUG_ASSERT(total_ha_2pc == (ulong) opt_bin_log+1); // only InnoDB and binlog
  tc_heuristic_recover= TC_HEURISTIC_RECOVER_ROLLBACK; // forcing ROLLBACK
  info.dry_run=FALSE;
#endif

  for (info.len= MAX_XID_LIST_SIZE ; 
       info.list==0 && info.len > MIN_XID_LIST_SIZE; info.len/=2)
  {
    info.list=(XID *)my_malloc(info.len*sizeof(XID), MYF(0));
  }
  if (!info.list)
  {
    sql_print_error(ER(ER_OUTOFMEMORY), info.len*sizeof(XID));
    DBUG_RETURN(1);
  }

  plugin_foreach(NULL, xarecover_handlerton, 
                 MYSQL_STORAGE_ENGINE_PLUGIN, &info);

1126
  my_free((uchar*)info.list, MYF(0));
unknown's avatar
unknown committed
1127 1128 1129 1130
  if (info.found_foreign_xids)
    sql_print_warning("Found %d prepared XA transactions", 
                      info.found_foreign_xids);
  if (info.dry_run && info.found_my_xids)
unknown's avatar
unknown committed
1131 1132 1133 1134 1135 1136 1137
  {
    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.",
unknown's avatar
unknown committed
1138
                    info.found_my_xids, opt_tc_log_file);
unknown's avatar
unknown committed
1139 1140
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
1141
  if (info.commit_list)
unknown's avatar
unknown committed
1142
    sql_print_information("Crash recovery finished.");
1143
  DBUG_RETURN(0);
1144
}
1145

1146
/** @brief
1147
  return the list of XID's to a client, the same way SHOW commands do
unknown's avatar
unknown committed
1148

1149 1150 1151 1152
  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
1153
*/
1154
bool mysql_xa_recover(THD *thd)
unknown's avatar
unknown committed
1155
{
1156 1157
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
1158 1159
  int i=0;
  XID_STATE *xs;
1160 1161
  DBUG_ENTER("mysql_xa_recover");

1162 1163 1164
  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));
1165 1166 1167 1168 1169
  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
1170

1171
  pthread_mutex_lock(&LOCK_xid_cache);
unknown's avatar
unknown committed
1172
  while ((xs= (XID_STATE*)hash_element(&xid_cache, i++)))
1173
  {
1174
    if (xs->xa_state==XA_PREPARED)
1175
    {
1176 1177 1178 1179 1180 1181 1182
      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())
1183
      {
1184 1185
        pthread_mutex_unlock(&LOCK_xid_cache);
        DBUG_RETURN(1);
1186 1187
      }
    }
unknown's avatar
unknown committed
1188
  }
1189

1190
  pthread_mutex_unlock(&LOCK_xid_cache);
1191
  send_eof(thd);
1192
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1193
}
1194

1195
/** @brief
1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
  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
*/
unknown's avatar
unknown committed
1211
static my_bool release_temporary_latches(THD *thd, plugin_ref plugin,
1212 1213
                                 void *unused)
{
unknown's avatar
unknown committed
1214
  handlerton *hton= plugin_data(plugin, handlerton *);
1215 1216

  if (hton->state == SHOW_OPTION_YES && hton->release_temporary_latches)
1217
    hton->release_temporary_latches(hton, thd);
1218 1219 1220 1221 1222

  return FALSE;
}


1223 1224
int ha_release_temporary_latches(THD *thd)
{
1225 1226 1227
  plugin_foreach(thd, release_temporary_latches, MYSQL_STORAGE_ENGINE_PLUGIN, 
                 NULL);

1228
  return 0;
1229 1230
}

1231
int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1232 1233
{
  int error=0;
1234 1235
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
1236 1237
  handlerton **ht=trans->ht, **end_ht;
  DBUG_ENTER("ha_rollback_to_savepoint");
1238

1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
  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;
1249
    DBUG_ASSERT((*ht)->savepoint_set != 0);
1250
    if ((err= (*(*ht)->savepoint_rollback)(*ht, thd, (uchar *)(sv+1)+(*ht)->savepoint_offset)))
1251 1252 1253
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
1254
    }
1255
    status_var_increment(thd->status_var.ha_savepoint_rollback_count);
1256
    trans->no_2pc|=(*ht)->prepare == 0;
1257
  }
1258 1259 1260 1261 1262
  /*
    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
1263
  {
1264
    int err;
1265
    if ((err= (*(*ht)->rollback)(*ht, thd, !thd->in_sub_stmt)))
1266 1267 1268
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
unknown's avatar
unknown committed
1269
    }
1270
    status_var_increment(thd->status_var.ha_rollback_count);
1271
    *ht=0; // keep it conveniently zero-filled
1272
  }
unknown's avatar
unknown committed
1273 1274 1275
  DBUG_RETURN(error);
}

1276
/** @brief
1277 1278 1279
  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
1280
*/
1281
int ha_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1282 1283
{
  int error=0;
1284 1285
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
1286 1287
  handlerton **ht=trans->ht;
  DBUG_ENTER("ha_savepoint");
unknown's avatar
unknown committed
1288
#ifdef USING_TRANSACTIONS
1289
  for (; *ht; ht++)
unknown's avatar
unknown committed
1290
  {
1291 1292
    int err;
    if (! (*ht)->savepoint_set)
unknown's avatar
unknown committed
1293
    {
1294
      my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "SAVEPOINT");
unknown's avatar
unknown committed
1295
      error=1;
1296
      break;
unknown's avatar
unknown committed
1297
    }
1298
    if ((err= (*(*ht)->savepoint_set)(*ht, thd, (uchar *)(sv+1)+(*ht)->savepoint_offset)))
1299 1300
    { // cannot happen
      my_error(ER_GET_ERRNO, MYF(0), err);
unknown's avatar
unknown committed
1301 1302
      error=1;
    }
1303
    status_var_increment(thd->status_var.ha_savepoint_count);
unknown's avatar
unknown committed
1304
  }
1305
  sv->nht=trans->nht;
unknown's avatar
unknown committed
1306 1307 1308 1309
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

1310
int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1311 1312
{
  int error=0;
1313 1314 1315
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
  handlerton **ht=trans->ht, **end_ht;
1316 1317 1318 1319
  DBUG_ENTER("ha_release_savepoint");

  end_ht=ht+sv->nht;
  for (; ht < end_ht; ht++)
unknown's avatar
unknown committed
1320
  {
1321 1322 1323
    int err;
    if (!(*ht)->savepoint_release)
      continue;
1324
    if ((err= (*(*ht)->savepoint_release)(*ht, thd, 
1325
                                          (uchar *)(sv+1)+
1326
                                          (*ht)->savepoint_offset)))
1327 1328 1329
    { // cannot happen
      my_error(ER_GET_ERRNO, MYF(0), err);
      error=1;
unknown's avatar
unknown committed
1330
    }
unknown's avatar
unknown committed
1331 1332 1333 1334
  }
  DBUG_RETURN(error);
}

1335

unknown's avatar
unknown committed
1336
static my_bool snapshot_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
1337 1338
                                   void *arg)
{
unknown's avatar
unknown committed
1339
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
1340 1341 1342
  if (hton->state == SHOW_OPTION_YES &&
      hton->start_consistent_snapshot)
  {
1343
    hton->start_consistent_snapshot(hton, thd);
unknown's avatar
unknown committed
1344 1345 1346 1347 1348
    *((bool *)arg)= false;
  }
  return FALSE;
}

1349 1350
int ha_start_consistent_snapshot(THD *thd)
{
1351 1352
  bool warn= true;

unknown's avatar
unknown committed
1353 1354
  plugin_foreach(thd, snapshot_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, &warn);

1355 1356 1357 1358
  /*
    Same idea as when one wants to CREATE TABLE in one engine which does not
    exist:
  */
1359 1360 1361 1362
  if (warn)
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
                 "This MySQL server does not support any "
                 "consistent-read capable storage engine");
1363 1364 1365 1366
  return 0;
}


unknown's avatar
unknown committed
1367
static my_bool flush_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
1368
                                void *arg)
unknown's avatar
unknown committed
1369
{
unknown's avatar
unknown committed
1370
  handlerton *hton= plugin_data(plugin, handlerton *);
1371 1372
  if (hton->state == SHOW_OPTION_YES && hton->flush_logs && 
      hton->flush_logs(hton))
unknown's avatar
unknown committed
1373 1374 1375 1376
    return TRUE;
  return FALSE;
}

1377

unknown's avatar
unknown committed
1378 1379 1380
bool ha_flush_logs(handlerton *db_type)
{
  if (db_type == NULL)
1381
  {
unknown's avatar
unknown committed
1382 1383 1384
    if (plugin_foreach(NULL, flush_handlerton,
                          MYSQL_STORAGE_ENGINE_PLUGIN, 0))
      return TRUE;
1385
  }
unknown's avatar
unknown committed
1386 1387 1388
  else
  {
    if (db_type->state != SHOW_OPTION_YES ||
1389
        (db_type->flush_logs && db_type->flush_logs(db_type)))
unknown's avatar
unknown committed
1390 1391 1392
      return TRUE;
  }
  return FALSE;
unknown's avatar
unknown committed
1393 1394
}

1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
static const char *check_lowercase_names(handler *file, const char *path,
                                         char *tmp_path)
{
  if (lower_case_table_names != 2 || (file->ha_table_flags() & HA_FILE_BASED))
    return path;

  /* Ensure that table handler get path in lower case */
  if (tmp_path != path)
    strmov(tmp_path, path);

  /*
    we only should turn into lowercase database/table part
    so start the process after homedirectory
  */
  my_casedn_str(files_charset_info, tmp_path + mysql_data_home_len);
  return tmp_path;
}


1414
/** @brief
unknown's avatar
unknown committed
1415 1416 1417
  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
1418
int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
unknown's avatar
unknown committed
1419
                    const char *db, const char *alias, bool generate_warning)
unknown's avatar
unknown committed
1420
{
1421
  handler *file;
unknown's avatar
unknown committed
1422
  char tmp_path[FN_REFLEN];
1423 1424 1425 1426 1427 1428 1429 1430
  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;
1431 1432

  /* DB_TYPE_UNKNOWN is used in ALTER TABLE when renaming only .frm files */
unknown's avatar
unknown committed
1433
  if (table_type == NULL ||
unknown's avatar
unknown committed
1434
      ! (file=get_new_handler((TABLE_SHARE*)0, thd->mem_root, table_type)))
1435
    DBUG_RETURN(ENOENT);
1436

1437
  path= check_lowercase_names(file, path, tmp_path);
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455
  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;
1456
    thd->spcont= NULL;
1457 1458 1459 1460
    thd->lex->current_select= 0;
    thd->net.last_error[0]= 0;

    /* Fill up strucutures that print_error may need */
unknown's avatar
unknown committed
1461 1462 1463 1464 1465 1466
    dummy_share.path.str= (char*) path;
    dummy_share.path.length= strlen(path);
    dummy_share.db.str= (char*) db;
    dummy_share.db.length= strlen(db);
    dummy_share.table_name.str= (char*) alias;
    dummy_share.table_name.length= strlen(alias);
1467 1468
    dummy_table.alias= alias;

unknown's avatar
unknown committed
1469 1470
    file->table_share= &dummy_share;
    file->table= &dummy_table;
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481
    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
1482
  delete file;
1483
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1484
}
unknown's avatar
unknown committed
1485

unknown's avatar
unknown committed
1486 1487 1488
/****************************************************************************
** General handler functions
****************************************************************************/
unknown's avatar
unknown committed
1489 1490
handler *handler::clone(MEM_ROOT *mem_root)
{
unknown's avatar
unknown committed
1491
  handler *new_handler= get_new_handler(table->s, mem_root, table->s->db_type());
unknown's avatar
unknown committed
1492 1493 1494
  if (new_handler && !new_handler->ha_open(table,
                                           table->s->normalized_path.str,
                                           table->db_stat,
unknown's avatar
unknown committed
1495 1496 1497 1498 1499
                                           HA_OPEN_IGNORE_IF_LOCKED))
    return new_handler;
  return NULL;
}

unknown's avatar
unknown committed
1500

1501 1502 1503

void handler::ha_statistic_increment(ulong SSV::*offset) const
{
1504
  status_var_increment(table->in_use->status_var.*offset);
1505 1506
}

1507
void **handler::ha_data(THD *thd) const
unknown's avatar
unknown committed
1508
{
1509
  return (void **) thd->ha_data + ht->slot;
unknown's avatar
unknown committed
1510 1511 1512 1513
}

THD *handler::ha_thd(void) const
{
unknown's avatar
unknown committed
1514
  DBUG_ASSERT(!table || !table->in_use || table->in_use == current_thd);
unknown's avatar
unknown committed
1515 1516 1517
  return (table && table->in_use) ? table->in_use : current_thd;
}

1518 1519 1520 1521 1522 1523

bool handler::check_if_log_table_locking_is_allowed(uint sql_command,
                                                    ulong type, TABLE *table)
{
  /*
    Deny locking of the log tables, which is incompatible with
1524 1525 1526
    concurrent insert. The routine is not called if the table is
    being locked from a logger THD (general_log_thd or slow_log_thd)
    or from a privileged thread (see log.cc for details)
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
  */
  if (table->s->log_table &&
      sql_command != SQLCOM_TRUNCATE &&
      sql_command != SQLCOM_ALTER_TABLE &&
      !(sql_command == SQLCOM_FLUSH &&
        type & REFRESH_LOG) &&
      (table->reginfo.lock_type >= TL_READ_NO_INSERT))
  {
    /*
      The check  >= TL_READ_NO_INSERT denies all write locks
      plus the only read lock (TL_READ_NO_INSERT itself)
    */
    table->reginfo.lock_type == TL_READ_NO_INSERT ?
      my_error(ER_CANT_READ_LOCK_LOG_TABLE, MYF(0)) :
        my_error(ER_CANT_WRITE_LOCK_LOG_TABLE, MYF(0));
    return FALSE;
  }
  return TRUE;
}

1547
/** @brief
unknown's avatar
unknown committed
1548 1549 1550 1551 1552 1553 1554 1555
  Open database-handler.

  IMPLEMENTATION
    Try O_RDONLY if cannot open as O_RDWR
    Don't wait for locks if not HA_OPEN_WAIT_IF_LOCKED is set
*/
int handler::ha_open(TABLE *table_arg, const char *name, int mode,
                     int test_if_locked)
unknown's avatar
unknown committed
1556 1557
{
  int error;
1558
  DBUG_ENTER("handler::ha_open");
unknown's avatar
unknown committed
1559 1560
  DBUG_PRINT("enter",
             ("name: %s  db_type: %d  db_stat: %d  mode: %d  lock_test: %d",
unknown's avatar
unknown committed
1561
              name, ht->db_type, table_arg->db_stat, mode,
unknown's avatar
unknown committed
1562 1563 1564 1565
              test_if_locked));

  table= table_arg;
  DBUG_ASSERT(table->s == table_share);
1566
  DBUG_ASSERT(alloc_root_inited(&table->mem_root));
unknown's avatar
unknown committed
1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578

  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)
  {
unknown's avatar
unknown committed
1579
    my_errno= error;                            /* Safeguard */
unknown's avatar
unknown committed
1580 1581 1582 1583
    DBUG_PRINT("error",("error: %d  errno: %d",error,errno));
  }
  else
  {
1584
    if (table->s->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
unknown's avatar
unknown committed
1585
      table->db_stat|=HA_READ_ONLY;
1586 1587
    (void) extra(HA_EXTRA_NO_READCHECK);	// Not needed in SQL

1588
    if (!(ref= (uchar*) alloc_root(&table->mem_root, ALIGN_SIZE(ref_length)*2)))
unknown's avatar
unknown committed
1589 1590 1591 1592 1593
    {
      close();
      error=HA_ERR_OUT_OF_MEM;
    }
    else
1594 1595
      dup_ref=ref+ALIGN_SIZE(ref_length);
    cached_table_flags= table_flags();
unknown's avatar
unknown committed
1596 1597 1598 1599
  }
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
1600

1601
/** @brief
1602
  Read first row (only) from a table
1603
  This is never called for InnoDB tables, as these table types
1604
  has the HA_STATS_RECORDS_IS_EXACT set.
1605
*/
1606
int handler::read_first_row(uchar * buf, uint primary_key)
unknown's avatar
unknown committed
1607 1608
{
  register int error;
1609
  DBUG_ENTER("handler::read_first_row");
unknown's avatar
unknown committed
1610

unknown's avatar
unknown committed
1611
  ha_statistic_increment(&SSV::ha_read_first_count);
1612 1613 1614 1615

  /*
    If there is very few deleted rows in the table, find the first row by
    scanning the table.
1616
    TODO remove the test for HA_READ_ORDER
1617
  */
1618
  if (stats.deleted < 10 || primary_key >= MAX_KEY ||
1619
      !(index_flags(primary_key, 0, 0) & HA_READ_ORDER))
1620
  {
unknown's avatar
unknown committed
1621
    (void) ha_rnd_init(1);
1622
    while ((error= rnd_next(buf)) == HA_ERR_RECORD_DELETED) ;
unknown's avatar
unknown committed
1623
    (void) ha_rnd_end();
1624 1625 1626 1627
  }
  else
  {
    /* Find the first row through the primary key */
1628
    (void) ha_index_init(primary_key, 0);
1629
    error=index_first(buf);
unknown's avatar
unknown committed
1630
    (void) ha_index_end();
1631
  }
unknown's avatar
unknown committed
1632 1633 1634
  DBUG_RETURN(error);
}

1635
/** @brief
1636 1637 1638 1639
  Generate the next auto-increment number based on increment and offset:
  computes the lowest number
  - strictly greater than "nr"
  - of the form: auto_increment_offset + N * auto_increment_increment
unknown's avatar
unknown committed
1640

1641 1642 1643 1644 1645 1646
  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
1647
compute_next_insert_id(ulonglong nr,struct system_variables *variables)
1648
{
1649 1650
  if (variables->auto_increment_increment == 1)
    return (nr+1); // optimization of the formula below
1651 1652 1653 1654 1655 1656 1657 1658
  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);
}


1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
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.
  */
  if ((next_insert_id > 0) && (nr >= next_insert_id))
    set_next_insert_id(compute_next_insert_id(nr, &table->in_use->variables));
}


1671
/** @brief
1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697
  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
1698
                       (ulong) nr, variables->auto_increment_offset));
1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709
    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);
}


1710
/*
1711 1712 1713
  Update the auto_increment field if necessary

  SYNOPSIS
1714
    update_auto_increment()
1715 1716 1717

  RETURN
    0	ok
unknown's avatar
unknown committed
1718 1719 1720 1721
    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.
1722 1723 1724 1725
    

  IMPLEMENTATION

1726
    Updates the record's Field of type NEXT_NUMBER if:
1727 1728 1729 1730 1731 1732 1733

  - 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).

1734 1735 1736
    In those cases, we check if the currently reserved interval still has
    values we have not used. If yes, we pick the smallest one and use it.
    Otherwise:
1737

1738 1739 1740
  - If a list of intervals has been provided to the statement via SET
    INSERT_ID or via an Intvar_log_event (in a replication slave), we pick the
    first unused interval from this list, consider it as reserved.
1741

1742 1743 1744 1745 1746 1747
  - Otherwise we set the column for the first row to the value
    next_insert_id(get_auto_increment(column))) which is usually
    max-used-column-value+1.
    We call get_auto_increment() for the first row in a multi-row
    statement. get_auto_increment() will tell us the interval of values it
    reserved for us.
1748

1749 1750 1751 1752 1753
  - In both cases, for the following rows we use those reserved values without
    calling the handler again (we just progress in the interval, computing
    each new value from the previous one). Until we have exhausted them, then
    we either take the next provided interval or call get_auto_increment()
    again to reserve a new interval.
1754

1755 1756 1757 1758
  - In both cases, the reserved intervals are remembered in
    thd->auto_inc_intervals_in_cur_stmt_for_binlog if statement-based
    binlogging; the last reserved interval is remembered in
    auto_inc_interval_for_cur_row.
1759 1760 1761 1762 1763 1764 1765 1766 1767 1768

    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.

1769 1770 1771 1772 1773 1774 1775
    This function's "outputs" are: the table's auto_increment field is filled
    with a value, thd->next_insert_id is filled with the value to use for the
    next row, if a value was autogenerated for the current row it is stored in
    thd->insert_id_for_cur_row, if get_auto_increment() was called
    thd->auto_inc_interval_for_cur_row is modified, if that interval is not
    present in thd->auto_inc_intervals_in_cur_stmt_for_binlog it is added to
    this list.
1776 1777 1778 1779 1780 1781 1782 1783

   TODO

    Replace all references to "next number" or NEXT_NUMBER to
    "auto_increment", everywhere (see below: there is
    table->auto_increment_field_not_null, and there also exists
    table->next_number_field, it's not consistent).

1784
*/
unknown's avatar
unknown committed
1785

1786 1787 1788 1789
#define AUTO_INC_DEFAULT_NB_ROWS 1 // Some prefer 1024 here
#define AUTO_INC_DEFAULT_NB_MAX_BITS 16
#define AUTO_INC_DEFAULT_NB_MAX ((1 << AUTO_INC_DEFAULT_NB_MAX_BITS) - 1)

unknown's avatar
unknown committed
1790
int handler::update_auto_increment()
unknown's avatar
unknown committed
1791
{
1792 1793
  ulonglong nr, nb_reserved_values;
  bool append= FALSE;
1794 1795
  THD *thd= table->in_use;
  struct system_variables *variables= &thd->variables;
1796
  DBUG_ENTER("handler::update_auto_increment");
1797 1798

  /*
1799 1800
    next_insert_id is a "cursor" into the reserved interval, it may go greater
    than the interval, but not smaller.
1801
  */
1802
  DBUG_ASSERT(next_insert_id >= auto_inc_interval_for_cur_row.minimum());
1803 1804

  if ((nr= table->next_number_field->val_int()) != 0 ||
1805
      table->auto_increment_field_not_null &&
1806
      thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO)
1807
  {
1808 1809 1810 1811 1812 1813
    /*
      Update next_insert_id if we had already generated a value in this
      statement (case of INSERT VALUES(null),(3763),(null):
      the last NULL needs to insert 3764, not the value of the first NULL plus
      1).
    */
1814
    adjust_next_insert_id_after_explicit_value(nr);
1815
    insert_id_for_cur_row= 0; // didn't generate anything
1816
    DBUG_RETURN(0);
1817
  }
1818 1819

  if ((nr= next_insert_id) >= auto_inc_interval_for_cur_row.maximum())
1820
  {
1821 1822 1823 1824 1825 1826 1827 1828 1829
    /* next_insert_id is beyond what is reserved, so we reserve more. */
    const Discrete_interval *forced=
      thd->auto_inc_intervals_forced.get_next();
    if (forced != NULL)
    {
      nr= forced->minimum();
      nb_reserved_values= forced->values();
    }
    else
1830
    {
1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852
      /*
        handler::estimation_rows_to_insert was set by
        handler::ha_start_bulk_insert(); if 0 it means "unknown".
      */
      uint nb_already_reserved_intervals=
        thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements();
      ulonglong nb_desired_values;
      /*
        If an estimation was given to the engine:
        - use it.
        - if we already reserved numbers, it means the estimation was
        not accurate, then we'll reserve 2*AUTO_INC_DEFAULT_NB_ROWS the 2nd
        time, twice that the 3rd time etc.
        If no estimation was given, use those increasing defaults from the
        start, starting from AUTO_INC_DEFAULT_NB_ROWS.
        Don't go beyond a max to not reserve "way too much" (because
        reservation means potentially losing unused values).
      */
      if (nb_already_reserved_intervals == 0 &&
          (estimation_rows_to_insert > 0))
        nb_desired_values= estimation_rows_to_insert;
      else /* go with the increasing defaults */
1853
      {
1854 1855 1856 1857 1858 1859 1860 1861 1862
        /* avoid overflow in formula, with this if() */
        if (nb_already_reserved_intervals <= AUTO_INC_DEFAULT_NB_MAX_BITS)
        {
          nb_desired_values= AUTO_INC_DEFAULT_NB_ROWS * 
            (1 << nb_already_reserved_intervals);
          set_if_smaller(nb_desired_values, AUTO_INC_DEFAULT_NB_MAX);
        }
        else
          nb_desired_values= AUTO_INC_DEFAULT_NB_MAX;
1863
      }
1864 1865 1866 1867 1868 1869
      /* This call ignores all its parameters but nr, currently */
      get_auto_increment(variables->auto_increment_offset,
                         variables->auto_increment_increment,
                         nb_desired_values, &nr,
                         &nb_reserved_values);
      if (nr == ~(ulonglong) 0)
1870
        DBUG_RETURN(HA_ERR_AUTOINC_READ_FAILED);  // Mark failure
1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882
      
      /*
        That rounding below should not be needed when all engines actually
        respect offset and increment in get_auto_increment(). But they don't
        so we still do it. Wonder if for the not-first-in-index we should do
        it. Hope that this rounding didn't push us out of the interval; even
        if it did we cannot do anything about it (calling the engine again
        will not help as we inserted no row).
      */
      nr= compute_next_insert_id(nr-1, variables);
    }
    
1883
    if (table->s->next_number_keypart == 0)
1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896
    {
      /* We must defer the appending until "nr" has been possibly truncated */
      append= TRUE;
    }
    else
    {
      /*
        For such auto_increment there is no notion of interval, just a
        singleton. The interval is not even stored in
        thd->auto_inc_interval_for_cur_row, so we are sure to call the engine
        for next row.
      */
      DBUG_PRINT("info",("auto_increment: special not-first-in-index"));
1897
    }
1898 1899 1900 1901
  }

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

1902
  if (unlikely(table->next_number_field->store((longlong) nr, TRUE)))
1903
  {
1904
    /*
1905 1906 1907 1908 1909
      first test if the query was aborted due to strict mode constraints
    */
    if (thd->killed == THD::KILL_BAD_DATA)
      DBUG_RETURN(HA_ERR_AUTOINC_ERANGE);

1910
    /*
1911
      field refused this value (overflow) and truncated it, use the result of
1912 1913
      the truncation (which is going to be inserted); however we try to
      decrease it to honour auto_increment_* variables.
1914 1915 1916
      That will shift the left bound of the reserved interval, we don't
      bother shifting the right bound (anyway any other value from this
      interval will cause a duplicate key).
1917
    */
1918 1919 1920
    nr= prev_insert_id(table->next_number_field->val_int(), variables);
    if (unlikely(table->next_number_field->store((longlong) nr, TRUE)))
      nr= table->next_number_field->val_int();
1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
  }
  if (append)
  {
    auto_inc_interval_for_cur_row.replace(nr, nb_reserved_values,
                                          variables->auto_increment_increment);
    /* Row-based replication does not need to store intervals in binlog */
    if (!thd->current_stmt_binlog_row_based)
        thd->auto_inc_intervals_in_cur_stmt_for_binlog.append(auto_inc_interval_for_cur_row.minimum(),
                                                              auto_inc_interval_for_cur_row.values(),
                                                              variables->auto_increment_increment);
unknown's avatar
unknown committed
1931
  }
1932

1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945
  /*
    Record this autogenerated value. If the caller then
    succeeds to insert this value, it will call
    record_first_successful_insert_id_in_cur_stmt()
    which will set first_successful_insert_id_in_cur_stmt if it's not
    already set.
  */
  insert_id_for_cur_row= nr;
  /*
    Set next insert id to point to next auto-increment value to be able to
    handle multi-row statements.
  */
  set_next_insert_id(compute_next_insert_id(nr, variables));
1946

unknown's avatar
unknown committed
1947
  DBUG_RETURN(0);
1948 1949
}

unknown's avatar
unknown committed
1950

1951
/** @brief
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966
  MySQL signal that it changed the column bitmap

  USAGE
    This is for handlers that needs to setup their own column bitmaps.
    Normally the handler should set up their own column bitmaps in
    index_init() or rnd_init() and in any column_bitmaps_signal() call after
    this.

    The handler is allowd to do changes to the bitmap after a index_init or
    rnd_init() call is made as after this, MySQL will not use the bitmap
    for any program logic checking.
*/
void handler::column_bitmaps_signal()
{
  DBUG_ENTER("column_bitmaps_signal");
unknown's avatar
unknown committed
1967 1968
  DBUG_PRINT("info", ("read_set: 0x%lx  write_set: 0x%lx", (long) table->read_set,
                      (long) table->write_set));
1969 1970 1971 1972
  DBUG_VOID_RETURN;
}


1973
/** @brief
1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993
  Reserves an interval of auto_increment values from the handler.

  SYNOPSIS
    get_auto_increment()
    offset              
    increment
    nb_desired_values   how many values we want
    first_value         (OUT) the first value reserved by the handler
    nb_reserved_values  (OUT) how many values the handler reserved

  offset and increment means that we want values to be of the form
  offset + N * increment, where N>=0 is integer.
  If the function sets *first_value to ~(ulonglong)0 it means an error.
  If the function sets *nb_reserved_values to ULONGLONG_MAX it means it has
  reserved to "positive infinite".
*/
void handler::get_auto_increment(ulonglong offset, ulonglong increment,
                                 ulonglong nb_desired_values,
                                 ulonglong *first_value,
                                 ulonglong *nb_reserved_values)
unknown's avatar
unknown committed
1994
{
1995
  ulonglong nr;
unknown's avatar
unknown committed
1996
  int error;
unknown's avatar
unknown committed
1997

unknown's avatar
unknown committed
1998
  (void) extra(HA_EXTRA_KEYREAD);
1999 2000 2001
  table->mark_columns_used_by_index_no_reset(table->s->next_number_index,
                                        table->read_set);
  column_bitmaps_signal();
2002
  index_init(table->s->next_number_index, 1);
2003
  if (table->s->next_number_keypart == 0)
unknown's avatar
unknown committed
2004 2005
  {						// Autoincrement at key-start
    error=index_last(table->record[1]);
2006 2007 2008 2009 2010 2011
    /*
      MySQL implicitely assumes such method does locking (as MySQL decides to
      use nr+increment without checking again with the handler, in
      handler::update_auto_increment()), so reserves to infinite.
    */
    *nb_reserved_values= ULONGLONG_MAX;
unknown's avatar
unknown committed
2012 2013 2014
  }
  else
  {
2015
    uchar key[MAX_KEY_LENGTH];
2016
    key_copy(key, table->record[0],
2017 2018
             table->key_info + table->s->next_number_index,
             table->s->next_number_key_offset);
2019 2020
    error= index_read(table->record[1], key,
                      make_prev_keypart_map(table->s->next_number_keypart),
2021
                      HA_READ_PREFIX_LAST);
2022 2023 2024 2025 2026 2027 2028
    /*
      MySQL needs to call us for next row: assume we are inserting ("a",null)
      here, we return 3, and next this statement will want to insert
      ("b",null): there is no reason why ("b",3+1) would be the good row to
      insert: maybe it already exists, maybe 3+1 is too large...
    */
    *nb_reserved_values= 1;
unknown's avatar
unknown committed
2029 2030
  }

unknown's avatar
unknown committed
2031 2032 2033
  if (error)
    nr=1;
  else
2034 2035
    nr= ((ulonglong) table->next_number_field->
         val_int_offset(table->s->rec_buff_length)+1);
unknown's avatar
unknown committed
2036
  index_end();
unknown's avatar
unknown committed
2037
  (void) extra(HA_EXTRA_NO_KEYREAD);
2038
  *first_value= nr;
unknown's avatar
unknown committed
2039 2040
}

2041

2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058
void handler::ha_release_auto_increment()
{
  release_auto_increment();
  insert_id_for_cur_row= 0;
  auto_inc_interval_for_cur_row.replace(0, 0, 0);
  if (next_insert_id > 0)
  {
    next_insert_id= 0;
    /*
      this statement used forced auto_increment values if there were some,
      wipe them away for other statements.
    */
    table->in_use->auto_inc_intervals_forced.empty();
  }
}


2059
void handler::print_keydup_error(uint key_nr, const char *msg)
2060 2061 2062 2063
{
  /* Write the duplicated key in the error message */
  char key[MAX_KEY_LENGTH];
  String str(key,sizeof(key),system_charset_info);
2064 2065 2066 2067

  if (key_nr == MAX_KEY)
  {
    /* Key is unknown */
2068
    str.copy("", 0, system_charset_info);
2069
    my_printf_error(ER_DUP_ENTRY, msg, MYF(0), str.c_ptr(), "*UNKNOWN*");
2070 2071
  }
  else
2072
  {
2073 2074 2075 2076 2077 2078 2079 2080
    /* Table is opened and defined at this point */
    key_unpack(&str,table,(uint) key_nr);
    uint max_length=MYSQL_ERRMSG_SIZE-(uint) strlen(msg);
    if (str.length() >= max_length)
    {
      str.length(max_length-4);
      str.append(STRING_WITH_LEN("..."));
    }
2081
    my_printf_error(ER_DUP_ENTRY, msg,
2082
		    MYF(0), str.c_ptr(), table->key_info[key_nr].name);
2083 2084 2085 2086
  }
}


2087
/** @brief
2088 2089
  Print error that we got from handler function

unknown's avatar
unknown committed
2090
  NOTE
2091 2092 2093 2094 2095
   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
2096 2097
void handler::print_error(int error, myf errflag)
{
2098
  DBUG_ENTER("handler::print_error");
unknown's avatar
unknown committed
2099 2100 2101 2102
  DBUG_PRINT("enter",("error: %d",error));

  int textno=ER_GET_ERRNO;
  switch (error) {
2103 2104 2105
  case EACCES:
    textno=ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116
  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
2117
  case HA_ERR_WRONG_MRG_TABLE_DEF:
unknown's avatar
unknown committed
2118 2119 2120 2121 2122 2123 2124
    textno=ER_WRONG_MRG_TABLE;
    break;
  case HA_ERR_FOUND_DUPP_KEY:
  {
    uint key_nr=get_dup_key(error);
    if ((int) key_nr >= 0)
    {
unknown's avatar
unknown committed
2125
      print_keydup_error(key_nr, ER(ER_DUP_ENTRY_WITH_KEY_NAME));
unknown's avatar
unknown committed
2126 2127 2128 2129 2130
      DBUG_VOID_RETURN;
    }
    textno=ER_DUP_KEY;
    break;
  }
2131 2132 2133 2134 2135
  case HA_ERR_FOREIGN_DUPLICATE_KEY:
  {
    uint key_nr= get_dup_key(error);
    if ((int) key_nr >= 0)
    {
2136
      uint max_length;
2137 2138 2139 2140 2141
      /* Write the key in the error message */
      char key[MAX_KEY_LENGTH];
      String str(key,sizeof(key),system_charset_info);
      /* Table is opened and defined at this point */
      key_unpack(&str,table,(uint) key_nr);
2142 2143
      max_length= (MYSQL_ERRMSG_SIZE-
                   (uint) strlen(ER(ER_FOREIGN_DUPLICATE_KEY)));
2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155
      if (str.length() >= max_length)
      {
        str.length(max_length-4);
        str.append(STRING_WITH_LEN("..."));
      }
      my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table_share->table_name.str,
        str.c_ptr(), key_nr+1);
      DBUG_VOID_RETURN;
    }
    textno= ER_DUP_KEY;
    break;
  }
2156
  case HA_ERR_NULL_IN_SPATIAL:
2157 2158
    my_error(ER_CANT_CREATE_GEOMETRY_OBJECT, MYF(0));
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2159 2160 2161 2162 2163 2164 2165 2166 2167
  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;
2168 2169 2170
  case HA_ERR_WRONG_IN_RECORD:
    textno= ER_CRASHED_ON_USAGE;
    break;
2171 2172 2173
  case HA_ERR_CRASHED_ON_USAGE:
    textno=ER_CRASHED_ON_USAGE;
    break;
2174 2175 2176
  case HA_ERR_NOT_A_TABLE:
    textno= error;
    break;
2177 2178 2179
  case HA_ERR_CRASHED_ON_REPAIR:
    textno=ER_CRASHED_ON_REPAIR;
    break;
unknown's avatar
unknown committed
2180
  case HA_ERR_OUT_OF_MEM:
2181 2182
    textno=ER_OUT_OF_RESOURCES;
    break;
unknown's avatar
unknown committed
2183 2184 2185 2186 2187 2188 2189 2190 2191 2192
  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:
2193
  case HA_ERR_INDEX_FILE_FULL:
2194
    textno=ER_RECORD_FILE_FULL;
2195
    break;
2196 2197 2198 2199 2200 2201
  case HA_ERR_LOCK_WAIT_TIMEOUT:
    textno=ER_LOCK_WAIT_TIMEOUT;
    break;
  case HA_ERR_LOCK_TABLE_FULL:
    textno=ER_LOCK_TABLE_FULL;
    break;
2202 2203 2204
  case HA_ERR_LOCK_DEADLOCK:
    textno=ER_LOCK_DEADLOCK;
    break;
2205 2206 2207
  case HA_ERR_READ_ONLY_TRANSACTION:
    textno=ER_READ_ONLY_TRANSACTION;
    break;
unknown's avatar
Merge  
unknown committed
2208 2209 2210 2211
  case HA_ERR_CANNOT_ADD_FOREIGN:
    textno=ER_CANNOT_ADD_FOREIGN;
    break;
  case HA_ERR_ROW_IS_REFERENCED:
2212 2213 2214 2215 2216 2217
  {
    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
2218
  case HA_ERR_NO_REFERENCED_ROW:
2219 2220 2221 2222 2223 2224
  {
    String str;
    get_error_message(error, &str);
    my_error(ER_NO_REFERENCED_ROW_2, MYF(0), str.c_ptr_safe());
    DBUG_VOID_RETURN;
  }
2225 2226 2227
  case HA_ERR_TABLE_DEF_CHANGED:
    textno=ER_TABLE_DEF_CHANGED;
    break;
2228
  case HA_ERR_NO_SUCH_TABLE:
unknown's avatar
unknown committed
2229 2230
    my_error(ER_NO_SUCH_TABLE, MYF(0), table_share->db.str,
             table_share->table_name.str);
2231
    break;
2232 2233 2234
  case HA_ERR_RBR_LOGGING_FAILED:
    textno= ER_BINLOG_ROW_LOGGING_FAILED;
    break;
2235 2236 2237 2238 2239 2240 2241 2242 2243
  case HA_ERR_DROP_INDEX_FK:
  {
    const char *ptr= "???";
    uint key_nr= get_dup_key(error);
    if ((int) key_nr >= 0)
      ptr= table->key_info[key_nr].name;
    my_error(ER_DROP_INDEX_FK, MYF(0), ptr);
    DBUG_VOID_RETURN;
  }
unknown's avatar
unknown committed
2244 2245 2246
  case HA_ERR_TABLE_NEEDS_UPGRADE:
    textno=ER_TABLE_NEEDS_UPGRADE;
    break;
2247 2248 2249
  case HA_ERR_TABLE_READONLY:
    textno= ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
2250 2251 2252 2253 2254 2255
  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
2256 2257
  default:
    {
2258 2259 2260
      /* The error was "unknown" to this function.
	 Ask handler if it has got a message for this error */
      bool temporary= FALSE;
2261 2262 2263
      String str;
      temporary= get_error_message(error, &str);
      if (!str.is_empty())
2264
      {
2265
	const char* engine= table_type();
2266
	if (temporary)
2267
	  my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(), engine);
2268
	else
2269
	  my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine);
2270
      }
2271
      else
2272
	my_error(ER_GET_ERRNO,errflag,error);
unknown's avatar
unknown committed
2273 2274 2275
      DBUG_VOID_RETURN;
    }
  }
unknown's avatar
unknown committed
2276
  my_error(textno, errflag, table_share->table_name.str, error);
unknown's avatar
unknown committed
2277 2278 2279
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
2280

2281
/** @brief
2282
   Return an error message specific to this handler
2283

2284
   SYNOPSIS
2285 2286
   error        error code previously returned by handler
   buf          Pointer to String where to add error message
unknown's avatar
unknown committed
2287

2288
   Returns true if this is a temporary error
2289
*/
2290
bool handler::get_error_message(int error, String* buf)
2291
{
unknown's avatar
unknown committed
2292
  return FALSE;
2293 2294 2295
}


unknown's avatar
unknown committed
2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314
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];
2315
        if (field->type() == MYSQL_TYPE_BLOB)
unknown's avatar
unknown committed
2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
        {
          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++)
    {
2337
      if ((*field)->type() == MYSQL_TYPE_NEWDECIMAL)
unknown's avatar
unknown committed
2338 2339 2340
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
2341 2342 2343 2344
      if ((*field)->type() == MYSQL_TYPE_VAR_STRING)
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
unknown's avatar
unknown committed
2345 2346 2347 2348 2349 2350
    }
  }
  return 0;
}


2351
static bool update_frm_version(TABLE *table)
unknown's avatar
unknown committed
2352 2353 2354 2355 2356 2357 2358 2359 2360
{
  char path[FN_REFLEN];
  File file;
  int result= 1;
  DBUG_ENTER("update_frm_version");

  if (table->s->mysql_version != MYSQL_VERSION_ID)
    DBUG_RETURN(0);

unknown's avatar
unknown committed
2361
  strxmov(path, table->s->normalized_path.str, reg_ext, NullS);
unknown's avatar
unknown committed
2362 2363 2364 2365

  if ((file= my_open(path, O_RDWR|O_BINARY, MYF(MY_WME))) >= 0)
  {
    uchar version[4];
unknown's avatar
unknown committed
2366 2367
    char *key= table->s->table_cache_key.str;
    uint key_length= table->s->table_cache_key.length;
unknown's avatar
unknown committed
2368 2369 2370 2371 2372
    TABLE *entry;
    HASH_SEARCH_STATE state;

    int4store(version, MYSQL_VERSION_ID);

2373
    if ((result= my_pwrite(file,(uchar*) version,4,51L,MYF_RW)))
unknown's avatar
unknown committed
2374 2375
      goto err;

2376
    for (entry=(TABLE*) hash_first(&open_cache,(uchar*) key,key_length, &state);
unknown's avatar
unknown committed
2377
         entry;
2378
         entry= (TABLE*) hash_next(&open_cache,(uchar*) key,key_length, &state))
unknown's avatar
unknown committed
2379 2380 2381 2382 2383 2384 2385 2386 2387 2388
      entry->s->mysql_version= MYSQL_VERSION_ID;
  }
err:
  if (file >= 0)
    VOID(my_close(file,MYF(MY_WME)));
  DBUG_RETURN(result);
}



2389 2390
/** @brief
  Return key if error because of duplicated keys */
unknown's avatar
unknown committed
2391 2392
uint handler::get_dup_key(int error)
{
2393
  DBUG_ENTER("handler::get_dup_key");
unknown's avatar
unknown committed
2394
  table->file->errkey  = (uint) -1;
2395 2396 2397
  if (error == HA_ERR_FOUND_DUPP_KEY || error == HA_ERR_FOREIGN_DUPLICATE_KEY ||
      error == HA_ERR_FOUND_DUPP_UNIQUE || error == HA_ERR_NULL_IN_SPATIAL ||
      error == HA_ERR_DROP_INDEX_FK)
unknown's avatar
unknown committed
2398 2399 2400 2401
    info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
  DBUG_RETURN(table->file->errkey);
}

unknown's avatar
unknown committed
2402

2403
/** @brief
2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
  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
2416
	didn't get any other errors than ENOENT
2417
    #   Error
2418
*/
unknown's avatar
unknown committed
2419 2420
int handler::delete_table(const char *name)
{
2421 2422
  int error= 0;
  int enoent_or_zero= ENOENT;                   // Error if no file was deleted
2423
  char buff[FN_REFLEN];
2424

unknown's avatar
unknown committed
2425 2426
  for (const char **ext=bas_ext(); *ext ; ext++)
  {
2427
    fn_format(buff, name, "", *ext, MY_UNPACK_FILENAME|MY_APPEND_EXT);
2428
    if (my_delete_with_symlink(buff, MYF(0)))
unknown's avatar
unknown committed
2429
    {
2430
      if ((error= my_errno) != ENOENT)
unknown's avatar
unknown committed
2431 2432
	break;
    }
2433
    else
2434
      enoent_or_zero= 0;                        // No error for ENOENT
2435
    error= enoent_or_zero;
unknown's avatar
unknown committed
2436
  }
unknown's avatar
unknown committed
2437
  return error;
unknown's avatar
unknown committed
2438 2439 2440 2441 2442
}


int handler::rename_table(const char * from, const char * to)
{
unknown's avatar
unknown committed
2443 2444
  int error= 0;
  for (const char **ext= bas_ext(); *ext ; ext++)
unknown's avatar
unknown committed
2445
  {
unknown's avatar
unknown committed
2446 2447 2448 2449 2450 2451
    if (rename_file_ext(from, to, *ext))
    {
      if ((error=my_errno) != ENOENT)
	break;
      error= 0;
    }
unknown's avatar
unknown committed
2452
  }
unknown's avatar
unknown committed
2453
  return error;
unknown's avatar
unknown committed
2454 2455
}

unknown's avatar
unknown committed
2456 2457 2458 2459 2460 2461 2462 2463

void handler::drop_table(const char *name)
{
  close();
  delete_table(name);
}


2464
/** @brief
unknown's avatar
unknown committed
2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499
   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;
2500
  return update_frm_version(table);
unknown's avatar
unknown committed
2501 2502 2503 2504 2505 2506 2507 2508
}


int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
{
  int result;
  if ((result= repair(thd, check_opt)))
    return result;
2509
  return update_frm_version(table);
unknown's avatar
unknown committed
2510 2511 2512
}


2513
/** @brief
2514 2515 2516 2517 2518 2519
  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.
2520
*/
2521
int ha_enable_transaction(THD *thd, bool on)
2522 2523 2524
{
  int error=0;

2525 2526
  DBUG_ENTER("ha_enable_transaction");
  thd->transaction.on= on;
unknown's avatar
unknown committed
2527
  if (on)
2528 2529 2530 2531 2532 2533 2534
  {
    /*
      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.
    */
2535 2536
    if (!(error= ha_commit_stmt(thd)))
      error= end_trans(thd, COMMIT);
2537
  }
2538 2539 2540
  DBUG_RETURN(error);
}

2541
int handler::index_next_same(uchar *buf, const uchar *key, uint keylen)
unknown's avatar
unknown committed
2542 2543 2544 2545
{
  int error;
  if (!(error=index_next(buf)))
  {
unknown's avatar
unknown committed
2546
    if (key_cmp_if_same(table, key, active_index, keylen))
unknown's avatar
unknown committed
2547 2548 2549 2550 2551 2552 2553 2554 2555
    {
      table->status=STATUS_NOT_FOUND;
      error=HA_ERR_END_OF_FILE;
    }
  }
  return error;
}


2556 2557
void handler::get_dynamic_partition_info(PARTITION_INFO *stat_info,
                                         uint part_id)
2558 2559 2560
{
  info(HA_STATUS_CONST | HA_STATUS_TIME | HA_STATUS_VARIABLE |
       HA_STATUS_NO_LOCK);
2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
  stat_info->records=              stats.records;
  stat_info->mean_rec_length=      stats.mean_rec_length;
  stat_info->data_file_length=     stats.data_file_length;
  stat_info->max_data_file_length= stats.max_data_file_length;
  stat_info->index_file_length=    stats.index_file_length;
  stat_info->delete_length=        stats.delete_length;
  stat_info->create_time=          stats.create_time;
  stat_info->update_time=          stats.update_time;
  stat_info->check_time=           stats.check_time;
  stat_info->check_sum=            0;
2571
  if (table_flags() & (ulong) HA_HAS_CHECKSUM)
2572
    stat_info->check_sum= checksum();
2573 2574 2575 2576
  return;
}


unknown's avatar
unknown committed
2577 2578 2579 2580
/****************************************************************************
** Some general functions that isn't in the handler class
****************************************************************************/

2581
/** @brief
2582
  Initiates table-file and calls appropriate database-creator
unknown's avatar
unknown committed
2583 2584 2585

  NOTES
    We must have a write lock on LOCK_open to be sure no other thread
2586
    interferes with table
unknown's avatar
unknown committed
2587 2588 2589 2590
    
  RETURN
   0  ok
   1  error
unknown's avatar
unknown committed
2591
*/
unknown's avatar
unknown committed
2592 2593 2594
int ha_create_table(THD *thd, const char *path,
                    const char *db, const char *table_name,
                    HA_CREATE_INFO *create_info,
unknown's avatar
unknown committed
2595 2596
		    bool update_create_info)
{
unknown's avatar
unknown committed
2597
  int error= 1;
unknown's avatar
unknown committed
2598
  TABLE table;
unknown's avatar
unknown committed
2599
  char name_buff[FN_REFLEN];
unknown's avatar
unknown committed
2600 2601
  const char *name;
  TABLE_SHARE share;
unknown's avatar
unknown committed
2602
  DBUG_ENTER("ha_create_table");
unknown's avatar
unknown committed
2603 2604 2605
  
  init_tmp_table_share(&share, db, 0, table_name, path);
  if (open_table_def(thd, &share, 0) ||
unknown's avatar
unknown committed
2606 2607
      open_table_from_share(thd, &share, "", 0, (uint) READ_ALL, 0, &table,
                            TRUE))
unknown's avatar
unknown committed
2608
    goto err;
unknown's avatar
unknown committed
2609 2610 2611

  if (update_create_info)
    update_create_info_from_table(create_info, &table);
unknown's avatar
unknown committed
2612

2613
  name= check_lowercase_names(table.file, share.path.str, name_buff);
unknown's avatar
unknown committed
2614

unknown's avatar
unknown committed
2615 2616
  error= table.file->create(name, &table, create_info);
  VOID(closefrm(&table, 0));
unknown's avatar
unknown committed
2617
  if (error)
unknown's avatar
unknown committed
2618 2619 2620 2621 2622 2623
  {
    strxmov(name_buff, db, ".", table_name, NullS);
    my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), name_buff, error);
  }
err:
  free_table_share(&share);
unknown's avatar
unknown committed
2624 2625 2626
  DBUG_RETURN(error != 0);
}

2627
/** @brief
unknown's avatar
unknown committed
2628 2629 2630 2631
  Try to discover table from engine

  NOTES
    If found, write the frm file to disk.
2632

2633
  RETURN VALUES:
unknown's avatar
unknown committed
2634 2635 2636
  -1    Table did not exists
   0    Table created ok
   > 0  Error, table existed but could not be created
2637 2638

*/
unknown's avatar
unknown committed
2639
int ha_create_table_from_engine(THD* thd, const char *db, const char *name)
2640
{
unknown's avatar
unknown committed
2641
  int error;
2642 2643
  uchar *frmblob;
  size_t frmlen;
2644 2645 2646
  char path[FN_REFLEN];
  HA_CREATE_INFO create_info;
  TABLE table;
unknown's avatar
unknown committed
2647
  TABLE_SHARE share;
2648
  DBUG_ENTER("ha_create_table_from_engine");
unknown's avatar
unknown committed
2649
  DBUG_PRINT("enter", ("name '%s'.'%s'", db, name));
2650

2651
  bzero((uchar*) &create_info,sizeof(create_info));
2652
  if ((error= ha_discover(thd, db, name, &frmblob, &frmlen)))
2653
  {
unknown's avatar
unknown committed
2654
    /* Table could not be discovered and thus not created */
2655
    DBUG_RETURN(error);
2656 2657
  }

unknown's avatar
unknown committed
2658
  /*
2659 2660
    Table exists in handler and could be discovered
    frmblob and frmlen are set, write the frm to disk
unknown's avatar
unknown committed
2661
  */
2662

2663 2664
  (void)strxnmov(path,FN_REFLEN-1,mysql_data_home,FN_ROOTDIR,
                 db,FN_ROOTDIR,name,NullS);
2665
  // Save the frm file
unknown's avatar
unknown committed
2666
  error= writefrm(path, frmblob, frmlen);
2667
  my_free(frmblob, MYF(0));
unknown's avatar
unknown committed
2668
  if (error)
2669
    DBUG_RETURN(2);
2670

unknown's avatar
unknown committed
2671 2672 2673 2674 2675
  init_tmp_table_share(&share, db, 0, name, path);
  if (open_table_def(thd, &share, 0))
  {
    DBUG_RETURN(3);
  }
unknown's avatar
unknown committed
2676
  if (open_table_from_share(thd, &share, "" ,0, 0, 0, &table, FALSE))
unknown's avatar
unknown committed
2677 2678
  {
    free_table_share(&share);
2679
    DBUG_RETURN(3);
unknown's avatar
unknown committed
2680
  }
2681

2682
  update_create_info_from_table(&create_info, &table);
2683
  create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE;
2684

2685
  check_lowercase_names(table.file, path, path);
2686
  error=table.file->create(path,&table,&create_info);
unknown's avatar
unknown committed
2687
  VOID(closefrm(&table, 1));
2688

2689
  DBUG_RETURN(error != 0);
2690 2691
}

2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708
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)
*****************************************************************************/

2709 2710 2711
/** @brief
  Init a key cache if it has not been initied before
*/
unknown's avatar
unknown committed
2712
int ha_init_key_cache(const char *name, KEY_CACHE *key_cache)
unknown's avatar
unknown committed
2713
{
2714 2715
  DBUG_ENTER("ha_init_key_cache");

unknown's avatar
unknown committed
2716
  if (!key_cache->key_cache_inited)
2717 2718
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
2719 2720
    ulong tmp_buff_size= (ulong) key_cache->param_buff_size;
    uint tmp_block_size= (uint) key_cache->param_block_size;
unknown's avatar
unknown committed
2721 2722
    uint division_limit= key_cache->param_division_limit;
    uint age_threshold=  key_cache->param_age_threshold;
2723
    pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2724
    DBUG_RETURN(!init_key_cache(key_cache,
2725 2726
				tmp_block_size,
				tmp_buff_size,
unknown's avatar
unknown committed
2727
				division_limit, age_threshold));
2728
  }
2729
  DBUG_RETURN(0);
unknown's avatar
unknown committed
2730 2731
}

2732

2733 2734 2735
/** @brief
  Resize key cache
*/
unknown's avatar
unknown committed
2736
int ha_resize_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
2737
{
2738 2739
  DBUG_ENTER("ha_resize_key_cache");

unknown's avatar
unknown committed
2740
  if (key_cache->key_cache_inited)
2741 2742
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2743 2744 2745 2746
    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;
2747
    pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
2748 2749 2750
    DBUG_RETURN(!resize_key_cache(key_cache, tmp_block_size,
				  tmp_buff_size,
				  division_limit, age_threshold));
2751
  }
2752
  DBUG_RETURN(0);
2753 2754
}

2755

2756 2757 2758
/** @brief
  Change parameters for key cache (like size)
*/
unknown's avatar
unknown committed
2759
int ha_change_key_cache_param(KEY_CACHE *key_cache)
2760
{
unknown's avatar
unknown committed
2761 2762 2763 2764 2765 2766 2767 2768
  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);
  }
2769 2770
  return 0;
}
unknown's avatar
unknown committed
2771

2772 2773 2774
/** @brief
  Free memory allocated by a key cache
*/
unknown's avatar
unknown committed
2775
int ha_end_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
2776
{
unknown's avatar
unknown committed
2777
  end_key_cache(key_cache, 1);		// Can never fail
2778
  return 0;
unknown's avatar
unknown committed
2779
}
unknown's avatar
unknown committed
2780

2781 2782 2783
/** @brief
  Move all tables from one key cache to another one
*/
unknown's avatar
unknown committed
2784 2785
int ha_change_key_cache(KEY_CACHE *old_key_cache,
			KEY_CACHE *new_key_cache)
unknown's avatar
unknown committed
2786
{
2787 2788
  mi_change_key_cache(old_key_cache, new_key_cache);
  return 0;
unknown's avatar
unknown committed
2789
}
2790 2791


2792
/** @brief
unknown's avatar
unknown committed
2793
  Try to discover one table from handler(s)
unknown's avatar
unknown committed
2794 2795

  RETURN
2796 2797 2798
   -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
2799
*/
2800
struct st_discover_args
unknown's avatar
unknown committed
2801 2802 2803
{
  const char *db;
  const char *name;
2804 2805
  uchar **frmblob; 
  size_t *frmlen;
unknown's avatar
unknown committed
2806 2807
};

unknown's avatar
unknown committed
2808
static my_bool discover_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
2809 2810 2811
                                   void *arg)
{
  st_discover_args *vargs= (st_discover_args *)arg;
unknown's avatar
unknown committed
2812
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
2813
  if (hton->state == SHOW_OPTION_YES && hton->discover &&
2814 2815 2816
      (!(hton->discover(hton, thd, vargs->db, vargs->name, 
                        vargs->frmblob, 
                        vargs->frmlen))))
unknown's avatar
unknown committed
2817 2818 2819 2820 2821
    return TRUE;

  return FALSE;
}

unknown's avatar
unknown committed
2822
int ha_discover(THD *thd, const char *db, const char *name,
2823
		uchar **frmblob, size_t *frmlen)
unknown's avatar
unknown committed
2824
{
2825
  int error= -1; // Table does not exist in any handler
unknown's avatar
unknown committed
2826
  DBUG_ENTER("ha_discover");
2827
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
unknown's avatar
unknown committed
2828 2829
  st_discover_args args= {db, name, frmblob, frmlen};

2830 2831
  if (is_prefix(name,tmp_file_prefix)) /* skip temporary tables */
    DBUG_RETURN(error);
unknown's avatar
unknown committed
2832 2833 2834 2835 2836

  if (plugin_foreach(thd, discover_handlerton,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &args))
    error= 0;

unknown's avatar
unknown committed
2837
  if (!error)
2838
    status_var_increment(thd->status_var.ha_discover_count);
unknown's avatar
unknown committed
2839 2840 2841 2842
  DBUG_RETURN(error);
}


2843
/** @brief
2844
  Call this function in order to give the handler the possibility 
2845 2846
  to ask engine if there are any new tables that should be written to disk 
  or any dropped tables that need to be removed from disk
2847
*/
2848
struct st_find_files_args
2849 2850 2851 2852 2853 2854 2855 2856
{
  const char *db;
  const char *path;
  const char *wild;
  bool dir;
  List<char> *files;
};

unknown's avatar
unknown committed
2857
static my_bool find_files_handlerton(THD *thd, plugin_ref plugin,
2858 2859 2860
                                   void *arg)
{
  st_find_files_args *vargs= (st_find_files_args *)arg;
unknown's avatar
unknown committed
2861
  handlerton *hton= plugin_data(plugin, handlerton *);
2862 2863 2864


  if (hton->state == SHOW_OPTION_YES && hton->find_files)
2865
      if (hton->find_files(hton, thd, vargs->db, vargs->path, vargs->wild, 
2866 2867 2868 2869 2870
                          vargs->dir, vargs->files))
        return TRUE;

  return FALSE;
}
2871

2872 2873
int
ha_find_files(THD *thd,const char *db,const char *path,
unknown's avatar
unknown committed
2874
	      const char *wild, bool dir, List<char> *files)
2875 2876
{
  int error= 0;
2877
  DBUG_ENTER("ha_find_files");
unknown's avatar
unknown committed
2878 2879
  DBUG_PRINT("enter", ("db: '%s'  path: '%s'  wild: '%s'  dir: %d", 
		       db, path, wild ? wild : "NULL", dir));
2880 2881 2882 2883 2884
  st_find_files_args args= {db, path, wild, dir, files};

  plugin_foreach(thd, find_files_handlerton,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &args);
  /* The return value is not currently used */
2885 2886 2887
  DBUG_RETURN(error);
}

2888
/*
2889 2890 2891
  Ask handler if the table exists in engine

  RETURN
2892 2893 2894 2895 2896
    HA_ERR_NO_SUCH_TABLE     Table does not exist
    HA_ERR_TABLE_EXIST       Table exists
    #                        Error code

 */
2897

2898
struct st_table_exists_in_engine_args
2899 2900 2901
{
  const char *db;
  const char *name;
2902
  int err;
2903 2904
};

unknown's avatar
unknown committed
2905
static my_bool table_exists_in_engine_handlerton(THD *thd, plugin_ref plugin,
2906 2907 2908
                                   void *arg)
{
  st_table_exists_in_engine_args *vargs= (st_table_exists_in_engine_args *)arg;
unknown's avatar
unknown committed
2909
  handlerton *hton= plugin_data(plugin, handlerton *);
2910

2911 2912
  int err= HA_ERR_NO_SUCH_TABLE;

2913
  if (hton->state == SHOW_OPTION_YES && hton->table_exists_in_engine)
2914 2915 2916 2917 2918
    err = hton->table_exists_in_engine(hton, thd, vargs->db, vargs->name);

  vargs->err = err;
  if (vargs->err == HA_ERR_TABLE_EXIST)
    return TRUE;
2919 2920 2921 2922

  return FALSE;
}

2923
int ha_table_exists_in_engine(THD* thd, const char* db, const char* name)
2924
{
2925
  DBUG_ENTER("ha_table_exists_in_engine");
2926
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
2927 2928
  st_table_exists_in_engine_args args= {db, name, HA_ERR_NO_SUCH_TABLE};
  plugin_foreach(thd, table_exists_in_engine_handlerton,
2929
                 MYSQL_STORAGE_ENGINE_PLUGIN, &args);
2930 2931
  DBUG_PRINT("exit", ("error: %d", args.err));
  DBUG_RETURN(args.err);
2932 2933
}

unknown's avatar
unknown committed
2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953
#ifdef HAVE_NDB_BINLOG
/*
  TODO: change this into a dynamic struct
  List<handlerton> does not work as
  1. binlog_end is called when MEM_ROOT is gone
  2. cannot work with thd MEM_ROOT as memory should be freed
*/
#define MAX_HTON_LIST_ST 63
struct hton_list_st
{
  handlerton *hton[MAX_HTON_LIST_ST];
  uint sz;
};

struct binlog_func_st
{
  enum_binlog_func fn;
  void *arg;
};

2954
/** @brief
unknown's avatar
unknown committed
2955 2956
  Listing handlertons first to avoid recursive calls and deadlock
*/
unknown's avatar
unknown committed
2957
static my_bool binlog_func_list(THD *thd, plugin_ref plugin, void *arg)
unknown's avatar
unknown committed
2958 2959
{
  hton_list_st *hton_list= (hton_list_st *)arg;
unknown's avatar
unknown committed
2960
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977
  if (hton->state == SHOW_OPTION_YES && hton->binlog_func)
  {
    uint sz= hton_list->sz;
    if (sz == MAX_HTON_LIST_ST-1)
    {
      /* list full */
      return FALSE;
    }
    hton_list->hton[sz]= hton;
    hton_list->sz= sz+1;
  }
  return FALSE;
}

static my_bool binlog_func_foreach(THD *thd, binlog_func_st *bfn)
{
  hton_list_st hton_list;
2978 2979
  uint i, sz;

unknown's avatar
unknown committed
2980 2981 2982 2983
  hton_list.sz= 0;
  plugin_foreach(thd, binlog_func_list,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &hton_list);

2984 2985
  for (i= 0, sz= hton_list.sz; i < sz ; i++)
    hton_list.hton[i]->binlog_func(hton_list.hton[i], thd, bfn->fn, bfn->arg);
unknown's avatar
unknown committed
2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018
  return FALSE;
}

int ha_reset_logs(THD *thd)
{
  binlog_func_st bfn= {BFN_RESET_LOGS, 0};
  binlog_func_foreach(thd, &bfn);
  return 0;
}

void ha_reset_slave(THD* thd)
{
  binlog_func_st bfn= {BFN_RESET_SLAVE, 0};
  binlog_func_foreach(thd, &bfn);
}

void ha_binlog_wait(THD* thd)
{
  binlog_func_st bfn= {BFN_BINLOG_WAIT, 0};
  binlog_func_foreach(thd, &bfn);
}

int ha_binlog_end(THD* thd)
{
  binlog_func_st bfn= {BFN_BINLOG_END, 0};
  binlog_func_foreach(thd, &bfn);
  return 0;
}

int ha_binlog_index_purge_file(THD *thd, const char *file)
{
  binlog_func_st bfn= {BFN_BINLOG_PURGE_FILE, (void *)file};
  binlog_func_foreach(thd, &bfn);
unknown's avatar
unknown committed
3019
  return 0;
unknown's avatar
unknown committed
3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030
}

struct binlog_log_query_st
{
  enum_binlog_command binlog_command;
  const char *query;
  uint query_length;
  const char *db;
  const char *table_name;
};

3031
static my_bool binlog_log_query_handlerton2(THD *thd,
3032
                                            handlerton *hton,
3033
                                            void *args)
unknown's avatar
unknown committed
3034 3035 3036
{
  struct binlog_log_query_st *b= (struct binlog_log_query_st*)args;
  if (hton->state == SHOW_OPTION_YES && hton->binlog_log_query)
3037
    hton->binlog_log_query(hton, thd,
unknown's avatar
unknown committed
3038 3039 3040 3041 3042 3043 3044 3045
                           b->binlog_command,
                           b->query,
                           b->query_length,
                           b->db,
                           b->table_name);
  return FALSE;
}

3046
static my_bool binlog_log_query_handlerton(THD *thd,
unknown's avatar
unknown committed
3047
                                           plugin_ref plugin,
3048 3049
                                           void *args)
{
unknown's avatar
unknown committed
3050
  return binlog_log_query_handlerton2(thd, plugin_data(plugin, handlerton *), args);
3051 3052
}

3053
void ha_binlog_log_query(THD *thd, handlerton *hton,
3054
                         enum_binlog_command binlog_command,
unknown's avatar
unknown committed
3055 3056 3057 3058 3059 3060 3061 3062 3063
                         const char *query, uint query_length,
                         const char *db, const char *table_name)
{
  struct binlog_log_query_st b;
  b.binlog_command= binlog_command;
  b.query= query;
  b.query_length= query_length;
  b.db= db;
  b.table_name= table_name;
3064 3065 3066 3067 3068
  if (hton == 0)
    plugin_foreach(thd, binlog_log_query_handlerton,
                   MYSQL_STORAGE_ENGINE_PLUGIN, &b);
  else
    binlog_log_query_handlerton2(thd, hton, &b);
unknown's avatar
unknown committed
3069 3070
}
#endif
3071

3072
/** @brief
unknown's avatar
unknown committed
3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104
  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;

3105 3106 3107
  table->mark_columns_used_by_index_no_reset(active_index, table->read_set);
  table->column_bitmaps_set(table->read_set, table->write_set);

unknown's avatar
unknown committed
3108 3109 3110 3111
  for (multi_range_curr= ranges, multi_range_end= ranges + range_count;
       multi_range_curr < multi_range_end;
       multi_range_curr++)
  {
3112
    result= read_range_first(multi_range_curr->start_key.keypart_map ?
unknown's avatar
unknown committed
3113
                             &multi_range_curr->start_key : 0,
3114
                             multi_range_curr->end_key.keypart_map ?
unknown's avatar
unknown committed
3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127
                             &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);
}


3128
/** @brief
unknown's avatar
unknown committed
3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178
  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++)
    {
3179
      result= read_range_first(multi_range_curr->start_key.keypart_map ?
unknown's avatar
unknown committed
3180
                               &multi_range_curr->start_key : 0,
3181
                               multi_range_curr->end_key.keypart_map ?
unknown's avatar
unknown committed
3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197
                               &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);
}


3198
/** @brief
3199 3200 3201 3202 3203 3204 3205
  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
unknown committed
3206
    eq_range_arg	Set to 1 if start_key == end_key		
3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218
    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
3219
			      bool eq_range_arg, bool sorted)
3220 3221 3222 3223
{
  int result;
  DBUG_ENTER("handler::read_range_first");

unknown's avatar
unknown committed
3224
  eq_range= eq_range_arg;
3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239
  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,
3240
                       start_key->keypart_map,
3241 3242
		       start_key->flag);
  if (result)
unknown's avatar
unknown committed
3243 3244 3245
    DBUG_RETURN((result == HA_ERR_KEY_NOT_FOUND) 
		? HA_ERR_END_OF_FILE
		: result);
3246 3247 3248 3249 3250

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


3251
/** @brief
3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264
  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
3265
int handler::read_range_next()
3266 3267 3268 3269 3270
{
  int result;
  DBUG_ENTER("handler::read_range_next");

  if (eq_range)
unknown's avatar
unknown committed
3271 3272 3273 3274 3275 3276 3277
  {
    /* 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]);
3278 3279 3280 3281 3282 3283
  if (result)
    DBUG_RETURN(result);
  DBUG_RETURN(compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
}


3284
/** @brief
unknown's avatar
unknown committed
3285
  Compare if found key (in row) is over max-value
3286 3287 3288

  SYNOPSIS
    compare_key
unknown's avatar
unknown committed
3289
    range		range to compare to row. May be 0 for no range
3290 3291
 
  NOTES
unknown's avatar
unknown committed
3292
    See key.cc::key_cmp() for details
3293 3294

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

3297 3298 3299 3300 3301 3302
    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
3303
  int cmp;
3304 3305
  if (!range)
    return 0;					// No max range
unknown's avatar
unknown committed
3306 3307 3308 3309
  cmp= key_cmp(range_key_part, range->key, range->length);
  if (!cmp)
    cmp= key_compare_result_on_equal;
  return cmp;
3310
}
unknown's avatar
unknown committed
3311

3312

3313
int handler::index_read_idx(uchar * buf, uint index, const uchar * key,
unknown's avatar
unknown committed
3314 3315
                            key_part_map keypart_map,
                            enum ha_rkey_function find_flag)
unknown's avatar
unknown committed
3316
{
3317 3318
  int error, error1;
  error= index_init(index, 0);
unknown's avatar
unknown committed
3319
  if (!error)
3320 3321 3322 3323 3324
  {
    error= index_read(buf, key, keypart_map, find_flag);
    error1= index_end();
  }
  return error ?  error : error1;
unknown's avatar
unknown committed
3325 3326
}

3327

3328
/** @brief
3329 3330 3331 3332
  Returns a list of all known extensions.

  SYNOPSIS
    ha_known_exts()
unknown's avatar
unknown committed
3333

3334 3335
  NOTES
    No mutexes, worst case race is a minor surplus memory allocation
3336 3337
    We have to recreate the extension map if mysqld is restarted (for example
    within libmysqld)
3338 3339 3340 3341

  RETURN VALUE
    pointer		pointer to TYPELIB structure
*/
unknown's avatar
unknown committed
3342
static my_bool exts_handlerton(THD *unused, plugin_ref plugin,
unknown's avatar
unknown committed
3343 3344 3345
                               void *arg)
{
  List<char> *found_exts= (List<char> *) arg;
unknown's avatar
unknown committed
3346
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
3347 3348
  handler *file;
  if (hton->state == SHOW_OPTION_YES && hton->create &&
3349
      (file= hton->create(hton, (TABLE_SHARE*) 0, current_thd->mem_root)))
unknown's avatar
unknown committed
3350 3351 3352
  {
    List_iterator_fast<char> it(*found_exts);
    const char **ext, *old_ext;
unknown's avatar
unknown committed
3353

unknown's avatar
unknown committed
3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370
    for (ext= file->bas_ext(); *ext; ext++)
    {
      while ((old_ext= it++))
      {
        if (!strcmp(old_ext, *ext))
	  break;
      }
      if (!old_ext)
        found_exts->push_back((char *) *ext);

      it.rewind();
    }
    delete file;
  }
  return FALSE;
}

3371 3372
TYPELIB *ha_known_exts(void)
{
3373
  if (!known_extensions.type_names || mysys_usage_id != known_extensions_id)
3374 3375
  {
    List<char> found_exts;
3376 3377 3378
    const char **ext, *old_ext;

    known_extensions_id= mysys_usage_id;
3379 3380
    found_exts.push_back((char*) TRG_EXT);
    found_exts.push_back((char*) TRN_EXT);
unknown's avatar
unknown committed
3381 3382

    plugin_foreach(NULL, exts_handlerton,
unknown's avatar
unknown committed
3383 3384
                   MYSQL_STORAGE_ENGINE_PLUGIN, &found_exts);

3385 3386 3387
    ext= (const char **) my_once_alloc(sizeof(char *)*
                                       (found_exts.elements+1),
                                       MYF(MY_WME | MY_FAE));
unknown's avatar
unknown committed
3388

3389
    DBUG_ASSERT(ext != 0);
3390 3391
    known_extensions.count= found_exts.elements;
    known_extensions.type_names= ext;
3392

unknown's avatar
unknown committed
3393
    List_iterator_fast<char> it(found_exts);
3394 3395 3396
    while ((old_ext= it++))
      *ext++= old_ext;
    *ext= 0;
3397 3398 3399
  }
  return &known_extensions;
}
unknown's avatar
unknown committed
3400

3401

unknown's avatar
unknown committed
3402 3403 3404
static bool stat_print(THD *thd, const char *type, uint type_len,
                       const char *file, uint file_len,
                       const char *status, uint status_len)
3405 3406 3407
{
  Protocol *protocol= thd->protocol;
  protocol->prepare_for_resend();
unknown's avatar
unknown committed
3408 3409 3410
  protocol->store(type, type_len, system_charset_info);
  protocol->store(file, file_len, system_charset_info);
  protocol->store(status, status_len, system_charset_info);
3411 3412 3413 3414 3415
  if (protocol->write())
    return TRUE;
  return FALSE;
}

unknown's avatar
unknown committed
3416

unknown's avatar
unknown committed
3417
static my_bool showstat_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
3418 3419 3420
                                   void *arg)
{
  enum ha_stat_type stat= *(enum ha_stat_type *) arg;
unknown's avatar
unknown committed
3421
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
3422
  if (hton->state == SHOW_OPTION_YES && hton->show_status &&
3423
      hton->show_status(hton, thd, stat_print, stat))
unknown's avatar
unknown committed
3424 3425 3426 3427 3428
    return TRUE;
  return FALSE;
}

bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat)
3429 3430 3431
{
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
unknown's avatar
unknown committed
3432
  bool result;
3433 3434 3435 3436 3437 3438 3439 3440 3441

  field_list.push_back(new Item_empty_string("Type",10));
  field_list.push_back(new Item_empty_string("Name",FN_REFLEN));
  field_list.push_back(new Item_empty_string("Status",10));

  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
    return TRUE;

unknown's avatar
unknown committed
3442
  if (db_type == NULL)
3443
  {
unknown's avatar
unknown committed
3444
    result= plugin_foreach(thd, showstat_handlerton,
unknown's avatar
unknown committed
3445 3446 3447 3448 3449
                           MYSQL_STORAGE_ENGINE_PLUGIN, &stat);
  }
  else
  {
    if (db_type->state != SHOW_OPTION_YES)
unknown's avatar
unknown committed
3450
    {
unknown's avatar
unknown committed
3451 3452
      const LEX_STRING *name=&hton2plugin[db_type->slot]->name;
      result= stat_print(thd, name->str, name->length,
unknown's avatar
unknown committed
3453
                         "", 0, "DISABLED", 8) ? 1 : 0;
unknown's avatar
unknown committed
3454
    }
unknown's avatar
unknown committed
3455
    else
unknown's avatar
unknown committed
3456
      result= db_type->show_status &&
3457
              db_type->show_status(db_type, thd, stat_print, stat) ? 1 : 0;
3458 3459
  }

unknown's avatar
unknown committed
3460 3461 3462
  if (!result)
    send_eof(thd);
  return result;
3463 3464
}

3465 3466 3467 3468 3469
/*
  Function to check if the conditions for row-based binlogging is
  correct for the table.

  A row in the given table should be replicated if:
3470
  - Row-based replication is enabled in the current thread
3471
  - The binlog is enabled
3472 3473 3474
  - It is not a temporary table
  - The binary log is open
  - The database the table resides in shall be binlogged (binlog_*_db rules)
3475
  - table is not mysql.event
3476 3477
*/

3478 3479 3480 3481
/* The Sun compiler cannot instantiate the template below if this is
   declared static, but it works by putting it into an anonymous
   namespace. */
namespace {
3482
  bool check_table_binlog_row_based(THD *thd, TABLE *table)
3483
  {
3484
    if (table->s->cached_row_logging_check == -1)
3485 3486 3487
    {
      int const check(table->s->tmp_table == NO_TMP_TABLE &&
                      binlog_filter->db_ok(table->s->db.str) &&
3488
                      !table->no_replicate);
3489 3490
      table->s->cached_row_logging_check= check;
    }
3491 3492 3493 3494

    DBUG_ASSERT(table->s->cached_row_logging_check == 0 ||
                table->s->cached_row_logging_check == 1);

3495 3496 3497 3498
    return (thd->current_stmt_binlog_row_based &&
            (thd->options & OPTION_BIN_LOG) &&
            mysql_bin_log.is_open() &&
            table->s->cached_row_logging_check);
3499
  }
3500 3501
}

3502
/** @brief
3503 3504 3505
   Write table maps for all (manually or automatically) locked tables
   to the binary log.

3506 3507 3508 3509 3510 3511 3512 3513 3514
   SYNOPSIS
     write_locked_table_maps()
       thd     Pointer to THD structure

   DESCRIPTION
       This function will generate and write table maps for all tables
       that are locked by the thread 'thd'.  Either manually locked
       (stored in THD::locked_tables) and automatically locked (stored
       in THD::lock) are considered.
3515
   
3516 3517 3518 3519 3520 3521 3522
   RETURN VALUE
       0   All OK
       1   Failed to write all table maps

   SEE ALSO
       THD::lock
       THD::locked_tables
3523
*/
3524
namespace
3525
{
3526
  int write_locked_table_maps(THD *thd)
3527
  {
3528
    DBUG_ENTER("write_locked_table_maps");
unknown's avatar
unknown committed
3529 3530 3531 3532
    DBUG_PRINT("enter", ("thd: 0x%lx  thd->lock: 0x%lx  thd->locked_tables: 0x%lx  "
                         "thd->extra_lock: 0x%lx",
                         (long) thd, (long) thd->lock,
                         (long) thd->locked_tables, (long) thd->extra_lock));
3533 3534

    if (thd->get_binlog_table_maps() == 0)
3535
    {
3536 3537 3538 3539 3540
      MYSQL_LOCK *locks[3];
      locks[0]= thd->extra_lock;
      locks[1]= thd->lock;
      locks[2]= thd->locked_tables;
      for (uint i= 0 ; i < sizeof(locks)/sizeof(*locks) ; ++i )
3541
      {
3542 3543 3544 3545 3546 3547 3548 3549
        MYSQL_LOCK const *const lock= locks[i];
        if (lock == NULL)
          continue;

        TABLE **const end_ptr= lock->table + lock->table_count;
        for (TABLE **table_ptr= lock->table ; 
             table_ptr != end_ptr ;
             ++table_ptr)
3550
        {
3551
          TABLE *const table= *table_ptr;
unknown's avatar
unknown committed
3552
          DBUG_PRINT("info", ("Checking table %s", table->s->table_name.str));
3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564
          if (table->current_lock == F_WRLCK &&
              check_table_binlog_row_based(thd, table))
          {
            int const has_trans= table->file->has_transactions();
            int const error= thd->binlog_write_table_map(table, has_trans);
            /*
              If an error occurs, it is the responsibility of the caller to
              roll back the transaction.
            */
            if (unlikely(error))
              DBUG_RETURN(1);
          }
3565
        }
3566 3567
      }
    }
3568
    DBUG_RETURN(0);
3569
  }
3570

3571 3572
  template<class RowsEventT> int
  binlog_log_row(TABLE* table,
3573 3574
                 const uchar *before_record,
                 const uchar *after_record)
3575
  {
3576
    if (table->file->ha_table_flags() & HA_HAS_OWN_BINLOGGING)
3577 3578 3579
      return 0;
    bool error= 0;
    THD *const thd= table->in_use;
3580

3581
    if (check_table_binlog_row_based(thd, table))
3582
    {
3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596
      MY_BITMAP cols;
      /* Potential buffer on the stack for the bitmap */
      uint32 bitbuf[BITMAP_STACKBUF_SIZE/sizeof(uint32)];
      uint n_fields= table->s->fields;
      my_bool use_bitbuf= n_fields <= sizeof(bitbuf)*8;

      /*
        If there are no table maps written to the binary log, this is
        the first row handled in this statement. In that case, we need
        to write table maps for all locked tables to the binary log.
      */
      if (likely(!(error= bitmap_init(&cols,
                                      use_bitbuf ? bitbuf : NULL,
                                      (n_fields + 7) & ~7UL,
unknown's avatar
unknown committed
3597
                                      FALSE))))
3598
      {
3599 3600 3601 3602 3603
        bitmap_set_all(&cols);
        if (likely(!(error= write_locked_table_maps(thd))))
        {
          error=
            RowsEventT::binlog_row_logging_function(thd, table,
unknown's avatar
unknown committed
3604 3605
                                                    table->file->
                                                    has_transactions(),
3606
                                                    &cols, table->s->fields,
unknown's avatar
unknown committed
3607 3608
                                                    before_record,
                                                    after_record);
3609 3610 3611
        }
        if (!use_bitbuf)
          bitmap_free(&cols);
3612
      }
3613
    }
3614
    return error ? HA_ERR_RBR_LOGGING_FAILED : 0;
3615 3616
  }

3617 3618 3619 3620
  /*
    Instantiate the versions we need for the above template function,
    because we have -fno-implicit-template as compiling option.
  */
3621

3622
  template int
3623
  binlog_log_row<Write_rows_log_event>(TABLE *, const uchar *, const uchar *);
3624

3625
  template int
3626
  binlog_log_row<Delete_rows_log_event>(TABLE *, const uchar *, const uchar *);
3627

3628
  template int
3629
  binlog_log_row<Update_rows_log_event>(TABLE *, const uchar *, const uchar *);
3630
}
3631 3632


3633
int handler::ha_external_lock(THD *thd, int lock_type)
3634
{
3635
  DBUG_ENTER("handler::ha_external_lock");
3636 3637 3638 3639 3640 3641
  /*
    Whether this is lock or unlock, this should be true, and is to verify that
    if get_auto_increment() was called (thus may have reserved intervals or
    taken a table lock), ha_release_auto_increment() was too.
  */
  DBUG_ASSERT(next_insert_id == 0);
3642 3643 3644 3645 3646 3647 3648 3649 3650

  /*
    We cache the table flags if the locking succeeded. Otherwise, we
    keep them as they were when they were fetched in ha_open().
  */
  int error= external_lock(thd, lock_type);
  if (error == 0)
    cached_table_flags= table_flags();
  DBUG_RETURN(error);
3651 3652
}

3653

3654
/** @brief
3655 3656 3657 3658 3659
  Check handler usage and reset state of file to after 'open'
*/
int handler::ha_reset()
{
  DBUG_ENTER("ha_reset");
unknown's avatar
unknown committed
3660
  /* Check that we have called all proper deallocation functions */
3661
  DBUG_ASSERT((uchar*) table->def_read_set.bitmap +
3662
              table->s->column_bitmap_size ==
3663
              (uchar*) table->def_write_set.bitmap);
3664 3665 3666 3667 3668 3669 3670 3671 3672 3673
  DBUG_ASSERT(bitmap_is_set_all(&table->s->all_set));
  DBUG_ASSERT(table->key_read == 0);
  /* ensure that ha_index_end / ha_rnd_end has been called */
  DBUG_ASSERT(inited == NONE);
  /* Free cache used by filesort */
  free_io_cache(table);
  DBUG_RETURN(reset());
}


3674
int handler::ha_write_row(uchar *buf)
3675 3676
{
  int error;
3677 3678 3679 3680 3681
  if (unlikely(error= write_row(buf)))
    return error;
  if (unlikely(error= binlog_log_row<Write_rows_log_event>(table, 0, buf)))
    return error;
  return 0;
3682 3683
}

3684
int handler::ha_update_row(const uchar *old_data, uchar *new_data)
3685 3686
{
  int error;
3687 3688 3689 3690 3691 3692 3693

  /*
    Some storage engines require that the new record is in record[0]
    (and the old record is in record[1]).
   */
  DBUG_ASSERT(new_data == table->record[0]);

3694 3695 3696 3697 3698
  if (unlikely(error= update_row(old_data, new_data)))
    return error;
  if (unlikely(error= binlog_log_row<Update_rows_log_event>(table, old_data, new_data)))
    return error;
  return 0;
3699 3700
}

3701
int handler::ha_delete_row(const uchar *buf)
3702 3703
{
  int error;
3704 3705 3706 3707 3708
  if (unlikely(error= delete_row(buf)))
    return error;
  if (unlikely(error= binlog_log_row<Delete_rows_log_event>(table, buf, 0)))
    return error;
  return 0;
3709
}
3710

3711

3712

3713
/** @brief
3714 3715 3716 3717 3718 3719 3720 3721 3722
  use_hidden_primary_key() is called in case of an update/delete when
  (table_flags() and HA_PRIMARY_KEY_REQUIRED_FOR_DELETE) is defined
  but we don't have a primary key
*/
void handler::use_hidden_primary_key()
{
  /* fallback to use all columns in the table to identify row */
  table->use_all_columns();
}
3723 3724


3725
/** @brief
3726 3727 3728 3729 3730 3731 3732 3733 3734 3735
  Dummy function which accept information about log files which is not need
  by handlers
*/
void signal_log_not_needed(struct handlerton, char *log_file)
{
  DBUG_ENTER("signal_log_not_needed");
  DBUG_PRINT("enter", ("logfile '%s'", log_file));
  DBUG_VOID_RETURN;
}

3736

3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753
#ifdef TRANS_LOG_MGM_EXAMPLE_CODE
/*
  Example of transaction log management functions based on assumption that logs
  placed into a directory
*/
#include <my_dir.h>
#include <my_sys.h>
int example_of_iterator_using_for_logs_cleanup(handlerton *hton)
{
  void *buffer;
  int res= 1;
  struct handler_iterator iterator;
  struct handler_log_file_data data;

  if (!hton->create_iterator)
    return 1; /* iterator creator is not supported */

3754
  if ((*hton->create_iterator)(hton, HA_TRANSACTLOG_ITERATOR, &iterator) !=
3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783
      HA_ITERATOR_OK)
  {
    /* error during creation of log iterator or iterator is not supported */
    return 1;
  }
  while((*iterator.next)(&iterator, (void*)&data) == 0)
  {
    printf("%s\n", data.filename.str);
    if (data.status == HA_LOG_STATUS_FREE &&
        my_delete(data.filename.str, MYF(MY_WME)))
      goto err;
  }
  res= 0;
err:
  (*iterator.destroy)(&iterator);
  return res;
}


/*
  Here we should get info from handler where it save logs but here is
  just example, so we use constant.
  IMHO FN_ROOTDIR ("/") is safe enough for example, because nobody has
  rights on it except root and it consist of directories only at lest for
  *nix (sorry, can't find windows-safe solution here, but it is only example).
*/
#define fl_dir FN_ROOTDIR


3784
/** @brief
3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823
  Dummy function to return log status should be replaced by function which
  really detect the log status and check that the file is a log of this
  handler.
*/
enum log_status fl_get_log_status(char *log)
{
  MY_STAT stat_buff;
  if (my_stat(log, &stat_buff, MYF(0)))
    return HA_LOG_STATUS_INUSE;
  return HA_LOG_STATUS_NOSUCHLOG;
}


struct fl_buff
{
  LEX_STRING *names;
  enum log_status *statuses;
  uint32 entries;
  uint32 current;
};


int fl_log_iterator_next(struct handler_iterator *iterator,
                          void *iterator_object)
{
  struct fl_buff *buff= (struct fl_buff *)iterator->buffer;
  struct handler_log_file_data *data=
    (struct handler_log_file_data *) iterator_object;
  if (buff->current >= buff->entries)
    return 1;
  data->filename= buff->names[buff->current];
  data->status= buff->statuses[buff->current];
  buff->current++;
  return 0;
}


void fl_log_iterator_destroy(struct handler_iterator *iterator)
{
3824
  my_free((uchar*)iterator->buffer, MYF(MY_ALLOW_ZERO_PTR));
3825 3826 3827
}


3828
/** @brief
3829 3830 3831 3832 3833 3834 3835 3836
  returns buffer, to be assigned in handler_iterator struct
*/
enum handler_create_iterator_result
fl_log_iterator_buffer_init(struct handler_iterator *iterator)
{
  MY_DIR *dirp;
  struct fl_buff *buff;
  char *name_ptr;
3837
  uchar *ptr;
3838 3839 3840 3841 3842 3843 3844 3845 3846 3847
  FILEINFO *file;
  uint32 i;

  /* to be able to make my_free without crash in case of error */
  iterator->buffer= 0;

  if (!(dirp = my_dir(fl_dir, MYF(0))))
  {
    return HA_ITERATOR_ERROR;
  }
3848
  if ((ptr= (uchar*)my_malloc(ALIGN_SIZE(sizeof(fl_buff)) +
3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895
                             ((ALIGN_SIZE(sizeof(LEX_STRING)) +
                               sizeof(enum log_status) +
                               + FN_REFLEN) *
                              (uint) dirp->number_off_files),
                             MYF(0))) == 0)
  {
    return HA_ITERATOR_ERROR;
  }
  buff= (struct fl_buff *)ptr;
  buff->entries= buff->current= 0;
  ptr= ptr + (ALIGN_SIZE(sizeof(fl_buff)));
  buff->names= (LEX_STRING*) (ptr);
  ptr= ptr + ((ALIGN_SIZE(sizeof(LEX_STRING)) *
               (uint) dirp->number_off_files));
  buff->statuses= (enum log_status *)(ptr);
  name_ptr= (char *)(ptr + (sizeof(enum log_status) *
                            (uint) dirp->number_off_files));
  for (i=0 ; i < (uint) dirp->number_off_files  ; i++)
  {
    enum log_status st;
    file= dirp->dir_entry + i;
    if ((file->name[0] == '.' &&
         ((file->name[1] == '.' && file->name[2] == '\0') ||
            file->name[1] == '\0')))
      continue;
    if ((st= fl_get_log_status(file->name)) == HA_LOG_STATUS_NOSUCHLOG)
      continue;
    name_ptr= strxnmov(buff->names[buff->entries].str= name_ptr,
                       FN_REFLEN, fl_dir, file->name, NullS);
    buff->names[buff->entries].length= (name_ptr -
                                        buff->names[buff->entries].str) - 1;
    buff->statuses[buff->entries]= st;
    buff->entries++;
  }

  iterator->buffer= buff;
  iterator->next= &fl_log_iterator_next;
  iterator->destroy= &fl_log_iterator_destroy;
  return HA_ITERATOR_OK;
}


/* An example of a iterator creator */
enum handler_create_iterator_result
fl_create_iterator(enum handler_iterator_type type,
                   struct handler_iterator *iterator)
{
3896
  switch(type) {
3897 3898 3899 3900 3901 3902 3903
  case HA_TRANSACTLOG_ITERATOR:
    return fl_log_iterator_buffer_init(iterator);
  default:
    return HA_ITERATOR_UNSUPPORTED;
  }
}
#endif /*TRANS_LOG_MGM_EXAMPLE_CODE*/