handler.cc 141 KB
Newer Older
1
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
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
#include <myisampack.h>
#include <errno.h>
30

31 32
#ifdef WITH_PARTITION_STORAGE_ENGINE
#include "ha_partition.h"
33
#endif
34

35 36 37 38 39
/*
  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
40
st_plugin_int *hton2plugin[MAX_HA];
unknown's avatar
unknown committed
41

42
static handlerton *installed_htons[128];
43

unknown's avatar
unknown committed
44 45
#define BITMAP_STACKBUF_SIZE (128/8)

unknown's avatar
unknown committed
46
KEY_CREATE_INFO default_key_create_info= { HA_KEY_ALG_UNDEF, 0, {NullS,0} };
47

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

unknown's avatar
unknown committed
55
static const LEX_STRING sys_table_aliases[]=
56
{
unknown's avatar
unknown committed
57 58 59
  { 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") },
60
  { C_STRING_WITH_LEN("MERGE") },     { C_STRING_WITH_LEN("MRG_MYISAM") },
unknown's avatar
unknown committed
61
  {NullS, 0}
unknown's avatar
unknown committed
62
};
63

unknown's avatar
unknown committed
64
const char *ha_row_type[] = {
65 66 67
  "", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT",
  /* Reserved to be "PAGE" in future versions */ "?",
  "?","?","?"
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
}


unknown's avatar
unknown committed
204 205
/**
  Use other database handler if databasehandler is not compiled in.
206
*/
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->initialize_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


unknown's avatar
unknown committed
285
/**
286 287
  Register handler error messages for use with my_error().

unknown's avatar
unknown committed
288
  @retval
289
    0           OK
unknown's avatar
unknown committed
290 291
  @retval
    !=0         Error
292
*/
293 294

int ha_init_errors(void)
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
{
#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));
334 335
  SETMSG(HA_ERR_NO_REFERENCED_ROW,      ER(ER_NO_REFERENCED_ROW_2));
  SETMSG(HA_ERR_ROW_IS_REFERENCED,      ER(ER_ROW_IS_REFERENCED_2));
336 337 338 339 340
  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");
341
  SETMSG(HA_ERR_TABLE_DEF_CHANGED,      ER(ER_TABLE_DEF_CHANGED));
342
  SETMSG(HA_ERR_FOREIGN_DUPLICATE_KEY,  "FK constraint would lead to duplicate key");
unknown's avatar
unknown committed
343
  SETMSG(HA_ERR_TABLE_NEEDS_UPGRADE,    ER(ER_TABLE_NEEDS_UPGRADE));
344
  SETMSG(HA_ERR_TABLE_READONLY,         ER(ER_OPEN_AS_READONLY));
unknown's avatar
unknown committed
345 346
  SETMSG(HA_ERR_AUTOINC_READ_FAILED,    ER(ER_AUTOINC_READ_FAILED));
  SETMSG(HA_ERR_AUTOINC_ERANGE,         ER(ER_WARN_DATA_OUT_OF_RANGE));
347
  SETMSG(HA_ERR_TOO_MANY_CONCURRENT_TRXS, ER(ER_TOO_MANY_CONCURRENT_TRXS));
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);
}


unknown's avatar
unknown committed
354
/**
355 356
  Unregister handler error messages.

unknown's avatar
unknown committed
357
  @retval
358
    0           OK
unknown's avatar
unknown committed
359 360
  @retval
    !=0         Error
361 362 363 364 365 366 367 368
*/
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;
369
  my_free((uchar*) errmsgs, MYF(0));
370 371
  return 0;
}
unknown's avatar
unknown committed
372

373

unknown's avatar
unknown committed
374
int ha_finalize_handlerton(st_plugin_int *plugin)
375
{
unknown's avatar
unknown committed
376
  handlerton *hton= (handlerton *)plugin->data;
unknown's avatar
unknown committed
377 378
  DBUG_ENTER("ha_finalize_handlerton");

379 380 381 382
  /* hton can be NULL here, if ha_initialize_handlerton() failed. */
  if (!hton)
    goto end;

unknown's avatar
unknown committed
383 384 385 386 387 388 389 390 391 392
  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;
  };
393

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

397 398 399 400 401 402 403 404 405 406 407 408 409 410
  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));
    }
  }

411 412 413 414 415 416 417
  /*
    In case a plugin is uninstalled and re-installed later, it should
    reuse an array slot. Otherwise the number of uninstall/install
    cycles would be limited.
  */
  hton2plugin[hton->slot]= NULL;

418
  my_free((uchar*)hton, MYF(0));
419

420
 end:
unknown's avatar
unknown committed
421
  DBUG_RETURN(0);
422
}
423

unknown's avatar
unknown committed
424

unknown's avatar
unknown committed
425
int ha_initialize_handlerton(st_plugin_int *plugin)
unknown's avatar
unknown committed
426
{
427
  handlerton *hton;
unknown's avatar
unknown committed
428
  DBUG_ENTER("ha_initialize_handlerton");
429
  DBUG_PRINT("plugin", ("initialize plugin: '%s'", plugin->name.str));
unknown's avatar
unknown committed
430

431 432 433
  hton= (handlerton *)my_malloc(sizeof(handlerton),
                                MYF(MY_WME | MY_ZEROFILL));
  /* Historical Requirement */
unknown's avatar
unknown committed
434
  plugin->data= hton; // shortcut for the future
435
  if (plugin->plugin->init && plugin->plugin->init(hton))
436
  {
437 438 439
    sql_print_error("Plugin '%s' init function returned error.",
                    plugin->name.str);
    goto err;  
440
  }
unknown's avatar
unknown committed
441

unknown's avatar
unknown committed
442 443 444 445
  /*
    the switch below and hton->state should be removed when
    command-line options for plugins will be implemented
  */
unknown's avatar
unknown committed
446
  switch (hton->state) {
unknown's avatar
unknown committed
447 448 449 450
  case SHOW_OPTION_NO:
    break;
  case SHOW_OPTION_YES:
    {
unknown's avatar
unknown committed
451
      uint tmp;
452
      ulong fslot;
unknown's avatar
unknown committed
453
      /* now check the db_type for conflict */
unknown's avatar
unknown committed
454
      if (hton->db_type <= DB_TYPE_UNKNOWN ||
unknown's avatar
unknown committed
455 456 457 458
          hton->db_type >= DB_TYPE_DEFAULT ||
          installed_htons[hton->db_type])
      {
        int idx= (int) DB_TYPE_FIRST_DYNAMIC;
unknown's avatar
unknown committed
459

unknown's avatar
unknown committed
460 461 462 463 464 465
        while (idx < (int) DB_TYPE_DEFAULT && installed_htons[idx])
          idx++;

        if (idx == (int) DB_TYPE_DEFAULT)
        {
          sql_print_warning("Too many storage engines!");
466
          goto err_deinit;
unknown's avatar
unknown committed
467 468 469
        }
        if (hton->db_type != DB_TYPE_UNKNOWN)
          sql_print_warning("Storage engine '%s' has conflicting typecode. "
unknown's avatar
unknown committed
470
                            "Assigning value %d.", plugin->plugin->name, idx);
unknown's avatar
unknown committed
471 472
        hton->db_type= (enum legacy_db_type) idx;
      }
473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492

      /*
        In case a plugin is uninstalled and re-installed later, it should
        reuse an array slot. Otherwise the number of uninstall/install
        cycles would be limited. So look for a free slot.
      */
      DBUG_PRINT("plugin", ("total_ha: %lu", total_ha));
      for (fslot= 0; fslot < total_ha; fslot++)
      {
        if (!hton2plugin[fslot])
          break;
      }
      if (fslot < total_ha)
        hton->slot= fslot;
      else
      {
        if (total_ha >= MAX_HA)
        {
          sql_print_error("Too many plugins loaded. Limit is %lu. "
                          "Failed on '%s'", (ulong) MAX_HA, plugin->name.str);
493
          goto err_deinit;
494 495 496
        }
        hton->slot= total_ha++;
      }
497 498 499 500
      installed_htons[hton->db_type]= hton;
      tmp= hton->savepoint_offset;
      hton->savepoint_offset= savepoint_alloc_size;
      savepoint_alloc_size+= tmp;
unknown's avatar
unknown committed
501
      hton2plugin[hton->slot]=plugin;
unknown's avatar
unknown committed
502 503
      if (hton->prepare)
        total_ha_2pc++;
unknown's avatar
unknown committed
504 505 506 507 508 509 510
      break;
    }
    /* fall through */
  default:
    hton->state= SHOW_OPTION_DISABLED;
    break;
  }
511 512
  
  /* 
513 514 515
    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.
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
  */
  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
531
  DBUG_RETURN(0);
532 533 534 535 536 537 538 539 540

err_deinit:
  /* 
    Let plugin do its inner deinitialization as plugin->init() 
    was successfully called before.
  */
  if (plugin->plugin->deinit)
    (void) plugin->plugin->deinit(NULL);
          
541
err:
542 543
  my_free((uchar*) hton, MYF(0));
  plugin->data= NULL;
544
  DBUG_RETURN(1);
unknown's avatar
unknown committed
545 546
}

unknown's avatar
unknown committed
547 548
int ha_init()
{
549
  int error= 0;
unknown's avatar
unknown committed
550 551
  DBUG_ENTER("ha_init");

552
  DBUG_ASSERT(total_ha < MAX_HA);
553 554 555 556 557 558
  /*
    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;
559
  savepoint_alloc_size+= sizeof(SAVEPOINT);
unknown's avatar
unknown committed
560
  DBUG_RETURN(error);
unknown's avatar
unknown committed
561 562
}

563
int ha_end()
unknown's avatar
unknown committed
564
{
565 566
  int error= 0;
  DBUG_ENTER("ha_end");
unknown's avatar
unknown committed
567

unknown's avatar
unknown committed
568

569 570 571 572 573 574 575
  /* 
    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
576

577 578
  DBUG_RETURN(error);
}
unknown's avatar
unknown committed
579

unknown's avatar
unknown committed
580
static my_bool dropdb_handlerton(THD *unused1, plugin_ref plugin,
unknown's avatar
unknown committed
581 582
                                 void *path)
{
unknown's avatar
unknown committed
583
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
584
  if (hton->state == SHOW_OPTION_YES && hton->drop_database)
585
    hton->drop_database(hton, (char *)path);
unknown's avatar
unknown committed
586 587 588 589
  return FALSE;
}


590 591
void ha_drop_database(char* path)
{
unknown's avatar
unknown committed
592 593
  plugin_foreach(NULL, dropdb_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, path);
}
594

unknown's avatar
unknown committed
595

unknown's avatar
unknown committed
596
static my_bool closecon_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
597 598
                                   void *unused)
{
unknown's avatar
unknown committed
599
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
600 601 602 603
  /*
    there's no need to rollback here as all transactions must
    be rolled back already
  */
unknown's avatar
unknown committed
604
  if (hton->state == SHOW_OPTION_YES && hton->close_connection &&
605
      thd_get_ha_data(thd, hton))
606
    hton->close_connection(hton, thd);
unknown's avatar
unknown committed
607
  return FALSE;
608
}
unknown's avatar
unknown committed
609

unknown's avatar
unknown committed
610

unknown's avatar
unknown committed
611 612 613
/**
  @note
    don't bother to rollback here, it's done already
614
*/
615 616
void ha_close_connection(THD* thd)
{
unknown's avatar
unknown committed
617
  plugin_foreach(thd, closecon_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, 0);
618 619 620 621 622
}

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

623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
/**
  Transaction handling in the server
  ==================================

  In each client connection, MySQL maintains two transactional
  states:
  - a statement transaction,
  - a standard, also called normal transaction.

  Historical note
  ---------------
  "Statement transaction" is a non-standard term that comes
  from the times when MySQL supported BerkeleyDB storage engine.

  First of all, it should be said that in BerkeleyDB auto-commit
  mode auto-commits operations that are atomic to the storage
  engine itself, such as a write of a record, and are too
  high-granular to be atomic from the application perspective
  (MySQL). One SQL statement could involve many BerkeleyDB
  auto-committed operations and thus BerkeleyDB auto-commit was of
  little use to MySQL.

  Secondly, instead of SQL standard savepoints, BerkeleyDB
  provided the concept of "nested transactions". In a nutshell,
  transactions could be arbitrarily nested, but when the parent
  transaction was committed or aborted, all its child (nested)
  transactions were handled committed or aborted as well.
  Commit of a nested transaction, in turn, made its changes
  visible, but not durable: it destroyed the nested transaction,
  all its changes would become available to the parent and
  currently active nested transactions of this parent.

  So the mechanism of nested transactions was employed to
  provide "all or nothing" guarantee of SQL statements
  required by the standard.
  A nested transaction would be created at start of each SQL
  statement, and destroyed (committed or aborted) at statement
  end. Such nested transaction was internally referred to as
  a "statement transaction" and gave birth to the term.

  <Historical note ends>

  Since then a statement transaction is started for each statement
  that accesses transactional tables or uses the binary log.  If
  the statement succeeds, the statement transaction is committed.
  If the statement fails, the transaction is rolled back. Commits
  of statement transactions are not durable -- each such
  transaction is nested in the normal transaction, and if the
  normal transaction is rolled back, the effects of all enclosed
  statement transactions are undone as well.  Technically,
  a statement transaction can be viewed as a savepoint which is
  maintained automatically in order to make effects of one
  statement atomic.

  The normal transaction is started by the user and is ended
  usually upon a user request as well. The normal transaction
  encloses transactions of all statements issued between
  its beginning and its end.
  In autocommit mode, the normal transaction is equivalent
  to the statement transaction.

  Since MySQL supports PSEA (pluggable storage engine
  architecture), more than one transactional engine can be
  active at a time. Hence transactions, from the server
  point of view, are always distributed. In particular,
  transactional state is maintained independently for each
  engine. In order to commit a transaction the two phase
  commit protocol is employed.

  Not all statements are executed in context of a transaction.
  Administrative and status information statements do not modify
  engine data, and thus do not start a statement transaction and
  also have no effect on the normal transaction. Examples of such
  statements are SHOW STATUS and RESET SLAVE.

  Similarly DDL statements are not transactional,
  and therefore a transaction is [almost] never started for a DDL
  statement. The difference between a DDL statement and a purely
  administrative statement though is that a DDL statement always
  commits the current transaction before proceeding, if there is
  any.

  At last, SQL statements that work with non-transactional
  engines also have no effect on the transaction state of the
  connection. Even though they are written to the binary log,
  and the binary log is, overall, transactional, the writes
  are done in "write-through" mode, directly to the binlog
  file, followed with a OS cache sync, in other words,
  bypassing the binlog undo log (translog).
  They do not commit the current normal transaction.
  A failure of a statement that uses non-transactional tables
  would cause a rollback of the statement transaction, but
  in case there no non-transactional tables are used,
  no statement transaction is started.

  Data layout
  -----------

  The server stores its transaction-related data in
  thd->transaction. This structure has two members of type
  THD_TRANS. These members correspond to the statement and
  normal transactions respectively:

  - thd->transaction.stmt contains a list of engines
  that are participating in the given statement
  - thd->transaction.all contains a list of engines that
  have participated in any of the statement transactions started
  within the context of the normal transaction.
  Each element of the list contains a pointer to the storage
  engine, engine-specific transactional data, and engine-specific
  transaction flags.

  In autocommit mode thd->transaction.all is empty.
  Instead, data of thd->transaction.stmt is
  used to commit/rollback the normal transaction.

  The list of registered engines has a few important properties:
  - no engine is registered in the list twice
  - engines are present in the list a reverse temporal order --
  new participants are always added to the beginning of the list.

  Transaction life cycle
  ----------------------

  When a new connection is established, thd->transaction
  members are initialized to an empty state.
  If a statement uses any tables, all affected engines
  are registered in the statement engine list. In
  non-autocommit mode, the same engines are registered in
  the normal transaction list.
  At the end of the statement, the server issues a commit
  or a roll back for all engines in the statement list.
  At this point transaction flags of an engine, if any, are
  propagated from the statement list to the list of the normal
  transaction.
  When commit/rollback is finished, the statement list is
  cleared. It will be filled in again by the next statement,
  and emptied again at the next statement's end.

  The normal transaction is committed in a similar way
  (by going over all engines in thd->transaction.all list)
  but at different times:
  - upon COMMIT SQL statement is issued by the user
  - implicitly, by the server, at the beginning of a DDL statement
  or SET AUTOCOMMIT={0|1} statement.

  The normal transaction can be rolled back as well:
  - if the user has requested so, by issuing ROLLBACK SQL
  statement
  - if one of the storage engines requested a rollback
  by setting thd->transaction_rollback_request. This may
  happen in case, e.g., when the transaction in the engine was
  chosen a victim of the internal deadlock resolution algorithm
  and rolled back internally. When such a situation happens, there
  is little the server can do and the only option is to rollback
  transactions in all other participating engines.  In this case
  the rollback is accompanied by an error sent to the user.

  As follows from the use cases above, the normal transaction
  is never committed when there is an outstanding statement
  transaction. In most cases there is no conflict, since
  commits of the normal transaction are issued by a stand-alone
  administrative or DDL statement, thus no outstanding statement
  transaction of the previous statement exists. Besides,
  all statements that manipulate with the normal transaction
  are prohibited in stored functions and triggers, therefore
  no conflicting situation can occur in a sub-statement either.
  The remaining rare cases when the server explicitly has
  to commit the statement transaction prior to committing the normal
  one cover error-handling scenarios (see for example
  SQLCOM_LOCK_TABLES).

  When committing a statement or a normal transaction, the server
  either uses the two-phase commit protocol, or issues a commit
  in each engine independently. The two-phase commit protocol
  is used only if:
  - all participating engines support two-phase commit (provide
    handlerton::prepare PSEA API call) and
  - transactions in at least two engines modify data (i.e. are
  not read-only).

  Note that the two phase commit is used for
  statement transactions, even though they are not durable anyway.
  This is done to ensure logical consistency of data in a multiple-
  engine transaction.
  For example, imagine that some day MySQL supports unique
  constraint checks deferred till the end of statement. In such
  case a commit in one of the engines may yield ER_DUP_KEY,
  and MySQL should be able to gracefully abort statement
  transactions of other participants.

  After the normal transaction has been committed,
  thd->transaction.all list is cleared.

  When a connection is closed, the current normal transaction, if
  any, is rolled back.

  Roles and responsibilities
  --------------------------

  The server has no way to know that an engine participates in
  the statement and a transaction has been started
  in it unless the engine says so. Thus, in order to be
  a part of a transaction, the engine must "register" itself.
  This is done by invoking trans_register_ha() server call.
  Normally the engine registers itself whenever handler::external_lock()
  is called. trans_register_ha() can be invoked many times: if
  an engine is already registered, the call does nothing.
  In case autocommit is not set, the engine must register itself
  twice -- both in the statement list and in the normal transaction
  list.
  In which list to register is a parameter of trans_register_ha().

  Note, that although the registration interface in itself is
  fairly clear, the current usage practice often leads to undesired
  effects. E.g. since a call to trans_register_ha() in most engines
  is embedded into implementation of handler::external_lock(), some
  DDL statements start a transaction (at least from the server
  point of view) even though they are not expected to. E.g.
  CREATE TABLE does not start a transaction, since
  handler::external_lock() is never called during CREATE TABLE. But
  CREATE TABLE ... SELECT does, since handler::external_lock() is
  called for the table that is being selected from. This has no
  practical effects currently, but must be kept in mind
  nevertheless.

  Once an engine is registered, the server will do the rest
  of the work.

  During statement execution, whenever any of data-modifying
  PSEA API methods is used, e.g. handler::write_row() or
  handler::update_row(), the read-write flag is raised in the
  statement transaction for the involved engine.
  Currently All PSEA calls are "traced", and the data can not be
  changed in a way other than issuing a PSEA call. Important:
  unless this invariant is preserved the server will not know that
  a transaction in a given engine is read-write and will not
  involve the two-phase commit protocol!

  At the end of a statement, server call
  ha_autocommit_or_rollback() is invoked. This call in turn
  invokes handlerton::prepare() for every involved engine.
  Prepare is followed by a call to handlerton::commit_one_phase()
  If a one-phase commit will suffice, handlerton::prepare() is not
  invoked and the server only calls handlerton::commit_one_phase().
  At statement commit, the statement-related read-write engine
  flag is propagated to the corresponding flag in the normal
  transaction.  When the commit is complete, the list of registered
  engines is cleared.

  Rollback is handled in a similar fashion.

  Additional notes on DDL and the normal transaction.
  ---------------------------------------------------

  DDLs and operations with non-transactional engines
  do not "register" in thd->transaction lists, and thus do not
  modify the transaction state. Besides, each DDL in
  MySQL is prefixed with an implicit normal transaction commit
  (a call to end_active_trans()), and thus leaves nothing
  to modify.
  However, as it has been pointed out with CREATE TABLE .. SELECT,
  some DDL statements can start a *new* transaction.

  Behaviour of the server in this case is currently badly
  defined.
  DDL statements use a form of "semantic" logging
  to maintain atomicity: if CREATE TABLE .. SELECT failed,
  the newly created table is deleted.
  In addition, some DDL statements issue interim transaction
  commits: e.g. ALTER TABLE issues a commit after data is copied
  from the original table to the internal temporary table. Other
  statements, e.g. CREATE TABLE ... SELECT do not always commit
  after itself.
  And finally there is a group of DDL statements such as
  RENAME/DROP TABLE that doesn't start a new transaction
  and doesn't commit.

  This diversity makes it hard to say what will happen if
  by chance a stored function is invoked during a DDL --
  whether any modifications it makes will be committed or not
  is not clear. Fortunately, SQL grammar of few DDLs allows
  invocation of a stored function.

  A consistent behaviour is perhaps to always commit the normal
  transaction after all DDLs, just like the statement transaction
  is always committed at the end of all statements.
*/

unknown's avatar
unknown committed
912 913
/**
  Register a storage engine for a transaction.
unknown's avatar
unknown committed
914

unknown's avatar
unknown committed
915 916 917 918 919
  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.
920

unknown's avatar
unknown committed
921
  @note
922 923 924
    trans_register_ha is idempotent - storage engine may register many
    times per transaction.

unknown's avatar
unknown committed
925
*/
926 927 928
void trans_register_ha(THD *thd, bool all, handlerton *ht_arg)
{
  THD_TRANS *trans;
929
  Ha_trx_info *ha_info;
unknown's avatar
unknown committed
930 931 932
  DBUG_ENTER("trans_register_ha");
  DBUG_PRINT("enter",("%s", all ? "all" : "stmt"));

933 934 935 936 937 938 939 940
  if (all)
  {
    trans= &thd->transaction.all;
    thd->server_status|= SERVER_STATUS_IN_TRANS;
  }
  else
    trans= &thd->transaction.stmt;

941 942 943 944 945 946
  ha_info= thd->ha_data[ht_arg->slot].ha_info + static_cast<unsigned>(all);

  if (ha_info->is_started())
    DBUG_VOID_RETURN; /* already registered, return */

  ha_info->register_ha(trans, ht_arg);
unknown's avatar
unknown committed
947

948
  trans->no_2pc|=(ht_arg->prepare==0);
949 950
  if (thd->transaction.xid_state.xid.is_null())
    thd->transaction.xid_state.xid.set(thd->query_id);
unknown's avatar
unknown committed
951
  DBUG_VOID_RETURN;
952 953
}

unknown's avatar
unknown committed
954 955 956 957 958
/**
  @retval
    0   ok
  @retval
    1   error, transaction was rolled back
959 960 961 962 963
*/
int ha_prepare(THD *thd)
{
  int error=0, all=1;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
964
  Ha_trx_info *ha_info= trans->ha_list;
965 966
  DBUG_ENTER("ha_prepare");
#ifdef USING_TRANSACTIONS
967
  if (ha_info)
968
  {
969
    for (; ha_info; ha_info= ha_info->next())
970 971
    {
      int err;
972
      handlerton *ht= ha_info->ht();
973
      status_var_increment(thd->status_var.ha_prepare_count);
974
      if (ht->prepare)
975
      {
976
        if ((err= ht->prepare(ht, thd, all)))
977 978 979 980 981 982 983 984 985 986
        {
          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
987
                            ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
988
                            ha_resolve_storage_engine_name(ht));
989 990 991 992 993 994 995
      }
    }
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

996 997 998 999 1000 1001
/**
  Check if we can skip the two-phase commit.

  A helper function to evaluate if two-phase commit is mandatory.
  As a side effect, propagates the read-only/read-write flags
  of the statement transaction to its enclosing normal transaction.
1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
  
  If we have at least two engines with read-write changes we must
  run a two-phase commit. Otherwise we can run several independent
  commits as the only transactional engine has read-write changes
  and others are read-only.

  @retval   0   All engines are read-only.
  @retval   1   We have the only engine with read-write changes.
  @retval   >1  More than one engine have read-write changes.
                Note: return value might NOT be the exact number of
                engines with read-write changes.
1013 1014 1015
*/

static
1016
uint
1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
ha_check_and_coalesce_trx_read_only(THD *thd, Ha_trx_info *ha_list,
                                    bool all)
{
  /* The number of storage engines that have actual changes. */
  unsigned rw_ha_count= 0;
  Ha_trx_info *ha_info;

  for (ha_info= ha_list; ha_info; ha_info= ha_info->next())
  {
    if (ha_info->is_trx_read_write())
      ++rw_ha_count;

    if (! all)
    {
      Ha_trx_info *ha_info_all= &thd->ha_data[ha_info->ht()->slot].ha_info[1];
      DBUG_ASSERT(ha_info != ha_info_all);
      /*
        Merge read-only/read-write information about statement
        transaction to its enclosing normal transaction. Do this
        only if in a real transaction -- that is, if we know
        that ha_info_all is registered in thd->transaction.all.
        Since otherwise we only clutter the normal transaction flags.
      */
      if (ha_info_all->is_started()) /* FALSE if autocommit. */
        ha_info_all->coalesce_trx_with(ha_info);
    }
    else if (rw_ha_count > 1)
    {
      /*
        It is a normal transaction, so we don't need to merge read/write
        information up, and the need for two-phase commit has been
        already established. Break the loop prematurely.
      */
      break;
    }
  }
1053
  return rw_ha_count;
1054 1055 1056
}


unknown's avatar
unknown committed
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
/**
  @retval
    0   ok
  @retval
    1   transaction was rolled back
  @retval
    2   error during commit, data may be inconsistent

  @todo
    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.
1070 1071 1072 1073
*/
int ha_commit_trans(THD *thd, bool all)
{
  int error= 0, cookie= 0;
1074 1075 1076 1077
  /*
    'all' means that this is either an explicit commit issued by
    user, or an implicit commit issued by a DDL.
  */
1078
  THD_TRANS *trans= all ? &thd->transaction.all : &thd->transaction.stmt;
1079 1080 1081 1082 1083 1084 1085
  /*
    "real" is a nick name for a transaction for which a commit will
    make persistent changes. E.g. a 'stmt' transaction inside a 'all'
    transation is not 'real': even though it's possible to commit it,
    the changes are not durable as they might be rolled back if the
    enclosing 'all' transaction is rolled back.
  */
1086 1087
  bool is_real_trans= all || thd->transaction.all.ha_list == 0;
  Ha_trx_info *ha_info= trans->ha_list;
1088
  my_xid xid= thd->transaction.xid_state.xid.get_my_xid();
1089
  DBUG_ENTER("ha_commit_trans");
1090

1091 1092 1093 1094 1095 1096 1097 1098 1099
  /*
    We must not commit the normal transaction if a statement
    transaction is pending. Otherwise statement transaction
    flags will not get propagated to its normal transaction's
    counterpart.
  */
  DBUG_ASSERT(thd->transaction.stmt.ha_list == NULL ||
              trans == &thd->transaction.stmt);

1100
  if (thd->in_sub_stmt)
1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119
  {
    /*
      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);
  }
1120
#ifdef USING_TRANSACTIONS
1121
  if (ha_info)
1122
  {
1123 1124 1125 1126 1127 1128 1129 1130
    uint rw_ha_count;
    bool rw_trans;

    DBUG_EXECUTE_IF("crash_commit_before", abort(););

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

1132 1133 1134 1135 1136 1137
    rw_ha_count= ha_check_and_coalesce_trx_read_only(thd, ha_info, all);
    /* rw_trans is TRUE when we in a transaction changing data */
    rw_trans= is_real_trans && (rw_ha_count > 0);

    if (rw_trans &&
        wait_if_global_read_lock(thd, 0, 0))
1138 1139 1140 1141
    {
      ha_rollback_trans(thd, all);
      DBUG_RETURN(1);
    }
unknown's avatar
unknown committed
1142

1143 1144 1145 1146
    if (rw_trans &&
        opt_readonly &&
        !(thd->security_ctx->master_access & SUPER_ACL) &&
        !thd->slave_thread)
unknown's avatar
unknown committed
1147 1148 1149 1150 1151 1152 1153
    {
      my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
      ha_rollback_trans(thd, all);
      error= 1;
      goto end;
    }

1154
    if (!trans->no_2pc && (rw_ha_count > 1))
1155
    {
1156
      for (; ha_info && !error; ha_info= ha_info->next())
1157 1158
      {
        int err;
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
        handlerton *ht= ha_info->ht();
        /*
          Do not call two-phase commit if this particular
          transaction is read-only. This allows for simpler
          implementation in engines that are always read-only.
        */
        if (! ha_info->is_trx_read_write())
          continue;
        /*
          Sic: we know that prepare() is not NULL since otherwise
          trans->no_2pc would have been set.
        */
        if ((err= ht->prepare(ht, thd, all)))
1172 1173
        {
          my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
1174
          error= 1;
1175
        }
1176
        status_var_increment(thd->status_var.ha_prepare_count);
1177
      }
1178
      DBUG_EXECUTE_IF("crash_commit_after_prepare", abort(););
unknown's avatar
unknown committed
1179
      if (error || (is_real_trans && xid &&
1180
                    (error= !(cookie= tc_log->log_xid(thd, xid)))))
1181 1182
      {
        ha_rollback_trans(thd, all);
1183 1184
        error= 1;
        goto end;
1185
      }
1186
      DBUG_EXECUTE_IF("crash_commit_after_log", abort(););
1187
    }
1188
    error=ha_commit_one_phase(thd, all) ? (cookie ? 2 : 1) : 0;
1189
    DBUG_EXECUTE_IF("crash_commit_before_unlog", abort(););
1190
    if (cookie)
unknown's avatar
unknown committed
1191
      tc_log->unlog(cookie, xid);
1192
    DBUG_EXECUTE_IF("crash_commit_after", abort(););
1193
end:
1194
    if (rw_trans)
1195
      start_waiting_global_read_lock(thd);
1196
  }
1197 1198
  /* Free resources and perform other cleanup even for 'empty' transactions. */
  else if (is_real_trans)
1199
    thd->transaction.cleanup();
1200 1201 1202 1203
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
1204 1205 1206
/**
  @note
  This function does not care about global read lock. A caller should.
1207
*/
1208 1209 1210 1211
int ha_commit_one_phase(THD *thd, bool all)
{
  int error=0;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
1212 1213 1214 1215 1216 1217 1218
  /*
    "real" is a nick name for a transaction for which a commit will
    make persistent changes. E.g. a 'stmt' transaction inside a 'all'
    transation is not 'real': even though it's possible to commit it,
    the changes are not durable as they might be rolled back if the
    enclosing 'all' transaction is rolled back.
  */
1219 1220
  bool is_real_trans=all || thd->transaction.all.ha_list == 0;
  Ha_trx_info *ha_info= trans->ha_list, *ha_info_next;
1221 1222
  DBUG_ENTER("ha_commit_one_phase");
#ifdef USING_TRANSACTIONS
1223
  if (ha_info)
1224
  {
1225
    for (; ha_info; ha_info= ha_info_next)
1226 1227
    {
      int err;
1228 1229
      handlerton *ht= ha_info->ht();
      if ((err= ht->commit(ht, thd, all)))
1230 1231 1232 1233
      {
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
        error=1;
      }
1234
      status_var_increment(thd->status_var.ha_commit_count);
1235 1236
      ha_info_next= ha_info->next();
      ha_info->reset(); /* keep it conveniently zero-filled */
1237
    }
1238
    trans->ha_list= 0;
1239 1240 1241 1242 1243 1244
    trans->no_2pc=0;
    if (all)
    {
#ifdef HAVE_QUERY_CACHE
      if (thd->transaction.changed_tables)
        query_cache.invalidate(thd->transaction.changed_tables);
unknown's avatar
unknown committed
1245
#endif
1246 1247 1248
      thd->variables.tx_isolation=thd->session_tx_isolation;
    }
  }
1249 1250 1251
  /* Free resources and perform other cleanup even for 'empty' transactions. */
  if (is_real_trans)
    thd->transaction.cleanup();
1252 1253 1254 1255 1256 1257 1258 1259 1260
#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;
1261
  Ha_trx_info *ha_info= trans->ha_list, *ha_info_next;
1262 1263 1264 1265 1266 1267 1268
  /*
    "real" is a nick name for a transaction for which a commit will
    make persistent changes. E.g. a 'stmt' transaction inside a 'all'
    transation is not 'real': even though it's possible to commit it,
    the changes are not durable as they might be rolled back if the
    enclosing 'all' transaction is rolled back.
  */
1269
  bool is_real_trans=all || thd->transaction.all.ha_list == 0;
1270
  DBUG_ENTER("ha_rollback_trans");
1271 1272 1273 1274 1275 1276 1277 1278

  /*
    We must not rollback the normal transaction if a statement
    transaction is pending.
  */
  DBUG_ASSERT(thd->transaction.stmt.ha_list == NULL ||
              trans == &thd->transaction.stmt);

1279
  if (thd->in_sub_stmt)
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291
  {
    /*
      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);
  }
1292
#ifdef USING_TRANSACTIONS
1293
  if (ha_info)
1294
  {
1295 1296 1297 1298
    /* Close all cursors that can not survive ROLLBACK */
    if (is_real_trans)                          /* not a statement commit */
      thd->stmt_map.close_transient_cursors();

1299
    for (; ha_info; ha_info= ha_info_next)
1300 1301
    {
      int err;
1302 1303
      handlerton *ht= ha_info->ht();
      if ((err= ht->rollback(ht, thd, all)))
1304 1305 1306 1307
      { // cannot happen
        my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
        error=1;
      }
1308
      status_var_increment(thd->status_var.ha_rollback_count);
1309 1310
      ha_info_next= ha_info->next();
      ha_info->reset(); /* keep it conveniently zero-filled */
1311
    }
1312
    trans->ha_list= 0;
1313
    trans->no_2pc=0;
1314 1315
    if (is_real_trans && thd->transaction_rollback_request &&
        thd->transaction.xid_state.xa_state != XA_NOTR)
1316
      thd->transaction.xid_state.rm_error= thd->main_da.sql_errno();
1317 1318 1319
    if (all)
      thd->variables.tx_isolation=thd->session_tx_isolation;
  }
1320
  /* Always cleanup. Even if there nht==0. There may be savepoints. */
1321
  if (is_real_trans)
1322
    thd->transaction.cleanup();
1323
#endif /* USING_TRANSACTIONS */
1324 1325 1326
  if (all)
    thd->transaction_rollback_request= FALSE;

1327 1328 1329 1330 1331 1332 1333 1334 1335
  /*
    If a non-transactional table was updated, warn; don't warn if this is a
    slave thread (because when a slave thread executes a ROLLBACK, it has
    been read from the binary log, so it's 100% sure and normal to produce
    error ER_WARNING_NOT_COMPLETE_ROLLBACK. If we sent the warning to the
    slave SQL thread, it would not stop the thread but just be printed in
    the error log; but we don't want users to wonder why they have this
    message in the error log, so we don't send it.
  */
unknown's avatar
unknown committed
1336
  if (is_real_trans && thd->transaction.all.modified_non_trans_table &&
unknown's avatar
unknown committed
1337
      !thd->slave_thread && thd->killed != THD::KILL_CONNECTION)
1338 1339 1340 1341
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                 ER_WARNING_NOT_COMPLETE_ROLLBACK,
                 ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
  DBUG_RETURN(error);
1342 1343
}

unknown's avatar
unknown committed
1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
/**
  This is used to commit or rollback a single statement depending on
  the value of error.

  @note
    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.
1354
*/
unknown's avatar
unknown committed
1355 1356 1357
int ha_autocommit_or_rollback(THD *thd, int error)
{
  DBUG_ENTER("ha_autocommit_or_rollback");
1358
#ifdef USING_TRANSACTIONS
1359
  if (thd->transaction.stmt.ha_list)
unknown's avatar
unknown committed
1360
  {
1361 1362
    if (!error)
    {
1363
      if (ha_commit_trans(thd, 0))
1364 1365
	error=1;
    }
1366 1367 1368 1369 1370 1371
    else 
    {
      (void) ha_rollback_trans(thd, 0);
      if (thd->transaction_rollback_request && !thd->in_sub_stmt)
        (void) ha_rollback(thd);
    }
1372 1373 1374 1375 1376 1377 1378 1379
  } 
  else if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)))
  {
    /* 
       If we're in autocommit mode, reset tx_isolation
       to the default value
    */
    thd->variables.tx_isolation= thd->session_tx_isolation;
unknown's avatar
unknown committed
1380 1381 1382 1383 1384
  }
#endif
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
1385

unknown's avatar
unknown committed
1386 1387 1388 1389 1390
struct xahton_st {
  XID *xid;
  int result;
};

unknown's avatar
unknown committed
1391
static my_bool xacommit_handlerton(THD *unused1, plugin_ref plugin,
unknown's avatar
unknown committed
1392
                                   void *arg)
1393
{
unknown's avatar
unknown committed
1394
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
1395 1396
  if (hton->state == SHOW_OPTION_YES && hton->recover)
  {
1397
    hton->commit_by_xid(hton, ((struct xahton_st *)arg)->xid);
unknown's avatar
unknown committed
1398 1399 1400 1401
    ((struct xahton_st *)arg)->result= 0;
  }
  return FALSE;
}
1402

unknown's avatar
unknown committed
1403
static my_bool xarollback_handlerton(THD *unused1, plugin_ref plugin,
unknown's avatar
unknown committed
1404 1405
                                     void *arg)
{
unknown's avatar
unknown committed
1406
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
1407
  if (hton->state == SHOW_OPTION_YES && hton->recover)
unknown's avatar
unknown committed
1408
  {
1409
    hton->rollback_by_xid(hton, ((struct xahton_st *)arg)->xid);
unknown's avatar
unknown committed
1410
    ((struct xahton_st *)arg)->result= 0;
unknown's avatar
unknown committed
1411
  }
unknown's avatar
unknown committed
1412 1413 1414 1415 1416 1417 1418 1419 1420
  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
1421

unknown's avatar
unknown committed
1422 1423 1424 1425
  plugin_foreach(NULL, commit ? xacommit_handlerton : xarollback_handlerton,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &xaop);

  return xaop.result;
1426
}
unknown's avatar
unknown committed
1427

unknown's avatar
unknown committed
1428

unknown's avatar
unknown committed
1429
#ifndef DBUG_OFF
unknown's avatar
unknown committed
1430 1431 1432 1433
/**
  @note
    This does not need to be multi-byte safe or anything
*/
unknown's avatar
unknown committed
1434 1435 1436 1437 1438 1439 1440 1441
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
1442 1443
    /* is_next_dig is set if next character is a number */
    bool is_next_dig= FALSE;
unknown's avatar
unknown committed
1444 1445
    if (i < XIDDATASIZE)
    {
unknown's avatar
unknown committed
1446 1447
      char ch= xid->data[i+1];
      is_next_dig= (ch >= '0' && ch <='9');
unknown's avatar
unknown committed
1448
    }
unknown's avatar
unknown committed
1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460
    if (i == xid->gtrid_length)
    {
      *s++='\'';
      if (xid->bqual_length)
      {
        *s++='.';
        *s++='\'';
      }
    }
    if (c < 32 || c > 126)
    {
      *s++='\\';
unknown's avatar
unknown committed
1461 1462 1463 1464 1465
      /*
        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
1466 1467 1468 1469 1470
      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
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
    }
    else
    {
      if (c == '\'' || c == '\\')
        *s++='\\';
      *s++=c;
    }
  }
  *s++='\'';
  *s=0;
  return buf;
}
#endif

unknown's avatar
unknown committed
1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499
/**
  recover() step of xa.

  @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
1500
*/
unknown's avatar
unknown committed
1501 1502 1503 1504 1505 1506 1507
struct xarecover_st
{
  int len, found_foreign_xids, found_my_xids;
  XID *list;
  HASH *commit_list;
  bool dry_run;
};
1508

unknown's avatar
unknown committed
1509
static my_bool xarecover_handlerton(THD *unused, plugin_ref plugin,
unknown's avatar
unknown committed
1510 1511
                                    void *arg)
{
unknown's avatar
unknown committed
1512
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
1513 1514
  struct xarecover_st *info= (struct xarecover_st *) arg;
  int got;
unknown's avatar
unknown committed
1515

unknown's avatar
unknown committed
1516
  if (hton->state == SHOW_OPTION_YES && hton->recover)
1517
  {
1518
    while ((got= hton->recover(hton, info->list, info->len)) > 0 )
1519
    {
unknown's avatar
unknown committed
1520
      sql_print_information("Found %d prepared transaction(s) in %s",
unknown's avatar
unknown committed
1521
                            got, ha_resolve_storage_engine_name(hton));
1522 1523
      for (int i=0; i < got; i ++)
      {
unknown's avatar
unknown committed
1524
        my_xid x=info->list[i].get_my_xid();
1525
        if (!x) // not "mine" - that is generated by external TM
unknown's avatar
unknown committed
1526
        {
unknown's avatar
unknown committed
1527 1528
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
unknown's avatar
unknown committed
1529
          sql_print_information("ignore xid %s", xid_to_str(buf, info->list+i));
unknown's avatar
unknown committed
1530
#endif
unknown's avatar
unknown committed
1531 1532
          xid_cache_insert(info->list+i, XA_PREPARED);
          info->found_foreign_xids++;
unknown's avatar
unknown committed
1533 1534
          continue;
        }
unknown's avatar
unknown committed
1535
        if (info->dry_run)
unknown's avatar
unknown committed
1536
        {
unknown's avatar
unknown committed
1537
          info->found_my_xids++;
1538
          continue;
unknown's avatar
unknown committed
1539 1540
        }
        // recovery mode
unknown's avatar
unknown committed
1541
        if (info->commit_list ?
1542
            hash_search(info->commit_list, (uchar *)&x, sizeof(x)) != 0 :
1543
            tc_heuristic_recover == TC_HEURISTIC_RECOVER_COMMIT)
unknown's avatar
unknown committed
1544 1545 1546
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
unknown's avatar
unknown committed
1547
          sql_print_information("commit xid %s", xid_to_str(buf, info->list+i));
unknown's avatar
unknown committed
1548
#endif
1549
          hton->commit_by_xid(hton, info->list+i);
unknown's avatar
unknown committed
1550
        }
1551
        else
unknown's avatar
unknown committed
1552 1553 1554
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
unknown's avatar
unknown committed
1555 1556
          sql_print_information("rollback xid %s",
                                xid_to_str(buf, info->list+i));
unknown's avatar
unknown committed
1557
#endif
1558
          hton->rollback_by_xid(hton, info->list+i);
unknown's avatar
unknown committed
1559
        }
1560
      }
unknown's avatar
unknown committed
1561
      if (got < info->len)
1562
        break;
1563 1564
    }
  }
unknown's avatar
unknown committed
1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
  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);

1612
  my_free((uchar*)info.list, MYF(0));
unknown's avatar
unknown committed
1613 1614 1615 1616
  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
1617 1618 1619 1620 1621 1622 1623
  {
    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
1624
                    info.found_my_xids, opt_tc_log_file);
unknown's avatar
unknown committed
1625 1626
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
1627
  if (info.commit_list)
unknown's avatar
unknown committed
1628
    sql_print_information("Crash recovery finished.");
1629
  DBUG_RETURN(0);
1630
}
1631

unknown's avatar
unknown committed
1632 1633
/**
  return the list of XID's to a client, the same way SHOW commands do.
unknown's avatar
unknown committed
1634

unknown's avatar
unknown committed
1635
  @note
1636 1637 1638
    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
1639
*/
1640
bool mysql_xa_recover(THD *thd)
unknown's avatar
unknown committed
1641
{
1642 1643
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
1644 1645
  int i=0;
  XID_STATE *xs;
1646 1647
  DBUG_ENTER("mysql_xa_recover");

1648 1649 1650
  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));
1651 1652 1653 1654 1655
  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
1656

1657
  pthread_mutex_lock(&LOCK_xid_cache);
unknown's avatar
unknown committed
1658
  while ((xs= (XID_STATE*)hash_element(&xid_cache, i++)))
1659
  {
1660
    if (xs->xa_state==XA_PREPARED)
1661
    {
1662 1663 1664 1665 1666 1667 1668
      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())
1669
      {
1670 1671
        pthread_mutex_unlock(&LOCK_xid_cache);
        DBUG_RETURN(1);
1672 1673
      }
    }
unknown's avatar
unknown committed
1674
  }
1675

1676
  pthread_mutex_unlock(&LOCK_xid_cache);
1677
  my_eof(thd);
1678
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1679
}
1680

unknown's avatar
unknown committed
1681 1682
/**
  @details
1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693
  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.

unknown's avatar
unknown committed
1694 1695 1696 1697
  @param thd           the thread handle of the current connection

  @return
    always 0
1698
*/
1699

1700 1701
int ha_release_temporary_latches(THD *thd)
{
1702
  Ha_trx_info *info;
1703

1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
  /*
    Note that below we assume that only transactional storage engines
    may need release_temporary_latches(). If this will ever become false,
    we could iterate on thd->open_tables instead (and remove duplicates
    as if (!seen[hton->slot]) { seen[hton->slot]=1; ... }).
  */
  for (info= thd->transaction.stmt.ha_list; info; info= info->next())
  {
    handlerton *hton= info->ht();
    if (hton && hton->release_temporary_latches)
        hton->release_temporary_latches(hton, thd);
  }
1716
  return 0;
1717 1718
}

1719
int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1720 1721
{
  int error=0;
1722 1723
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
1724 1725
  Ha_trx_info *ha_info, *ha_info_next;

1726
  DBUG_ENTER("ha_rollback_to_savepoint");
1727

1728 1729 1730 1731 1732
  trans->no_2pc=0;
  /*
    rolling back to savepoint in all storage engines that were part of the
    transaction when the savepoint was set
  */
1733
  for (ha_info= sv->ha_list; ha_info; ha_info= ha_info->next())
1734 1735
  {
    int err;
1736 1737 1738 1739 1740
    handlerton *ht= ha_info->ht();
    DBUG_ASSERT(ht);
    DBUG_ASSERT(ht->savepoint_set != 0);
    if ((err= ht->savepoint_rollback(ht, thd,
                                     (uchar *)(sv+1)+ht->savepoint_offset)))
1741 1742 1743
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
1744
    }
1745
    status_var_increment(thd->status_var.ha_savepoint_rollback_count);
1746
    trans->no_2pc|= ht->prepare == 0;
1747
  }
1748 1749 1750 1751
  /*
    rolling back the transaction in all storage engines that were not part of
    the transaction when the savepoint was set
  */
1752 1753
  for (ha_info= trans->ha_list; ha_info != sv->ha_list;
       ha_info= ha_info_next)
unknown's avatar
unknown committed
1754
  {
1755
    int err;
1756 1757
    handlerton *ht= ha_info->ht();
    if ((err= ht->rollback(ht, thd, !thd->in_sub_stmt)))
1758 1759 1760
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
unknown's avatar
unknown committed
1761
    }
1762
    status_var_increment(thd->status_var.ha_rollback_count);
1763 1764
    ha_info_next= ha_info->next();
    ha_info->reset(); /* keep it conveniently zero-filled */
1765
  }
1766
  trans->ha_list= sv->ha_list;
unknown's avatar
unknown committed
1767 1768 1769
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
1770 1771 1772
/**
  @note
  according to the sql standard (ISO/IEC 9075-2:2003)
1773 1774
  section "4.33.4 SQL-statements and transaction states",
  SAVEPOINT is *not* transaction-initiating SQL-statement
unknown's avatar
unknown committed
1775
*/
1776
int ha_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1777 1778
{
  int error=0;
1779 1780
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
1781
  Ha_trx_info *ha_info= trans->ha_list;
1782
  DBUG_ENTER("ha_savepoint");
unknown's avatar
unknown committed
1783
#ifdef USING_TRANSACTIONS
1784
  for (; ha_info; ha_info= ha_info->next())
unknown's avatar
unknown committed
1785
  {
1786
    int err;
1787 1788 1789
    handlerton *ht= ha_info->ht();
    DBUG_ASSERT(ht);
    if (! ht->savepoint_set)
unknown's avatar
unknown committed
1790
    {
1791
      my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "SAVEPOINT");
unknown's avatar
unknown committed
1792
      error=1;
1793
      break;
unknown's avatar
unknown committed
1794
    }
1795
    if ((err= ht->savepoint_set(ht, thd, (uchar *)(sv+1)+ht->savepoint_offset)))
1796 1797
    { // cannot happen
      my_error(ER_GET_ERRNO, MYF(0), err);
unknown's avatar
unknown committed
1798 1799
      error=1;
    }
1800
    status_var_increment(thd->status_var.ha_savepoint_count);
unknown's avatar
unknown committed
1801
  }
1802 1803 1804 1805 1806
  /*
    Remember the list of registered storage engines. All new
    engines are prepended to the beginning of the list.
  */
  sv->ha_list= trans->ha_list;
unknown's avatar
unknown committed
1807 1808 1809 1810
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

1811
int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1812 1813
{
  int error=0;
1814
  Ha_trx_info *ha_info= sv->ha_list;
1815 1816
  DBUG_ENTER("ha_release_savepoint");

1817
  for (; ha_info; ha_info= ha_info->next())
unknown's avatar
unknown committed
1818
  {
1819
    int err;
1820 1821 1822 1823
    handlerton *ht= ha_info->ht();
    /* Savepoint life time is enclosed into transaction life time. */
    DBUG_ASSERT(ht);
    if (!ht->savepoint_release)
1824
      continue;
1825 1826
    if ((err= ht->savepoint_release(ht, thd,
                                    (uchar *)(sv+1) + ht->savepoint_offset)))
1827 1828 1829
    { // cannot happen
      my_error(ER_GET_ERRNO, MYF(0), err);
      error=1;
unknown's avatar
unknown committed
1830
    }
unknown's avatar
unknown committed
1831 1832 1833 1834
  }
  DBUG_RETURN(error);
}

1835

unknown's avatar
unknown committed
1836
static my_bool snapshot_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
1837 1838
                                   void *arg)
{
unknown's avatar
unknown committed
1839
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
1840 1841 1842
  if (hton->state == SHOW_OPTION_YES &&
      hton->start_consistent_snapshot)
  {
1843
    hton->start_consistent_snapshot(hton, thd);
unknown's avatar
unknown committed
1844 1845 1846 1847 1848
    *((bool *)arg)= false;
  }
  return FALSE;
}

1849 1850
int ha_start_consistent_snapshot(THD *thd)
{
1851 1852
  bool warn= true;

unknown's avatar
unknown committed
1853 1854
  plugin_foreach(thd, snapshot_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, &warn);

1855 1856 1857 1858
  /*
    Same idea as when one wants to CREATE TABLE in one engine which does not
    exist:
  */
1859 1860 1861 1862
  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");
1863 1864 1865 1866
  return 0;
}


unknown's avatar
unknown committed
1867
static my_bool flush_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
1868
                                void *arg)
unknown's avatar
unknown committed
1869
{
unknown's avatar
unknown committed
1870
  handlerton *hton= plugin_data(plugin, handlerton *);
1871 1872
  if (hton->state == SHOW_OPTION_YES && hton->flush_logs && 
      hton->flush_logs(hton))
unknown's avatar
unknown committed
1873 1874 1875 1876
    return TRUE;
  return FALSE;
}

1877

unknown's avatar
unknown committed
1878 1879 1880
bool ha_flush_logs(handlerton *db_type)
{
  if (db_type == NULL)
1881
  {
unknown's avatar
unknown committed
1882 1883 1884
    if (plugin_foreach(NULL, flush_handlerton,
                          MYSQL_STORAGE_ENGINE_PLUGIN, 0))
      return TRUE;
1885
  }
unknown's avatar
unknown committed
1886 1887 1888
  else
  {
    if (db_type->state != SHOW_OPTION_YES ||
1889
        (db_type->flush_logs && db_type->flush_logs(db_type)))
unknown's avatar
unknown committed
1890 1891 1892
      return TRUE;
  }
  return FALSE;
unknown's avatar
unknown committed
1893 1894
}

1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917

/**
  @brief make canonical filename

  @param[in]  file     table handler
  @param[in]  path     original path
  @param[out] tmp_path buffer for canonized path

  @details Lower case db name and table name path parts for
           non file based tables when lower_case_table_names
           is 2 (store as is, compare in lower case).
           Filesystem path prefix (mysql_data_home or tmpdir)
           is left intact.

  @note tmp_path may be left intact if no conversion was
        performed.

  @retval canonized path

  @todo This may be done more efficiently when table path
        gets built. Convert this function to something like
        ASSERT_CANONICAL_FILENAME.
*/
1918 1919
const char *get_canonical_filename(handler *file, const char *path,
                                   char *tmp_path)
1920
{
1921
  uint i;
1922 1923 1924
  if (lower_case_table_names != 2 || (file->ha_table_flags() & HA_FILE_BASED))
    return path;

1925 1926 1927 1928 1929 1930
  for (i= 0; i <= mysql_tmpdir_list.max; i++)
  {
    if (is_prefix(path, mysql_tmpdir_list.list[i]))
      return path;
  }

1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943
  /* 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;
}


1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
/**
  An interceptor to hijack the text of the error message without
  setting an error in the thread. We need the text to present it
  in the form of a warning to the user.
*/

struct Ha_delete_table_error_handler: public Internal_error_handler
{
public:
  virtual bool handle_error(uint sql_errno,
                            const char *message,
                            MYSQL_ERROR::enum_warning_level level,
                            THD *thd);
  char buff[MYSQL_ERRMSG_SIZE];
};


bool
Ha_delete_table_error_handler::
handle_error(uint sql_errno,
             const char *message,
             MYSQL_ERROR::enum_warning_level level,
             THD *thd)
{
  /* Grab the error message */
  strmake(buff, message, sizeof(buff)-1);
  return TRUE;
}


1974
/** @brief
unknown's avatar
unknown committed
1975 1976 1977
  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
1978
int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
unknown's avatar
unknown committed
1979
                    const char *db, const char *alias, bool generate_warning)
unknown's avatar
unknown committed
1980
{
1981
  handler *file;
unknown's avatar
unknown committed
1982
  char tmp_path[FN_REFLEN];
1983 1984 1985 1986 1987 1988 1989 1990
  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;
1991 1992

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

1997
  path= get_canonical_filename(file, path, tmp_path);
1998
  if ((error= file->ha_delete_table(path)) && generate_warning)
1999 2000 2001
  {
    /*
      Because file->print_error() use my_error() to generate the error message
2002 2003 2004
      we use an internal error handler to intercept it and store the text
      in a temporary buffer. Later the message will be presented to user
      as a warning.
2005
    */
2006
    Ha_delete_table_error_handler ha_delete_table_error_handler;
2007 2008

    /* Fill up strucutures that print_error may need */
unknown's avatar
unknown committed
2009 2010 2011 2012 2013 2014
    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);
2015 2016
    dummy_table.alias= alias;

2017
    file->change_table_ptr(&dummy_table, &dummy_share);
2018 2019

    thd->push_internal_handler(&ha_delete_table_error_handler);
2020
    file->print_error(error, 0);
2021 2022 2023 2024 2025 2026 2027 2028 2029

    thd->pop_internal_handler();

    /*
      XXX: should we convert *all* errors to warnings here?
      What if the error is fatal?
    */
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, error,
                ha_delete_table_error_handler.buff);
2030
  }
unknown's avatar
unknown committed
2031
  delete file;
2032
  DBUG_RETURN(error);
unknown's avatar
unknown committed
2033
}
unknown's avatar
unknown committed
2034

unknown's avatar
unknown committed
2035 2036 2037
/****************************************************************************
** General handler functions
****************************************************************************/
unknown's avatar
unknown committed
2038 2039
handler *handler::clone(MEM_ROOT *mem_root)
{
unknown's avatar
unknown committed
2040
  handler *new_handler= get_new_handler(table->s, mem_root, table->s->db_type());
2041 2042 2043 2044 2045
  /*
    Allocate handler->ref here because otherwise ha_open will allocate it
    on this->table->mem_root and we will not be able to reclaim that memory 
    when the clone handler object is destroyed.
  */
2046
  if (!(new_handler->ref= (uchar*) alloc_root(mem_root, ALIGN_SIZE(ref_length)*2)))
2047
    return NULL;
unknown's avatar
unknown committed
2048 2049 2050
  if (new_handler && !new_handler->ha_open(table,
                                           table->s->normalized_path.str,
                                           table->db_stat,
unknown's avatar
unknown committed
2051 2052 2053 2054 2055
                                           HA_OPEN_IGNORE_IF_LOCKED))
    return new_handler;
  return NULL;
}

unknown's avatar
unknown committed
2056

2057 2058 2059

void handler::ha_statistic_increment(ulong SSV::*offset) const
{
2060
  status_var_increment(table->in_use->status_var.*offset);
2061 2062
}

2063
void **handler::ha_data(THD *thd) const
unknown's avatar
unknown committed
2064
{
2065
  return thd_ha_data(thd, ht);
unknown's avatar
unknown committed
2066 2067 2068 2069
}

THD *handler::ha_thd(void) const
{
unknown's avatar
unknown committed
2070
  DBUG_ASSERT(!table || !table->in_use || table->in_use == current_thd);
unknown's avatar
unknown committed
2071 2072 2073
  return (table && table->in_use) ? table->in_use : current_thd;
}

2074

2075
/** @brief
unknown's avatar
unknown committed
2076 2077 2078 2079 2080 2081 2082 2083
  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
2084 2085
{
  int error;
2086
  DBUG_ENTER("handler::ha_open");
unknown's avatar
unknown committed
2087 2088
  DBUG_PRINT("enter",
             ("name: %s  db_type: %d  db_stat: %d  mode: %d  lock_test: %d",
unknown's avatar
unknown committed
2089
              name, ht->db_type, table_arg->db_stat, mode,
unknown's avatar
unknown committed
2090 2091 2092 2093
              test_if_locked));

  table= table_arg;
  DBUG_ASSERT(table->s == table_share);
2094
  DBUG_ASSERT(alloc_root_inited(&table->mem_root));
unknown's avatar
unknown committed
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106

  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
2107
    my_errno= error;                            /* Safeguard */
unknown's avatar
unknown committed
2108 2109 2110 2111
    DBUG_PRINT("error",("error: %d  errno: %d",error,errno));
  }
  else
  {
2112
    if (table->s->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
unknown's avatar
unknown committed
2113
      table->db_stat|=HA_READ_ONLY;
2114 2115
    (void) extra(HA_EXTRA_NO_READCHECK);	// Not needed in SQL

2116
    /* ref is already allocated for us if we're called from handler::clone() */
2117
    if (!ref && !(ref= (uchar*) alloc_root(&table->mem_root, 
2118
                                          ALIGN_SIZE(ref_length)*2)))
unknown's avatar
unknown committed
2119 2120 2121 2122 2123
    {
      close();
      error=HA_ERR_OUT_OF_MEM;
    }
    else
2124 2125
      dup_ref=ref+ALIGN_SIZE(ref_length);
    cached_table_flags= table_flags();
unknown's avatar
unknown committed
2126 2127 2128 2129
  }
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
2130

unknown's avatar
unknown committed
2131 2132 2133
/**
  Read first row (only) from a table.

2134
  This is never called for InnoDB tables, as these table types
2135
  has the HA_STATS_RECORDS_IS_EXACT set.
2136
*/
2137
int handler::read_first_row(uchar * buf, uint primary_key)
unknown's avatar
unknown committed
2138 2139
{
  register int error;
2140
  DBUG_ENTER("handler::read_first_row");
unknown's avatar
unknown committed
2141

unknown's avatar
unknown committed
2142
  ha_statistic_increment(&SSV::ha_read_first_count);
2143 2144 2145 2146

  /*
    If there is very few deleted rows in the table, find the first row by
    scanning the table.
2147
    TODO remove the test for HA_READ_ORDER
2148
  */
2149
  if (stats.deleted < 10 || primary_key >= MAX_KEY ||
2150
      !(index_flags(primary_key, 0, 0) & HA_READ_ORDER))
2151
  {
unknown's avatar
unknown committed
2152
    (void) ha_rnd_init(1);
2153
    while ((error= rnd_next(buf)) == HA_ERR_RECORD_DELETED) ;
unknown's avatar
unknown committed
2154
    (void) ha_rnd_end();
2155 2156 2157 2158
  }
  else
  {
    /* Find the first row through the primary key */
2159
    (void) ha_index_init(primary_key, 0);
2160
    error=index_first(buf);
unknown's avatar
unknown committed
2161
    (void) ha_index_end();
2162
  }
unknown's avatar
unknown committed
2163 2164 2165
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
2166 2167
/**
  Generate the next auto-increment number based on increment and offset.
2168 2169 2170
  computes the lowest number
  - strictly greater than "nr"
  - of the form: auto_increment_offset + N * auto_increment_increment
unknown's avatar
unknown committed
2171

2172
  In most cases increment= offset= 1, in which case we get:
unknown's avatar
unknown committed
2173 2174 2175
  @verbatim 1,2,3,4,5,... @endverbatim
    If increment=10 and offset=5 and previous number is 1, we get:
  @verbatim 1,5,15,25,35,... @endverbatim
2176 2177
*/
inline ulonglong
2178
compute_next_insert_id(ulonglong nr,struct system_variables *variables)
2179
{
2180 2181
  if (variables->auto_increment_increment == 1)
    return (nr+1); // optimization of the formula below
2182 2183 2184 2185 2186 2187 2188 2189
  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);
}


2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
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));
}


2202
/** @brief
2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
  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
2229
                       (ulong) nr, variables->auto_increment_offset));
2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
    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);
}


unknown's avatar
unknown committed
2241 2242
/**
  Update the auto_increment field if necessary.
2243

unknown's avatar
unknown committed
2244
  Updates columns with type NEXT_NUMBER if:
2245 2246 2247 2248 2249 2250 2251

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

2252 2253 2254
    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:
2255

2256 2257 2258
  - 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.
2259

2260 2261 2262 2263 2264 2265
  - 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.
2266

2267 2268 2269 2270 2271
  - 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.
2272

2273 2274 2275
  - 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
Guilhem Bichot's avatar
Guilhem Bichot committed
2276 2277 2278 2279 2280 2281
    auto_inc_interval_for_cur_row. The number of reserved intervals is
    remembered in auto_inc_intervals_count. It differs from the number of
    elements in thd->auto_inc_intervals_in_cur_stmt_for_binlog() because the
    latter list is cumulative over all statements forming one binlog event
    (when stored functions and triggers are used), and collapses two
    contiguous intervals in one (see its append() method).
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291

    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.

2292 2293 2294 2295 2296 2297 2298
    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.
2299

unknown's avatar
unknown committed
2300
  @todo
2301 2302 2303 2304 2305
    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).

unknown's avatar
unknown committed
2306 2307 2308 2309 2310 2311 2312 2313
  @retval
    0	ok
  @retval
    HA_ERR_AUTOINC_READ_FAILED  get_auto_increment() was called and
    returned ~(ulonglong) 0
  @retval
    HA_ERR_AUTOINC_ERANGE storing value in field caused strict mode
    failure.
2314
*/
unknown's avatar
unknown committed
2315

2316 2317 2318 2319
#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
2320
int handler::update_auto_increment()
unknown's avatar
unknown committed
2321
{
2322 2323
  ulonglong nr, nb_reserved_values;
  bool append= FALSE;
2324 2325
  THD *thd= table->in_use;
  struct system_variables *variables= &thd->variables;
2326
  DBUG_ENTER("handler::update_auto_increment");
2327 2328

  /*
2329 2330
    next_insert_id is a "cursor" into the reserved interval, it may go greater
    than the interval, but not smaller.
2331
  */
2332
  DBUG_ASSERT(next_insert_id >= auto_inc_interval_for_cur_row.minimum());
2333 2334

  if ((nr= table->next_number_field->val_int()) != 0 ||
2335 2336
      (table->auto_increment_field_not_null &&
      thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO))
2337
  {
2338 2339 2340 2341 2342 2343
    /*
      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).
    */
2344
    adjust_next_insert_id_after_explicit_value(nr);
2345
    insert_id_for_cur_row= 0; // didn't generate anything
2346
    DBUG_RETURN(0);
2347
  }
2348 2349

  if ((nr= next_insert_id) >= auto_inc_interval_for_cur_row.maximum())
2350
  {
2351 2352 2353 2354 2355 2356 2357 2358 2359
    /* 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
2360
    {
2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375
      /*
        handler::estimation_rows_to_insert was set by
        handler::ha_start_bulk_insert(); if 0 it means "unknown".
      */
      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).
Guilhem Bichot's avatar
Guilhem Bichot committed
2376
        Note that in prelocked mode no estimation is given.
2377
      */
Guilhem Bichot's avatar
Guilhem Bichot committed
2378
      if ((auto_inc_intervals_count == 0) && (estimation_rows_to_insert > 0))
2379 2380
        nb_desired_values= estimation_rows_to_insert;
      else /* go with the increasing defaults */
2381
      {
2382
        /* avoid overflow in formula, with this if() */
Guilhem Bichot's avatar
Guilhem Bichot committed
2383
        if (auto_inc_intervals_count <= AUTO_INC_DEFAULT_NB_MAX_BITS)
2384
        {
Guilhem Bichot's avatar
Guilhem Bichot committed
2385 2386
          nb_desired_values= AUTO_INC_DEFAULT_NB_ROWS *
            (1 << auto_inc_intervals_count);
2387 2388 2389 2390
          set_if_smaller(nb_desired_values, AUTO_INC_DEFAULT_NB_MAX);
        }
        else
          nb_desired_values= AUTO_INC_DEFAULT_NB_MAX;
2391
      }
2392 2393 2394 2395 2396 2397
      /* 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)
2398
        DBUG_RETURN(HA_ERR_AUTOINC_READ_FAILED);  // Mark failure
Guilhem Bichot's avatar
Guilhem Bichot committed
2399

2400 2401 2402 2403 2404 2405 2406 2407 2408 2409
      /*
        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);
    }
Guilhem Bichot's avatar
Guilhem Bichot committed
2410

2411
    if (table->s->next_number_keypart == 0)
2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424
    {
      /* 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"));
2425
    }
2426 2427 2428 2429
  }

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

2430
  if (unlikely(table->next_number_field->store((longlong) nr, TRUE)))
2431
  {
2432
    /*
2433 2434 2435 2436 2437
      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);

2438
    /*
2439
      field refused this value (overflow) and truncated it, use the result of
2440 2441
      the truncation (which is going to be inserted); however we try to
      decrease it to honour auto_increment_* variables.
2442 2443 2444
      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).
2445
    */
2446 2447 2448
    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();
2449 2450 2451 2452 2453
  }
  if (append)
  {
    auto_inc_interval_for_cur_row.replace(nr, nb_reserved_values,
                                          variables->auto_increment_increment);
Guilhem Bichot's avatar
Guilhem Bichot committed
2454
    auto_inc_intervals_count++;
2455
    /* Row-based replication does not need to store intervals in binlog */
Guilhem Bichot's avatar
Guilhem Bichot committed
2456
    if (mysql_bin_log.is_open() && !thd->current_stmt_binlog_row_based)
2457 2458 2459
        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
2460
  }
2461

2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474
  /*
    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));
2475

unknown's avatar
unknown committed
2476
  DBUG_RETURN(0);
2477 2478
}

unknown's avatar
unknown committed
2479

2480
/** @brief
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495
  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
2496 2497
  DBUG_PRINT("info", ("read_set: 0x%lx  write_set: 0x%lx", (long) table->read_set,
                      (long) table->write_set));
2498 2499 2500 2501
  DBUG_VOID_RETURN;
}


2502
/** @brief
2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522
  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
2523
{
2524
  ulonglong nr;
unknown's avatar
unknown committed
2525
  int error;
unknown's avatar
unknown committed
2526

unknown's avatar
unknown committed
2527
  (void) extra(HA_EXTRA_KEYREAD);
2528 2529 2530
  table->mark_columns_used_by_index_no_reset(table->s->next_number_index,
                                        table->read_set);
  column_bitmaps_signal();
2531
  index_init(table->s->next_number_index, 1);
2532
  if (table->s->next_number_keypart == 0)
unknown's avatar
unknown committed
2533 2534
  {						// Autoincrement at key-start
    error=index_last(table->record[1]);
2535 2536 2537 2538 2539 2540
    /*
      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
2541 2542 2543
  }
  else
  {
2544
    uchar key[MAX_KEY_LENGTH];
2545
    key_copy(key, table->record[0],
2546 2547
             table->key_info + table->s->next_number_index,
             table->s->next_number_key_offset);
2548 2549 2550
    error= index_read_map(table->record[1], key,
                          make_prev_keypart_map(table->s->next_number_keypart),
                          HA_READ_PREFIX_LAST);
2551 2552 2553 2554 2555 2556 2557
    /*
      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
2558 2559
  }

unknown's avatar
unknown committed
2560 2561 2562
  if (error)
    nr=1;
  else
2563 2564
    nr= ((ulonglong) table->next_number_field->
         val_int_offset(table->s->rec_buff_length)+1);
unknown's avatar
unknown committed
2565
  index_end();
unknown's avatar
unknown committed
2566
  (void) extra(HA_EXTRA_NO_KEYREAD);
2567
  *first_value= nr;
unknown's avatar
unknown committed
2568 2569
}

2570

2571 2572 2573 2574 2575
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);
Guilhem Bichot's avatar
Guilhem Bichot committed
2576
  auto_inc_intervals_count= 0;
2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588
  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();
  }
}


2589
void handler::print_keydup_error(uint key_nr, const char *msg)
2590 2591 2592 2593
{
  /* Write the duplicated key in the error message */
  char key[MAX_KEY_LENGTH];
  String str(key,sizeof(key),system_charset_info);
2594 2595 2596 2597

  if (key_nr == MAX_KEY)
  {
    /* Key is unknown */
2598
    str.copy("", 0, system_charset_info);
2599
    my_printf_error(ER_DUP_ENTRY, msg, MYF(0), str.c_ptr(), "*UNKNOWN*");
2600 2601
  }
  else
2602
  {
2603 2604 2605 2606 2607 2608 2609 2610
    /* 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("..."));
    }
2611
    my_printf_error(ER_DUP_ENTRY, msg,
2612
		    MYF(0), str.c_ptr_safe(), table->key_info[key_nr].name);
2613 2614 2615 2616
  }
}


unknown's avatar
unknown committed
2617 2618
/**
  Print error that we got from handler function.
2619

unknown's avatar
unknown committed
2620 2621 2622 2623 2624
  @note
    In case of delete table it's only safe to use the following parts of
    the 'table' structure:
    - table->s->path
    - table->alias
2625
*/
unknown's avatar
unknown committed
2626 2627
void handler::print_error(int error, myf errflag)
{
2628
  DBUG_ENTER("handler::print_error");
unknown's avatar
unknown committed
2629 2630 2631 2632
  DBUG_PRINT("enter",("error: %d",error));

  int textno=ER_GET_ERRNO;
  switch (error) {
2633 2634 2635
  case EACCES:
    textno=ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
  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
2647
  case HA_ERR_WRONG_MRG_TABLE_DEF:
unknown's avatar
unknown committed
2648 2649 2650 2651 2652 2653 2654
    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
2655
      print_keydup_error(key_nr, ER(ER_DUP_ENTRY_WITH_KEY_NAME));
unknown's avatar
unknown committed
2656 2657 2658 2659 2660
      DBUG_VOID_RETURN;
    }
    textno=ER_DUP_KEY;
    break;
  }
2661 2662 2663 2664 2665
  case HA_ERR_FOREIGN_DUPLICATE_KEY:
  {
    uint key_nr= get_dup_key(error);
    if ((int) key_nr >= 0)
    {
2666
      uint max_length;
2667 2668 2669 2670 2671
      /* 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);
2672 2673
      max_length= (MYSQL_ERRMSG_SIZE-
                   (uint) strlen(ER(ER_FOREIGN_DUPLICATE_KEY)));
2674 2675 2676 2677 2678 2679
      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,
2680
        str.c_ptr_safe(), key_nr+1);
2681 2682 2683 2684 2685
      DBUG_VOID_RETURN;
    }
    textno= ER_DUP_KEY;
    break;
  }
2686
  case HA_ERR_NULL_IN_SPATIAL:
2687 2688
    my_error(ER_CANT_CREATE_GEOMETRY_OBJECT, MYF(0));
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2689 2690 2691 2692 2693 2694 2695 2696 2697
  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;
2698 2699 2700
  case HA_ERR_WRONG_IN_RECORD:
    textno= ER_CRASHED_ON_USAGE;
    break;
2701 2702 2703
  case HA_ERR_CRASHED_ON_USAGE:
    textno=ER_CRASHED_ON_USAGE;
    break;
2704 2705 2706
  case HA_ERR_NOT_A_TABLE:
    textno= error;
    break;
2707 2708 2709
  case HA_ERR_CRASHED_ON_REPAIR:
    textno=ER_CRASHED_ON_REPAIR;
    break;
unknown's avatar
unknown committed
2710
  case HA_ERR_OUT_OF_MEM:
2711 2712
    textno=ER_OUT_OF_RESOURCES;
    break;
unknown's avatar
unknown committed
2713 2714 2715 2716 2717 2718 2719 2720 2721 2722
  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:
2723
  case HA_ERR_INDEX_FILE_FULL:
2724
  {
2725
    textno=ER_RECORD_FILE_FULL;
2726 2727
    /* Write the error message to error log */
    errflag|= ME_NOREFRESH;
2728
    break;
2729
  }
2730 2731 2732 2733 2734 2735
  case HA_ERR_LOCK_WAIT_TIMEOUT:
    textno=ER_LOCK_WAIT_TIMEOUT;
    break;
  case HA_ERR_LOCK_TABLE_FULL:
    textno=ER_LOCK_TABLE_FULL;
    break;
2736 2737 2738
  case HA_ERR_LOCK_DEADLOCK:
    textno=ER_LOCK_DEADLOCK;
    break;
2739 2740 2741
  case HA_ERR_READ_ONLY_TRANSACTION:
    textno=ER_READ_ONLY_TRANSACTION;
    break;
unknown's avatar
Merge  
unknown committed
2742 2743 2744 2745
  case HA_ERR_CANNOT_ADD_FOREIGN:
    textno=ER_CANNOT_ADD_FOREIGN;
    break;
  case HA_ERR_ROW_IS_REFERENCED:
2746 2747 2748 2749 2750 2751
  {
    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
2752
  case HA_ERR_NO_REFERENCED_ROW:
2753 2754 2755 2756 2757 2758
  {
    String str;
    get_error_message(error, &str);
    my_error(ER_NO_REFERENCED_ROW_2, MYF(0), str.c_ptr_safe());
    DBUG_VOID_RETURN;
  }
2759 2760 2761
  case HA_ERR_TABLE_DEF_CHANGED:
    textno=ER_TABLE_DEF_CHANGED;
    break;
2762
  case HA_ERR_NO_SUCH_TABLE:
unknown's avatar
unknown committed
2763 2764
    my_error(ER_NO_SUCH_TABLE, MYF(0), table_share->db.str,
             table_share->table_name.str);
2765
    DBUG_VOID_RETURN;
2766 2767 2768
  case HA_ERR_RBR_LOGGING_FAILED:
    textno= ER_BINLOG_ROW_LOGGING_FAILED;
    break;
2769 2770 2771 2772 2773 2774 2775 2776 2777
  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
2778 2779 2780
  case HA_ERR_TABLE_NEEDS_UPGRADE:
    textno=ER_TABLE_NEEDS_UPGRADE;
    break;
2781 2782 2783
  case HA_ERR_TABLE_READONLY:
    textno= ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
2784 2785 2786 2787 2788 2789
  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;
2790 2791 2792
  case HA_ERR_TOO_MANY_CONCURRENT_TRXS:
    textno= ER_TOO_MANY_CONCURRENT_TRXS;
    break;
unknown's avatar
unknown committed
2793 2794
  default:
    {
2795 2796 2797
      /* The error was "unknown" to this function.
	 Ask handler if it has got a message for this error */
      bool temporary= FALSE;
2798 2799 2800
      String str;
      temporary= get_error_message(error, &str);
      if (!str.is_empty())
2801
      {
2802
	const char* engine= table_type();
2803
	if (temporary)
2804
	  my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(), engine);
2805
	else
2806
	  my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine);
2807
      }
2808
      else
2809
	my_error(ER_GET_ERRNO,errflag,error);
unknown's avatar
unknown committed
2810 2811 2812
      DBUG_VOID_RETURN;
    }
  }
unknown's avatar
unknown committed
2813
  my_error(textno, errflag, table_share->table_name.str, error);
unknown's avatar
unknown committed
2814 2815 2816
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
2817

unknown's avatar
unknown committed
2818 2819
/**
  Return an error message specific to this handler.
2820

unknown's avatar
unknown committed
2821 2822
  @param error  error code previously returned by handler
  @param buf    pointer to String where to add error message
unknown's avatar
unknown committed
2823

unknown's avatar
unknown committed
2824 2825
  @return
    Returns true if this is a temporary error
2826
*/
2827
bool handler::get_error_message(int error, String* buf)
2828
{
unknown's avatar
unknown committed
2829
  return FALSE;
2830 2831 2832
}


2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845
/**
  Check for incompatible collation changes.
   
  @retval
    HA_ADMIN_NEEDS_UPGRADE   Table may have data requiring upgrade.
  @retval
    0                        No upgrade required.
*/

int handler::check_collation_compatibility()
{
  ulong mysql_version= table->s->mysql_version;

2846
  if (mysql_version < 50124)
2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859
  {
    KEY *key= table->key_info;
    KEY *key_end= key + table->s->keys;
    for (; key < key_end; key++)
    {
      KEY_PART_INFO *key_part= key->key_part;
      KEY_PART_INFO *key_part_end= key_part + key->key_parts;
      for (; key_part < key_part_end; key_part++)
      {
        if (!key_part->fieldnr)
          continue;
        Field *field= table->field[key_part->fieldnr - 1];
        uint cs_number= field->charset()->number;
2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871
        if ((mysql_version < 50048 &&
             (cs_number == 11 || /* ascii_general_ci - bug #29499, bug #27562 */
              cs_number == 41 || /* latin7_general_ci - bug #29461 */
              cs_number == 42 || /* latin7_general_cs - bug #29461 */
              cs_number == 20 || /* latin7_estonian_cs - bug #29461 */
              cs_number == 21 || /* latin2_hungarian_ci - bug #29461 */
              cs_number == 22 || /* koi8u_general_ci - bug #29461 */
              cs_number == 23 || /* cp1251_ukrainian_ci - bug #29461 */
              cs_number == 26)) || /* cp1250_general_ci - bug #29461 */
             (mysql_version < 50124 &&
             (cs_number == 33 || /* utf8_general_ci - bug #27877 */
              cs_number == 35))) /* ucs2_general_ci - bug #27877 */
2872 2873 2874 2875 2876 2877 2878 2879
          return HA_ADMIN_NEEDS_UPGRADE;
      }  
    }  
  }  
  return 0;
}


unknown's avatar
unknown committed
2880 2881
int handler::ha_check_for_upgrade(HA_CHECK_OPT *check_opt)
{
2882
  int error;
unknown's avatar
unknown committed
2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899
  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];
2900
        if (field->type() == MYSQL_TYPE_BLOB)
unknown's avatar
unknown committed
2901 2902 2903 2904 2905 2906 2907 2908
        {
          if (check_opt->sql_flags & TT_FOR_UPGRADE)
            check_opt->flags= T_MEDIUM;
          return HA_ADMIN_NEEDS_CHECK;
        }
      }
    }
  }
2909 2910
  if (table->s->frm_version != FRM_VER_TRUE_VARCHAR)
    return HA_ADMIN_NEEDS_ALTER;
2911 2912 2913 2914

  if ((error= check_collation_compatibility()))
    return error;
    
unknown's avatar
unknown committed
2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927
  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++)
    {
2928
      if ((*field)->type() == MYSQL_TYPE_NEWDECIMAL)
unknown's avatar
unknown committed
2929 2930 2931
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
2932 2933 2934 2935
      if ((*field)->type() == MYSQL_TYPE_VAR_STRING)
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
unknown's avatar
unknown committed
2936 2937 2938 2939 2940 2941
    }
  }
  return 0;
}


2942
static bool update_frm_version(TABLE *table)
unknown's avatar
unknown committed
2943 2944 2945 2946 2947 2948
{
  char path[FN_REFLEN];
  File file;
  int result= 1;
  DBUG_ENTER("update_frm_version");

2949 2950 2951 2952 2953 2954 2955
  /*
    No need to update frm version in case table was created or checked
    by server with the same version. This also ensures that we do not
    update frm version for temporary tables as this code doesn't support
    temporary tables.
  */
  if (table->s->mysql_version == MYSQL_VERSION_ID)
unknown's avatar
unknown committed
2956 2957
    DBUG_RETURN(0);

unknown's avatar
unknown committed
2958
  strxmov(path, table->s->normalized_path.str, reg_ext, NullS);
unknown's avatar
unknown committed
2959 2960 2961 2962

  if ((file= my_open(path, O_RDWR|O_BINARY, MYF(MY_WME))) >= 0)
  {
    uchar version[4];
unknown's avatar
unknown committed
2963 2964
    char *key= table->s->table_cache_key.str;
    uint key_length= table->s->table_cache_key.length;
unknown's avatar
unknown committed
2965 2966 2967 2968 2969
    TABLE *entry;
    HASH_SEARCH_STATE state;

    int4store(version, MYSQL_VERSION_ID);

2970
    if ((result= my_pwrite(file,(uchar*) version,4,51L,MYF_RW)))
unknown's avatar
unknown committed
2971 2972
      goto err;

2973
    for (entry=(TABLE*) hash_first(&open_cache,(uchar*) key,key_length, &state);
unknown's avatar
unknown committed
2974
         entry;
2975
         entry= (TABLE*) hash_next(&open_cache,(uchar*) key,key_length, &state))
unknown's avatar
unknown committed
2976 2977 2978 2979 2980 2981 2982 2983 2984 2985
      entry->s->mysql_version= MYSQL_VERSION_ID;
  }
err:
  if (file >= 0)
    VOID(my_close(file,MYF(MY_WME)));
  DBUG_RETURN(result);
}



unknown's avatar
unknown committed
2986 2987 2988 2989
/**
  @return
    key if error because of duplicated keys
*/
unknown's avatar
unknown committed
2990 2991
uint handler::get_dup_key(int error)
{
2992
  DBUG_ENTER("handler::get_dup_key");
unknown's avatar
unknown committed
2993
  table->file->errkey  = (uint) -1;
2994 2995 2996
  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)
2997
    table->file->info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
unknown's avatar
unknown committed
2998 2999 3000
  DBUG_RETURN(table->file->errkey);
}

unknown's avatar
unknown committed
3001

unknown's avatar
unknown committed
3002 3003
/**
  Delete all files with extension from bas_ext().
3004

unknown's avatar
unknown committed
3005
  @param name		Base name of table
3006

unknown's avatar
unknown committed
3007
  @note
3008 3009 3010
    We assume that the handler may return more extensions than
    was actually used for the file.

unknown's avatar
unknown committed
3011
  @retval
3012
    0   If we successfully deleted at least one file from base_ext and
unknown's avatar
unknown committed
3013 3014 3015
    didn't get any other errors than ENOENT
  @retval
    !0  Error
3016
*/
unknown's avatar
unknown committed
3017 3018
int handler::delete_table(const char *name)
{
3019
  int saved_error= 0;
3020 3021
  int error= 0;
  int enoent_or_zero= ENOENT;                   // Error if no file was deleted
3022
  char buff[FN_REFLEN];
3023

unknown's avatar
unknown committed
3024 3025
  for (const char **ext=bas_ext(); *ext ; ext++)
  {
3026
    fn_format(buff, name, "", *ext, MY_UNPACK_FILENAME|MY_APPEND_EXT);
3027
    if (my_delete_with_symlink(buff, MYF(0)))
unknown's avatar
unknown committed
3028
    {
3029 3030 3031 3032 3033 3034 3035 3036 3037 3038
      if (my_errno != ENOENT)
      {
        /*
          If error on the first existing file, return the error.
          Otherwise delete as much as possible.
        */
        if (enoent_or_zero)
          return my_errno;
	saved_error= my_errno;
      }
unknown's avatar
unknown committed
3039
    }
3040
    else
3041
      enoent_or_zero= 0;                        // No error for ENOENT
3042
    error= enoent_or_zero;
unknown's avatar
unknown committed
3043
  }
3044
  return saved_error ? saved_error : error;
unknown's avatar
unknown committed
3045 3046 3047 3048 3049
}


int handler::rename_table(const char * from, const char * to)
{
unknown's avatar
unknown committed
3050
  int error= 0;
3051 3052 3053
  const char **ext, **start_ext;
  start_ext= bas_ext();
  for (ext= start_ext; *ext ; ext++)
unknown's avatar
unknown committed
3054
  {
unknown's avatar
unknown committed
3055 3056 3057 3058 3059 3060
    if (rename_file_ext(from, to, *ext))
    {
      if ((error=my_errno) != ENOENT)
	break;
      error= 0;
    }
unknown's avatar
unknown committed
3061
  }
3062 3063 3064 3065 3066 3067
  if (error)
  {
    /* Try to revert the rename. Ignore errors. */
    for (; ext >= start_ext; ext--)
      rename_file_ext(to, from, *ext);
  }
unknown's avatar
unknown committed
3068
  return error;
unknown's avatar
unknown committed
3069 3070
}

unknown's avatar
unknown committed
3071 3072 3073 3074 3075 3076 3077 3078

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


unknown's avatar
unknown committed
3079 3080
/**
  Performs checks upon the table.
unknown's avatar
unknown committed
3081

unknown's avatar
unknown committed
3082 3083
  @param thd                thread doing CHECK TABLE operation
  @param check_opt          options from the parser
unknown's avatar
unknown committed
3084

unknown's avatar
unknown committed
3085 3086 3087 3088 3089 3090 3091 3092
  @retval
    HA_ADMIN_OK               Successful upgrade
  @retval
    HA_ADMIN_NEEDS_UPGRADE    Table has structures requiring upgrade
  @retval
    HA_ADMIN_NEEDS_ALTER      Table has structures requiring ALTER TABLE
  @retval
    HA_ADMIN_NOT_IMPLEMENTED
unknown's avatar
unknown committed
3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113
*/
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;
3114
  return update_frm_version(table);
unknown's avatar
unknown committed
3115 3116
}

3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146
/**
  A helper function to mark a transaction read-write,
  if it is started.
*/

inline
void
handler::mark_trx_read_write()
{
  Ha_trx_info *ha_info= &ha_thd()->ha_data[ht->slot].ha_info[0];
  /*
    When a storage engine method is called, the transaction must
    have been started, unless it's a DDL call, for which the
    storage engine starts the transaction internally, and commits
    it internally, without registering in the ha_list.
    Unfortunately here we can't know know for sure if the engine
    has registered the transaction or not, so we must check.
  */
  if (ha_info->is_started())
  {
    DBUG_ASSERT(has_transactions());
    /*
      table_share can be NULL in ha_delete_table(). See implementation
      of standalone function ha_delete_table() in sql_base.cc.
    */
    if (table_share == NULL || table_share->tmp_table == NO_TMP_TABLE)
      ha_info->set_trx_read_write();
  }
}

unknown's avatar
unknown committed
3147

3148 3149 3150 3151 3152 3153
/**
  Repair table: public interface.

  @sa handler::repair()
*/

unknown's avatar
unknown committed
3154 3155 3156
int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
{
  int result;
3157 3158 3159

  mark_trx_read_write();

unknown's avatar
unknown committed
3160 3161
  if ((result= repair(thd, check_opt)))
    return result;
3162
  return update_frm_version(table);
unknown's avatar
unknown committed
3163 3164 3165
}


3166 3167 3168 3169 3170 3171 3172 3173 3174 3175
/**
  Bulk update row: public interface.

  @sa handler::bulk_update_row()
*/

int
handler::ha_bulk_update_row(const uchar *old_data, uchar *new_data,
                            uint *dup_key_found)
{
3176 3177
  mark_trx_read_write();

3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190
  return bulk_update_row(old_data, new_data, dup_key_found);
}


/**
  Delete all rows: public interface.

  @sa handler::delete_all_rows()
*/

int
handler::ha_delete_all_rows()
{
3191 3192
  mark_trx_read_write();

3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205
  return delete_all_rows();
}


/**
  Reset auto increment: public interface.

  @sa handler::reset_auto_increment()
*/

int
handler::ha_reset_auto_increment(ulonglong value)
{
3206 3207
  mark_trx_read_write();

3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220
  return reset_auto_increment(value);
}


/**
  Backup table: public interface.

  @sa handler::backup()
*/

int
handler::ha_backup(THD* thd, HA_CHECK_OPT* check_opt)
{
3221 3222
  mark_trx_read_write();

3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235
  return backup(thd, check_opt);
}


/**
  Restore table: public interface.

  @sa handler::restore()
*/

int
handler::ha_restore(THD* thd, HA_CHECK_OPT* check_opt)
{
3236 3237
  mark_trx_read_write();

3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250
  return restore(thd, check_opt);
}


/**
  Optimize table: public interface.

  @sa handler::optimize()
*/

int
handler::ha_optimize(THD* thd, HA_CHECK_OPT* check_opt)
{
3251 3252
  mark_trx_read_write();

3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265
  return optimize(thd, check_opt);
}


/**
  Analyze table: public interface.

  @sa handler::analyze()
*/

int
handler::ha_analyze(THD* thd, HA_CHECK_OPT* check_opt)
{
3266 3267
  mark_trx_read_write();

3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280
  return analyze(thd, check_opt);
}


/**
  Check and repair table: public interface.

  @sa handler::check_and_repair()
*/

bool
handler::ha_check_and_repair(THD *thd)
{
3281 3282
  mark_trx_read_write();

3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295
  return check_and_repair(thd);
}


/**
  Disable indexes: public interface.

  @sa handler::disable_indexes()
*/

int
handler::ha_disable_indexes(uint mode)
{
3296 3297
  mark_trx_read_write();

3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310
  return disable_indexes(mode);
}


/**
  Enable indexes: public interface.

  @sa handler::enable_indexes()
*/

int
handler::ha_enable_indexes(uint mode)
{
3311 3312
  mark_trx_read_write();

3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325
  return enable_indexes(mode);
}


/**
  Discard or import tablespace: public interface.

  @sa handler::discard_or_import_tablespace()
*/

int
handler::ha_discard_or_import_tablespace(my_bool discard)
{
3326 3327
  mark_trx_read_write();

3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342
  return discard_or_import_tablespace(discard);
}


/**
  Prepare for alter: public interface.

  Called to prepare an *online* ALTER.

  @sa handler::prepare_for_alter()
*/

void
handler::ha_prepare_for_alter()
{
3343 3344
  mark_trx_read_write();

3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357
  prepare_for_alter();
}


/**
  Rename table: public interface.

  @sa handler::rename_table()
*/

int
handler::ha_rename_table(const char *from, const char *to)
{
3358 3359
  mark_trx_read_write();

3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372
  return rename_table(from, to);
}


/**
  Delete table: public interface.

  @sa handler::delete_table()
*/

int
handler::ha_delete_table(const char *name)
{
3373 3374
  mark_trx_read_write();

3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387
  return delete_table(name);
}


/**
  Drop table in the engine: public interface.

  @sa handler::drop_table()
*/

void
handler::ha_drop_table(const char *name)
{
3388 3389
  mark_trx_read_write();

3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402
  return drop_table(name);
}


/**
  Create a table in the engine: public interface.

  @sa handler::create()
*/

int
handler::ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info)
{
3403 3404
  mark_trx_read_write();

3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418
  return create(name, form, info);
}


/**
  Create handler files for CREATE TABLE: public interface.

  @sa handler::create_handler_files()
*/

int
handler::ha_create_handler_files(const char *name, const char *old_name,
                        int action_flag, HA_CREATE_INFO *info)
{
3419 3420
  mark_trx_read_write();

3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433
  return create_handler_files(name, old_name, action_flag, info);
}


/**
  Change partitions: public interface.

  @sa handler::change_partitions()
*/

int
handler::ha_change_partitions(HA_CREATE_INFO *create_info,
                     const char *path,
3434 3435
                     ulonglong * const copied,
                     ulonglong * const deleted,
3436 3437 3438
                     const uchar *pack_frm_data,
                     size_t pack_frm_len)
{
3439 3440
  mark_trx_read_write();

3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454
  return change_partitions(create_info, path, copied, deleted,
                           pack_frm_data, pack_frm_len);
}


/**
  Drop partitions: public interface.

  @sa handler::drop_partitions()
*/

int
handler::ha_drop_partitions(const char *path)
{
3455 3456
  mark_trx_read_write();

3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469
  return drop_partitions(path);
}


/**
  Rename partitions: public interface.

  @sa handler::rename_partitions()
*/

int
handler::ha_rename_partitions(const char *path)
{
3470 3471
  mark_trx_read_write();

3472 3473 3474 3475
  return rename_partitions(path);
}


unknown's avatar
unknown committed
3476
/**
3477 3478 3479 3480 3481 3482
  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.
3483
*/
3484
int ha_enable_transaction(THD *thd, bool on)
3485 3486
{
  int error=0;
3487
  DBUG_ENTER("ha_enable_transaction");
unknown's avatar
unknown committed
3488 3489
  DBUG_PRINT("enter", ("on: %d", (int) on));

3490
  if ((thd->transaction.on= on))
3491 3492 3493 3494 3495 3496 3497
  {
    /*
      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.
    */
3498
    if (!(error= ha_commit_trans(thd, 0)))
3499
      error= end_trans(thd, COMMIT);
3500
  }
3501 3502 3503
  DBUG_RETURN(error);
}

3504
int handler::index_next_same(uchar *buf, const uchar *key, uint keylen)
unknown's avatar
unknown committed
3505 3506
{
  int error;
3507
  DBUG_ENTER("index_next_same");
unknown's avatar
unknown committed
3508 3509
  if (!(error=index_next(buf)))
  {
3510
    my_ptrdiff_t ptrdiff= buf - table->record[0];
3511 3512 3513 3514
    uchar *UNINIT_VAR(save_record_0);
    KEY *UNINIT_VAR(key_info);
    KEY_PART_INFO *UNINIT_VAR(key_part);
    KEY_PART_INFO *UNINIT_VAR(key_part_end);
3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537

    /*
      key_cmp_if_same() compares table->record[0] against 'key'.
      In parts it uses table->record[0] directly, in parts it uses
      field objects with their local pointers into table->record[0].
      If 'buf' is distinct from table->record[0], we need to move
      all record references. This is table->record[0] itself and
      the field pointers of the fields used in this key.
    */
    if (ptrdiff)
    {
      save_record_0= table->record[0];
      table->record[0]= buf;
      key_info= table->key_info + active_index;
      key_part= key_info->key_part;
      key_part_end= key_part + key_info->key_parts;
      for (; key_part < key_part_end; key_part++)
      {
        DBUG_ASSERT(key_part->field);
        key_part->field->move_field_offset(ptrdiff);
      }
    }

unknown's avatar
unknown committed
3538
    if (key_cmp_if_same(table, key, active_index, keylen))
unknown's avatar
unknown committed
3539 3540 3541 3542
    {
      table->status=STATUS_NOT_FOUND;
      error=HA_ERR_END_OF_FILE;
    }
3543 3544 3545 3546 3547 3548 3549 3550

    /* Move back if necessary. */
    if (ptrdiff)
    {
      table->record[0]= save_record_0;
      for (key_part= key_info->key_part; key_part < key_part_end; key_part++)
        key_part->field->move_field_offset(-ptrdiff);
    }
unknown's avatar
unknown committed
3551
  }
3552
  DBUG_RETURN(error);
unknown's avatar
unknown committed
3553 3554 3555
}


3556 3557
void handler::get_dynamic_partition_info(PARTITION_INFO *stat_info,
                                         uint part_id)
3558 3559 3560
{
  info(HA_STATUS_CONST | HA_STATUS_TIME | HA_STATUS_VARIABLE |
       HA_STATUS_NO_LOCK);
3561 3562 3563 3564 3565 3566 3567 3568 3569 3570
  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;
3571
  if (table_flags() & (ulong) HA_HAS_CHECKSUM)
3572
    stat_info->check_sum= checksum();
3573 3574 3575 3576
  return;
}


unknown's avatar
unknown committed
3577 3578 3579 3580
/****************************************************************************
** Some general functions that isn't in the handler class
****************************************************************************/

unknown's avatar
unknown committed
3581 3582
/**
  Initiates table-file and calls appropriate database-creator.
unknown's avatar
unknown committed
3583

unknown's avatar
unknown committed
3584
  @retval
unknown's avatar
unknown committed
3585
   0  ok
unknown's avatar
unknown committed
3586
  @retval
unknown's avatar
unknown committed
3587
   1  error
unknown's avatar
unknown committed
3588
*/
unknown's avatar
unknown committed
3589 3590 3591
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
3592 3593
		    bool update_create_info)
{
unknown's avatar
unknown committed
3594
  int error= 1;
unknown's avatar
unknown committed
3595
  TABLE table;
unknown's avatar
unknown committed
3596
  char name_buff[FN_REFLEN];
unknown's avatar
unknown committed
3597 3598
  const char *name;
  TABLE_SHARE share;
unknown's avatar
unknown committed
3599
  DBUG_ENTER("ha_create_table");
unknown's avatar
unknown committed
3600
  
3601
  init_tmp_table_share(thd, &share, db, 0, table_name, path);
unknown's avatar
unknown committed
3602
  if (open_table_def(thd, &share, 0) ||
unknown's avatar
unknown committed
3603 3604
      open_table_from_share(thd, &share, "", 0, (uint) READ_ALL, 0, &table,
                            TRUE))
unknown's avatar
unknown committed
3605
    goto err;
unknown's avatar
unknown committed
3606 3607 3608

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

3610
  name= get_canonical_filename(table.file, share.path.str, name_buff);
unknown's avatar
unknown committed
3611

3612
  error= table.file->ha_create(name, &table, create_info);
unknown's avatar
unknown committed
3613
  VOID(closefrm(&table, 0));
unknown's avatar
unknown committed
3614
  if (error)
unknown's avatar
unknown committed
3615 3616 3617 3618 3619 3620
  {
    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
3621 3622 3623
  DBUG_RETURN(error != 0);
}

unknown's avatar
unknown committed
3624 3625
/**
  Try to discover table from engine.
unknown's avatar
unknown committed
3626

unknown's avatar
unknown committed
3627
  @note
unknown's avatar
unknown committed
3628
    If found, write the frm file to disk.
3629

unknown's avatar
unknown committed
3630
  @retval
unknown's avatar
unknown committed
3631
  -1    Table did not exists
unknown's avatar
unknown committed
3632
  @retval
unknown's avatar
unknown committed
3633
   0    Table created ok
unknown's avatar
unknown committed
3634
  @retval
unknown's avatar
unknown committed
3635
   > 0  Error, table existed but could not be created
3636
*/
unknown's avatar
unknown committed
3637
int ha_create_table_from_engine(THD* thd, const char *db, const char *name)
3638
{
unknown's avatar
unknown committed
3639
  int error;
3640 3641
  uchar *frmblob;
  size_t frmlen;
3642
  char path[FN_REFLEN + 1];
3643 3644
  HA_CREATE_INFO create_info;
  TABLE table;
unknown's avatar
unknown committed
3645
  TABLE_SHARE share;
3646
  DBUG_ENTER("ha_create_table_from_engine");
unknown's avatar
unknown committed
3647
  DBUG_PRINT("enter", ("name '%s'.'%s'", db, name));
3648

3649
  bzero((uchar*) &create_info,sizeof(create_info));
3650
  if ((error= ha_discover(thd, db, name, &frmblob, &frmlen)))
3651
  {
unknown's avatar
unknown committed
3652
    /* Table could not be discovered and thus not created */
3653
    DBUG_RETURN(error);
3654 3655
  }

unknown's avatar
unknown committed
3656
  /*
3657 3658
    Table exists in handler and could be discovered
    frmblob and frmlen are set, write the frm to disk
unknown's avatar
unknown committed
3659
  */
3660

3661
  build_table_filename(path, sizeof(path) - 1, db, name, "", 0);
3662
  // Save the frm file
unknown's avatar
unknown committed
3663
  error= writefrm(path, frmblob, frmlen);
3664
  my_free(frmblob, MYF(0));
unknown's avatar
unknown committed
3665
  if (error)
3666
    DBUG_RETURN(2);
3667

3668
  init_tmp_table_share(thd, &share, db, 0, name, path);
unknown's avatar
unknown committed
3669 3670 3671 3672
  if (open_table_def(thd, &share, 0))
  {
    DBUG_RETURN(3);
  }
unknown's avatar
unknown committed
3673
  if (open_table_from_share(thd, &share, "" ,0, 0, 0, &table, FALSE))
unknown's avatar
unknown committed
3674 3675
  {
    free_table_share(&share);
3676
    DBUG_RETURN(3);
unknown's avatar
unknown committed
3677
  }
3678

3679
  update_create_info_from_table(&create_info, &table);
3680
  create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE;
3681

3682
  get_canonical_filename(table.file, path, path);
3683
  error=table.file->ha_create(path, &table, &create_info);
unknown's avatar
unknown committed
3684
  VOID(closefrm(&table, 1));
3685

3686
  DBUG_RETURN(error != 0);
3687 3688
}

3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705
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)
*****************************************************************************/

unknown's avatar
unknown committed
3706 3707
/**
  Init a key cache if it has not been initied before.
3708
*/
unknown's avatar
unknown committed
3709
int ha_init_key_cache(const char *name, KEY_CACHE *key_cache)
unknown's avatar
unknown committed
3710
{
3711 3712
  DBUG_ENTER("ha_init_key_cache");

unknown's avatar
unknown committed
3713
  if (!key_cache->key_cache_inited)
3714 3715
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
3716
    size_t tmp_buff_size= (size_t) key_cache->param_buff_size;
3717
    uint tmp_block_size= (uint) key_cache->param_block_size;
unknown's avatar
unknown committed
3718 3719
    uint division_limit= key_cache->param_division_limit;
    uint age_threshold=  key_cache->param_age_threshold;
3720
    pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
3721
    DBUG_RETURN(!init_key_cache(key_cache,
3722 3723
				tmp_block_size,
				tmp_buff_size,
unknown's avatar
unknown committed
3724
				division_limit, age_threshold));
3725
  }
3726
  DBUG_RETURN(0);
unknown's avatar
unknown committed
3727 3728
}

3729

unknown's avatar
unknown committed
3730 3731
/**
  Resize key cache.
3732
*/
unknown's avatar
unknown committed
3733
int ha_resize_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
3734
{
3735 3736
  DBUG_ENTER("ha_resize_key_cache");

unknown's avatar
unknown committed
3737
  if (key_cache->key_cache_inited)
3738 3739
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
3740
    size_t tmp_buff_size= (size_t) key_cache->param_buff_size;
unknown's avatar
unknown committed
3741 3742 3743
    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;
3744
    pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
3745 3746 3747
    DBUG_RETURN(!resize_key_cache(key_cache, tmp_block_size,
				  tmp_buff_size,
				  division_limit, age_threshold));
3748
  }
3749
  DBUG_RETURN(0);
3750 3751
}

3752

unknown's avatar
unknown committed
3753
/**
3754 3755
  Change parameters for key cache (like size)
*/
unknown's avatar
unknown committed
3756
int ha_change_key_cache_param(KEY_CACHE *key_cache)
3757
{
unknown's avatar
unknown committed
3758 3759 3760 3761 3762 3763 3764 3765
  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);
  }
3766 3767
  return 0;
}
unknown's avatar
unknown committed
3768

unknown's avatar
unknown committed
3769 3770
/**
  Free memory allocated by a key cache.
3771
*/
unknown's avatar
unknown committed
3772
int ha_end_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
3773
{
unknown's avatar
unknown committed
3774
  end_key_cache(key_cache, 1);		// Can never fail
3775
  return 0;
unknown's avatar
unknown committed
3776
}
unknown's avatar
unknown committed
3777

unknown's avatar
unknown committed
3778 3779
/**
  Move all tables from one key cache to another one.
3780
*/
unknown's avatar
unknown committed
3781 3782
int ha_change_key_cache(KEY_CACHE *old_key_cache,
			KEY_CACHE *new_key_cache)
unknown's avatar
unknown committed
3783
{
3784 3785
  mi_change_key_cache(old_key_cache, new_key_cache);
  return 0;
unknown's avatar
unknown committed
3786
}
3787 3788


unknown's avatar
unknown committed
3789 3790
/**
  Try to discover one table from handler(s).
unknown's avatar
unknown committed
3791

unknown's avatar
unknown committed
3792 3793 3794 3795 3796 3797
  @retval
    -1   Table did not exists
  @retval
    0   OK. In this case *frmblob and *frmlen are set
  @retval
    >0   error.  frmblob and frmlen may not be set
unknown's avatar
unknown committed
3798
*/
3799
struct st_discover_args
unknown's avatar
unknown committed
3800 3801 3802
{
  const char *db;
  const char *name;
3803 3804
  uchar **frmblob; 
  size_t *frmlen;
unknown's avatar
unknown committed
3805 3806
};

unknown's avatar
unknown committed
3807
static my_bool discover_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
3808 3809 3810
                                   void *arg)
{
  st_discover_args *vargs= (st_discover_args *)arg;
unknown's avatar
unknown committed
3811
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
3812
  if (hton->state == SHOW_OPTION_YES && hton->discover &&
3813 3814 3815
      (!(hton->discover(hton, thd, vargs->db, vargs->name, 
                        vargs->frmblob, 
                        vargs->frmlen))))
unknown's avatar
unknown committed
3816 3817 3818 3819 3820
    return TRUE;

  return FALSE;
}

unknown's avatar
unknown committed
3821
int ha_discover(THD *thd, const char *db, const char *name,
3822
		uchar **frmblob, size_t *frmlen)
unknown's avatar
unknown committed
3823
{
3824
  int error= -1; // Table does not exist in any handler
unknown's avatar
unknown committed
3825
  DBUG_ENTER("ha_discover");
3826
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
unknown's avatar
unknown committed
3827 3828
  st_discover_args args= {db, name, frmblob, frmlen};

3829 3830
  if (is_prefix(name,tmp_file_prefix)) /* skip temporary tables */
    DBUG_RETURN(error);
unknown's avatar
unknown committed
3831 3832 3833 3834 3835

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

unknown's avatar
unknown committed
3836
  if (!error)
3837
    status_var_increment(thd->status_var.ha_discover_count);
unknown's avatar
unknown committed
3838 3839 3840 3841
  DBUG_RETURN(error);
}


unknown's avatar
unknown committed
3842 3843 3844
/**
  Call this function in order to give the handler the possiblity
  to ask engine if there are any new tables that should be written to disk
3845
  or any dropped tables that need to be removed from disk
3846
*/
3847
struct st_find_files_args
3848 3849 3850 3851 3852
{
  const char *db;
  const char *path;
  const char *wild;
  bool dir;
3853
  List<LEX_STRING> *files;
3854 3855
};

unknown's avatar
unknown committed
3856
static my_bool find_files_handlerton(THD *thd, plugin_ref plugin,
3857 3858 3859
                                   void *arg)
{
  st_find_files_args *vargs= (st_find_files_args *)arg;
unknown's avatar
unknown committed
3860
  handlerton *hton= plugin_data(plugin, handlerton *);
3861 3862 3863


  if (hton->state == SHOW_OPTION_YES && hton->find_files)
3864
      if (hton->find_files(hton, thd, vargs->db, vargs->path, vargs->wild, 
3865 3866 3867 3868 3869
                          vargs->dir, vargs->files))
        return TRUE;

  return FALSE;
}
3870

3871 3872
int
ha_find_files(THD *thd,const char *db,const char *path,
3873
	      const char *wild, bool dir, List<LEX_STRING> *files)
3874 3875
{
  int error= 0;
3876
  DBUG_ENTER("ha_find_files");
unknown's avatar
unknown committed
3877 3878
  DBUG_PRINT("enter", ("db: '%s'  path: '%s'  wild: '%s'  dir: %d", 
		       db, path, wild ? wild : "NULL", dir));
3879 3880 3881 3882 3883
  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 */
3884 3885 3886
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
3887 3888 3889
/**
  Ask handler if the table exists in engine.
  @retval
3890
    HA_ERR_NO_SUCH_TABLE     Table does not exist
unknown's avatar
unknown committed
3891
  @retval
3892
    HA_ERR_TABLE_EXIST       Table exists
unknown's avatar
unknown committed
3893 3894 3895
  @retval
    \#                  Error code
*/
3896
struct st_table_exists_in_engine_args
3897 3898 3899
{
  const char *db;
  const char *name;
3900
  int err;
3901 3902
};

unknown's avatar
unknown committed
3903
static my_bool table_exists_in_engine_handlerton(THD *thd, plugin_ref plugin,
3904 3905 3906
                                   void *arg)
{
  st_table_exists_in_engine_args *vargs= (st_table_exists_in_engine_args *)arg;
unknown's avatar
unknown committed
3907
  handlerton *hton= plugin_data(plugin, handlerton *);
3908

3909 3910
  int err= HA_ERR_NO_SUCH_TABLE;

3911
  if (hton->state == SHOW_OPTION_YES && hton->table_exists_in_engine)
3912 3913 3914 3915 3916
    err = hton->table_exists_in_engine(hton, thd, vargs->db, vargs->name);

  vargs->err = err;
  if (vargs->err == HA_ERR_TABLE_EXIST)
    return TRUE;
3917 3918 3919 3920

  return FALSE;
}

3921
int ha_table_exists_in_engine(THD* thd, const char* db, const char* name)
3922
{
3923
  DBUG_ENTER("ha_table_exists_in_engine");
3924
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
3925 3926
  st_table_exists_in_engine_args args= {db, name, HA_ERR_NO_SUCH_TABLE};
  plugin_foreach(thd, table_exists_in_engine_handlerton,
3927
                 MYSQL_STORAGE_ENGINE_PLUGIN, &args);
3928 3929
  DBUG_PRINT("exit", ("error: %d", args.err));
  DBUG_RETURN(args.err);
3930 3931
}

unknown's avatar
unknown committed
3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951
#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;
};

3952
/** @brief
unknown's avatar
unknown committed
3953 3954
  Listing handlertons first to avoid recursive calls and deadlock
*/
unknown's avatar
unknown committed
3955
static my_bool binlog_func_list(THD *thd, plugin_ref plugin, void *arg)
unknown's avatar
unknown committed
3956 3957
{
  hton_list_st *hton_list= (hton_list_st *)arg;
unknown's avatar
unknown committed
3958
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975
  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;
3976 3977
  uint i, sz;

unknown's avatar
unknown committed
3978 3979 3980 3981
  hton_list.sz= 0;
  plugin_foreach(thd, binlog_func_list,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &hton_list);

3982 3983
  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
3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016
  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
4017
  return 0;
unknown's avatar
unknown committed
4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028
}

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

4029
static my_bool binlog_log_query_handlerton2(THD *thd,
4030
                                            handlerton *hton,
4031
                                            void *args)
unknown's avatar
unknown committed
4032 4033 4034
{
  struct binlog_log_query_st *b= (struct binlog_log_query_st*)args;
  if (hton->state == SHOW_OPTION_YES && hton->binlog_log_query)
4035
    hton->binlog_log_query(hton, thd,
unknown's avatar
unknown committed
4036 4037 4038 4039 4040 4041 4042 4043
                           b->binlog_command,
                           b->query,
                           b->query_length,
                           b->db,
                           b->table_name);
  return FALSE;
}

4044
static my_bool binlog_log_query_handlerton(THD *thd,
unknown's avatar
unknown committed
4045
                                           plugin_ref plugin,
4046 4047
                                           void *args)
{
unknown's avatar
unknown committed
4048
  return binlog_log_query_handlerton2(thd, plugin_data(plugin, handlerton *), args);
4049 4050
}

4051
void ha_binlog_log_query(THD *thd, handlerton *hton,
4052
                         enum_binlog_command binlog_command,
unknown's avatar
unknown committed
4053 4054 4055 4056 4057 4058 4059 4060 4061
                         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;
4062 4063 4064 4065 4066
  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
4067 4068
}
#endif
4069

unknown's avatar
unknown committed
4070
/**
unknown's avatar
unknown committed
4071 4072
  Read the first row of a multi-range set.

unknown's avatar
unknown committed
4073 4074 4075 4076 4077 4078 4079 4080 4081 4082
  @param found_range_p       Returns a pointer to the element in 'ranges' that
                             corresponds to the returned row.
  @param ranges              An array of KEY_MULTI_RANGE range descriptions.
  @param range_count         Number of ranges in 'ranges'.
  @param sorted	      If result should be sorted per key.
  @param buffer              A HANDLER_BUFFER for internal handler usage.

  @note
    - Record is read into table->record[0].
    - *found_range_p returns a valid value only if read_multi_range_first()
unknown's avatar
unknown committed
4083
    returns 0.
unknown's avatar
unknown committed
4084
    - Sorting is done within each range. If you want an overall sort, enter
unknown's avatar
unknown committed
4085 4086
    'ranges' with sorted ranges.

unknown's avatar
unknown committed
4087
  @retval
unknown's avatar
unknown committed
4088
    0			OK, found a row
unknown's avatar
unknown committed
4089
  @retval
unknown's avatar
unknown committed
4090
    HA_ERR_END_OF_FILE	No rows in range
unknown's avatar
unknown committed
4091 4092
  @retval
    \#			Error code
unknown's avatar
unknown committed
4093 4094 4095 4096 4097 4098 4099 4100 4101 4102
*/
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;

4103 4104 4105
  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
4106 4107 4108 4109
  for (multi_range_curr= ranges, multi_range_end= ranges + range_count;
       multi_range_curr < multi_range_end;
       multi_range_curr++)
  {
4110
    result= read_range_first(multi_range_curr->start_key.keypart_map ?
unknown's avatar
unknown committed
4111
                             &multi_range_curr->start_key : 0,
4112
                             multi_range_curr->end_key.keypart_map ?
unknown's avatar
unknown committed
4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125
                             &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);
}


unknown's avatar
unknown committed
4126
/**
unknown's avatar
unknown committed
4127 4128
  Read the next row of a multi-range set.

unknown's avatar
unknown committed
4129 4130
  @param found_range_p       Returns a pointer to the element in 'ranges' that
                             corresponds to the returned row.
unknown's avatar
unknown committed
4131

unknown's avatar
unknown committed
4132 4133 4134
  @note
    - Record is read into table->record[0].
    - *found_range_p returns a valid value only if read_multi_range_next()
unknown's avatar
unknown committed
4135 4136
    returns 0.

unknown's avatar
unknown committed
4137
  @retval
unknown's avatar
unknown committed
4138
    0			OK, found a row
unknown's avatar
unknown committed
4139
  @retval
unknown's avatar
unknown committed
4140
    HA_ERR_END_OF_FILE	No (more) rows in range
unknown's avatar
unknown committed
4141 4142
  @retval
    \#			Error code
unknown's avatar
unknown committed
4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164
*/
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
    {
unknown's avatar
unknown committed
4165 4166
      if (was_semi_consistent_read())
        goto scan_it_again;
unknown's avatar
unknown committed
4167 4168 4169 4170 4171 4172 4173
      /*
        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;
    }

unknown's avatar
unknown committed
4174 4175
    multi_range_curr++;
scan_it_again:
unknown's avatar
unknown committed
4176
    /* Try the next range(s) until one matches a record. */
unknown's avatar
unknown committed
4177
    for (; multi_range_curr < multi_range_end; multi_range_curr++)
unknown's avatar
unknown committed
4178
    {
4179
      result= read_range_first(multi_range_curr->start_key.keypart_map ?
unknown's avatar
unknown committed
4180
                               &multi_range_curr->start_key : 0,
4181
                               multi_range_curr->end_key.keypart_map ?
unknown's avatar
unknown committed
4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197
                               &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);
}


unknown's avatar
unknown committed
4198
/**
4199
  Read first row between two ranges.
unknown's avatar
unknown committed
4200
  Store ranges for future calls to read_range_next.
4201

unknown's avatar
unknown committed
4202 4203 4204 4205 4206 4207
  @param start_key		Start key. Is 0 if no min range
  @param end_key		End key.  Is 0 if no max range
  @param eq_range_arg	        Set to 1 if start_key == end_key
  @param sorted		Set to 1 if result should be sorted per key

  @note
4208 4209
    Record is read into table->record[0]

unknown's avatar
unknown committed
4210
  @retval
4211
    0			Found row
unknown's avatar
unknown committed
4212
  @retval
4213
    HA_ERR_END_OF_FILE	No rows in range
unknown's avatar
unknown committed
4214 4215
  @retval
    \#			Error code
4216 4217 4218
*/
int handler::read_range_first(const key_range *start_key,
			      const key_range *end_key,
unknown's avatar
unknown committed
4219
			      bool eq_range_arg, bool sorted)
4220 4221 4222 4223
{
  int result;
  DBUG_ENTER("handler::read_range_first");

unknown's avatar
unknown committed
4224
  eq_range= eq_range_arg;
4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237
  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
4238 4239 4240 4241
    result= index_read_map(table->record[0],
                           start_key->key,
                           start_key->keypart_map,
                           start_key->flag);
4242
  if (result)
unknown's avatar
unknown committed
4243 4244 4245
    DBUG_RETURN((result == HA_ERR_KEY_NOT_FOUND) 
		? HA_ERR_END_OF_FILE
		: result);
4246 4247 4248 4249 4250

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


unknown's avatar
unknown committed
4251
/**
4252 4253
  Read next row between two ranges.

unknown's avatar
unknown committed
4254
  @note
4255 4256
    Record is read into table->record[0]

unknown's avatar
unknown committed
4257
  @retval
4258
    0			Found row
unknown's avatar
unknown committed
4259
  @retval
4260
    HA_ERR_END_OF_FILE	No rows in range
unknown's avatar
unknown committed
4261 4262
  @retval
    \#			Error code
4263
*/
unknown's avatar
unknown committed
4264
int handler::read_range_next()
4265 4266 4267 4268 4269
{
  int result;
  DBUG_ENTER("handler::read_range_next");

  if (eq_range)
unknown's avatar
unknown committed
4270 4271 4272 4273 4274 4275 4276
  {
    /* 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]);
4277 4278 4279 4280 4281 4282
  if (result)
    DBUG_RETURN(result);
  DBUG_RETURN(compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
}


unknown's avatar
unknown committed
4283 4284
/**
  Compare if found key (in row) is over max-value.
4285

unknown's avatar
unknown committed
4286
  @param range		range to compare to row. May be 0 for no range
4287

unknown's avatar
unknown committed
4288 4289 4290 4291
  @seealso
    key.cc::key_cmp()

  @return
unknown's avatar
unknown committed
4292 4293
    The return value is SIGN(key_in_row - range_key):

unknown's avatar
unknown committed
4294 4295 4296
    - 0   : Key is equal to range or 'range' == 0 (no range)
    - -1  : Key is less than range
    - 1   : Key is larger than range
4297 4298 4299
*/
int handler::compare_key(key_range *range)
{
unknown's avatar
unknown committed
4300
  int cmp;
4301 4302
  if (!range)
    return 0;					// No max range
unknown's avatar
unknown committed
4303 4304 4305 4306
  cmp= key_cmp(range_key_part, range->key, range->length);
  if (!cmp)
    cmp= key_compare_result_on_equal;
  return cmp;
4307
}
unknown's avatar
unknown committed
4308

4309

4310 4311 4312
int handler::index_read_idx_map(uchar * buf, uint index, const uchar * key,
                                key_part_map keypart_map,
                                enum ha_rkey_function find_flag)
unknown's avatar
unknown committed
4313
{
4314 4315
  int error, error1;
  error= index_init(index, 0);
unknown's avatar
unknown committed
4316
  if (!error)
4317
  {
4318
    error= index_read_map(buf, key, keypart_map, find_flag);
4319 4320 4321
    error1= index_end();
  }
  return error ?  error : error1;
unknown's avatar
unknown committed
4322 4323
}

4324

unknown's avatar
unknown committed
4325
/**
4326 4327 4328
  Returns a list of all known extensions.

    No mutexes, worst case race is a minor surplus memory allocation
4329 4330
    We have to recreate the extension map if mysqld is restarted (for example
    within libmysqld)
4331

unknown's avatar
unknown committed
4332
  @retval
4333 4334
    pointer		pointer to TYPELIB structure
*/
unknown's avatar
unknown committed
4335
static my_bool exts_handlerton(THD *unused, plugin_ref plugin,
unknown's avatar
unknown committed
4336 4337 4338
                               void *arg)
{
  List<char> *found_exts= (List<char> *) arg;
unknown's avatar
unknown committed
4339
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
4340 4341
  handler *file;
  if (hton->state == SHOW_OPTION_YES && hton->create &&
4342
      (file= hton->create(hton, (TABLE_SHARE*) 0, current_thd->mem_root)))
unknown's avatar
unknown committed
4343 4344 4345
  {
    List_iterator_fast<char> it(*found_exts);
    const char **ext, *old_ext;
unknown's avatar
unknown committed
4346

unknown's avatar
unknown committed
4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363
    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;
}

4364 4365
TYPELIB *ha_known_exts(void)
{
4366
  if (!known_extensions.type_names || mysys_usage_id != known_extensions_id)
4367 4368
  {
    List<char> found_exts;
4369 4370 4371
    const char **ext, *old_ext;

    known_extensions_id= mysys_usage_id;
4372 4373
    found_exts.push_back((char*) TRG_EXT);
    found_exts.push_back((char*) TRN_EXT);
unknown's avatar
unknown committed
4374 4375

    plugin_foreach(NULL, exts_handlerton,
unknown's avatar
unknown committed
4376 4377
                   MYSQL_STORAGE_ENGINE_PLUGIN, &found_exts);

4378 4379 4380
    ext= (const char **) my_once_alloc(sizeof(char *)*
                                       (found_exts.elements+1),
                                       MYF(MY_WME | MY_FAE));
unknown's avatar
unknown committed
4381

4382
    DBUG_ASSERT(ext != 0);
4383 4384
    known_extensions.count= found_exts.elements;
    known_extensions.type_names= ext;
4385

unknown's avatar
unknown committed
4386
    List_iterator_fast<char> it(found_exts);
4387 4388 4389
    while ((old_ext= it++))
      *ext++= old_ext;
    *ext= 0;
4390 4391 4392
  }
  return &known_extensions;
}
unknown's avatar
unknown committed
4393

4394

unknown's avatar
unknown committed
4395 4396 4397
static bool stat_print(THD *thd, const char *type, uint type_len,
                       const char *file, uint file_len,
                       const char *status, uint status_len)
4398 4399 4400
{
  Protocol *protocol= thd->protocol;
  protocol->prepare_for_resend();
unknown's avatar
unknown committed
4401 4402 4403
  protocol->store(type, type_len, system_charset_info);
  protocol->store(file, file_len, system_charset_info);
  protocol->store(status, status_len, system_charset_info);
4404 4405 4406 4407 4408
  if (protocol->write())
    return TRUE;
  return FALSE;
}

unknown's avatar
unknown committed
4409

unknown's avatar
unknown committed
4410
static my_bool showstat_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
4411 4412 4413
                                   void *arg)
{
  enum ha_stat_type stat= *(enum ha_stat_type *) arg;
unknown's avatar
unknown committed
4414
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
4415
  if (hton->state == SHOW_OPTION_YES && hton->show_status &&
4416
      hton->show_status(hton, thd, stat_print, stat))
unknown's avatar
unknown committed
4417 4418 4419 4420 4421
    return TRUE;
  return FALSE;
}

bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat)
4422 4423 4424
{
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
unknown's avatar
unknown committed
4425
  bool result;
4426 4427 4428 4429 4430 4431 4432 4433 4434

  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
4435
  if (db_type == NULL)
4436
  {
unknown's avatar
unknown committed
4437
    result= plugin_foreach(thd, showstat_handlerton,
unknown's avatar
unknown committed
4438 4439 4440 4441 4442
                           MYSQL_STORAGE_ENGINE_PLUGIN, &stat);
  }
  else
  {
    if (db_type->state != SHOW_OPTION_YES)
unknown's avatar
unknown committed
4443
    {
unknown's avatar
unknown committed
4444 4445
      const LEX_STRING *name=&hton2plugin[db_type->slot]->name;
      result= stat_print(thd, name->str, name->length,
unknown's avatar
unknown committed
4446
                         "", 0, "DISABLED", 8) ? 1 : 0;
unknown's avatar
unknown committed
4447
    }
unknown's avatar
unknown committed
4448
    else
unknown's avatar
unknown committed
4449
      result= db_type->show_status &&
4450
              db_type->show_status(db_type, thd, stat_print, stat) ? 1 : 0;
4451 4452
  }

unknown's avatar
unknown committed
4453
  if (!result)
4454
    my_eof(thd);
unknown's avatar
unknown committed
4455
  return result;
4456 4457
}

4458 4459 4460 4461 4462
/*
  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:
4463
  - Row-based replication is enabled in the current thread
4464
  - The binlog is enabled
4465 4466 4467
  - It is not a temporary table
  - The binary log is open
  - The database the table resides in shall be binlogged (binlog_*_db rules)
4468
  - table is not mysql.event
4469 4470
*/

4471 4472 4473
static bool check_table_binlog_row_based(THD *thd, TABLE *table)
{
  if (table->s->cached_row_logging_check == -1)
4474
  {
4475 4476 4477 4478
    int const check(table->s->tmp_table == NO_TMP_TABLE &&
                    binlog_filter->db_ok(table->s->db.str));
    table->s->cached_row_logging_check= check;
  }
4479

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

4483 4484 4485 4486
  return (thd->current_stmt_binlog_row_based &&
          table->s->cached_row_logging_check &&
          (thd->options & OPTION_BIN_LOG) &&
          mysql_bin_log.is_open());
4487 4488 4489
}


4490
/** @brief
4491 4492 4493
   Write table maps for all (manually or automatically) locked tables
   to the binary log.

4494 4495 4496 4497 4498 4499 4500 4501 4502
   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.
4503

4504 4505 4506 4507 4508 4509 4510
   RETURN VALUE
       0   All OK
       1   Failed to write all table maps

   SEE ALSO
       THD::lock
       THD::locked_tables
4511
*/
4512

4513
static int write_locked_table_maps(THD *thd)
4514
{
4515 4516 4517 4518 4519
  DBUG_ENTER("write_locked_table_maps");
  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));
4520

4521 4522
  DBUG_PRINT("debug", ("get_binlog_table_maps(): %d", thd->get_binlog_table_maps()));

4523 4524 4525 4526 4527 4528 4529
  if (thd->get_binlog_table_maps() == 0)
  {
    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 )
4530
    {
4531 4532 4533 4534 4535 4536 4537 4538
      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)
4539
      {
4540 4541 4542 4543
        TABLE *const table= *table_ptr;
        DBUG_PRINT("info", ("Checking table %s", table->s->table_name.str));
        if (table->current_lock == F_WRLCK &&
            check_table_binlog_row_based(thd, table))
4544
        {
4545 4546 4547 4548 4549 4550 4551 4552
          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);
4553
        }
4554 4555 4556
      }
    }
  }
4557 4558
  DBUG_RETURN(0);
}
4559

4560 4561 4562 4563

typedef bool Log_func(THD*, TABLE*, bool, MY_BITMAP*,
                      uint, const uchar*, const uchar*);

4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574
static int binlog_log_row(TABLE* table,
                          const uchar *before_record,
                          const uchar *after_record,
                          Log_func *log_func)
{
  if (table->no_replicate)
    return 0;
  bool error= 0;
  THD *const thd= table->in_use;

  if (check_table_binlog_row_based(thd, table))
4575
  {
4576 4577 4578 4579 4580
    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;
4581

4582 4583 4584 4585 4586 4587 4588 4589 4590
    /*
      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,
                                    FALSE))))
4591
    {
4592 4593 4594 4595 4596 4597 4598 4599
      bitmap_set_all(&cols);
      if (likely(!(error= write_locked_table_maps(thd))))
        error= (*log_func)(thd, table, table->file->has_transactions(),
                           &cols, table->s->fields,
                           before_record, after_record);

      if (!use_bitbuf)
        bitmap_free(&cols);
4600 4601
    }
  }
4602
  return error ? HA_ERR_RBR_LOGGING_FAILED : 0;
4603
}
4604

4605
int handler::ha_external_lock(THD *thd, int lock_type)
4606
{
4607
  DBUG_ENTER("handler::ha_external_lock");
4608 4609 4610 4611 4612 4613
  /*
    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);
4614 4615 4616 4617 4618 4619 4620 4621 4622

  /*
    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);
4623 4624
}

4625

4626
/** @brief
4627 4628 4629 4630 4631
  Check handler usage and reset state of file to after 'open'
*/
int handler::ha_reset()
{
  DBUG_ENTER("ha_reset");
unknown's avatar
unknown committed
4632
  /* Check that we have called all proper deallocation functions */
4633
  DBUG_ASSERT((uchar*) table->def_read_set.bitmap +
4634
              table->s->column_bitmap_size ==
4635
              (uchar*) table->def_write_set.bitmap);
4636 4637 4638 4639 4640 4641
  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);
4642 4643
  /* reset the bitmaps to point to defaults */
  table->default_column_bitmaps();
4644 4645 4646 4647
  DBUG_RETURN(reset());
}


4648
int handler::ha_write_row(uchar *buf)
4649 4650
{
  int error;
4651
  Log_func *log_func= Write_rows_log_event::binlog_row_logging_function;
4652
  DBUG_ENTER("handler::ha_write_row");
4653 4654 4655

  mark_trx_read_write();

4656
  if (unlikely(error= write_row(buf)))
4657
    DBUG_RETURN(error);
4658
  if (unlikely(error= binlog_log_row(table, 0, buf, log_func)))
4659 4660
    DBUG_RETURN(error); /* purecov: inspected */
  DBUG_RETURN(0);
4661 4662
}

4663

4664
int handler::ha_update_row(const uchar *old_data, uchar *new_data)
4665 4666
{
  int error;
4667
  Log_func *log_func= Update_rows_log_event::binlog_row_logging_function;
4668 4669 4670 4671 4672 4673 4674

  /*
    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]);

4675 4676
  mark_trx_read_write();

4677 4678
  if (unlikely(error= update_row(old_data, new_data)))
    return error;
4679
  if (unlikely(error= binlog_log_row(table, old_data, new_data, log_func)))
4680 4681
    return error;
  return 0;
4682 4683
}

4684
int handler::ha_delete_row(const uchar *buf)
4685 4686
{
  int error;
4687
  Log_func *log_func= Delete_rows_log_event::binlog_row_logging_function;
4688 4689 4690

  mark_trx_read_write();

4691 4692
  if (unlikely(error= delete_row(buf)))
    return error;
4693
  if (unlikely(error= binlog_log_row(table, buf, 0, log_func)))
4694 4695
    return error;
  return 0;
4696
}
4697

4698

4699

4700
/** @brief
4701 4702 4703 4704 4705 4706 4707 4708 4709
  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();
}
4710 4711


4712
/** @brief
4713 4714 4715 4716 4717 4718 4719 4720 4721 4722
  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;
}

4723

4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740
#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 */

4741
  if ((*hton->create_iterator)(hton, HA_TRANSACTLOG_ITERATOR, &iterator) !=
4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770
      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


4771
/** @brief
4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810
  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)
{
4811
  my_free((uchar*)iterator->buffer, MYF(MY_ALLOW_ZERO_PTR));
4812 4813 4814
}


4815
/** @brief
4816 4817 4818 4819 4820 4821 4822 4823
  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;
4824
  uchar *ptr;
4825 4826 4827 4828 4829 4830 4831 4832 4833 4834
  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;
  }
4835
  if ((ptr= (uchar*)my_malloc(ALIGN_SIZE(sizeof(fl_buff)) +
4836 4837
                             ((ALIGN_SIZE(sizeof(LEX_STRING)) +
                               sizeof(enum log_status) +
4838
                               + FN_REFLEN + 1) *
4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865
                              (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 -
4866
                                        buff->names[buff->entries].str);
4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882
    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)
{
4883
  switch(type) {
4884 4885 4886 4887 4888 4889 4890
  case HA_TRANSACTLOG_ITERATOR:
    return fl_log_iterator_buffer_init(iterator);
  default:
    return HA_ITERATOR_UNSUPPORTED;
  }
}
#endif /*TRANS_LOG_MGM_EXAMPLE_CODE*/