handler.cc 165 KB
Newer Older
Sergei Golubchik's avatar
Sergei Golubchik committed
1 2
/* Copyright (c) 2000, 2013, Oracle and/or its affiliates.
   Copyright (c) 2009, 2013, Monty Program Ab.
unknown's avatar
unknown committed
3

unknown's avatar
unknown committed
4 5
   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
6
   the Free Software Foundation; version 2 of the License.
unknown's avatar
unknown committed
7

unknown's avatar
unknown committed
8 9 10 11
   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
12

unknown's avatar
unknown committed
13
   You should have received a copy of the GNU General Public License
14 15
   along with this program; if not, write to the Free Software Foundation,
   Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA */
unknown's avatar
unknown committed
16

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

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

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

27 28
#include "sql_priv.h"
#include "unireg.h"
He Zhenxing's avatar
He Zhenxing committed
29
#include "rpl_handler.h"
30
#include "sql_cache.h"                   // query_cache, query_cache_*
Sergei Golubchik's avatar
Sergei Golubchik committed
31
#include "sql_connect.h"                 // global_table_stats
32 33 34 35 36
#include "key.h"     // key_copy, key_unpack, key_cmp_if_same, key_cmp
#include "sql_table.h"                   // build_table_filename
#include "sql_parse.h"                          // check_stack_overrun
#include "sql_acl.h"            // SUPER_ACL
#include "sql_base.h"           // free_io_cache
37
#include "discover.h"           // extension_based_table_discovery, etc
38
#include "log_event.h"          // *_rows_log_event
39
#include "create_options.h"
40
#include "rpl_filter.h"
41
#include <myisampack.h>
Konstantin Osipov's avatar
Konstantin Osipov committed
42
#include "transaction.h"
43
#include "myisam.h"
44
#include "probes_mysql.h"
45
#include "debug_sync.h"         // DEBUG_SYNC
46
#include "sql_audit.h"
47

48 49
#ifdef WITH_PARTITION_STORAGE_ENGINE
#include "ha_partition.h"
50
#endif
51

52 53 54 55
#ifdef WITH_ARIA_STORAGE_ENGINE
#include "../storage/maria/ha_maria.h"
#endif

56 57 58 59 60
/*
  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
61
st_plugin_int *hton2plugin[MAX_HA];
unknown's avatar
unknown committed
62

63
static handlerton *installed_htons[128];
64

unknown's avatar
unknown committed
65 66
#define BITMAP_STACKBUF_SIZE (128/8)

67 68
KEY_CREATE_INFO default_key_create_info=
  { HA_KEY_ALG_UNDEF, 0, {NullS, 0}, {NullS, 0} };
69

unknown's avatar
unknown committed
70
/* number of entries in handlertons[] */
unknown's avatar
unknown committed
71
ulong total_ha= 0;
unknown's avatar
unknown committed
72
/* number of storage engines (from handlertons[]) that support 2pc */
unknown's avatar
unknown committed
73
ulong total_ha_2pc= 0;
unknown's avatar
unknown committed
74
/* size of savepoint storage area (see ha_init) */
unknown's avatar
unknown committed
75
ulong savepoint_alloc_size= 0;
76

unknown's avatar
unknown committed
77
static const LEX_STRING sys_table_aliases[]=
78
{
unknown's avatar
unknown committed
79 80 81
  { 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") },
82
  { C_STRING_WITH_LEN("MERGE") },     { C_STRING_WITH_LEN("MRG_MYISAM") },
Sergei Golubchik's avatar
Sergei Golubchik committed
83
  { C_STRING_WITH_LEN("Maria") },      { C_STRING_WITH_LEN("Aria") },
unknown's avatar
unknown committed
84
  {NullS, 0}
unknown's avatar
unknown committed
85
};
86

unknown's avatar
unknown committed
87
const char *ha_row_type[] = {
88
  "", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT",
89
  "PAGE",
90
  "?","?","?"
unknown's avatar
unknown committed
91 92
};

unknown's avatar
unknown committed
93
const char *tx_isolation_names[] =
94 95 96
{ "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",
  NullS};
TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
97
			       tx_isolation_names, NULL};
unknown's avatar
unknown committed
98

99
static TYPELIB known_extensions= {0,"known_exts", NULL, NULL};
100
uint known_extensions_id= 0;
101

102 103
static int commit_one_phase_2(THD *thd, bool all, THD_TRANS *trans,
                              bool is_real_trans);
unknown's avatar
unknown committed
104

unknown's avatar
unknown committed
105 106 107 108
static plugin_ref ha_default_plugin(THD *thd)
{
  if (thd->variables.table_plugin)
    return thd->variables.table_plugin;
109
  return my_plugin_lock(thd, global_system_variables.table_plugin);
unknown's avatar
unknown committed
110 111 112
}


113
/** @brief
unknown's avatar
unknown committed
114
  Return the default storage engine handlerton for thread
115

unknown's avatar
unknown committed
116 117 118
  SYNOPSIS
    ha_default_handlerton(thd)
    thd         current thread
119

unknown's avatar
unknown committed
120 121 122 123
  RETURN
    pointer to handlerton
*/
handlerton *ha_default_handlerton(THD *thd)
124
{
unknown's avatar
unknown committed
125 126 127 128 129
  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
130 131 132
}


133
/** @brief
unknown's avatar
unknown committed
134 135 136 137 138 139 140 141
  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
142
    pointer to storage engine plugin handle
unknown's avatar
unknown committed
143
*/
unknown's avatar
unknown committed
144
plugin_ref ha_resolve_by_name(THD *thd, const LEX_STRING *name)
unknown's avatar
unknown committed
145 146
{
  const LEX_STRING *table_alias;
unknown's avatar
unknown committed
147
  plugin_ref plugin;
148

unknown's avatar
unknown committed
149 150 151
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
152
                           (const uchar *)name->str, name->length,
unknown's avatar
unknown committed
153
                           (const uchar *)STRING_WITH_LEN("DEFAULT"), 0))
unknown's avatar
unknown committed
154
    return ha_default_plugin(thd);
unknown's avatar
unknown committed
155

unknown's avatar
unknown committed
156
  if ((plugin= my_plugin_lock_by_name(thd, name, MYSQL_STORAGE_ENGINE_PLUGIN)))
157
  {
unknown's avatar
unknown committed
158
    handlerton *hton= plugin_data(plugin, handlerton *);
159
    if (hton && !(hton->flags & HTON_NOT_USER_SELECTABLE))
unknown's avatar
unknown committed
160 161 162 163 164 165
      return plugin;
      
    /*
      unlocking plugin immediately after locking is relatively low cost.
    */
    plugin_unlock(thd, plugin);
166
  }
unknown's avatar
unknown committed
167

168
  /*
169
    We check for the historical aliases.
170
  */
unknown's avatar
unknown committed
171
  for (table_alias= sys_table_aliases; table_alias->str; table_alias+= 2)
172
  {
173
    if (!my_strnncoll(&my_charset_latin1,
unknown's avatar
unknown committed
174
                      (const uchar *)name->str, name->length,
unknown's avatar
unknown committed
175 176 177 178 179
                      (const uchar *)table_alias->str, table_alias->length))
    {
      name= table_alias + 1;
      goto redo;
    }
180
  }
181

unknown's avatar
unknown committed
182
  return NULL;
183
}
unknown's avatar
unknown committed
184 185


186
plugin_ref ha_lock_engine(THD *thd, const handlerton *hton)
187
{
unknown's avatar
unknown committed
188 189
  if (hton)
  {
190 191
    st_plugin_int *plugin= hton2plugin[hton->slot];
    return my_plugin_lock(thd, plugin_int_to_ref(plugin));
192
  }
unknown's avatar
unknown committed
193
  return NULL;
194 195
}

unknown's avatar
unknown committed
196

unknown's avatar
unknown committed
197 198
handlerton *ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type)
{
unknown's avatar
unknown committed
199
  plugin_ref plugin;
200
  switch (db_type) {
unknown's avatar
unknown committed
201
  case DB_TYPE_DEFAULT:
unknown's avatar
unknown committed
202
    return ha_default_handlerton(thd);
unknown's avatar
unknown committed
203
  default:
unknown's avatar
unknown committed
204 205 206 207 208
    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
209
    return NULL;
210
  }
211 212 213
}


unknown's avatar
unknown committed
214 215
/**
  Use other database handler if databasehandler is not compiled in.
216
*/
unknown's avatar
unknown committed
217
handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type,
218
                          bool no_substitute, bool report_error)
unknown's avatar
unknown committed
219
{
unknown's avatar
unknown committed
220 221 222 223
  handlerton *hton= ha_resolve_by_legacy_type(thd, database_type);
  if (ha_storage_engine_is_enabled(hton))
    return hton;

224 225 226 227
  if (no_substitute)
  {
    if (report_error)
    {
unknown's avatar
unknown committed
228
      const char *engine_name= ha_resolve_storage_engine_name(hton);
229 230
      my_error(ER_FEATURE_DISABLED,MYF(0),engine_name,engine_name);
    }
unknown's avatar
unknown committed
231
    return NULL;
232 233
  }

He Zhenxing's avatar
He Zhenxing committed
234 235
  RUN_HOOK(transaction, after_rollback, (thd, FALSE));

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


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

247
  if (db_type && db_type->state == SHOW_OPTION_YES && db_type->create)
248
  {
249
    if ((file= db_type->create(db_type, share, alloc)))
250 251
      file->init();
    DBUG_RETURN(file);
252
  }
253 254 255 256 257
  /*
    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
258
  DBUG_RETURN(get_new_handler(share, alloc, ha_default_handlerton(current_thd)));
unknown's avatar
unknown committed
259 260
}

261

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


287
static const char **handler_errmsgs;
288

289 290
C_MODE_START
static const char **get_handler_errmsgs()
291 292 293
{
  return handler_errmsgs;
}
294
C_MODE_END
295 296


unknown's avatar
unknown committed
297
/**
298 299
  Register handler error messages for use with my_error().

unknown's avatar
unknown committed
300
  @retval
301
    0           OK
unknown's avatar
unknown committed
302 303
  @retval
    !=0         Error
304
*/
305 306

int ha_init_errors(void)
307
{
308
#define SETMSG(nr, msg) handler_errmsgs[(nr) - HA_ERR_FIRST]= (msg)
309 310 311

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

  /* Set the dedicated error messages. */
317 318
  SETMSG(HA_ERR_KEY_NOT_FOUND,          ER_DEFAULT(ER_KEY_NOT_FOUND));
  SETMSG(HA_ERR_FOUND_DUPP_KEY,         ER_DEFAULT(ER_DUP_KEY));
319 320
  SETMSG(HA_ERR_RECORD_CHANGED,         "Update wich is recoverable");
  SETMSG(HA_ERR_WRONG_INDEX,            "Wrong index given to function");
321 322
  SETMSG(HA_ERR_CRASHED,                ER_DEFAULT(ER_NOT_KEYFILE));
  SETMSG(HA_ERR_WRONG_IN_RECORD,        ER_DEFAULT(ER_CRASHED_ON_USAGE));
323 324 325
  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");
326
  SETMSG(HA_ERR_OLD_FILE,               ER_DEFAULT(ER_OLD_KEYFILE));
327 328
  SETMSG(HA_ERR_NO_ACTIVE_RECORD,       "No record read in update");
  SETMSG(HA_ERR_RECORD_DELETED,         "Intern record deleted");
329
  SETMSG(HA_ERR_RECORD_FILE_FULL,       ER_DEFAULT(ER_RECORD_FILE_FULL));
330 331
  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");
332
  SETMSG(HA_ERR_UNSUPPORTED,            ER_DEFAULT(ER_ILLEGAL_HA));
333 334
  SETMSG(HA_ERR_TO_BIG_ROW,             "Too big row");
  SETMSG(HA_WRONG_CREATE_OPTION,        "Wrong create option");
335
  SETMSG(HA_ERR_FOUND_DUPP_UNIQUE,      ER_DEFAULT(ER_DUP_UNIQUE));
336
  SETMSG(HA_ERR_UNKNOWN_CHARSET,        "Can't open charset");
337 338 339 340 341 342 343 344 345 346
  SETMSG(HA_ERR_WRONG_MRG_TABLE_DEF,    ER_DEFAULT(ER_WRONG_MRG_TABLE));
  SETMSG(HA_ERR_CRASHED_ON_REPAIR,      ER_DEFAULT(ER_CRASHED_ON_REPAIR));
  SETMSG(HA_ERR_CRASHED_ON_USAGE,       ER_DEFAULT(ER_CRASHED_ON_USAGE));
  SETMSG(HA_ERR_LOCK_WAIT_TIMEOUT,      ER_DEFAULT(ER_LOCK_WAIT_TIMEOUT));
  SETMSG(HA_ERR_LOCK_TABLE_FULL,        ER_DEFAULT(ER_LOCK_TABLE_FULL));
  SETMSG(HA_ERR_READ_ONLY_TRANSACTION,  ER_DEFAULT(ER_READ_ONLY_TRANSACTION));
  SETMSG(HA_ERR_LOCK_DEADLOCK,          ER_DEFAULT(ER_LOCK_DEADLOCK));
  SETMSG(HA_ERR_CANNOT_ADD_FOREIGN,     ER_DEFAULT(ER_CANNOT_ADD_FOREIGN));
  SETMSG(HA_ERR_NO_REFERENCED_ROW,      ER_DEFAULT(ER_NO_REFERENCED_ROW_2));
  SETMSG(HA_ERR_ROW_IS_REFERENCED,      ER_DEFAULT(ER_ROW_IS_REFERENCED_2));
347 348 349
  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'");
350
  SETMSG(HA_ERR_TABLE_EXIST,            ER_DEFAULT(ER_TABLE_EXISTS_ERROR));
351
  SETMSG(HA_ERR_NO_CONNECTION,          "Could not connect to storage engine");
352
  SETMSG(HA_ERR_TABLE_DEF_CHANGED,      ER_DEFAULT(ER_TABLE_DEF_CHANGED));
353
  SETMSG(HA_ERR_FOREIGN_DUPLICATE_KEY,  "FK constraint would lead to duplicate key");
354 355 356 357 358
  SETMSG(HA_ERR_TABLE_NEEDS_UPGRADE,    ER_DEFAULT(ER_TABLE_NEEDS_UPGRADE));
  SETMSG(HA_ERR_TABLE_READONLY,         ER_DEFAULT(ER_OPEN_AS_READONLY));
  SETMSG(HA_ERR_AUTOINC_READ_FAILED,    ER_DEFAULT(ER_AUTOINC_READ_FAILED));
  SETMSG(HA_ERR_AUTOINC_ERANGE,         ER_DEFAULT(ER_WARN_DATA_OUT_OF_RANGE));
  SETMSG(HA_ERR_TOO_MANY_CONCURRENT_TRXS, ER_DEFAULT(ER_TOO_MANY_CONCURRENT_TRXS));
359
  SETMSG(HA_ERR_INDEX_COL_TOO_LONG,	ER_DEFAULT(ER_INDEX_COLUMN_TOO_LONG));
360
  SETMSG(HA_ERR_INDEX_CORRUPT,		ER_DEFAULT(ER_INDEX_CORRUPT));
361
  SETMSG(HA_ERR_TABLE_IN_FK_CHECK,	ER_DEFAULT(ER_TABLE_IN_FK_CHECK));
Sergei Golubchik's avatar
Sergei Golubchik committed
362
  SETMSG(HA_ERR_DISK_FULL,              ER_DEFAULT(ER_DISK_FULL));
363 364

  /* Register the error messages for use with my_error(). */
365
  return my_error_register(get_handler_errmsgs, HA_ERR_FIRST, HA_ERR_LAST);
366 367 368
}


unknown's avatar
unknown committed
369
/**
370 371
  Unregister handler error messages.

unknown's avatar
unknown committed
372
  @retval
373
    0           OK
unknown's avatar
unknown committed
374 375
  @retval
    !=0         Error
376 377 378 379 380 381 382 383
*/
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;
384
  my_free(errmsgs);
385 386
  return 0;
}
unknown's avatar
unknown committed
387

388 389 390
static volatile int32 need_full_discover_for_existence= 0;
static volatile int32 engines_with_discover_table_names= 0;

391 392
static int full_discover_for_existence(handlerton *, const char *, const char *)
{ return 1; }
393

394 395
static int ext_based_existence(handlerton *, const char *, const char *)
{ return 1; }
396

397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
static int hton_ext_based_table_discovery(handlerton *hton, LEX_STRING *db,
                             MY_DIR *dir, handlerton::discovered_list *result)
{
  /*
    tablefile_extensions[0] is the metadata file, see
    the comment above tablefile_extensions declaration
  */
  return extension_based_table_discovery(dir, hton->tablefile_extensions[0],
                                         result);
}

static void update_discovery_counters(handlerton *hton, int val)
{
  if (hton->discover_table_existence == full_discover_for_existence)
    my_atomic_add32(&need_full_discover_for_existence,  val);

  if (hton->discover_table_names)
    my_atomic_add32(&engines_with_discover_table_names, val);
}

unknown's avatar
unknown committed
417
int ha_finalize_handlerton(st_plugin_int *plugin)
418
{
unknown's avatar
unknown committed
419
  handlerton *hton= (handlerton *)plugin->data;
unknown's avatar
unknown committed
420 421
  DBUG_ENTER("ha_finalize_handlerton");

422 423 424 425
  /* hton can be NULL here, if ha_initialize_handlerton() failed. */
  if (!hton)
    goto end;

426
  switch (hton->state) {
unknown's avatar
unknown committed
427 428 429 430 431 432 433 434
  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;
  };
435

unknown's avatar
unknown committed
436 437 438
  if (hton->panic)
    hton->panic(hton, HA_PANIC_CLOSE);

439 440 441 442 443 444 445 446 447 448 449 450 451 452
  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));
    }
  }

453 454 455
  free_sysvar_table_options(hton);
  update_discovery_counters(hton, -1);

456 457 458 459 460
  /*
    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.
  */
461 462 463 464 465 466 467
  if (hton->slot != HA_SLOT_UNDEF)
  {
    /* Make sure we are not unpluging another plugin */
    DBUG_ASSERT(hton2plugin[hton->slot] == plugin);
    DBUG_ASSERT(hton->slot < MAX_HA);
    hton2plugin[hton->slot]= NULL;
  }
468

469
  my_free(hton);
470

471
 end:
unknown's avatar
unknown committed
472
  DBUG_RETURN(0);
473
}
474

unknown's avatar
unknown committed
475

unknown's avatar
unknown committed
476
int ha_initialize_handlerton(st_plugin_int *plugin)
unknown's avatar
unknown committed
477
{
478
  handlerton *hton;
479
  static const char *no_exts[]= { 0 };
unknown's avatar
unknown committed
480
  DBUG_ENTER("ha_initialize_handlerton");
481
  DBUG_PRINT("plugin", ("initialize plugin: '%s'", plugin->name.str));
unknown's avatar
unknown committed
482

483 484
  hton= (handlerton *)my_malloc(sizeof(handlerton),
                                MYF(MY_WME | MY_ZEROFILL));
485 486 487 488 489 490 491
  if (hton == NULL)
  {
    sql_print_error("Unable to allocate memory for plugin '%s' handlerton.",
                    plugin->name.str);
    goto err_no_hton_memory;
  }

492 493 494
  hton->tablefile_extensions= no_exts;
  hton->discover_table_names= hton_ext_based_table_discovery;

495
  hton->slot= HA_SLOT_UNDEF;
496
  /* Historical Requirement */
unknown's avatar
unknown committed
497
  plugin->data= hton; // shortcut for the future
498
  if (plugin->plugin->init && plugin->plugin->init(hton))
499
  {
500
    sql_print_error("Plugin '%s' init function returned error.",
501 502
		    plugin->name.str);
    goto err;
503
  }
unknown's avatar
unknown committed
504

505 506 507 508 509
  // hton_ext_based_table_discovery() works only when discovery
  // is supported and the engine if file-based.
  if (hton->discover_table_names == hton_ext_based_table_discovery &&
      (!hton->discover_table || !hton->tablefile_extensions[0]))
    hton->discover_table_names= NULL;
510

511
  // default discover_table_existence implementation
512
  if (!hton->discover_table_existence && hton->discover_table)
513 514 515 516 517 518 519
  {
    if (hton->tablefile_extensions[0])
      hton->discover_table_existence= ext_based_existence;
    else
      hton->discover_table_existence= full_discover_for_existence;
  }

unknown's avatar
unknown committed
520 521 522 523
  /*
    the switch below and hton->state should be removed when
    command-line options for plugins will be implemented
  */
unknown's avatar
unknown committed
524
  switch (hton->state) {
unknown's avatar
unknown committed
525 526 527 528
  case SHOW_OPTION_NO:
    break;
  case SHOW_OPTION_YES:
    {
unknown's avatar
unknown committed
529
      uint tmp;
530
      ulong fslot;
unknown's avatar
unknown committed
531
      /* now check the db_type for conflict */
unknown's avatar
unknown committed
532
      if (hton->db_type <= DB_TYPE_UNKNOWN ||
unknown's avatar
unknown committed
533 534 535 536
          hton->db_type >= DB_TYPE_DEFAULT ||
          installed_htons[hton->db_type])
      {
        int idx= (int) DB_TYPE_FIRST_DYNAMIC;
unknown's avatar
unknown committed
537

unknown's avatar
unknown committed
538 539 540 541 542 543
        while (idx < (int) DB_TYPE_DEFAULT && installed_htons[idx])
          idx++;

        if (idx == (int) DB_TYPE_DEFAULT)
        {
          sql_print_warning("Too many storage engines!");
544
	  goto err_deinit;
unknown's avatar
unknown committed
545 546 547
        }
        if (hton->db_type != DB_TYPE_UNKNOWN)
          sql_print_warning("Storage engine '%s' has conflicting typecode. "
unknown's avatar
unknown committed
548
                            "Assigning value %d.", plugin->plugin->name, idx);
unknown's avatar
unknown committed
549 550
        hton->db_type= (enum legacy_db_type) idx;
      }
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570

      /*
        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);
571
          goto err_deinit;
572 573 574
        }
        hton->slot= total_ha++;
      }
575 576 577 578
      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
579
      hton2plugin[hton->slot]=plugin;
unknown's avatar
unknown committed
580 581
      if (hton->prepare)
        total_ha_2pc++;
unknown's avatar
unknown committed
582 583 584 585 586 587 588
      break;
    }
    /* fall through */
  default:
    hton->state= SHOW_OPTION_DISABLED;
    break;
  }
589 590
  
  /* 
591 592 593
    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.
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
  */
  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;
  };

609
  resolve_sysvar_table_options(hton);
610
  update_discovery_counters(hton, 1);
611

unknown's avatar
unknown committed
612
  DBUG_RETURN(0);
613 614 615 616 617 618 619 620 621

err_deinit:
  /* 
    Let plugin do its inner deinitialization as plugin->init() 
    was successfully called before.
  */
  if (plugin->plugin->deinit)
    (void) plugin->plugin->deinit(NULL);
          
622
err:
623
  my_free(hton);
624
err_no_hton_memory:
625
  plugin->data= NULL;
626
  DBUG_RETURN(1);
unknown's avatar
unknown committed
627 628
}

unknown's avatar
unknown committed
629 630
int ha_init()
{
631
  int error= 0;
unknown's avatar
unknown committed
632 633
  DBUG_ENTER("ha_init");

634
  DBUG_ASSERT(total_ha < MAX_HA);
635 636 637 638 639 640
  /*
    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;
641
  savepoint_alloc_size+= sizeof(SAVEPOINT);
unknown's avatar
unknown committed
642
  DBUG_RETURN(error);
unknown's avatar
unknown committed
643 644
}

645
int ha_end()
unknown's avatar
unknown committed
646
{
647 648
  int error= 0;
  DBUG_ENTER("ha_end");
unknown's avatar
unknown committed
649

unknown's avatar
unknown committed
650

651 652 653 654 655 656 657
  /* 
    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
658

659 660
  DBUG_RETURN(error);
}
unknown's avatar
unknown committed
661

unknown's avatar
unknown committed
662
static my_bool dropdb_handlerton(THD *unused1, plugin_ref plugin,
unknown's avatar
unknown committed
663 664
                                 void *path)
{
unknown's avatar
unknown committed
665
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
666
  if (hton->state == SHOW_OPTION_YES && hton->drop_database)
667
    hton->drop_database(hton, (char *)path);
unknown's avatar
unknown committed
668 669 670 671
  return FALSE;
}


672 673
void ha_drop_database(char* path)
{
unknown's avatar
unknown committed
674 675
  plugin_foreach(NULL, dropdb_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, path);
}
676

unknown's avatar
unknown committed
677

678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693
static my_bool checkpoint_state_handlerton(THD *unused1, plugin_ref plugin,
                                           void *disable)
{
  handlerton *hton= plugin_data(plugin, handlerton *);
  if (hton->state == SHOW_OPTION_YES && hton->checkpoint_state)
    hton->checkpoint_state(hton, (int) *(bool*) disable);
  return FALSE;
}


void ha_checkpoint_state(bool disable)
{
  plugin_foreach(NULL, checkpoint_state_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, &disable);
}


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
struct st_commit_checkpoint_request {
  void *cookie;
  void (*pre_hook)(void *);
};

static my_bool commit_checkpoint_request_handlerton(THD *unused1, plugin_ref plugin,
                                           void *data)
{
  st_commit_checkpoint_request *st= (st_commit_checkpoint_request *)data;
  handlerton *hton= plugin_data(plugin, handlerton *);
  if (hton->state == SHOW_OPTION_YES && hton->commit_checkpoint_request)
  {
    void *cookie= st->cookie;
    if (st->pre_hook)
      (*st->pre_hook)(cookie);
    (*hton->commit_checkpoint_request)(hton, cookie);
  }
  return FALSE;
}


/*
  Invoke commit_checkpoint_request() in all storage engines that implement it.

  If pre_hook is non-NULL, the hook will be called prior to each invocation.
*/
void
ha_commit_checkpoint_request(void *cookie, void (*pre_hook)(void *))
{
  st_commit_checkpoint_request st;
  st.cookie= cookie;
  st.pre_hook= pre_hook;
  plugin_foreach(NULL, commit_checkpoint_request_handlerton,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &st);
}


731

unknown's avatar
unknown committed
732
static my_bool closecon_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
733 734
                                   void *unused)
{
unknown's avatar
unknown committed
735
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
736 737 738 739
  /*
    there's no need to rollback here as all transactions must
    be rolled back already
  */
740 741 742 743 744 745 746
  if (hton->state == SHOW_OPTION_YES && thd_get_ha_data(thd, hton))
  {
    if (hton->close_connection)
      hton->close_connection(hton, thd);
    /* make sure ha_data is reset and ha_data_lock is released */
    thd_set_ha_data(thd, hton, NULL);
  }
unknown's avatar
unknown committed
747
  return FALSE;
748
}
unknown's avatar
unknown committed
749

unknown's avatar
unknown committed
750 751 752
/**
  @note
    don't bother to rollback here, it's done already
753
*/
754 755
void ha_close_connection(THD* thd)
{
unknown's avatar
unknown committed
756
  plugin_foreach(thd, closecon_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, 0);
757 758
}

759
static my_bool kill_handlerton(THD *thd, plugin_ref plugin,
760
                               void *level)
761 762 763 764 765
{
  handlerton *hton= plugin_data(plugin, handlerton *);

  if (hton->state == SHOW_OPTION_YES && hton->kill_query &&
      thd_get_ha_data(thd, hton))
766
    hton->kill_query(hton, thd, *(enum thd_kill_levels *) level);
767 768 769
  return FALSE;
}

770
void ha_kill_query(THD* thd, enum thd_kill_levels level)
771 772
{
  DBUG_ENTER("ha_kill_query");
773
  plugin_foreach(thd, kill_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, &level);
774 775 776 777
  DBUG_VOID_RETURN;
}


778 779 780
/* ========================================================================
 ======================= TRANSACTIONS ===================================*/

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 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019
/**
  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!

Konstantin Osipov's avatar
Konstantin Osipov committed
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
  At the end of a statement, server call trans_commit_stmt 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.
1030 1031 1032 1033 1034 1035 1036 1037 1038 1039

  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
Konstantin Osipov's avatar
Konstantin Osipov committed
1040
  (a call to trans_commit_implicit()), and thus leaves nothing
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
  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
1070 1071
/**
  Register a storage engine for a transaction.
unknown's avatar
unknown committed
1072

unknown's avatar
unknown committed
1073 1074 1075 1076 1077
  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.
1078

unknown's avatar
unknown committed
1079
  @note
1080 1081 1082
    trans_register_ha is idempotent - storage engine may register many
    times per transaction.

unknown's avatar
unknown committed
1083
*/
1084 1085 1086
void trans_register_ha(THD *thd, bool all, handlerton *ht_arg)
{
  THD_TRANS *trans;
1087
  Ha_trx_info *ha_info;
unknown's avatar
unknown committed
1088 1089 1090
  DBUG_ENTER("trans_register_ha");
  DBUG_PRINT("enter",("%s", all ? "all" : "stmt"));

1091 1092 1093 1094 1095 1096 1097 1098
  if (all)
  {
    trans= &thd->transaction.all;
    thd->server_status|= SERVER_STATUS_IN_TRANS;
  }
  else
    trans= &thd->transaction.stmt;

1099 1100 1101 1102 1103 1104
  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
1105

1106
  trans->no_2pc|=(ht_arg->prepare==0);
1107 1108
  if (thd->transaction.xid_state.xid.is_null())
    thd->transaction.xid_state.xid.set(thd->query_id);
unknown's avatar
unknown committed
1109
  DBUG_VOID_RETURN;
1110 1111
}

unknown's avatar
unknown committed
1112 1113 1114 1115 1116
/**
  @retval
    0   ok
  @retval
    1   error, transaction was rolled back
1117 1118 1119 1120 1121
*/
int ha_prepare(THD *thd)
{
  int error=0, all=1;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
1122
  Ha_trx_info *ha_info= trans->ha_list;
1123
  DBUG_ENTER("ha_prepare");
Konstantin Osipov's avatar
Konstantin Osipov committed
1124

1125
  if (ha_info)
1126
  {
1127
    for (; ha_info; ha_info= ha_info->next())
1128 1129
    {
      int err;
1130
      handlerton *ht= ha_info->ht();
1131
      status_var_increment(thd->status_var.ha_prepare_count);
1132
      if (ht->prepare)
1133
      {
1134
        if ((err= ht->prepare(ht, thd, all)))
1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
        {
          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,
1145 1146
                            ER_GET_ERRNO, ER(ER_GET_ERRNO),
                            HA_ERR_WRONG_COMMAND,
1147
                            ha_resolve_storage_engine_name(ht));
1148 1149 1150
      }
    }
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
1151

1152 1153 1154
  DBUG_RETURN(error);
}

1155 1156 1157 1158 1159 1160
/**
  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.
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
  
  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.
1172 1173 1174
*/

static
1175
uint
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211
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;
    }
  }
1212
  return rw_ha_count;
1213 1214 1215
}


unknown's avatar
unknown committed
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
/**
  @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.
1229 1230 1231
*/
int ha_commit_trans(THD *thd, bool all)
{
1232
  int error= 0, cookie;
1233 1234 1235 1236
  /*
    'all' means that this is either an explicit commit issued by
    user, or an implicit commit issued by a DDL.
  */
1237
  THD_TRANS *trans= all ? &thd->transaction.all : &thd->transaction.stmt;
1238 1239 1240 1241 1242 1243 1244
  /*
    "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.
  */
1245 1246
  bool is_real_trans= all || thd->transaction.all.ha_list == 0;
  Ha_trx_info *ha_info= trans->ha_list;
1247 1248
  bool need_prepare_ordered, need_commit_ordered;
  my_xid xid;
1249
  DBUG_ENTER("ha_commit_trans");
1250

1251 1252 1253 1254 1255 1256
  /* Just a random warning to test warnings pushed during autocommit. */
  DBUG_EXECUTE_IF("warn_during_ha_commit_trans",
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                 ER_WARNING_NOT_COMPLETE_ROLLBACK,
                 ER(ER_WARNING_NOT_COMPLETE_ROLLBACK)););

1257 1258 1259 1260 1261 1262 1263 1264 1265
  /*
    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);

1266
  if (thd->in_sub_stmt)
1267
  {
1268
    DBUG_ASSERT(0);
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
    /*
      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.
    */
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(2);
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
1286

1287
#ifdef WITH_ARIA_STORAGE_ENGINE
1288
    ha_maria::implicit_commit(thd, TRUE);
1289 1290
#endif

1291
  if (!ha_info)
1292
  {
1293 1294 1295 1296 1297
    /* Free resources and perform other cleanup even for 'empty' transactions. */
    if (is_real_trans)
      thd->transaction.cleanup();
    DBUG_RETURN(0);
  }
1298

1299
  DBUG_EXECUTE_IF("crash_commit_before", DBUG_SUICIDE(););
1300

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

1305 1306 1307
  uint 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 */
  bool rw_trans= is_real_trans && (rw_ha_count > 0);
Sergei Golubchik's avatar
Sergei Golubchik committed
1308
  MDL_request mdl_request;
1309

Sergei Golubchik's avatar
Sergei Golubchik committed
1310
  if (rw_trans)
1311
  {
Sergei Golubchik's avatar
Sergei Golubchik committed
1312 1313 1314 1315
    /*
      Acquire a metadata lock which will ensure that COMMIT is blocked
      by an active FLUSH TABLES WITH READ LOCK (and vice versa:
      COMMIT in progress blocks FTWRL).
1316

Sergei Golubchik's avatar
Sergei Golubchik committed
1317 1318 1319 1320 1321
      We allow the owner of FTWRL to COMMIT; we assume that it knows
      what it does.
    */
    mdl_request.init(MDL_key::COMMIT, "", "", MDL_INTENTION_EXCLUSIVE,
                     MDL_EXPLICIT);
unknown's avatar
unknown committed
1322

Sergei Golubchik's avatar
Sergei Golubchik committed
1323 1324
    if (thd->mdl_context.acquire_lock(&mdl_request,
                                      thd->variables.lock_wait_timeout))
unknown's avatar
unknown committed
1325 1326
    {
      ha_rollback_trans(thd, all);
Sergei Golubchik's avatar
Sergei Golubchik committed
1327
      DBUG_RETURN(1);
unknown's avatar
unknown committed
1328 1329
    }

Sergei Golubchik's avatar
Sergei Golubchik committed
1330
    DEBUG_SYNC(thd, "ha_commit_trans_after_acquire_commit_lock");
1331
  }
unknown's avatar
unknown committed
1332

1333 1334 1335 1336 1337 1338 1339 1340
  if (rw_trans &&
      opt_readonly &&
      !(thd->security_ctx->master_access & SUPER_ACL) &&
      !thd->slave_thread)
  {
    my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
    goto err;
  }
unknown's avatar
unknown committed
1341

1342 1343 1344
  if (trans->no_2pc || (rw_ha_count <= 1))
  {
    error= ha_commit_one_phase(thd, all);
Sergei Golubchik's avatar
Sergei Golubchik committed
1345
    goto done;
1346
  }
1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366

  need_prepare_ordered= FALSE;
  need_commit_ordered= FALSE;
  xid= thd->transaction.xid_state.xid.get_my_xid();

  for (Ha_trx_info *hi= ha_info; hi; hi= hi->next())
  {
    int err;
    handlerton *ht= hi->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 (! hi->is_trx_read_write())
      continue;
    /*
      Sic: we know that prepare() is not NULL since otherwise
      trans->no_2pc would have been set.
    */
unknown's avatar
unknown committed
1367
    err= ht->prepare(ht, thd, all);
1368
    status_var_increment(thd->status_var.ha_prepare_count);
unknown's avatar
unknown committed
1369 1370
    if (err)
      my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
1371 1372 1373 1374

    if (err)
      goto err;

unknown's avatar
unknown committed
1375 1376
    need_prepare_ordered|= (ht->prepare_ordered != NULL);
    need_commit_ordered|= (ht->commit_ordered != NULL);
1377
  }
1378
  DEBUG_SYNC(thd, "ha_commit_trans_after_prepare");
1379
  DBUG_EXECUTE_IF("crash_commit_after_prepare", DBUG_SUICIDE(););
1380 1381 1382 1383

  if (!is_real_trans)
  {
    error= commit_one_phase_2(thd, all, trans, is_real_trans);
Sergei Golubchik's avatar
Sergei Golubchik committed
1384
    goto done;
1385 1386
  }

1387
  DEBUG_SYNC(thd, "ha_commit_trans_before_log_and_order");
1388 1389 1390 1391 1392
  cookie= tc_log->log_and_order(thd, xid, all, need_prepare_ordered,
                                need_commit_ordered);
  if (!cookie)
    goto err;

1393
  DEBUG_SYNC(thd, "ha_commit_trans_after_log_and_order");
1394
  DBUG_EXECUTE_IF("crash_commit_after_log", DBUG_SUICIDE(););
1395 1396 1397

  error= commit_one_phase_2(thd, all, trans, is_real_trans) ? 2 : 0;

1398
  DBUG_EXECUTE_IF("crash_commit_before_unlog", DBUG_SUICIDE(););
1399 1400 1401 1402 1403
  if (tc_log->unlog(cookie, xid))
  {
    error= 2;                                /* Error during commit */
    goto end;
  }
1404

Sergei Golubchik's avatar
Sergei Golubchik committed
1405
done:
1406
  DBUG_EXECUTE_IF("crash_commit_after", DBUG_SUICIDE(););
Sergei Golubchik's avatar
Sergei Golubchik committed
1407
  RUN_HOOK(transaction, after_commit, (thd, FALSE));
1408 1409 1410 1411
  goto end;

  /* Come here if error and we need to rollback. */
err:
unknown's avatar
unknown committed
1412
  error= 1;                                  /* Transaction was rolled back */
1413 1414
  ha_rollback_trans(thd, all);

1415
end:
Sergei Golubchik's avatar
Sergei Golubchik committed
1416 1417 1418 1419 1420 1421 1422 1423 1424
  if (rw_trans && mdl_request.ticket)
  {
    /*
      We do not always immediately release transactional locks
      after ha_commit_trans() (see uses of ha_enable_transaction()),
      thus we release the commit blocker lock as soon as it's
      not needed.
    */
    thd->mdl_context.release_lock(mdl_request.ticket);
1425 1426 1427 1428
  }
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
1429 1430 1431
/**
  @note
  This function does not care about global read lock. A caller should.
1432 1433 1434 1435 1436 1437

  @param[in]  all  Is set in case of explicit commit
                   (COMMIT statement), or implicit commit
                   issued by DDL. Is not set when called
                   at the end of statement, even if
                   autocommit=1.
1438
*/
1439

1440 1441 1442
int ha_commit_one_phase(THD *thd, bool all)
{
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
1443 1444 1445
  /*
    "real" is a nick name for a transaction for which a commit will
    make persistent changes. E.g. a 'stmt' transaction inside a 'all'
1446
    transaction is not 'real': even though it's possible to commit it,
1447 1448
    the changes are not durable as they might be rolled back if the
    enclosing 'all' transaction is rolled back.
1449 1450 1451 1452 1453 1454
    We establish the value of 'is_real_trans' by checking
    if it's an explicit COMMIT/BEGIN statement, or implicit
    commit issued by DDL (all == TRUE), or if we're running
    in autocommit mode (it's only in the autocommit mode
    ha_commit_one_phase() can be called with an empty
    transaction.all.ha_list, see why in trans_register_ha()).
1455
  */
1456
  bool is_real_trans=all || thd->transaction.all.ha_list == 0;
1457
  DBUG_ENTER("ha_commit_one_phase");
Sergei Golubchik's avatar
Sergei Golubchik committed
1458 1459
  int res= commit_one_phase_2(thd, all, trans, is_real_trans);
  DBUG_RETURN(res);
1460
}
Konstantin Osipov's avatar
Konstantin Osipov committed
1461

Sergei Golubchik's avatar
Sergei Golubchik committed
1462

1463 1464 1465 1466 1467 1468
static int
commit_one_phase_2(THD *thd, bool all, THD_TRANS *trans, bool is_real_trans)
{
  int error= 0;
  Ha_trx_info *ha_info= trans->ha_list, *ha_info_next;
  DBUG_ENTER("commit_one_phase_2");
1469
  if (ha_info)
1470
  {
1471
    for (; ha_info; ha_info= ha_info_next)
1472 1473
    {
      int err;
1474 1475
      handlerton *ht= ha_info->ht();
      if ((err= ht->commit(ht, thd, all)))
1476 1477 1478 1479
      {
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
        error=1;
      }
1480
      /* Should this be done only if is_real_trans is set ? */
1481
      status_var_increment(thd->status_var.ha_commit_count);
1482 1483
      ha_info_next= ha_info->next();
      ha_info->reset(); /* keep it conveniently zero-filled */
1484
    }
1485
    trans->ha_list= 0;
1486 1487 1488 1489 1490
    trans->no_2pc=0;
    if (all)
    {
#ifdef HAVE_QUERY_CACHE
      if (thd->transaction.changed_tables)
1491
        query_cache.invalidate(thd, thd->transaction.changed_tables);
unknown's avatar
unknown committed
1492
#endif
1493 1494
    }
  }
1495 1496 1497
  /* Free resources and perform other cleanup even for 'empty' transactions. */
  if (is_real_trans)
    thd->transaction.cleanup();
Konstantin Osipov's avatar
Konstantin Osipov committed
1498

1499 1500 1501 1502 1503 1504 1505 1506
  DBUG_RETURN(error);
}


int ha_rollback_trans(THD *thd, bool all)
{
  int error=0;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
1507
  Ha_trx_info *ha_info= trans->ha_list, *ha_info_next;
1508 1509 1510
  /*
    "real" is a nick name for a transaction for which a commit will
    make persistent changes. E.g. a 'stmt' transaction inside a 'all'
1511
    transaction is not 'real': even though it's possible to commit it,
1512 1513
    the changes are not durable as they might be rolled back if the
    enclosing 'all' transaction is rolled back.
1514 1515 1516 1517 1518 1519
    We establish the value of 'is_real_trans' by checking
    if it's an explicit COMMIT or BEGIN statement, or implicit
    commit issued by DDL (in these cases all == TRUE),
    or if we're running in autocommit mode (it's only in the autocommit mode
    ha_commit_one_phase() is called with an empty
    transaction.all.ha_list, see why in trans_register_ha()).
1520
  */
1521
  bool is_real_trans=all || thd->transaction.all.ha_list == 0;
1522
  DBUG_ENTER("ha_rollback_trans");
1523 1524 1525 1526 1527 1528 1529 1530

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

1531
  if (thd->in_sub_stmt)
1532
  {
1533
    DBUG_ASSERT(0);
1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
    /*
      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);
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
Konstantin Osipov's avatar
Konstantin Osipov committed
1544

1545
  if (ha_info)
1546
  {
1547 1548 1549 1550
    /* Close all cursors that can not survive ROLLBACK */
    if (is_real_trans)                          /* not a statement commit */
      thd->stmt_map.close_transient_cursors();

1551
    for (; ha_info; ha_info= ha_info_next)
1552 1553
    {
      int err;
1554 1555
      handlerton *ht= ha_info->ht();
      if ((err= ht->rollback(ht, thd, all)))
1556 1557 1558 1559
      { // cannot happen
        my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
        error=1;
      }
1560
      status_var_increment(thd->status_var.ha_rollback_count);
1561 1562
      ha_info_next= ha_info->next();
      ha_info->reset(); /* keep it conveniently zero-filled */
1563
    }
1564
    trans->ha_list= 0;
1565
    trans->no_2pc=0;
1566 1567
    if (is_real_trans && thd->transaction_rollback_request &&
        thd->transaction.xid_state.xa_state != XA_NOTR)
Marc Alff's avatar
Marc Alff committed
1568
      thd->transaction.xid_state.rm_error= thd->stmt_da->sql_errno();
1569
  }
1570
  /* Always cleanup. Even if nht==0. There may be savepoints. */
1571
  if (is_real_trans)
1572
    thd->transaction.cleanup();
1573 1574 1575
  if (all)
    thd->transaction_rollback_request= FALSE;

1576 1577 1578 1579 1580 1581 1582 1583
  /*
    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.
1584

1585
    We don't have to test for thd->killed == KILL_SYSTEM_THREAD as
1586 1587
    it doesn't matter if a warning is pushed to a system thread or not:
    No one will see it...
1588
  */
unknown's avatar
unknown committed
1589
  if (is_real_trans && thd->transaction.all.modified_non_trans_table &&
1590
      !thd->slave_thread && thd->killed < KILL_CONNECTION)
1591 1592 1593
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                 ER_WARNING_NOT_COMPLETE_ROLLBACK,
                 ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
He Zhenxing's avatar
He Zhenxing committed
1594
  RUN_HOOK(transaction, after_rollback, (thd, FALSE));
1595
  DBUG_RETURN(error);
1596 1597
}

unknown's avatar
unknown committed
1598

unknown's avatar
unknown committed
1599 1600 1601 1602 1603
struct xahton_st {
  XID *xid;
  int result;
};

unknown's avatar
unknown committed
1604
static my_bool xacommit_handlerton(THD *unused1, plugin_ref plugin,
unknown's avatar
unknown committed
1605
                                   void *arg)
1606
{
unknown's avatar
unknown committed
1607
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
1608 1609
  if (hton->state == SHOW_OPTION_YES && hton->recover)
  {
1610
    hton->commit_by_xid(hton, ((struct xahton_st *)arg)->xid);
unknown's avatar
unknown committed
1611 1612 1613 1614
    ((struct xahton_st *)arg)->result= 0;
  }
  return FALSE;
}
1615

unknown's avatar
unknown committed
1616
static my_bool xarollback_handlerton(THD *unused1, plugin_ref plugin,
unknown's avatar
unknown committed
1617 1618
                                     void *arg)
{
unknown's avatar
unknown committed
1619
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
1620
  if (hton->state == SHOW_OPTION_YES && hton->recover)
unknown's avatar
unknown committed
1621
  {
1622
    hton->rollback_by_xid(hton, ((struct xahton_st *)arg)->xid);
unknown's avatar
unknown committed
1623
    ((struct xahton_st *)arg)->result= 0;
unknown's avatar
unknown committed
1624
  }
unknown's avatar
unknown committed
1625 1626 1627 1628 1629 1630 1631 1632 1633
  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
1634

unknown's avatar
unknown committed
1635 1636 1637 1638
  plugin_foreach(NULL, commit ? xacommit_handlerton : xarollback_handlerton,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &xaop);

  return xaop.result;
1639
}
unknown's avatar
unknown committed
1640

unknown's avatar
unknown committed
1641

unknown's avatar
unknown committed
1642
#ifndef DBUG_OFF
unknown's avatar
unknown committed
1643 1644 1645 1646
/**
  @note
    This does not need to be multi-byte safe or anything
*/
unknown's avatar
unknown committed
1647 1648 1649 1650 1651 1652 1653 1654
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
1655 1656
    /* is_next_dig is set if next character is a number */
    bool is_next_dig= FALSE;
unknown's avatar
unknown committed
1657 1658
    if (i < XIDDATASIZE)
    {
unknown's avatar
unknown committed
1659 1660
      char ch= xid->data[i+1];
      is_next_dig= (ch >= '0' && ch <='9');
unknown's avatar
unknown committed
1661
    }
unknown's avatar
unknown committed
1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
    if (i == xid->gtrid_length)
    {
      *s++='\'';
      if (xid->bqual_length)
      {
        *s++='.';
        *s++='\'';
      }
    }
    if (c < 32 || c > 126)
    {
      *s++='\\';
unknown's avatar
unknown committed
1674 1675 1676 1677 1678
      /*
        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
1679 1680 1681 1682 1683
      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
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697
    }
    else
    {
      if (c == '\'' || c == '\\')
        *s++='\\';
      *s++=c;
    }
  }
  *s++='\'';
  *s=0;
  return buf;
}
#endif

unknown's avatar
unknown committed
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712
/**
  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
1713
*/
unknown's avatar
unknown committed
1714 1715 1716 1717 1718 1719 1720
struct xarecover_st
{
  int len, found_foreign_xids, found_my_xids;
  XID *list;
  HASH *commit_list;
  bool dry_run;
};
1721

unknown's avatar
unknown committed
1722
static my_bool xarecover_handlerton(THD *unused, plugin_ref plugin,
unknown's avatar
unknown committed
1723 1724
                                    void *arg)
{
unknown's avatar
unknown committed
1725
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
1726 1727
  struct xarecover_st *info= (struct xarecover_st *) arg;
  int got;
unknown's avatar
unknown committed
1728

unknown's avatar
unknown committed
1729
  if (hton->state == SHOW_OPTION_YES && hton->recover)
1730
  {
1731
    while ((got= hton->recover(hton, info->list, info->len)) > 0 )
1732
    {
unknown's avatar
unknown committed
1733
      sql_print_information("Found %d prepared transaction(s) in %s",
1734
                            got, hton_name(hton)->str);
1735 1736
      for (int i=0; i < got; i ++)
      {
unknown's avatar
unknown committed
1737
        my_xid x=info->list[i].get_my_xid();
1738
        if (!x) // not "mine" - that is generated by external TM
unknown's avatar
unknown committed
1739
        {
unknown's avatar
unknown committed
1740 1741
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
unknown's avatar
unknown committed
1742
          sql_print_information("ignore xid %s", xid_to_str(buf, info->list+i));
unknown's avatar
unknown committed
1743
#endif
unknown's avatar
unknown committed
1744 1745
          xid_cache_insert(info->list+i, XA_PREPARED);
          info->found_foreign_xids++;
unknown's avatar
unknown committed
1746 1747
          continue;
        }
unknown's avatar
unknown committed
1748
        if (info->dry_run)
unknown's avatar
unknown committed
1749
        {
unknown's avatar
unknown committed
1750
          info->found_my_xids++;
1751
          continue;
unknown's avatar
unknown committed
1752 1753
        }
        // recovery mode
unknown's avatar
unknown committed
1754
        if (info->commit_list ?
Konstantin Osipov's avatar
Konstantin Osipov committed
1755
            my_hash_search(info->commit_list, (uchar *)&x, sizeof(x)) != 0 :
1756
            tc_heuristic_recover == TC_HEURISTIC_RECOVER_COMMIT)
unknown's avatar
unknown committed
1757 1758 1759
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
unknown's avatar
unknown committed
1760
          sql_print_information("commit xid %s", xid_to_str(buf, info->list+i));
unknown's avatar
unknown committed
1761
#endif
1762
          hton->commit_by_xid(hton, info->list+i);
unknown's avatar
unknown committed
1763
        }
1764
        else
unknown's avatar
unknown committed
1765 1766 1767
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
unknown's avatar
unknown committed
1768 1769
          sql_print_information("rollback xid %s",
                                xid_to_str(buf, info->list+i));
unknown's avatar
unknown committed
1770
#endif
1771
          hton->rollback_by_xid(hton, info->list+i);
unknown's avatar
unknown committed
1772
        }
1773
      }
unknown's avatar
unknown committed
1774
      if (got < info->len)
1775
        break;
1776 1777
    }
  }
unknown's avatar
unknown committed
1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
  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...");

  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)
  {
1808 1809
    sql_print_error(ER(ER_OUTOFMEMORY),
                    static_cast<int>(info.len*sizeof(XID)));
unknown's avatar
unknown committed
1810 1811 1812 1813 1814 1815
    DBUG_RETURN(1);
  }

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

1816
  my_free(info.list);
unknown's avatar
unknown committed
1817 1818 1819 1820
  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
1821 1822 1823 1824 1825 1826 1827
  {
    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
1828
                    info.found_my_xids, opt_tc_log_file);
unknown's avatar
unknown committed
1829 1830
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
1831
  if (info.commit_list)
unknown's avatar
unknown committed
1832
    sql_print_information("Crash recovery finished.");
1833
  DBUG_RETURN(0);
1834
}
1835

unknown's avatar
unknown committed
1836 1837
/**
  return the list of XID's to a client, the same way SHOW commands do.
unknown's avatar
unknown committed
1838

unknown's avatar
unknown committed
1839
  @note
1840 1841 1842
    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
1843
*/
1844
bool mysql_xa_recover(THD *thd)
unknown's avatar
unknown committed
1845
{
1846 1847
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
1848 1849
  int i=0;
  XID_STATE *xs;
1850 1851
  DBUG_ENTER("mysql_xa_recover");

1852 1853 1854
  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));
1855 1856
  field_list.push_back(new Item_empty_string("data",XIDDATASIZE));

1857
  if (protocol->send_result_set_metadata(&field_list,
1858 1859
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
    DBUG_RETURN(1);
unknown's avatar
unknown committed
1860

Marc Alff's avatar
Marc Alff committed
1861
  mysql_mutex_lock(&LOCK_xid_cache);
Konstantin Osipov's avatar
Konstantin Osipov committed
1862
  while ((xs= (XID_STATE*) my_hash_element(&xid_cache, i++)))
1863
  {
1864
    if (xs->xa_state==XA_PREPARED)
1865
    {
1866 1867 1868 1869 1870 1871 1872
      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())
1873
      {
Marc Alff's avatar
Marc Alff committed
1874
        mysql_mutex_unlock(&LOCK_xid_cache);
1875
        DBUG_RETURN(1);
1876 1877
      }
    }
unknown's avatar
unknown committed
1878
  }
1879

Marc Alff's avatar
Marc Alff committed
1880
  mysql_mutex_unlock(&LOCK_xid_cache);
1881
  my_eof(thd);
1882
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1883
}
1884

1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895
/*
  Called by engine to notify TC that a new commit checkpoint has been reached.
  See comments on handlerton method commit_checkpoint_request() for details.
*/
void
commit_checkpoint_notify_ha(handlerton *hton, void *cookie)
{
  tc_log->commit_checkpoint_notify(cookie);
}


unknown's avatar
unknown committed
1896 1897
/**
  @details
1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908
  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
1909 1910 1911 1912
  @param thd           the thread handle of the current connection

  @return
    always 0
1913
*/
1914

1915 1916
int ha_release_temporary_latches(THD *thd)
{
1917
  Ha_trx_info *info;
1918

1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
  /*
    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);
  }
1931
  return 0;
1932 1933
}

1934
int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1935 1936
{
  int error=0;
1937 1938
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
1939 1940
  Ha_trx_info *ha_info, *ha_info_next;

1941
  DBUG_ENTER("ha_rollback_to_savepoint");
1942

1943 1944 1945 1946 1947
  trans->no_2pc=0;
  /*
    rolling back to savepoint in all storage engines that were part of the
    transaction when the savepoint was set
  */
1948
  for (ha_info= sv->ha_list; ha_info; ha_info= ha_info->next())
1949 1950
  {
    int err;
1951 1952 1953 1954 1955
    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)))
1956 1957 1958
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
1959
    }
1960
    status_var_increment(thd->status_var.ha_savepoint_rollback_count);
1961
    trans->no_2pc|= ht->prepare == 0;
1962
  }
1963 1964 1965 1966
  /*
    rolling back the transaction in all storage engines that were not part of
    the transaction when the savepoint was set
  */
1967 1968
  for (ha_info= trans->ha_list; ha_info != sv->ha_list;
       ha_info= ha_info_next)
unknown's avatar
unknown committed
1969
  {
1970
    int err;
1971 1972
    handlerton *ht= ha_info->ht();
    if ((err= ht->rollback(ht, thd, !thd->in_sub_stmt)))
1973 1974 1975
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
unknown's avatar
unknown committed
1976
    }
1977
    status_var_increment(thd->status_var.ha_rollback_count);
1978 1979
    ha_info_next= ha_info->next();
    ha_info->reset(); /* keep it conveniently zero-filled */
1980
  }
1981
  trans->ha_list= sv->ha_list;
unknown's avatar
unknown committed
1982 1983 1984
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
1985 1986 1987
/**
  @note
  according to the sql standard (ISO/IEC 9075-2:2003)
1988 1989
  section "4.33.4 SQL-statements and transaction states",
  SAVEPOINT is *not* transaction-initiating SQL-statement
unknown's avatar
unknown committed
1990
*/
1991
int ha_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1992 1993
{
  int error=0;
1994 1995
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
1996
  Ha_trx_info *ha_info= trans->ha_list;
1997
  DBUG_ENTER("ha_savepoint");
Konstantin Osipov's avatar
Konstantin Osipov committed
1998

1999
  for (; ha_info; ha_info= ha_info->next())
unknown's avatar
unknown committed
2000
  {
2001
    int err;
2002 2003 2004
    handlerton *ht= ha_info->ht();
    DBUG_ASSERT(ht);
    if (! ht->savepoint_set)
unknown's avatar
unknown committed
2005
    {
2006
      my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "SAVEPOINT");
unknown's avatar
unknown committed
2007
      error=1;
2008
      break;
unknown's avatar
unknown committed
2009
    }
2010
    if ((err= ht->savepoint_set(ht, thd, (uchar *)(sv+1)+ht->savepoint_offset)))
2011
    { // cannot happen
2012
      my_error(ER_GET_ERRNO, MYF(0), err, hton_name(ht)->str);
unknown's avatar
unknown committed
2013 2014
      error=1;
    }
2015
    status_var_increment(thd->status_var.ha_savepoint_count);
unknown's avatar
unknown committed
2016
  }
2017 2018 2019 2020 2021
  /*
    Remember the list of registered storage engines. All new
    engines are prepended to the beginning of the list.
  */
  sv->ha_list= trans->ha_list;
Konstantin Osipov's avatar
Konstantin Osipov committed
2022

unknown's avatar
unknown committed
2023 2024 2025
  DBUG_RETURN(error);
}

2026
int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
2027 2028
{
  int error=0;
2029
  Ha_trx_info *ha_info= sv->ha_list;
2030 2031
  DBUG_ENTER("ha_release_savepoint");

2032
  for (; ha_info; ha_info= ha_info->next())
unknown's avatar
unknown committed
2033
  {
2034
    int err;
2035 2036 2037 2038
    handlerton *ht= ha_info->ht();
    /* Savepoint life time is enclosed into transaction life time. */
    DBUG_ASSERT(ht);
    if (!ht->savepoint_release)
2039
      continue;
2040 2041
    if ((err= ht->savepoint_release(ht, thd,
                                    (uchar *)(sv+1) + ht->savepoint_offset)))
2042
    { // cannot happen
2043
      my_error(ER_GET_ERRNO, MYF(0), err, hton_name(ht)->str);
2044
      error=1;
unknown's avatar
unknown committed
2045
    }
unknown's avatar
unknown committed
2046 2047 2048 2049
  }
  DBUG_RETURN(error);
}

2050

unknown's avatar
unknown committed
2051
static my_bool snapshot_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
2052 2053
                                   void *arg)
{
unknown's avatar
unknown committed
2054
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
2055 2056 2057
  if (hton->state == SHOW_OPTION_YES &&
      hton->start_consistent_snapshot)
  {
2058
    hton->start_consistent_snapshot(hton, thd);
unknown's avatar
unknown committed
2059 2060 2061 2062 2063
    *((bool *)arg)= false;
  }
  return FALSE;
}

2064 2065
int ha_start_consistent_snapshot(THD *thd)
{
2066 2067
  bool warn= true;

unknown's avatar
unknown committed
2068
  /*
unknown's avatar
unknown committed
2069 2070 2071 2072 2073
    Holding the LOCK_commit_ordered mutex ensures that we get the same
    snapshot for all engines (including the binary log).  This allows us
    among other things to do backups with
    START TRANSACTION WITH CONSISTENT SNAPSHOT and
    have a consistent binlog position.
unknown's avatar
unknown committed
2074
  */
Sergei Golubchik's avatar
Sergei Golubchik committed
2075
  mysql_mutex_lock(&LOCK_commit_ordered);
unknown's avatar
unknown committed
2076
  plugin_foreach(thd, snapshot_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, &warn);
Sergei Golubchik's avatar
Sergei Golubchik committed
2077
  mysql_mutex_unlock(&LOCK_commit_ordered);
unknown's avatar
unknown committed
2078

2079 2080 2081 2082
  /*
    Same idea as when one wants to CREATE TABLE in one engine which does not
    exist:
  */
2083 2084 2085 2086
  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");
2087 2088 2089 2090
  return 0;
}


unknown's avatar
unknown committed
2091
static my_bool flush_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
2092
                                void *arg)
unknown's avatar
unknown committed
2093
{
unknown's avatar
unknown committed
2094
  handlerton *hton= plugin_data(plugin, handlerton *);
2095 2096
  if (hton->state == SHOW_OPTION_YES && hton->flush_logs && 
      hton->flush_logs(hton))
unknown's avatar
unknown committed
2097 2098 2099 2100
    return TRUE;
  return FALSE;
}

2101

unknown's avatar
unknown committed
2102 2103 2104
bool ha_flush_logs(handlerton *db_type)
{
  if (db_type == NULL)
2105
  {
unknown's avatar
unknown committed
2106 2107 2108
    if (plugin_foreach(NULL, flush_handlerton,
                          MYSQL_STORAGE_ENGINE_PLUGIN, 0))
      return TRUE;
2109
  }
unknown's avatar
unknown committed
2110 2111 2112
  else
  {
    if (db_type->state != SHOW_OPTION_YES ||
2113
        (db_type->flush_logs && db_type->flush_logs(db_type)))
unknown's avatar
unknown committed
2114 2115 2116
      return TRUE;
  }
  return FALSE;
unknown's avatar
unknown committed
2117 2118
}

2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141

/**
  @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.
*/
2142 2143
const char *get_canonical_filename(handler *file, const char *path,
                                   char *tmp_path)
2144
{
2145
  uint i;
2146 2147 2148
  if (lower_case_table_names != 2 || (file->ha_table_flags() & HA_FILE_BASED))
    return path;

2149 2150 2151 2152 2153 2154
  for (i= 0; i <= mysql_tmpdir_list.max; i++)
  {
    if (is_prefix(path, mysql_tmpdir_list.list[i]))
      return path;
  }

2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167
  /* 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;
}


2168 2169 2170 2171 2172 2173 2174 2175 2176
/**
  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:
Marc Alff's avatar
Marc Alff committed
2177 2178 2179 2180 2181 2182
  virtual bool handle_condition(THD *thd,
                                uint sql_errno,
                                const char* sqlstate,
                                MYSQL_ERROR::enum_warning_level level,
                                const char* msg,
                                MYSQL_ERROR ** cond_hdl);
2183 2184 2185 2186 2187 2188
  char buff[MYSQL_ERRMSG_SIZE];
};


bool
Ha_delete_table_error_handler::
Marc Alff's avatar
Marc Alff committed
2189 2190 2191 2192 2193 2194
handle_condition(THD *,
                 uint,
                 const char*,
                 MYSQL_ERROR::enum_warning_level,
                 const char* msg,
                 MYSQL_ERROR ** cond_hdl)
2195
{
Marc Alff's avatar
Marc Alff committed
2196
  *cond_hdl= NULL;
2197
  /* Grab the error message */
2198
  strmake_buf(buff, msg);
2199 2200 2201 2202
  return TRUE;
}


2203
/** @brief
unknown's avatar
unknown committed
2204 2205 2206
  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
2207
int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
unknown's avatar
unknown committed
2208
                    const char *db, const char *alias, bool generate_warning)
unknown's avatar
unknown committed
2209
{
2210
  handler *file;
unknown's avatar
unknown committed
2211
  char tmp_path[FN_REFLEN];
2212 2213 2214 2215 2216
  int error;
  TABLE dummy_table;
  TABLE_SHARE dummy_share;
  DBUG_ENTER("ha_delete_table");

2217 2218 2219 2220 2221
  /* table_type is NULL in ALTER TABLE when renaming only .frm files */
  if (table_type == NULL || table_type == view_pseudo_hton ||
      ! (file=get_new_handler((TABLE_SHARE*)0, thd->mem_root, table_type)))
    DBUG_RETURN(HA_ERR_NO_SUCH_TABLE);

2222 2223 2224
  bzero((char*) &dummy_table, sizeof(dummy_table));
  bzero((char*) &dummy_share, sizeof(dummy_share));
  dummy_table.s= &dummy_share;
2225

2226
  path= get_canonical_filename(file, path, tmp_path);
2227
  if ((error= file->ha_delete_table(path)) && generate_warning)
2228 2229 2230
  {
    /*
      Because file->print_error() use my_error() to generate the error message
2231 2232 2233
      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.
2234
    */
2235
    Ha_delete_table_error_handler ha_delete_table_error_handler;
2236 2237

    /* Fill up strucutures that print_error may need */
unknown's avatar
unknown committed
2238 2239
    dummy_share.path.str= (char*) path;
    dummy_share.path.length= strlen(path);
2240
    dummy_share.normalized_path= dummy_share.path;
unknown's avatar
unknown committed
2241 2242 2243 2244
    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);
2245 2246
    dummy_table.alias.set(alias, dummy_share.table_name.length,
                          table_alias_charset);
2247

2248
    file->change_table_ptr(&dummy_table, &dummy_share);
2249 2250

    thd->push_internal_handler(&ha_delete_table_error_handler);
2251
    file->print_error(error, 0);
2252 2253 2254 2255 2256 2257 2258

    thd->pop_internal_handler();

    /*
      XXX: should we convert *all* errors to warnings here?
      What if the error is fatal?
    */
Marc Alff's avatar
Marc Alff committed
2259
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, error,
2260
                ha_delete_table_error_handler.buff);
2261
  }
unknown's avatar
unknown committed
2262
  delete file;
2263
  DBUG_RETURN(error);
unknown's avatar
unknown committed
2264
}
unknown's avatar
unknown committed
2265

unknown's avatar
unknown committed
2266 2267 2268
/****************************************************************************
** General handler functions
****************************************************************************/
2269
handler *handler::clone(const char *name, MEM_ROOT *mem_root)
unknown's avatar
unknown committed
2270
{
2271
  handler *new_handler= get_new_handler(table->s, mem_root, ht);
2272
  if (! new_handler)
2273 2274
    return NULL;

2275 2276 2277 2278 2279
  /*
    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.
  */
2280 2281 2282

  if (!(new_handler->ref= (uchar*) alloc_root(mem_root,
                                              ALIGN_SIZE(ref_length)*2)))
2283
    return NULL;
2284

2285 2286 2287
  /*
    TODO: Implement a more efficient way to have more than one index open for
    the same table instance. The ha_open call is not cachable for clone.
2288 2289 2290

    This is not critical as the engines already have the table open
    and should be able to use the original instance of the table.
2291
  */
2292
  if (new_handler->ha_open(table, name, table->db_stat,
2293 2294
                           HA_OPEN_IGNORE_IF_LOCKED))
    return NULL;
2295

2296
  return new_handler;
unknown's avatar
unknown committed
2297 2298
}

unknown's avatar
unknown committed
2299

Sergei Golubchik's avatar
Sergei Golubchik committed
2300
double handler::keyread_time(uint index, uint ranges, ha_rows rows)
2301
{
Sergei Golubchik's avatar
Sergei Golubchik committed
2302 2303 2304 2305 2306 2307 2308
  /*
    It is assumed that we will read trough the whole key range and that all
    key blocks are half full (normally things are much better). It is also
    assumed that each time we read the next key from the index, the handler
    performs a random seek, thus the cost is proportional to the number of
    blocks read. This model does not take into account clustered indexes -
    engines that support that (e.g. InnoDB) may want to overwrite this method.
2309
    The model counts in the time to read index entries from cache.
Sergei Golubchik's avatar
Sergei Golubchik committed
2310
  */
2311
  ulong len= table->key_info[index].key_length + ref_length;
2312 2313
  if (index == table->s->primary_key && table->file->primary_key_is_clustered())
    len= table->s->stored_rec_length;
2314 2315 2316
  double keys_per_block= (stats.block_size/2.0/len+1);
  return (rows + keys_per_block-1)/ keys_per_block +
         len*rows/(stats.block_size+1)/TIME_FOR_COMPARE ;
2317 2318
}

2319
void **handler::ha_data(THD *thd) const
unknown's avatar
unknown committed
2320
{
2321
  return thd_ha_data(thd, ht);
unknown's avatar
unknown committed
2322 2323 2324 2325
}

THD *handler::ha_thd(void) const
{
unknown's avatar
unknown committed
2326
  DBUG_ASSERT(!table || !table->in_use || table->in_use == current_thd);
unknown's avatar
unknown committed
2327 2328 2329
  return (table && table->in_use) ? table->in_use : current_thd;
}

Marc Alff's avatar
Marc Alff committed
2330 2331 2332 2333
PSI_table_share *handler::ha_table_share_psi(const TABLE_SHARE *share) const
{
  return share->m_psi;
}
2334

2335
/** @brief
unknown's avatar
unknown committed
2336 2337 2338 2339 2340 2341 2342
  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,
2343
                     uint test_if_locked)
unknown's avatar
unknown committed
2344 2345
{
  int error;
2346
  DBUG_ENTER("handler::ha_open");
unknown's avatar
unknown committed
2347 2348
  DBUG_PRINT("enter",
             ("name: %s  db_type: %d  db_stat: %d  mode: %d  lock_test: %d",
unknown's avatar
unknown committed
2349
              name, ht->db_type, table_arg->db_stat, mode,
unknown's avatar
unknown committed
2350 2351 2352 2353
              test_if_locked));

  table= table_arg;
  DBUG_ASSERT(table->s == table_share);
2354
  DBUG_ASSERT(alloc_root_inited(&table->mem_root));
unknown's avatar
unknown committed
2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366

  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
2367
    my_errno= error;                            /* Safeguard */
unknown's avatar
unknown committed
2368 2369 2370 2371
    DBUG_PRINT("error",("error: %d  errno: %d",error,errno));
  }
  else
  {
2372
    if (table->s->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
unknown's avatar
unknown committed
2373
      table->db_stat|=HA_READ_ONLY;
2374 2375
    (void) extra(HA_EXTRA_NO_READCHECK);	// Not needed in SQL

2376
    /* ref is already allocated for us if we're called from handler::clone() */
2377
    if (!ref && !(ref= (uchar*) alloc_root(&table->mem_root, 
2378
                                          ALIGN_SIZE(ref_length)*2)))
unknown's avatar
unknown committed
2379 2380 2381 2382 2383
    {
      close();
      error=HA_ERR_OUT_OF_MEM;
    }
    else
2384 2385
      dup_ref=ref+ALIGN_SIZE(ref_length);
    cached_table_flags= table_flags();
unknown's avatar
unknown committed
2386
  }
2387 2388
  reset_statistics();
  internal_tmp_table= test(test_if_locked & HA_OPEN_INTERNAL_TABLE);
unknown's avatar
unknown committed
2389 2390 2391
  DBUG_RETURN(error);
}

2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402
int handler::ha_close()
{
  DBUG_ENTER("ha_close");
  /*
    Increment global statistics for temporary tables.
    In_use is 0 for tables that was closed from the table cache.
  */
  if (table->in_use)
    status_var_add(table->in_use->status_var.rows_tmp_read, rows_tmp_read);
  DBUG_RETURN(close());
}
unknown's avatar
unknown committed
2403

2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415
/* Initialize handler for random reading, with error handling */

int handler::ha_rnd_init_with_error(bool scan)
{
  int error;
  if (!(error= ha_rnd_init(scan)))
    return 0;
  table->file->print_error(error, MYF(0));
  return error;
}


unknown's avatar
unknown committed
2416 2417 2418
/**
  Read first row (only) from a table.

2419
  This is never called for InnoDB tables, as these table types
2420
  has the HA_STATS_RECORDS_IS_EXACT set.
2421
*/
2422
int handler::read_first_row(uchar * buf, uint primary_key)
unknown's avatar
unknown committed
2423 2424
{
  register int error;
2425
  DBUG_ENTER("handler::read_first_row");
unknown's avatar
unknown committed
2426

2427 2428 2429
  /*
    If there is very few deleted rows in the table, find the first row by
    scanning the table.
2430
    TODO remove the test for HA_READ_ORDER
2431
  */
2432
  if (stats.deleted < 10 || primary_key >= MAX_KEY ||
2433
      !(index_flags(primary_key, 0, 0) & HA_READ_ORDER))
2434
  {
2435
    if (!(error= ha_rnd_init(1)))
2436
    {
Sergei Golubchik's avatar
Sergei Golubchik committed
2437
      while ((error= ha_rnd_next(buf)) == HA_ERR_RECORD_DELETED)
2438 2439 2440 2441
        /* skip deleted row */;
      const int end_error= ha_rnd_end();
      if (!error)
        error= end_error;
2442
    }
2443 2444 2445 2446
  }
  else
  {
    /* Find the first row through the primary key */
2447 2448
    if (!(error= ha_index_init(primary_key, 0)))
    {
2449
      error= ha_index_first(buf);
2450 2451 2452 2453
      const int end_error= ha_index_end();
      if (!error)
        error= end_error;
    }
2454
  }
unknown's avatar
unknown committed
2455 2456 2457
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
2458 2459
/**
  Generate the next auto-increment number based on increment and offset.
2460 2461 2462
  computes the lowest number
  - strictly greater than "nr"
  - of the form: auto_increment_offset + N * auto_increment_increment
2463 2464
  If overflow happened then return MAX_ULONGLONG value as an
  indication of overflow.
2465
  In most cases increment= offset= 1, in which case we get:
unknown's avatar
unknown committed
2466 2467 2468
  @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
2469 2470
*/
inline ulonglong
2471
compute_next_insert_id(ulonglong nr,struct system_variables *variables)
2472
{
2473 2474
  const ulonglong save_nr= nr;

2475
  if (variables->auto_increment_increment == 1)
2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489
    nr= nr + 1; // optimization of the formula below
  else
  {
    nr= (((nr+ variables->auto_increment_increment -
           variables->auto_increment_offset)) /
         (ulonglong) variables->auto_increment_increment);
    nr= (nr* (ulonglong) variables->auto_increment_increment +
         variables->auto_increment_offset);
  }

  if (unlikely(nr <= save_nr))
    return ULONGLONG_MAX;

  return nr;
2490 2491 2492
}


2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504
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));
}


2505
/** @brief
2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531
  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
2532
                       (ulong) nr, variables->auto_increment_offset));
2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543
    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
2544 2545
/**
  Update the auto_increment field if necessary.
2546

unknown's avatar
unknown committed
2547
  Updates columns with type NEXT_NUMBER if:
2548 2549 2550 2551 2552 2553 2554

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

2555 2556 2557
    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:
2558

2559 2560 2561
  - 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.
2562

2563 2564 2565 2566 2567 2568
  - 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.
2569

2570 2571 2572 2573 2574
  - 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.
2575

2576 2577 2578
  - 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
2579 2580 2581 2582 2583 2584
    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).
2585 2586 2587 2588 2589 2590 2591 2592 2593 2594

    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.

2595 2596 2597 2598 2599 2600 2601
    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.
2602

unknown's avatar
unknown committed
2603
  @todo
2604 2605 2606 2607 2608
    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
2609 2610 2611 2612 2613 2614 2615 2616
  @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.
2617
*/
unknown's avatar
unknown committed
2618

2619 2620 2621 2622
#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
2623
int handler::update_auto_increment()
unknown's avatar
unknown committed
2624
{
2625 2626
  ulonglong nr, nb_reserved_values;
  bool append= FALSE;
2627 2628
  THD *thd= table->in_use;
  struct system_variables *variables= &thd->variables;
2629 2630
  int result=0, tmp;
  enum enum_check_fields save_count_cuted_fields;
2631
  DBUG_ENTER("handler::update_auto_increment");
2632 2633

  /*
2634 2635
    next_insert_id is a "cursor" into the reserved interval, it may go greater
    than the interval, but not smaller.
2636
  */
2637
  DBUG_ASSERT(next_insert_id >= auto_inc_interval_for_cur_row.minimum());
2638 2639

  if ((nr= table->next_number_field->val_int()) != 0 ||
2640
      (table->auto_increment_field_not_null &&
2641
       thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO))
2642
  {
2643 2644 2645 2646 2647
    /*
      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).
2648
      Ignore negative values.
2649
    */
2650 2651
    if ((longlong) nr > 0 || (table->next_number_field->flags & UNSIGNED_FLAG))
      adjust_next_insert_id_after_explicit_value(nr);
2652
    insert_id_for_cur_row= 0; // didn't generate anything
2653
    DBUG_RETURN(0);
2654
  }
2655 2656

  if ((nr= next_insert_id) >= auto_inc_interval_for_cur_row.maximum())
2657
  {
2658 2659 2660 2661 2662 2663 2664 2665 2666
    /* 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
2667
    {
2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682
      /*
        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
2683
        Note that in prelocked mode no estimation is given.
2684
      */
2685

Guilhem Bichot's avatar
Guilhem Bichot committed
2686
      if ((auto_inc_intervals_count == 0) && (estimation_rows_to_insert > 0))
2687
        nb_desired_values= estimation_rows_to_insert;
2688 2689 2690 2691 2692 2693 2694 2695 2696 2697
      else if ((auto_inc_intervals_count == 0) &&
               (thd->lex->many_values.elements > 0))
      {
        /*
          For multi-row inserts, if the bulk inserts cannot be started, the
          handler::estimation_rows_to_insert will not be set. But we still
          want to reserve the autoinc values.
        */
        nb_desired_values= thd->lex->many_values.elements;
      }
2698
      else /* go with the increasing defaults */
2699
      {
2700
        /* avoid overflow in formula, with this if() */
Guilhem Bichot's avatar
Guilhem Bichot committed
2701
        if (auto_inc_intervals_count <= AUTO_INC_DEFAULT_NB_MAX_BITS)
2702
        {
Guilhem Bichot's avatar
Guilhem Bichot committed
2703 2704
          nb_desired_values= AUTO_INC_DEFAULT_NB_ROWS *
            (1 << auto_inc_intervals_count);
2705 2706 2707 2708
          set_if_smaller(nb_desired_values, AUTO_INC_DEFAULT_NB_MAX);
        }
        else
          nb_desired_values= AUTO_INC_DEFAULT_NB_MAX;
2709
      }
2710 2711 2712 2713
      get_auto_increment(variables->auto_increment_offset,
                         variables->auto_increment_increment,
                         nb_desired_values, &nr,
                         &nb_reserved_values);
2714
      if (nr == ULONGLONG_MAX)
2715
        DBUG_RETURN(HA_ERR_AUTOINC_READ_FAILED);  // Mark failure
Guilhem Bichot's avatar
Guilhem Bichot committed
2716

2717 2718 2719 2720 2721 2722 2723 2724 2725 2726
      /*
        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
2727

2728
    if (table->s->next_number_keypart == 0)
2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741
    {
      /* 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"));
2742
    }
2743 2744
  }

2745
  if (unlikely(nr == ULONGLONG_MAX))
2746
      DBUG_RETURN(HA_ERR_AUTOINC_ERANGE);
2747

2748
  DBUG_PRINT("info",("auto_increment: %llu",nr));
2749

2750 2751 2752 2753 2754
  /* Store field without warning (Warning will be printed by insert) */
  save_count_cuted_fields= thd->count_cuted_fields;
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
  tmp= table->next_number_field->store((longlong) nr, TRUE);
  thd->count_cuted_fields= save_count_cuted_fields;
2755

2756 2757
  if (unlikely(tmp))                            // Out of range value in store
  {
2758
    /*
2759 2760
      It's better to return an error here than getting a confusing
      'duplicate key error' later.
2761
    */
2762
    result= HA_ERR_AUTOINC_ERANGE;
2763 2764 2765
  }
  if (append)
  {
2766 2767
    DBUG_PRINT("info",("nb_reserved_values: %llu",nb_reserved_values));

2768 2769
    auto_inc_interval_for_cur_row.replace(nr, nb_reserved_values,
                                          variables->auto_increment_increment);
Guilhem Bichot's avatar
Guilhem Bichot committed
2770
    auto_inc_intervals_count++;
2771
    /* Row-based replication does not need to store intervals in binlog */
2772
    if (mysql_bin_log.is_open() && !thd->is_current_stmt_binlog_format_row())
2773 2774 2775
        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
2776
  }
2777

2778 2779 2780 2781 2782 2783 2784 2785
  /*
    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;
2786 2787 2788 2789

  if (result)                                   // overflow
    DBUG_RETURN(result);

2790 2791 2792 2793 2794
  /*
    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));
2795

unknown's avatar
unknown committed
2796
  DBUG_RETURN(0);
2797 2798
}

unknown's avatar
unknown committed
2799

2800
/** @brief
2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815
  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");
2816 2817 2818
  if (table)
    DBUG_PRINT("info", ("read_set: 0x%lx  write_set: 0x%lx",
                        (long) table->read_set, (long) table->write_set));
2819 2820 2821 2822
  DBUG_VOID_RETURN;
}


2823
/** @brief
2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843
  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
2844
{
2845
  ulonglong nr;
unknown's avatar
unknown committed
2846
  int error;
unknown's avatar
unknown committed
2847

unknown's avatar
unknown committed
2848
  (void) extra(HA_EXTRA_KEYREAD);
2849 2850 2851
  table->mark_columns_used_by_index_no_reset(table->s->next_number_index,
                                        table->read_set);
  column_bitmaps_signal();
2852 2853 2854 2855 2856 2857 2858 2859 2860

  if (ha_index_init(table->s->next_number_index, 1))
  {
    /* This should never happen, assert in debug, and fail in release build */
    DBUG_ASSERT(0);
    *first_value= ULONGLONG_MAX;
    return;
  }

2861
  if (table->s->next_number_keypart == 0)
unknown's avatar
unknown committed
2862
  {						// Autoincrement at key-start
2863
    error=ha_index_last(table->record[1]);
2864 2865 2866 2867 2868 2869
    /*
      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
2870 2871 2872
  }
  else
  {
2873
    uchar key[MAX_KEY_LENGTH];
2874
    key_copy(key, table->record[0],
2875 2876
             table->key_info + table->s->next_number_index,
             table->s->next_number_key_offset);
2877 2878 2879 2880
    error= ha_index_read_map(table->record[1], key,
                             make_prev_keypart_map(table->s->
                                                   next_number_keypart),
                             HA_READ_PREFIX_LAST);
2881 2882 2883 2884 2885 2886 2887
    /*
      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
2888 2889
  }

unknown's avatar
unknown committed
2890
  if (error)
2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902
  {
    if (error == HA_ERR_END_OF_FILE || error == HA_ERR_KEY_NOT_FOUND)
    {
      /* No entry found, start with 1. */
      nr= 1;
    }
    else
    {
      DBUG_ASSERT(0);
      nr= ULONGLONG_MAX;
    }
  }
unknown's avatar
unknown committed
2903
  else
2904 2905
    nr= ((ulonglong) table->next_number_field->
         val_int_offset(table->s->rec_buff_length)+1);
2906
  ha_index_end();
unknown's avatar
unknown committed
2907
  (void) extra(HA_EXTRA_NO_KEYREAD);
2908
  *first_value= nr;
2909
  return;
unknown's avatar
unknown committed
2910 2911
}

2912

2913 2914
void handler::ha_release_auto_increment()
{
2915
  DBUG_ENTER("ha_release_auto_increment");
2916 2917 2918
  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
2919
  auto_inc_intervals_count= 0;
2920 2921 2922 2923 2924 2925 2926 2927 2928
  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();
  }
2929
  DBUG_VOID_RETURN;
2930 2931 2932
}


2933
void handler::print_keydup_error(uint key_nr, const char *msg, myf errflag)
2934 2935 2936 2937
{
  /* Write the duplicated key in the error message */
  char key[MAX_KEY_LENGTH];
  String str(key,sizeof(key),system_charset_info);
2938 2939 2940 2941

  if (key_nr == MAX_KEY)
  {
    /* Key is unknown */
2942
    str.copy("", 0, system_charset_info);
2943
    my_printf_error(ER_DUP_ENTRY, msg, errflag, str.c_ptr(), "*UNKNOWN*");
2944 2945
  }
  else
2946
  {
2947 2948 2949 2950 2951 2952 2953 2954
    /* 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("..."));
    }
2955
    my_printf_error(ER_DUP_ENTRY, msg,
2956
		    errflag, str.c_ptr_safe(), table->key_info[key_nr].name);
2957 2958 2959 2960
  }
}


unknown's avatar
unknown committed
2961 2962
/**
  Print error that we got from handler function.
2963

unknown's avatar
unknown committed
2964 2965 2966 2967 2968
  @note
    In case of delete table it's only safe to use the following parts of
    the 'table' structure:
    - table->s->path
    - table->alias
2969
*/
2970 2971 2972

#define SET_FATAL_ERROR fatal_error=1

unknown's avatar
unknown committed
2973 2974
void handler::print_error(int error, myf errflag)
{
2975
  bool fatal_error= 0;
2976
  DBUG_ENTER("handler::print_error");
unknown's avatar
unknown committed
2977 2978
  DBUG_PRINT("enter",("error: %d",error));

2979
  int textno= -1; // impossible value
unknown's avatar
unknown committed
2980
  switch (error) {
2981 2982 2983
  case EACCES:
    textno=ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
2984 2985 2986 2987 2988 2989
  case EAGAIN:
    textno=ER_FILE_USED;
    break;
  case ENOENT:
    textno=ER_FILE_NOT_FOUND;
    break;
2990 2991 2992 2993 2994
  case ENOSPC:
  case HA_ERR_DISK_FULL:
    textno= ER_DISK_FULL;
    SET_FATAL_ERROR;                            // Ensure error is logged
    break;
unknown's avatar
unknown committed
2995 2996
  case HA_ERR_KEY_NOT_FOUND:
  case HA_ERR_NO_ACTIVE_RECORD:
2997
  case HA_ERR_RECORD_DELETED:
unknown's avatar
unknown committed
2998
  case HA_ERR_END_OF_FILE:
2999 3000 3001 3002 3003 3004 3005
    /*
      This errors is not not normally fatal (for example for reads). However
      if you get it during an update or delete, then its fatal.
      As the user is calling print_error() (which is not done on read), we
      assume something when wrong with the update or delete.
    */
    SET_FATAL_ERROR;
unknown's avatar
unknown committed
3006 3007
    textno=ER_KEY_NOT_FOUND;
    break;
3008 3009 3010 3011 3012 3013
  case HA_ERR_ABORTED_BY_USER:
  {
    DBUG_ASSERT(table->in_use->killed);
    table->in_use->send_kill_message();
    DBUG_VOID_RETURN;
  }
unknown's avatar
unknown committed
3014
  case HA_ERR_WRONG_MRG_TABLE_DEF:
unknown's avatar
unknown committed
3015 3016 3017 3018
    textno=ER_WRONG_MRG_TABLE;
    break;
  case HA_ERR_FOUND_DUPP_KEY:
  {
3019
    if (table)
unknown's avatar
unknown committed
3020
    {
3021 3022 3023
      uint key_nr=get_dup_key(error);
      if ((int) key_nr >= 0)
      {
3024
        print_keydup_error(key_nr, ER(ER_DUP_ENTRY_WITH_KEY_NAME), errflag);
3025 3026
        DBUG_VOID_RETURN;
      }
unknown's avatar
unknown committed
3027 3028 3029 3030
    }
    textno=ER_DUP_KEY;
    break;
  }
3031 3032 3033 3034 3035
  case HA_ERR_FOREIGN_DUPLICATE_KEY:
  {
    uint key_nr= get_dup_key(error);
    if ((int) key_nr >= 0)
    {
3036
      uint max_length;
3037 3038 3039 3040
      /* 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 */
Michael Widenius's avatar
Michael Widenius committed
3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057

      /*
        Use primary_key instead of key_nr because key_nr is a key
        number in the child FK table, not in our 'table'. See
        Bug#12661768 UPDATE IGNORE CRASHES SERVER IF TABLE IS INNODB
        AND IT IS PARENT FOR OTHER ONE This bug gets a better fix in
        MySQL 5.6, but it is too risky to get that in 5.1 and 5.5
        (extending the handler interface and adding new error message
        codes)
      */
      if (table->s->primary_key < MAX_KEY)
        key_unpack(&str,table,table->s->primary_key);
      else
      {
        LEX_CUSTRING tmp= {USTRING_WITH_LEN("Unknown key value")};
        str.set((const char*) tmp.str, tmp.length, system_charset_info);
      }
3058 3059
      max_length= (MYSQL_ERRMSG_SIZE-
                   (uint) strlen(ER(ER_FOREIGN_DUPLICATE_KEY)));
3060 3061 3062 3063 3064
      if (str.length() >= max_length)
      {
        str.length(max_length-4);
        str.append(STRING_WITH_LEN("..."));
      }
Michael Widenius's avatar
Michael Widenius committed
3065 3066
      my_error(ER_FOREIGN_DUPLICATE_KEY, errflag, table_share->table_name.str,
               str.c_ptr_safe(), key_nr+1);
3067 3068 3069 3070 3071
      DBUG_VOID_RETURN;
    }
    textno= ER_DUP_KEY;
    break;
  }
3072
  case HA_ERR_NULL_IN_SPATIAL:
Michael Widenius's avatar
Michael Widenius committed
3073
    my_error(ER_CANT_CREATE_GEOMETRY_OBJECT, errflag);
3074
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
3075 3076 3077 3078
  case HA_ERR_FOUND_DUPP_UNIQUE:
    textno=ER_DUP_UNIQUE;
    break;
  case HA_ERR_RECORD_CHANGED:
3079 3080 3081 3082
    /*
      This is not fatal error when using HANDLER interface
      SET_FATAL_ERROR;
    */
unknown's avatar
unknown committed
3083 3084 3085
    textno=ER_CHECKREAD;
    break;
  case HA_ERR_CRASHED:
3086
    SET_FATAL_ERROR;
unknown's avatar
unknown committed
3087 3088
    textno=ER_NOT_KEYFILE;
    break;
3089
  case HA_ERR_WRONG_IN_RECORD:
3090
    SET_FATAL_ERROR;
3091 3092
    textno= ER_CRASHED_ON_USAGE;
    break;
3093
  case HA_ERR_CRASHED_ON_USAGE:
3094
    SET_FATAL_ERROR;
3095 3096
    textno=ER_CRASHED_ON_USAGE;
    break;
3097 3098 3099
  case HA_ERR_NOT_A_TABLE:
    textno= error;
    break;
3100
  case HA_ERR_CRASHED_ON_REPAIR:
3101
    SET_FATAL_ERROR;
3102 3103
    textno=ER_CRASHED_ON_REPAIR;
    break;
unknown's avatar
unknown committed
3104
  case HA_ERR_OUT_OF_MEM:
3105 3106
    textno=ER_OUT_OF_RESOURCES;
    break;
unknown's avatar
unknown committed
3107
  case HA_ERR_WRONG_COMMAND:
3108 3109 3110
    my_error(ER_ILLEGAL_HA, MYF(0), table_type(), table_share->db.str,
             table_share->table_name.str);
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
3111 3112 3113 3114 3115 3116 3117 3118
    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:
3119
  case HA_ERR_INDEX_FILE_FULL:
3120
  {
3121
    textno=ER_RECORD_FILE_FULL;
3122 3123
    /* Write the error message to error log */
    errflag|= ME_NOREFRESH;
3124
    break;
3125
  }
3126 3127 3128 3129 3130 3131
  case HA_ERR_LOCK_WAIT_TIMEOUT:
    textno=ER_LOCK_WAIT_TIMEOUT;
    break;
  case HA_ERR_LOCK_TABLE_FULL:
    textno=ER_LOCK_TABLE_FULL;
    break;
3132 3133
  case HA_ERR_LOCK_DEADLOCK:
    textno=ER_LOCK_DEADLOCK;
3134 3135
    /* cannot continue. the statement was already aborted in the engine */
    SET_FATAL_ERROR;
3136
    break;
3137 3138 3139
  case HA_ERR_READ_ONLY_TRANSACTION:
    textno=ER_READ_ONLY_TRANSACTION;
    break;
unknown's avatar
Merge  
unknown committed
3140 3141 3142 3143
  case HA_ERR_CANNOT_ADD_FOREIGN:
    textno=ER_CANNOT_ADD_FOREIGN;
    break;
  case HA_ERR_ROW_IS_REFERENCED:
3144 3145 3146
  {
    String str;
    get_error_message(error, &str);
Michael Widenius's avatar
Michael Widenius committed
3147
    my_error(ER_ROW_IS_REFERENCED_2, errflag, str.c_ptr_safe());
3148 3149
    DBUG_VOID_RETURN;
  }
unknown's avatar
Merge  
unknown committed
3150
  case HA_ERR_NO_REFERENCED_ROW:
3151 3152 3153
  {
    String str;
    get_error_message(error, &str);
Michael Widenius's avatar
Michael Widenius committed
3154
    my_error(ER_NO_REFERENCED_ROW_2, errflag, str.c_ptr_safe());
3155 3156
    DBUG_VOID_RETURN;
  }
3157 3158 3159
  case HA_ERR_TABLE_DEF_CHANGED:
    textno=ER_TABLE_DEF_CHANGED;
    break;
3160
  case HA_ERR_NO_SUCH_TABLE:
3161
    my_error(ER_NO_SUCH_TABLE_IN_ENGINE, errflag, table_share->db.str,
unknown's avatar
unknown committed
3162
             table_share->table_name.str);
3163
    DBUG_VOID_RETURN;
3164 3165 3166
  case HA_ERR_RBR_LOGGING_FAILED:
    textno= ER_BINLOG_ROW_LOGGING_FAILED;
    break;
3167 3168 3169 3170 3171 3172
  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;
Michael Widenius's avatar
Michael Widenius committed
3173
    my_error(ER_DROP_INDEX_FK, errflag, ptr);
3174 3175
    DBUG_VOID_RETURN;
  }
unknown's avatar
unknown committed
3176 3177 3178
  case HA_ERR_TABLE_NEEDS_UPGRADE:
    textno=ER_TABLE_NEEDS_UPGRADE;
    break;
3179 3180 3181
  case HA_ERR_NO_PARTITION_FOUND:
    textno=ER_WRONG_PARTITION_NAME;
    break;
3182 3183 3184
  case HA_ERR_TABLE_READONLY:
    textno= ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
3185 3186 3187 3188
  case HA_ERR_AUTOINC_READ_FAILED:
    textno= ER_AUTOINC_READ_FAILED;
    break;
  case HA_ERR_AUTOINC_ERANGE:
3189 3190 3191 3192
    textno= error;
    my_error(textno, errflag, table->next_number_field->field_name,
             table->in_use->warning_info->current_row_for_warning());
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
3193
    break;
3194 3195 3196
  case HA_ERR_TOO_MANY_CONCURRENT_TRXS:
    textno= ER_TOO_MANY_CONCURRENT_TRXS;
    break;
3197 3198 3199
  case HA_ERR_INDEX_COL_TOO_LONG:
    textno= ER_INDEX_COLUMN_TOO_LONG;
    break;
3200 3201 3202
  case HA_ERR_INDEX_CORRUPT:
    textno= ER_INDEX_CORRUPT;
    break;
3203 3204 3205
  case HA_ERR_UNDO_REC_TOO_BIG:
    textno= ER_UNDO_RECORD_TOO_BIG;
    break;
3206 3207 3208
  case HA_ERR_TABLE_IN_FK_CHECK:
    textno= ER_TABLE_IN_FK_CHECK;
    break;
unknown's avatar
unknown committed
3209 3210
  default:
    {
3211 3212 3213
      /* The error was "unknown" to this function.
	 Ask handler if it has got a message for this error */
      bool temporary= FALSE;
3214 3215 3216
      String str;
      temporary= get_error_message(error, &str);
      if (!str.is_empty())
3217
      {
3218
	const char* engine= table_type();
3219
	if (temporary)
Michael Widenius's avatar
Michael Widenius committed
3220
	  my_error(ER_GET_TEMPORARY_ERRMSG, errflag, error, str.c_ptr(),
3221
                   engine);
3222
	else
3223 3224
        {
          SET_FATAL_ERROR;
Michael Widenius's avatar
Michael Widenius committed
3225
	  my_error(ER_GET_ERRMSG, errflag, error, str.c_ptr(), engine);
3226
        }
3227
      }
3228
      else
3229
	my_error(ER_GET_ERRNO, errflag, error, table_type());
unknown's avatar
unknown committed
3230 3231 3232
      DBUG_VOID_RETURN;
    }
  }
3233
  DBUG_ASSERT(textno > 0);
Michael Widenius's avatar
Michael Widenius committed
3234
  if (fatal_error)
3235
  {
Michael Widenius's avatar
Michael Widenius committed
3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246
    /* Ensure this becomes a true error */
    errflag&= ~(ME_JUST_WARNING | ME_JUST_INFO);
    if ((debug_assert_if_crashed_table ||
                      global_system_variables.log_warnings > 1))
    {
      /*
        Log error to log before we crash or if extended warnings are requested
      */
      errflag|= ME_NOREFRESH;
    }
  }    
3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257

  /* if we got an OS error from a file-based engine, specify a path of error */
  if (error < HA_ERR_FIRST && bas_ext()[0])
  {
    char buff[FN_REFLEN];
    strxnmov(buff, sizeof(buff),
             table_share->normalized_path.str, bas_ext()[0], NULL);
    my_error(textno, errflag, buff, error);
  }
  else
    my_error(textno, errflag, table_share->table_name.str, error);
unknown's avatar
unknown committed
3258 3259 3260
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
3261

unknown's avatar
unknown committed
3262 3263
/**
  Return an error message specific to this handler.
3264

unknown's avatar
unknown committed
3265 3266
  @param error  error code previously returned by handler
  @param buf    pointer to String where to add error message
unknown's avatar
unknown committed
3267

unknown's avatar
unknown committed
3268 3269
  @return
    Returns true if this is a temporary error
3270
*/
3271
bool handler::get_error_message(int error, String* buf)
3272
{
unknown's avatar
unknown committed
3273
  return FALSE;
3274 3275 3276
}


3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289
/**
  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;

3290
  if (mysql_version < 50124)
3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303
  {
    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;
3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315
        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 */
3316 3317 3318 3319 3320 3321 3322 3323
          return HA_ADMIN_NEEDS_UPGRADE;
      }  
    }  
  }  
  return 0;
}


unknown's avatar
unknown committed
3324 3325
int handler::ha_check_for_upgrade(HA_CHECK_OPT *check_opt)
{
3326
  int error;
unknown's avatar
unknown committed
3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343
  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];
3344
        if (field->type() == MYSQL_TYPE_BLOB)
unknown's avatar
unknown committed
3345 3346 3347 3348 3349 3350 3351 3352
        {
          if (check_opt->sql_flags & TT_FOR_UPGRADE)
            check_opt->flags= T_MEDIUM;
          return HA_ADMIN_NEEDS_CHECK;
        }
      }
    }
  }
3353 3354
  if (table->s->frm_version != FRM_VER_TRUE_VARCHAR)
    return HA_ADMIN_NEEDS_ALTER;
3355 3356 3357 3358

  if ((error= check_collation_compatibility()))
    return error;
    
unknown's avatar
unknown committed
3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371
  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++)
    {
3372
      if ((*field)->type() == MYSQL_TYPE_NEWDECIMAL)
unknown's avatar
unknown committed
3373 3374 3375
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
3376 3377 3378 3379
      if ((*field)->type() == MYSQL_TYPE_VAR_STRING)
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
unknown's avatar
unknown committed
3380 3381 3382 3383 3384 3385
    }
  }
  return 0;
}


3386
static bool update_frm_version(TABLE *table)
unknown's avatar
unknown committed
3387 3388 3389 3390 3391 3392
{
  char path[FN_REFLEN];
  File file;
  int result= 1;
  DBUG_ENTER("update_frm_version");

3393 3394 3395 3396 3397 3398 3399
  /*
    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
3400 3401
    DBUG_RETURN(0);

unknown's avatar
unknown committed
3402
  strxmov(path, table->s->normalized_path.str, reg_ext, NullS);
unknown's avatar
unknown committed
3403

Marc Alff's avatar
Marc Alff committed
3404 3405
  if ((file= mysql_file_open(key_file_frm,
                             path, O_RDWR|O_BINARY, MYF(MY_WME))) >= 0)
unknown's avatar
unknown committed
3406 3407 3408 3409 3410
  {
    uchar version[4];

    int4store(version, MYSQL_VERSION_ID);

Marc Alff's avatar
Marc Alff committed
3411
    if ((result= mysql_file_pwrite(file, (uchar*) version, 4, 51L, MYF_RW)))
unknown's avatar
unknown committed
3412 3413
      goto err;

3414
    table->s->mysql_version= MYSQL_VERSION_ID;
unknown's avatar
unknown committed
3415 3416 3417
  }
err:
  if (file >= 0)
Marc Alff's avatar
Marc Alff committed
3418
    (void) mysql_file_close(file, MYF(MY_WME));
unknown's avatar
unknown committed
3419 3420 3421 3422 3423
  DBUG_RETURN(result);
}



unknown's avatar
unknown committed
3424 3425 3426 3427
/**
  @return
    key if error because of duplicated keys
*/
unknown's avatar
unknown committed
3428 3429
uint handler::get_dup_key(int error)
{
3430
  DBUG_ENTER("handler::get_dup_key");
unknown's avatar
unknown committed
3431
  table->file->errkey  = (uint) -1;
3432 3433 3434
  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)
3435
    table->file->info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
unknown's avatar
unknown committed
3436 3437 3438
  DBUG_RETURN(table->file->errkey);
}

unknown's avatar
unknown committed
3439

unknown's avatar
unknown committed
3440 3441
/**
  Delete all files with extension from bas_ext().
3442

unknown's avatar
unknown committed
3443
  @param name		Base name of table
3444

unknown's avatar
unknown committed
3445
  @note
3446 3447 3448
    We assume that the handler may return more extensions than
    was actually used for the file.

unknown's avatar
unknown committed
3449
  @retval
3450
    0   If we successfully deleted at least one file from base_ext and
unknown's avatar
unknown committed
3451 3452 3453
    didn't get any other errors than ENOENT
  @retval
    !0  Error
3454
*/
unknown's avatar
unknown committed
3455 3456
int handler::delete_table(const char *name)
{
3457
  int saved_error= 0;
3458
  int error= 0;
3459
  int enoent_or_zero;
3460
  char buff[FN_REFLEN];
3461

3462 3463 3464 3465 3466
  if (ht->discover_table)
    enoent_or_zero= 0; // the table may not exist in the engine, it's ok
  else
    enoent_or_zero= ENOENT;  // the first file of bas_ext() *must* exist

unknown's avatar
unknown committed
3467 3468
  for (const char **ext=bas_ext(); *ext ; ext++)
  {
3469
    fn_format(buff, name, "", *ext, MY_UNPACK_FILENAME|MY_APPEND_EXT);
Marc Alff's avatar
Marc Alff committed
3470
    if (mysql_file_delete_with_symlink(key_file_misc, buff, MYF(0)))
unknown's avatar
unknown committed
3471
    {
3472 3473 3474 3475 3476 3477 3478 3479 3480 3481
      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
3482
    }
3483
    else
3484
      enoent_or_zero= 0;                        // No error for ENOENT
3485
    error= enoent_or_zero;
unknown's avatar
unknown committed
3486
  }
3487
  return saved_error ? saved_error : error;
unknown's avatar
unknown committed
3488 3489 3490 3491 3492
}


int handler::rename_table(const char * from, const char * to)
{
unknown's avatar
unknown committed
3493
  int error= 0;
3494 3495 3496
  const char **ext, **start_ext;
  start_ext= bas_ext();
  for (ext= start_ext; *ext ; ext++)
unknown's avatar
unknown committed
3497
  {
unknown's avatar
unknown committed
3498 3499 3500 3501 3502 3503
    if (rename_file_ext(from, to, *ext))
    {
      if ((error=my_errno) != ENOENT)
	break;
      error= 0;
    }
unknown's avatar
unknown committed
3504
  }
3505 3506 3507 3508 3509 3510
  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
3511
  return error;
unknown's avatar
unknown committed
3512 3513
}

unknown's avatar
unknown committed
3514 3515 3516

void handler::drop_table(const char *name)
{
3517
  ha_close();
unknown's avatar
unknown committed
3518 3519 3520 3521
  delete_table(name);
}


unknown's avatar
unknown committed
3522 3523
/**
  Performs checks upon the table.
unknown's avatar
unknown committed
3524

unknown's avatar
unknown committed
3525 3526
  @param thd                thread doing CHECK TABLE operation
  @param check_opt          options from the parser
unknown's avatar
unknown committed
3527

unknown's avatar
unknown committed
3528 3529 3530 3531 3532 3533 3534 3535
  @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
3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556
*/
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;
3557 3558 3559
  /* Skip updating frm version if not main handler. */
  if (table->file != this)
    return error;
3560
  return update_frm_version(table);
unknown's avatar
unknown committed
3561 3562
}

3563 3564 3565 3566 3567 3568
/**
  A helper function to mark a transaction read-write,
  if it is started.
*/

void
3569
handler::mark_trx_read_write_part2()
3570 3571
{
  Ha_trx_info *ha_info= &ha_thd()->ha_data[ht->slot].ha_info[0];
3572 3573 3574 3575

  /* Don't call this function again for this statement */
  mark_trx_done= TRUE;

3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595
  /*
    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
3596

3597 3598 3599 3600 3601 3602
/**
  Repair table: public interface.

  @sa handler::repair()
*/

unknown's avatar
unknown committed
3603 3604 3605
int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
{
  int result;
3606 3607 3608

  mark_trx_read_write();

3609 3610 3611 3612 3613 3614 3615
  result= repair(thd, check_opt);
  DBUG_ASSERT(result == HA_ADMIN_NOT_IMPLEMENTED ||
              ha_table_flags() & HA_CAN_REPAIR);

  if (result == HA_ADMIN_OK)
    result= update_frm_version(table);
  return result;
unknown's avatar
unknown committed
3616 3617 3618
}


3619 3620 3621 3622 3623 3624 3625 3626 3627 3628
/**
  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)
{
3629 3630
  mark_trx_read_write();

3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643
  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()
{
3644 3645
  mark_trx_read_write();

3646 3647 3648 3649
  return delete_all_rows();
}


3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664
/**
  Truncate table: public interface.

  @sa handler::truncate()
*/

int
handler::ha_truncate()
{
  mark_trx_read_write();

  return truncate();
}


3665 3666 3667 3668 3669 3670 3671 3672 3673
/**
  Reset auto increment: public interface.

  @sa handler::reset_auto_increment()
*/

int
handler::ha_reset_auto_increment(ulonglong value)
{
3674 3675
  mark_trx_read_write();

3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688
  return reset_auto_increment(value);
}


/**
  Optimize table: public interface.

  @sa handler::optimize()
*/

int
handler::ha_optimize(THD* thd, HA_CHECK_OPT* check_opt)
{
3689 3690
  mark_trx_read_write();

3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703
  return optimize(thd, check_opt);
}


/**
  Analyze table: public interface.

  @sa handler::analyze()
*/

int
handler::ha_analyze(THD* thd, HA_CHECK_OPT* check_opt)
{
3704 3705
  mark_trx_read_write();

3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718
  return analyze(thd, check_opt);
}


/**
  Check and repair table: public interface.

  @sa handler::check_and_repair()
*/

bool
handler::ha_check_and_repair(THD *thd)
{
3719 3720
  mark_trx_read_write();

3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733
  return check_and_repair(thd);
}


/**
  Disable indexes: public interface.

  @sa handler::disable_indexes()
*/

int
handler::ha_disable_indexes(uint mode)
{
3734 3735
  mark_trx_read_write();

3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748
  return disable_indexes(mode);
}


/**
  Enable indexes: public interface.

  @sa handler::enable_indexes()
*/

int
handler::ha_enable_indexes(uint mode)
{
3749 3750
  mark_trx_read_write();

3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763
  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)
{
3764 3765
  mark_trx_read_write();

3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780
  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()
{
3781 3782
  mark_trx_read_write();

3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795
  prepare_for_alter();
}


/**
  Rename table: public interface.

  @sa handler::rename_table()
*/

int
handler::ha_rename_table(const char *from, const char *to)
{
3796 3797
  mark_trx_read_write();

3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810
  return rename_table(from, to);
}


/**
  Delete table: public interface.

  @sa handler::delete_table()
*/

int
handler::ha_delete_table(const char *name)
{
3811
  mark_trx_read_write();
3812 3813 3814 3815 3816 3817 3818 3819
  return delete_table(name);
}


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

  @sa handler::drop_table()
3820 3821 3822

  The difference between this and delete_table() is that the table is open in
  drop_table().
3823 3824 3825 3826 3827
*/

void
handler::ha_drop_table(const char *name)
{
3828 3829
  mark_trx_read_write();

3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842
  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)
{
3843
  mark_trx_read_write();
3844 3845 3846 3847 3848
  int error= create(name, form, info);
  if (!error &&
      !(info->options & (HA_LEX_CREATE_TMP_TABLE | HA_CREATE_TMP_ALTER)))
    mysql_audit_create_table(form);
  return error;
3849 3850 3851 3852 3853 3854
}


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

3855
  @sa handler::create_partitioning_metadata()
3856 3857 3858
*/

int
3859
handler::ha_create_partitioning_metadata(const char *name, const char *old_name,
3860
                                         int action_flag)
3861
{
3862 3863
  mark_trx_read_write();

3864
  return create_partitioning_metadata(name, old_name, action_flag);
3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876
}


/**
  Change partitions: public interface.

  @sa handler::change_partitions()
*/

int
handler::ha_change_partitions(HA_CREATE_INFO *create_info,
                     const char *path,
3877 3878
                     ulonglong * const copied,
                     ulonglong * const deleted,
3879 3880 3881
                     const uchar *pack_frm_data,
                     size_t pack_frm_len)
{
3882 3883
  mark_trx_read_write();

3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897
  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)
{
3898 3899
  mark_trx_read_write();

3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912
  return drop_partitions(path);
}


/**
  Rename partitions: public interface.

  @sa handler::rename_partitions()
*/

int
handler::ha_rename_partitions(const char *path)
{
3913 3914
  mark_trx_read_write();

3915 3916 3917 3918
  return rename_partitions(path);
}


unknown's avatar
unknown committed
3919
/**
3920 3921 3922 3923 3924 3925
  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.
3926
*/
3927
int ha_enable_transaction(THD *thd, bool on)
3928 3929
{
  int error=0;
3930
  DBUG_ENTER("ha_enable_transaction");
unknown's avatar
unknown committed
3931 3932
  DBUG_PRINT("enter", ("on: %d", (int) on));

3933
  if ((thd->transaction.on= on))
3934 3935 3936 3937 3938 3939 3940
  {
    /*
      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.
    */
3941
    if (!(error= ha_commit_trans(thd, 0)))
Konstantin Osipov's avatar
Konstantin Osipov committed
3942
      error= trans_commit_implicit(thd);
3943
  }
3944 3945 3946
  DBUG_RETURN(error);
}

3947
int handler::index_next_same(uchar *buf, const uchar *key, uint keylen)
unknown's avatar
unknown committed
3948 3949
{
  int error;
3950
  DBUG_ENTER("handler::index_next_same");
unknown's avatar
unknown committed
3951 3952
  if (!(error=index_next(buf)))
  {
3953
    my_ptrdiff_t ptrdiff= buf - table->record[0];
3954 3955 3956 3957
    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);
3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980

    /*
      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
3981
    if (key_cmp_if_same(table, key, active_index, keylen))
unknown's avatar
unknown committed
3982 3983 3984 3985
    {
      table->status=STATUS_NOT_FOUND;
      error=HA_ERR_END_OF_FILE;
    }
3986 3987 3988 3989 3990 3991 3992 3993

    /* 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
3994
  }
3995
  DBUG_PRINT("return",("%i", error));
3996
  DBUG_RETURN(error);
unknown's avatar
unknown committed
3997 3998 3999
}


4000
void handler::get_dynamic_partition_info(PARTITION_STATS *stat_info,
4001
                                         uint part_id)
4002 4003 4004
{
  info(HA_STATUS_CONST | HA_STATUS_TIME | HA_STATUS_VARIABLE |
       HA_STATUS_NO_LOCK);
4005 4006 4007 4008 4009 4010 4011 4012 4013 4014
  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;
4015
  if (table_flags() & (HA_HAS_OLD_CHECKSUM | HA_HAS_OLD_CHECKSUM))
4016
    stat_info->check_sum= checksum();
4017 4018 4019 4020
  return;
}


4021 4022 4023 4024 4025 4026 4027 4028 4029
/*
  Updates the global table stats with the TABLE this handler represents
*/

void handler::update_global_table_stats()
{
  TABLE_STATS * table_stats;

  status_var_add(table->in_use->status_var.rows_read, rows_read);
4030
  DBUG_ASSERT(rows_tmp_read == 0);
4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042

  if (!table->in_use->userstat_running)
  {
    rows_read= rows_changed= 0;
    return;
  }

  if (rows_read + rows_changed == 0)
    return;                                     // Nothing to update.

  DBUG_ASSERT(table->s && table->s->table_cache_key.str);

4043
  mysql_mutex_lock(&LOCK_global_table_stats);
4044 4045
  /* Gets the global table stats, creating one if necessary. */
  if (!(table_stats= (TABLE_STATS*)
4046
        my_hash_search(&global_table_stats,
4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065
                    (uchar*) table->s->table_cache_key.str,
                    table->s->table_cache_key.length)))
  {
    if (!(table_stats = ((TABLE_STATS*)
                         my_malloc(sizeof(TABLE_STATS),
                                   MYF(MY_WME | MY_ZEROFILL)))))
    {
      /* Out of memory error already given */
      goto end;
    }
    memcpy(table_stats->table, table->s->table_cache_key.str,
           table->s->table_cache_key.length);
    table_stats->table_name_length= table->s->table_cache_key.length;
    table_stats->engine_type= ht->db_type;
    /* No need to set variables to 0, as we use MY_ZEROFILL above */

    if (my_hash_insert(&global_table_stats, (uchar*) table_stats))
    {
      /* Out of memory error is already given */
4066
      my_free(table_stats);
4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077
      goto end;
    }
  }
  // Updates the global table stats.
  table_stats->rows_read+=    rows_read;
  table_stats->rows_changed+= rows_changed;
  table_stats->rows_changed_x_indexes+= (rows_changed *
                                         (table->s->keys ? table->s->keys :
                                          1));
  rows_read= rows_changed= 0;
end:
4078
  mysql_mutex_unlock(&LOCK_global_table_stats);
4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108
}


/*
  Updates the global index stats with this handler's accumulated index reads.
*/

void handler::update_global_index_stats()
{
  DBUG_ASSERT(table->s);

  if (!table->in_use->userstat_running)
  {
    /* Reset all index read values */
    bzero(index_rows_read, sizeof(index_rows_read[0]) * table->s->keys);
    return;
  }

  for (uint index = 0; index < table->s->keys; index++)
  {
    if (index_rows_read[index])
    {
      INDEX_STATS* index_stats;
      uint key_length;
      KEY *key_info = &table->key_info[index];  // Rows were read using this

      DBUG_ASSERT(key_info->cache_name);
      if (!key_info->cache_name)
        continue;
      key_length= table->s->table_cache_key.length + key_info->name_length + 1;
4109
      mysql_mutex_lock(&LOCK_global_index_stats);
4110
      // Gets the global index stats, creating one if necessary.
4111
      if (!(index_stats= (INDEX_STATS*) my_hash_search(&global_index_stats,
4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123
                                                    key_info->cache_name,
                                                    key_length)))
      {
        if (!(index_stats = ((INDEX_STATS*)
                             my_malloc(sizeof(INDEX_STATS),
                                       MYF(MY_WME | MY_ZEROFILL)))))
          goto end;                             // Error is already given

        memcpy(index_stats->index, key_info->cache_name, key_length);
        index_stats->index_name_length= key_length;
        if (my_hash_insert(&global_index_stats, (uchar*) index_stats))
        {
4124
          my_free(index_stats);
4125 4126 4127 4128 4129 4130 4131
          goto end;
        }
      }
      /* Updates the global index stats. */
      index_stats->rows_read+= index_rows_read[index];
      index_rows_read[index]= 0;
end:
4132
      mysql_mutex_unlock(&LOCK_global_index_stats);
4133 4134 4135 4136 4137
    }
  }
}


unknown's avatar
unknown committed
4138 4139 4140 4141
/****************************************************************************
** Some general functions that isn't in the handler class
****************************************************************************/

unknown's avatar
unknown committed
4142 4143
/**
  Initiates table-file and calls appropriate database-creator.
unknown's avatar
unknown committed
4144

unknown's avatar
unknown committed
4145
  @retval
unknown's avatar
unknown committed
4146
   0  ok
unknown's avatar
unknown committed
4147
  @retval
unknown's avatar
unknown committed
4148
   1  error
unknown's avatar
unknown committed
4149
*/
unknown's avatar
unknown committed
4150 4151
int ha_create_table(THD *thd, const char *path,
                    const char *db, const char *table_name,
4152
                    HA_CREATE_INFO *create_info, LEX_CUSTRING *frm)
unknown's avatar
unknown committed
4153
{
unknown's avatar
unknown committed
4154
  int error= 1;
unknown's avatar
unknown committed
4155
  TABLE table;
unknown's avatar
unknown committed
4156
  char name_buff[FN_REFLEN];
unknown's avatar
unknown committed
4157 4158
  const char *name;
  TABLE_SHARE share;
unknown's avatar
unknown committed
4159
  DBUG_ENTER("ha_create_table");
unknown's avatar
unknown committed
4160
  
4161
  init_tmp_table_share(thd, &share, db, 0, table_name, path);
4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177

  if (frm)
  {
    bool write_frm_now= !create_info->db_type->discover_table &&
                        !create_info->tmp_table();

    share.frm_image= frm;

    // open an frm image
    if (share.init_from_binary_frm_image(thd, write_frm_now,
                                         frm->str, frm->length))
      goto err;
  }
  else
  {
    // open an frm file
4178 4179
    share.db_plugin= ha_lock_engine(thd, create_info->db_type);

4180 4181 4182 4183 4184 4185
    if (open_table_def(thd, &share))
      goto err;
  }
  

  if (open_table_from_share(thd, &share, "", 0, READ_ALL, 0, &table, true))
unknown's avatar
unknown committed
4186
    goto err;
unknown's avatar
unknown committed
4187

4188
  update_create_info_from_table(create_info, &table);
unknown's avatar
unknown committed
4189

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

4192
  error= table.file->ha_create(name, &table, create_info);
4193

Konstantin Osipov's avatar
Konstantin Osipov committed
4194
  (void) closefrm(&table, 0);
4195

unknown's avatar
unknown committed
4196
  if (error)
4197 4198
    my_error(ER_CANT_CREATE_TABLE, MYF(0), db, table_name, error);
 
unknown's avatar
unknown committed
4199 4200
err:
  free_table_share(&share);
unknown's avatar
unknown committed
4201 4202 4203
  DBUG_RETURN(error != 0);
}

4204 4205 4206
void st_ha_check_opt::init()
{
  flags= sql_flags= 0;
4207
  start_time= my_time(0);
4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220
}


/*****************************************************************************
  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
4221 4222
/**
  Init a key cache if it has not been initied before.
4223
*/
4224 4225
int ha_init_key_cache(const char *name, KEY_CACHE *key_cache, void *unused
                      __attribute__((unused)))
unknown's avatar
unknown committed
4226
{
4227 4228
  DBUG_ENTER("ha_init_key_cache");

unknown's avatar
unknown committed
4229
  if (!key_cache->key_cache_inited)
4230
  {
Marc Alff's avatar
Marc Alff committed
4231
    mysql_mutex_lock(&LOCK_global_system_variables);
4232
    size_t tmp_buff_size= (size_t) key_cache->param_buff_size;
4233
    uint tmp_block_size= (uint) key_cache->param_block_size;
4234 4235 4236
    uint division_limit= (uint)key_cache->param_division_limit;
    uint age_threshold=  (uint)key_cache->param_age_threshold;
    uint partitions=     (uint)key_cache->param_partitions;
Marc Alff's avatar
Marc Alff committed
4237
    mysql_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
4238
    DBUG_RETURN(!init_key_cache(key_cache,
4239 4240
				tmp_block_size,
				tmp_buff_size,
4241 4242
				division_limit, age_threshold,
                                partitions));
4243
  }
4244
  DBUG_RETURN(0);
unknown's avatar
unknown committed
4245 4246
}

4247

unknown's avatar
unknown committed
4248 4249
/**
  Resize key cache.
4250
*/
unknown's avatar
unknown committed
4251
int ha_resize_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
4252
{
4253 4254
  DBUG_ENTER("ha_resize_key_cache");

unknown's avatar
unknown committed
4255
  if (key_cache->key_cache_inited)
4256
  {
Marc Alff's avatar
Marc Alff committed
4257
    mysql_mutex_lock(&LOCK_global_system_variables);
4258
    size_t tmp_buff_size= (size_t) key_cache->param_buff_size;
unknown's avatar
unknown committed
4259
    long tmp_block_size= (long) key_cache->param_block_size;
4260 4261
    uint division_limit= (uint)key_cache->param_division_limit;
    uint age_threshold=  (uint)key_cache->param_age_threshold;
Marc Alff's avatar
Marc Alff committed
4262
    mysql_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
4263 4264 4265
    DBUG_RETURN(!resize_key_cache(key_cache, tmp_block_size,
				  tmp_buff_size,
				  division_limit, age_threshold));
4266
  }
4267
  DBUG_RETURN(0);
4268 4269
}

4270

unknown's avatar
unknown committed
4271
/**
4272
  Change parameters for key cache (like division_limit)
4273
*/
unknown's avatar
unknown committed
4274
int ha_change_key_cache_param(KEY_CACHE *key_cache)
4275
{
4276 4277
  DBUG_ENTER("ha_change_key_cache_param");

unknown's avatar
unknown committed
4278 4279
  if (key_cache->key_cache_inited)
  {
Marc Alff's avatar
Marc Alff committed
4280
    mysql_mutex_lock(&LOCK_global_system_variables);
4281 4282
    uint division_limit= (uint)key_cache->param_division_limit;
    uint age_threshold=  (uint)key_cache->param_age_threshold;
Marc Alff's avatar
Marc Alff committed
4283
    mysql_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
4284 4285
    change_key_cache_param(key_cache, division_limit, age_threshold);
  }
4286
  DBUG_RETURN(0);
4287
}
unknown's avatar
unknown committed
4288

4289 4290 4291 4292 4293 4294 4295 4296 4297 4298

/**
  Repartition key cache 
*/
int ha_repartition_key_cache(KEY_CACHE *key_cache)
{
  DBUG_ENTER("ha_repartition_key_cache");

  if (key_cache->key_cache_inited)
  {
4299
    mysql_mutex_lock(&LOCK_global_system_variables);
4300 4301
    size_t tmp_buff_size= (size_t) key_cache->param_buff_size;
    long tmp_block_size= (long) key_cache->param_block_size;
4302 4303 4304
    uint division_limit= (uint)key_cache->param_division_limit;
    uint age_threshold=  (uint)key_cache->param_age_threshold;
    uint partitions=     (uint)key_cache->param_partitions;
4305
    mysql_mutex_unlock(&LOCK_global_system_variables);
4306 4307 4308 4309 4310 4311
    DBUG_RETURN(!repartition_key_cache(key_cache, tmp_block_size,
				       tmp_buff_size,
				       division_limit, age_threshold,
                                       partitions));
  }
  DBUG_RETURN(0);
4312
}
unknown's avatar
unknown committed
4313

4314

unknown's avatar
unknown committed
4315 4316
/**
  Move all tables from one key cache to another one.
4317
*/
unknown's avatar
unknown committed
4318 4319
int ha_change_key_cache(KEY_CACHE *old_key_cache,
			KEY_CACHE *new_key_cache)
unknown's avatar
unknown committed
4320
{
4321 4322
  mi_change_key_cache(old_key_cache, new_key_cache);
  return 0;
unknown's avatar
unknown committed
4323
}
4324 4325


unknown's avatar
unknown committed
4326
static my_bool discover_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
4327 4328
                                   void *arg)
{
4329
  TABLE_SHARE *share= (TABLE_SHARE *)arg;
unknown's avatar
unknown committed
4330
  handlerton *hton= plugin_data(plugin, handlerton *);
4331 4332
  if (hton->state == SHOW_OPTION_YES && hton->discover_table)
  {
4333
    share->db_plugin= plugin;
4334 4335 4336 4337 4338 4339
    int error= hton->discover_table(hton, thd, share);
    if (error != HA_ERR_NO_SUCH_TABLE)
    {
      if (error)
      {
        DBUG_ASSERT(share->error); // MUST be always set for get_cached_table_share to work
4340
        my_error(ER_GET_ERRNO, MYF(0), error, plugin_name(plugin)->str);
4341
        share->db_plugin= 0;
4342 4343 4344
      }
      else
        share->error= OPEN_FRM_OK;
unknown's avatar
unknown committed
4345

4346 4347 4348
      status_var_increment(thd->status_var.ha_discover_count);
      return TRUE; // abort the search
    }
4349
    share->db_plugin= 0;
4350 4351 4352 4353
  }

  DBUG_ASSERT(share->error == OPEN_FRM_OPEN_ERROR);
  return FALSE;    // continue with the next engine
unknown's avatar
unknown committed
4354 4355
}

4356
int ha_discover_table(THD *thd, TABLE_SHARE *share)
unknown's avatar
unknown committed
4357
{
4358
  DBUG_ENTER("ha_discover_table");
4359
  int found;
unknown's avatar
unknown committed
4360

4361
  DBUG_ASSERT(share->error == OPEN_FRM_OPEN_ERROR);   // share is not OK yet
unknown's avatar
unknown committed
4362

4363 4364 4365 4366 4367 4368 4369
  if (share->db_plugin)
    found= discover_handlerton(thd, share->db_plugin, share);
  else
    found= plugin_foreach(thd, discover_handlerton,
                        MYSQL_STORAGE_ENGINE_PLUGIN, share);
  
  if (!found)
4370
    open_table_error(share, OPEN_FRM_OPEN_ERROR, ENOENT); // not found
unknown's avatar
unknown committed
4371

4372
  DBUG_RETURN(share->error != OPEN_FRM_OK);
4373 4374
}

4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385
static my_bool file_ext_exists(char *path, size_t path_len, const char *ext)
{
  strmake(path + path_len, ext, FN_REFLEN - path_len);
  return !access(path, F_OK);
}

struct st_discover_existence_args
{
  char *path;
  size_t  path_len;
  const char *db, *table_name;
4386
  handlerton *hton;
4387 4388 4389 4390 4391 4392 4393 4394 4395 4396
};

static my_bool discover_existence(THD *thd, plugin_ref plugin,
                                  void *arg)
{
  st_discover_existence_args *args= (st_discover_existence_args*)arg;
  handlerton *ht= plugin_data(plugin, handlerton *);
  if (ht->state != SHOW_OPTION_YES || !ht->discover_table_existence)
    return FALSE;

4397 4398
  args->hton= ht;

4399 4400 4401 4402 4403 4404 4405
  if (ht->discover_table_existence == ext_based_existence)
    return file_ext_exists(args->path, args->path_len,
                           ht->tablefile_extensions[0]);

  return ht->discover_table_existence(ht, args->db, args->table_name);
}

4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422
class Table_exists_error_handler : public Internal_error_handler
{
public:
  Table_exists_error_handler()
    : m_handled_errors(0), m_unhandled_errors(0)
  {}

  bool handle_condition(THD *thd,
                        uint sql_errno,
                        const char* sqlstate,
                        MYSQL_ERROR::enum_warning_level level,
                        const char* msg,
                        MYSQL_ERROR ** cond_hdl)
  {
    *cond_hdl= NULL;
    if (sql_errno == ER_NO_SUCH_TABLE ||
        sql_errno == ER_NO_SUCH_TABLE_IN_ENGINE ||
4423
        sql_errno == ER_WRONG_OBJECT)
4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443
    {
      m_handled_errors++;
      return TRUE;
    }

    if (level == MYSQL_ERROR::WARN_LEVEL_ERROR)
      m_unhandled_errors++;
    return FALSE;
  }

  bool safely_trapped_errors()
  {
    return ((m_handled_errors > 0) && (m_unhandled_errors == 0));
  }

private:
  int m_handled_errors;
  int m_unhandled_errors;
};

4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455
/**
  Check if a given table exists, without doing a full discover, if possible

  If the 'hton' is not NULL, it's set to the handlerton of the storage engine
  of this table, or to view_pseudo_hton if the frm belongs to a view.


  @retval true    Table exists (even if the error occurred, like bad frm)
  @retval false   Table does not exist (one can do CREATE TABLE table_name)
*/
bool ha_table_exists(THD *thd, const char *db, const char *table_name,
                     handlerton **hton)
4456
{
4457 4458 4459 4460
  DBUG_ENTER("ha_table_exists");

  if (hton)
    *hton= 0;
4461 4462 4463 4464

  if (need_full_discover_for_existence)
  {
    TABLE_LIST table;
4465 4466 4467 4468
    uint flags = GTS_TABLE | GTS_VIEW;

    if (!hton)
      flags|= GTS_NOLOCK;
4469

4470 4471
    Table_exists_error_handler no_such_table_handler;
    thd->push_internal_handler(&no_such_table_handler);
4472
    TABLE_SHARE *share= get_table_share(thd, db, table_name, flags);
4473 4474
    thd->pop_internal_handler();

4475 4476 4477 4478 4479 4480 4481 4482
    if (hton && share)
    {
      *hton= share->db_type();
      mysql_mutex_lock(&LOCK_open);
      release_table_share(share);
      mysql_mutex_unlock(&LOCK_open);
    }

4483 4484
    // the table doesn't exist if we've caught ER_NO_SUCH_TABLE and nothing else
    DBUG_RETURN(!no_such_table_handler.safely_trapped_errors());
4485 4486 4487 4488
  }

  mysql_mutex_lock(&LOCK_open);
  TABLE_SHARE *share= get_cached_table_share(db, table_name);
4489 4490
  if (hton && share)
    *hton= share->db_type();
4491 4492 4493 4494 4495 4496 4497 4498 4499 4500
  mysql_mutex_unlock(&LOCK_open);

  if (share)
    DBUG_RETURN(TRUE);

  char path[FN_REFLEN + 1];
  size_t path_len = build_table_filename(path, sizeof(path) - 1,
                                         db, table_name, "", 0);

  if (file_ext_exists(path, path_len, reg_ext))
4501 4502 4503 4504 4505 4506 4507 4508 4509
  {
    if (hton)
    {
      enum legacy_db_type db_type;
      if (dd_frm_type(thd, path, &db_type) != FRMTYPE_VIEW)
        *hton= ha_resolve_by_legacy_type(thd, db_type);
      else
        *hton= view_pseudo_hton;
    }
4510
    DBUG_RETURN(TRUE);
4511
  }
4512

4513
  st_discover_existence_args args= {path, path_len, db, table_name, 0};
4514 4515 4516

  if (plugin_foreach(thd, discover_existence, MYSQL_STORAGE_ENGINE_PLUGIN,
                     &args))
4517 4518 4519
  {
    if (hton)
      *hton= args.hton;
4520
    DBUG_RETURN(TRUE);
4521
  }
4522 4523 4524

  DBUG_RETURN(FALSE);
}
4525 4526 4527 4528

/**
  Discover all table names in a given database
*/
4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603
extern "C" {

static int cmp_file_names(const void *a, const void *b)
{
  CHARSET_INFO *cs= character_set_filesystem;
  char *aa= ((FILEINFO *)a)->name;
  char *bb= ((FILEINFO *)b)->name;
  return my_strnncoll(cs, (uchar*)aa, strlen(aa), (uchar*)bb, strlen(bb));
}

static int cmp_table_names(LEX_STRING * const *a, LEX_STRING * const *b)
{
  return my_strnncoll(&my_charset_bin, (uchar*)((*a)->str), (*a)->length,
                                       (uchar*)((*b)->str), (*b)->length);
}

}

Discovered_table_list::Discovered_table_list(THD *thd_arg,
                 Dynamic_array<LEX_STRING*> *tables_arg,
                 const LEX_STRING *wild_arg)
{
  thd= thd_arg;
  tables= tables_arg;
  if (wild_arg->str && wild_arg->str[0])
  {
    wild= wild_arg->str;
    wend= wild + wild_arg->length;
  }
  else
    wild= 0;
}

bool Discovered_table_list::add_table(const char *tname, size_t tlen)
{
  if (wild && my_wildcmp(files_charset_info, tname, tname + tlen, wild, wend,
                         wild_prefix, wild_one, wild_many))
      return 0;

  LEX_STRING *name= thd->make_lex_string(tname, tlen);
  if (!name || tables->append(name))
    return 1;
  return 0;
}

bool Discovered_table_list::add_file(const char *fname)
{
  char tname[SAFE_NAME_LEN + 1];
  size_t tlen= filename_to_tablename(fname, tname, sizeof(tname));
  return add_table(tname, tlen);
}


void Discovered_table_list::sort()
{
  tables->sort(cmp_table_names);
}

void Discovered_table_list::remove_duplicates()
{
  LEX_STRING **src= tables->front();
  LEX_STRING **dst= src;
  while (++dst < tables->back())
  {
    LEX_STRING *s= *src, *d= *dst;
    DBUG_ASSERT(strncmp(s->str, d->str, min(s->length, d->length)) <= 0);
    if ((s->length != d->length || strncmp(s->str, d->str, d->length)))
    {
      src++;
      if (src != dst)
        *src= *dst;
    }
  }
  tables->set_elements(src - tables->front() + 1);
}
4604 4605 4606 4607 4608

struct st_discover_names_args
{
  LEX_STRING *db;
  MY_DIR *dirp;
4609 4610
  Discovered_table_list *result;
  uint possible_duplicates;
4611 4612 4613 4614 4615 4616 4617
};

static my_bool discover_names(THD *thd, plugin_ref plugin,
                              void *arg)
{
  st_discover_names_args *args= (st_discover_names_args *)arg;
  handlerton *ht= plugin_data(plugin, handlerton *);
4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631

  if (ht->state == SHOW_OPTION_YES && ht->discover_table_names)
  {
    uint old_elements= args->result->tables->elements();
    if (ht->discover_table_names(ht, args->db, args->dirp, args->result))
      return 1;

    /*
      hton_ext_based_table_discovery never discovers a table that has
      a corresponding .frm file; but custom engine discover methods might
    */
    if (ht->discover_table_names != hton_ext_based_table_discovery)
      args->possible_duplicates+= args->result->tables->elements() - old_elements;
  }
4632 4633 4634 4635 4636

  return 0;
}

int ha_discover_table_names(THD *thd, LEX_STRING *db, MY_DIR *dirp,
4637
                            Discovered_table_list *result, bool reusable)
4638 4639 4640 4641
{
  int error;
  DBUG_ENTER("ha_discover_table_names");

4642
  if (engines_with_discover_table_names == 0 && !reusable)
4643 4644 4645 4646 4647 4648 4649
  {
    error= ext_table_discovery_simple(dirp, result);
    result->sort();
  }
  else
  {
    st_discover_names_args args= {db, dirp, result, 0};
4650

4651 4652 4653
    /* extension_based_table_discovery relies on dirp being sorted */
    my_qsort(dirp->dir_entry, dirp->number_of_files,
             sizeof(FILEINFO), cmp_file_names);
4654

4655 4656 4657 4658 4659 4660 4661 4662
    error= extension_based_table_discovery(dirp, reg_ext, result) ||
           plugin_foreach(thd, discover_names,
                            MYSQL_STORAGE_ENGINE_PLUGIN, &args);
    result->sort();

    if (args.possible_duplicates > 0)
      result->remove_duplicates();
  }
4663 4664

  DBUG_RETURN(error);
unknown's avatar
unknown committed
4665 4666 4667
}


unknown's avatar
unknown committed
4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687
#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;
};

4688
/** @brief
unknown's avatar
unknown committed
4689 4690
  Listing handlertons first to avoid recursive calls and deadlock
*/
unknown's avatar
unknown committed
4691
static my_bool binlog_func_list(THD *thd, plugin_ref plugin, void *arg)
unknown's avatar
unknown committed
4692 4693
{
  hton_list_st *hton_list= (hton_list_st *)arg;
unknown's avatar
unknown committed
4694
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711
  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;
4712 4713
  uint i, sz;

unknown's avatar
unknown committed
4714 4715 4716 4717
  hton_list.sz= 0;
  plugin_foreach(thd, binlog_func_list,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &hton_list);

4718 4719
  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
4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752
  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
4753
  return 0;
unknown's avatar
unknown committed
4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764
}

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

4765
static my_bool binlog_log_query_handlerton2(THD *thd,
4766
                                            handlerton *hton,
4767
                                            void *args)
unknown's avatar
unknown committed
4768 4769 4770
{
  struct binlog_log_query_st *b= (struct binlog_log_query_st*)args;
  if (hton->state == SHOW_OPTION_YES && hton->binlog_log_query)
4771
    hton->binlog_log_query(hton, thd,
unknown's avatar
unknown committed
4772 4773 4774 4775 4776 4777 4778 4779
                           b->binlog_command,
                           b->query,
                           b->query_length,
                           b->db,
                           b->table_name);
  return FALSE;
}

4780
static my_bool binlog_log_query_handlerton(THD *thd,
unknown's avatar
unknown committed
4781
                                           plugin_ref plugin,
4782 4783
                                           void *args)
{
unknown's avatar
unknown committed
4784
  return binlog_log_query_handlerton2(thd, plugin_data(plugin, handlerton *), args);
4785 4786
}

4787
void ha_binlog_log_query(THD *thd, handlerton *hton,
4788
                         enum_binlog_command binlog_command,
unknown's avatar
unknown committed
4789 4790 4791 4792 4793 4794 4795 4796 4797
                         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;
4798 4799 4800 4801 4802
  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
4803 4804
}
#endif
4805

unknown's avatar
unknown committed
4806

unknown's avatar
unknown committed
4807
/**
4808
  Read first row between two ranges.
unknown's avatar
unknown committed
4809
  Store ranges for future calls to read_range_next.
4810

unknown's avatar
unknown committed
4811 4812 4813 4814 4815 4816
  @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
4817 4818
    Record is read into table->record[0]

unknown's avatar
unknown committed
4819
  @retval
4820
    0			Found row
unknown's avatar
unknown committed
4821
  @retval
4822
    HA_ERR_END_OF_FILE	No rows in range
unknown's avatar
unknown committed
4823 4824
  @retval
    \#			Error code
4825 4826 4827
*/
int handler::read_range_first(const key_range *start_key,
			      const key_range *end_key,
unknown's avatar
unknown committed
4828
			      bool eq_range_arg, bool sorted)
4829 4830 4831 4832
{
  int result;
  DBUG_ENTER("handler::read_range_first");

unknown's avatar
unknown committed
4833
  eq_range= eq_range_arg;
4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844
  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
4845
    result= ha_index_first(table->record[0]);
4846
  else
4847 4848 4849 4850
    result= ha_index_read_map(table->record[0],
                              start_key->key,
                              start_key->keypart_map,
                              start_key->flag);
4851
  if (result)
unknown's avatar
unknown committed
4852 4853 4854
    DBUG_RETURN((result == HA_ERR_KEY_NOT_FOUND) 
		? HA_ERR_END_OF_FILE
		: result);
4855

4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868
  if (compare_key(end_range) <= 0)
  {
    DBUG_RETURN(0);
  }
  else
  {
    /*
      The last read row does not fall in the range. So request
      storage engine to release row lock if possible.
    */
    unlock_row();
    DBUG_RETURN(HA_ERR_END_OF_FILE);
  }
4869 4870 4871
}


unknown's avatar
unknown committed
4872
/**
4873 4874
  Read next row between two ranges.

unknown's avatar
unknown committed
4875
  @note
4876 4877
    Record is read into table->record[0]

unknown's avatar
unknown committed
4878
  @retval
4879
    0			Found row
unknown's avatar
unknown committed
4880
  @retval
4881
    HA_ERR_END_OF_FILE	No rows in range
unknown's avatar
unknown committed
4882 4883
  @retval
    \#			Error code
4884
*/
unknown's avatar
unknown committed
4885
int handler::read_range_next()
4886 4887 4888 4889 4890
{
  int result;
  DBUG_ENTER("handler::read_range_next");

  if (eq_range)
unknown's avatar
unknown committed
4891 4892
  {
    /* We trust that index_next_same always gives a row in range */
4893 4894 4895
    DBUG_RETURN(ha_index_next_same(table->record[0],
                                   end_range->key,
                                   end_range->length));
unknown's avatar
unknown committed
4896
  }
4897
  result= ha_index_next(table->record[0]);
4898 4899
  if (result)
    DBUG_RETURN(result);
4900 4901 4902 4903 4904 4905 4906 4907 4908 4909 4910 4911 4912 4913

  if (compare_key(end_range) <= 0)
  {
    DBUG_RETURN(0);
  }
  else
  {
    /*
      The last read row does not fall in the range. So request
      storage engine to release row lock if possible.
    */
    unlock_row();
    DBUG_RETURN(HA_ERR_END_OF_FILE);
  }
4914 4915 4916
}


unknown's avatar
unknown committed
4917 4918
/**
  Compare if found key (in row) is over max-value.
4919

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

unknown's avatar
unknown committed
4922 4923 4924 4925
  @seealso
    key.cc::key_cmp()

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

unknown's avatar
unknown committed
4928 4929 4930
    - 0   : Key is equal to range or 'range' == 0 (no range)
    - -1  : Key is less than range
    - 1   : Key is larger than range
4931 4932 4933
*/
int handler::compare_key(key_range *range)
{
unknown's avatar
unknown committed
4934
  int cmp;
4935
  if (!range || in_range_check_pushed_down)
4936
    return 0;					// No max range
unknown's avatar
unknown committed
4937 4938 4939 4940
  cmp= key_cmp(range_key_part, range->key, range->length);
  if (!cmp)
    cmp= key_compare_result_on_equal;
  return cmp;
4941
}
unknown's avatar
unknown committed
4942

4943

4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960
/*
  Same as compare_key() but doesn't check have in_range_check_pushed_down.
  This is used by index condition pushdown implementation.
*/

int handler::compare_key2(key_range *range)
{
  int cmp;
  if (!range)
    return 0;					// no max range
  cmp= key_cmp(range_key_part, range->key, range->length);
  if (!cmp)
    cmp= key_compare_result_on_equal;
  return cmp;
}


4961 4962 4963 4964 4965 4966 4967 4968 4969
/**
  ICP callback - to be called by an engine to check the pushed condition
*/
extern "C" enum icp_result handler_index_cond_check(void* h_arg)
{
  handler *h= (handler*)h_arg;
  THD *thd= h->table->in_use;
  enum icp_result res;

4970 4971 4972
  enum thd_kill_levels abort_at= h->has_transactions() ?
    THD_ABORT_SOFTLY : THD_ABORT_ASAP;
  if (thd_kill_level(thd) > abort_at)
4973 4974 4975 4976
    return ICP_ABORTED_BY_USER;

  if (h->end_range && h->compare_key2(h->end_range) > 0)
    return ICP_OUT_OF_RANGE;
4977
  h->increment_statistics(&SSV::ha_icp_attempts);
4978
  if ((res= h->pushed_idx_cond->val_int()? ICP_MATCH : ICP_NO_MATCH) ==
4979 4980
      ICP_MATCH)
    h->increment_statistics(&SSV::ha_icp_match);
4981 4982 4983
  return res;
}

4984 4985 4986
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
4987
{
4988
  int error, error1;
Michael Widenius's avatar
Michael Widenius committed
4989 4990
  LINT_INIT(error1);

4991
  error= ha_index_init(index, 0);
unknown's avatar
unknown committed
4992
  if (!error)
4993
  {
4994
    error= index_read_map(buf, key, keypart_map, find_flag);
4995
    error1= ha_index_end();
4996 4997
  }
  return error ?  error : error1;
unknown's avatar
unknown committed
4998 4999
}

5000

unknown's avatar
unknown committed
5001
/**
5002 5003 5004
  Returns a list of all known extensions.

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

unknown's avatar
unknown committed
5008
  @retval
5009 5010
    pointer		pointer to TYPELIB structure
*/
unknown's avatar
unknown committed
5011
static my_bool exts_handlerton(THD *unused, plugin_ref plugin,
unknown's avatar
unknown committed
5012 5013 5014
                               void *arg)
{
  List<char> *found_exts= (List<char> *) arg;
unknown's avatar
unknown committed
5015
  handlerton *hton= plugin_data(plugin, handlerton *);
5016 5017
  List_iterator_fast<char> it(*found_exts);
  const char **ext, *old_ext;
unknown's avatar
unknown committed
5018

5019 5020 5021
  for (ext= hton->tablefile_extensions; *ext; ext++)
  {
    while ((old_ext= it++))
unknown's avatar
unknown committed
5022
    {
5023 5024
      if (!strcmp(old_ext, *ext))
        break;
unknown's avatar
unknown committed
5025
    }
5026 5027 5028 5029
    if (!old_ext)
      found_exts->push_back((char *) *ext);

    it.rewind();
unknown's avatar
unknown committed
5030 5031 5032 5033
  }
  return FALSE;
}

5034 5035
TYPELIB *ha_known_exts(void)
{
5036
  if (!known_extensions.type_names || mysys_usage_id != known_extensions_id)
5037 5038
  {
    List<char> found_exts;
5039 5040 5041
    const char **ext, *old_ext;

    known_extensions_id= mysys_usage_id;
5042 5043
    found_exts.push_back((char*) TRG_EXT);
    found_exts.push_back((char*) TRN_EXT);
unknown's avatar
unknown committed
5044 5045

    plugin_foreach(NULL, exts_handlerton,
unknown's avatar
unknown committed
5046 5047
                   MYSQL_STORAGE_ENGINE_PLUGIN, &found_exts);

5048 5049 5050
    ext= (const char **) my_once_alloc(sizeof(char *)*
                                       (found_exts.elements+1),
                                       MYF(MY_WME | MY_FAE));
unknown's avatar
unknown committed
5051

5052
    DBUG_ASSERT(ext != 0);
5053 5054
    known_extensions.count= found_exts.elements;
    known_extensions.type_names= ext;
5055

unknown's avatar
unknown committed
5056
    List_iterator_fast<char> it(found_exts);
5057 5058 5059
    while ((old_ext= it++))
      *ext++= old_ext;
    *ext= 0;
5060 5061 5062
  }
  return &known_extensions;
}
unknown's avatar
unknown committed
5063

5064

unknown's avatar
unknown committed
5065 5066 5067
static bool stat_print(THD *thd, const char *type, uint type_len,
                       const char *file, uint file_len,
                       const char *status, uint status_len)
5068 5069 5070
{
  Protocol *protocol= thd->protocol;
  protocol->prepare_for_resend();
unknown's avatar
unknown committed
5071 5072 5073
  protocol->store(type, type_len, system_charset_info);
  protocol->store(file, file_len, system_charset_info);
  protocol->store(status, status_len, system_charset_info);
5074 5075 5076 5077 5078
  if (protocol->write())
    return TRUE;
  return FALSE;
}

unknown's avatar
unknown committed
5079

unknown's avatar
unknown committed
5080
static my_bool showstat_handlerton(THD *thd, plugin_ref plugin,
unknown's avatar
unknown committed
5081 5082 5083
                                   void *arg)
{
  enum ha_stat_type stat= *(enum ha_stat_type *) arg;
unknown's avatar
unknown committed
5084
  handlerton *hton= plugin_data(plugin, handlerton *);
unknown's avatar
unknown committed
5085
  if (hton->state == SHOW_OPTION_YES && hton->show_status &&
5086
      hton->show_status(hton, thd, stat_print, stat))
unknown's avatar
unknown committed
5087 5088 5089 5090 5091
    return TRUE;
  return FALSE;
}

bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat)
5092 5093 5094
{
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
unknown's avatar
unknown committed
5095
  bool result;
5096 5097 5098 5099 5100

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

5101
  if (protocol->send_result_set_metadata(&field_list,
5102 5103 5104
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
    return TRUE;

unknown's avatar
unknown committed
5105
  if (db_type == NULL)
5106
  {
unknown's avatar
unknown committed
5107
    result= plugin_foreach(thd, showstat_handlerton,
unknown's avatar
unknown committed
5108 5109 5110 5111 5112
                           MYSQL_STORAGE_ENGINE_PLUGIN, &stat);
  }
  else
  {
    if (db_type->state != SHOW_OPTION_YES)
unknown's avatar
unknown committed
5113
    {
5114
      const LEX_STRING *name= hton_name(db_type);
unknown's avatar
unknown committed
5115
      result= stat_print(thd, name->str, name->length,
unknown's avatar
unknown committed
5116
                         "", 0, "DISABLED", 8) ? 1 : 0;
unknown's avatar
unknown committed
5117
    }
unknown's avatar
unknown committed
5118
    else
unknown's avatar
unknown committed
5119
      result= db_type->show_status &&
5120
              db_type->show_status(db_type, thd, stat_print, stat) ? 1 : 0;
5121 5122
  }

5123 5124 5125 5126 5127
  /*
    We also check thd->is_error() as Innodb may return 0 even if
    there was an error.
  */
  if (!result && !thd->is_error())
5128
    my_eof(thd);
5129
  else if (!thd->is_error())
5130
    my_error(ER_GET_ERRNO, MYF(0), errno, hton_name(db_type)->str);
unknown's avatar
unknown committed
5131
  return result;
5132 5133
}

5134 5135 5136 5137 5138
/*
  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:
5139
  - Row-based replication is enabled in the current thread
5140
  - The binlog is enabled
5141 5142 5143
  - It is not a temporary table
  - The binary log is open
  - The database the table resides in shall be binlogged (binlog_*_db rules)
5144
  - table is not mysql.event
5145 5146
*/

5147 5148 5149
static bool check_table_binlog_row_based(THD *thd, TABLE *table)
{
  if (table->s->cached_row_logging_check == -1)
5150
  {
5151 5152 5153 5154
    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;
  }
5155

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

5159
  return (thd->is_current_stmt_binlog_format_row() &&
5160
          table->s->cached_row_logging_check &&
5161
          (thd->variables.option_bits & OPTION_BIN_LOG) &&
5162
          mysql_bin_log.is_open());
5163 5164 5165
}


5166
/** @brief
5167
   Write table maps for all (manually or automatically) locked tables
5168
   to the binary log. Also, if binlog_annotate_row_events is ON,
5169
   write Annotate_rows event before the first table map.
5170

5171 5172 5173 5174 5175 5176
   SYNOPSIS
     write_locked_table_maps()
       thd     Pointer to THD structure

   DESCRIPTION
       This function will generate and write table maps for all tables
Konstantin Osipov's avatar
Konstantin Osipov committed
5177
       that are locked by the thread 'thd'.
5178

5179 5180 5181 5182 5183 5184
   RETURN VALUE
       0   All OK
       1   Failed to write all table maps

   SEE ALSO
       THD::lock
5185
*/
5186

5187
static int write_locked_table_maps(THD *thd)
5188
{
5189
  DBUG_ENTER("write_locked_table_maps");
Konstantin Osipov's avatar
Konstantin Osipov committed
5190
  DBUG_PRINT("enter", ("thd: 0x%lx  thd->lock: 0x%lx "
5191
                       "thd->extra_lock: 0x%lx",
Konstantin Osipov's avatar
Konstantin Osipov committed
5192
                       (long) thd, (long) thd->lock, (long) thd->extra_lock));
5193

5194 5195
  DBUG_PRINT("debug", ("get_binlog_table_maps(): %d", thd->get_binlog_table_maps()));

5196 5197
  if (thd->get_binlog_table_maps() == 0)
  {
Konstantin Osipov's avatar
Konstantin Osipov committed
5198
    MYSQL_LOCK *locks[2];
5199 5200
    locks[0]= thd->extra_lock;
    locks[1]= thd->lock;
5201
    my_bool with_annotate= thd->variables.binlog_annotate_row_events &&
5202 5203
                           thd->query() && thd->query_length();

5204
    for (uint i= 0 ; i < sizeof(locks)/sizeof(*locks) ; ++i )
5205
    {
5206 5207 5208 5209 5210 5211 5212 5213
      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)
5214
      {
5215 5216 5217 5218
        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))
5219
        {
5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234
          /*
            We need to have a transactional behavior for SQLCOM_CREATE_TABLE
            (e.g. CREATE TABLE... SELECT * FROM TABLE) in order to keep a
            compatible behavior with the STMT based replication even when
            the table is not transactional. In other words, if the operation
            fails while executing the insert phase nothing is written to the
            binlog.

            Note that at this point, we check the type of a set of tables to
            create the table map events. In the function binlog_log_row(),
            which calls the current function, we check the type of the table
            of the current row.
          */
          bool const has_trans= thd->lex->sql_command == SQLCOM_CREATE_TABLE ||
                                table->file->has_transactions();
5235 5236
          int const error= thd->binlog_write_table_map(table, has_trans,
                                                       &with_annotate);
5237 5238 5239 5240 5241 5242
          /*
            If an error occurs, it is the responsibility of the caller to
            roll back the transaction.
          */
          if (unlikely(error))
            DBUG_RETURN(1);
5243
        }
5244 5245 5246
      }
    }
  }
5247 5248
  DBUG_RETURN(0);
}
5249

5250 5251 5252 5253

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

5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264
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))
5265
  {
5266 5267 5268 5269 5270
    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;
5271

5272 5273 5274 5275 5276 5277 5278 5279 5280
    /*
      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))))
5281
    {
5282 5283
      bitmap_set_all(&cols);
      if (likely(!(error= write_locked_table_maps(thd))))
5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295
      {
        /*
          We need to have a transactional behavior for SQLCOM_CREATE_TABLE
          (i.e. CREATE TABLE... SELECT * FROM TABLE) in order to keep a
          compatible behavior with the STMT based replication even when
          the table is not transactional. In other words, if the operation
          fails while executing the insert phase nothing is written to the
          binlog.
        */
        bool const has_trans= thd->lex->sql_command == SQLCOM_CREATE_TABLE ||
                             table->file->has_transactions();
        error= (*log_func)(thd, table, has_trans, &cols, table->s->fields,
5296
                           before_record, after_record);
5297
      }
5298 5299
      if (!use_bitbuf)
        bitmap_free(&cols);
5300 5301
    }
  }
5302
  return error ? HA_ERR_RBR_LOGGING_FAILED : 0;
5303
}
5304

5305
int handler::ha_external_lock(THD *thd, int lock_type)
5306
{
5307
  DBUG_ENTER("handler::ha_external_lock");
5308 5309 5310 5311 5312 5313
  /*
    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);
5314

5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335
  if (MYSQL_HANDLER_RDLOCK_START_ENABLED() ||
      MYSQL_HANDLER_WRLOCK_START_ENABLED() ||
      MYSQL_HANDLER_UNLOCK_START_ENABLED())
  {
    if (lock_type == F_RDLCK)
    {
      MYSQL_HANDLER_RDLOCK_START(table_share->db.str,
                                 table_share->table_name.str);
    }
    else if (lock_type == F_WRLCK)
    {
      MYSQL_HANDLER_WRLOCK_START(table_share->db.str,
                                 table_share->table_name.str);
    }
    else if (lock_type == F_UNLCK)
    {
      MYSQL_HANDLER_UNLOCK_START(table_share->db.str,
                                 table_share->table_name.str);
    }
  }

5336 5337 5338 5339 5340
  /*
    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);
5341

5342
  if (error == 0)
5343
  {
5344
    cached_table_flags= table_flags();
5345 5346 5347
    if (table_share->tmp_table == NO_TMP_TABLE)
      mysql_audit_external_lock(thd, table_share, lock_type);
  }
5348

5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365
  if (MYSQL_HANDLER_RDLOCK_DONE_ENABLED() ||
      MYSQL_HANDLER_WRLOCK_DONE_ENABLED() ||
      MYSQL_HANDLER_UNLOCK_DONE_ENABLED())
  {
    if (lock_type == F_RDLCK)
    {
      MYSQL_HANDLER_RDLOCK_DONE(error);
    }
    else if (lock_type == F_WRLCK)
    {
      MYSQL_HANDLER_WRLOCK_DONE(error);
    }
    else if (lock_type == F_UNLCK)
    {
      MYSQL_HANDLER_UNLOCK_DONE(error);
    }
  }
5366
  DBUG_RETURN(error);
5367 5368
}

5369

5370
/** @brief
5371 5372 5373 5374 5375
  Check handler usage and reset state of file to after 'open'
*/
int handler::ha_reset()
{
  DBUG_ENTER("ha_reset");
unknown's avatar
unknown committed
5376
  /* Check that we have called all proper deallocation functions */
5377
  DBUG_ASSERT((uchar*) table->def_read_set.bitmap +
5378
              table->s->column_bitmap_size ==
5379
              (uchar*) table->def_write_set.bitmap);
5380 5381 5382 5383 5384 5385
  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);
5386 5387
  /* reset the bitmaps to point to defaults */
  table->default_column_bitmaps();
5388
  pushed_cond= NULL;
5389 5390 5391
  /* Reset information about pushed engine conditions */
  cancel_pushed_idx_cond();
  /* Reset information about pushed index conditions */
5392 5393 5394 5395
  DBUG_RETURN(reset());
}


5396
int handler::ha_write_row(uchar *buf)
5397 5398
{
  int error;
5399
  Log_func *log_func= Write_rows_log_event::binlog_row_logging_function;
5400
  DBUG_ENTER("handler::ha_write_row");
5401
  DEBUG_SYNC_C("ha_write_row_start");
5402 5403
  DBUG_EXECUTE_IF("inject_error_ha_write_row",
                  DBUG_RETURN(HA_ERR_INTERNAL_ERROR); );
5404

5405
  MYSQL_INSERT_ROW_START(table_share->db.str, table_share->table_name.str);
5406
  mark_trx_read_write();
5407
  increment_statistics(&SSV::ha_write_count);
5408

5409 5410 5411
  error= write_row(buf);
  MYSQL_INSERT_ROW_DONE(error);
  if (unlikely(error))
5412
    DBUG_RETURN(error);
5413
  rows_changed++;
5414
  if (unlikely(error= binlog_log_row(table, 0, buf, log_func)))
5415
    DBUG_RETURN(error); /* purecov: inspected */
5416 5417

  DEBUG_SYNC_C("ha_write_row_end");
5418
  DBUG_RETURN(0);
5419 5420
}

5421

5422
int handler::ha_update_row(const uchar *old_data, uchar *new_data)
5423 5424
{
  int error;
5425
  Log_func *log_func= Update_rows_log_event::binlog_row_logging_function;
5426 5427 5428 5429 5430 5431

  /*
    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]);
5432
  DBUG_ASSERT(old_data == table->record[1]);
5433

5434
  MYSQL_UPDATE_ROW_START(table_share->db.str, table_share->table_name.str);
5435
  mark_trx_read_write();
5436
  increment_statistics(&SSV::ha_update_count);
5437

5438 5439 5440
  error= update_row(old_data, new_data);
  MYSQL_UPDATE_ROW_DONE(error);
  if (unlikely(error))
5441
    return error;
5442
  rows_changed++;
5443
  if (unlikely(error= binlog_log_row(table, old_data, new_data, log_func)))
5444 5445
    return error;
  return 0;
5446 5447
}

5448
int handler::ha_delete_row(const uchar *buf)
5449 5450
{
  int error;
5451
  Log_func *log_func= Delete_rows_log_event::binlog_row_logging_function;
5452 5453 5454 5455 5456 5457 5458
  /*
    Normally table->record[0] is used, but sometimes table->record[1] is used.
  */
  DBUG_ASSERT(buf == table->record[0] ||
              buf == table->record[1]);
  DBUG_EXECUTE_IF("inject_error_ha_delete_row",
                  return HA_ERR_INTERNAL_ERROR; );
5459

5460
  MYSQL_DELETE_ROW_START(table_share->db.str, table_share->table_name.str);
5461
  mark_trx_read_write();
5462
  increment_statistics(&SSV::ha_delete_count);
5463

5464 5465 5466
  error= delete_row(buf);
  MYSQL_DELETE_ROW_DONE(error);
  if (unlikely(error))
5467
    return error;
5468
  rows_changed++;
5469
  if (unlikely(error= binlog_log_row(table, buf, 0, log_func)))
5470 5471
    return error;
  return 0;
5472
}
5473

5474

5475

5476
/** @brief
5477 5478 5479 5480 5481 5482 5483 5484 5485
  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();
}
5486 5487


5488
/** @brief
5489 5490 5491 5492 5493 5494 5495 5496 5497 5498
  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;
}

5499

5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516
#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 */

5517
  if ((*hton->create_iterator)(hton, HA_TRANSACTLOG_ITERATOR, &iterator) !=
5518 5519 5520 5521 5522 5523 5524 5525 5526
      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 &&
Marc Alff's avatar
Marc Alff committed
5527 5528
        mysql_file_delete(INSTRUMENT_ME,
                          data.filename.str, MYF(MY_WME)))
5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547
      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


5548
/** @brief
5549 5550 5551 5552 5553 5554 5555
  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;
Marc Alff's avatar
Marc Alff committed
5556
  if (mysql_file_stat(INSTRUMENT_ME, log, &stat_buff, MYF(0)))
5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587
    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)
{
5588
  my_free(iterator->buffer);
5589 5590 5591
}


5592
/** @brief
5593 5594 5595 5596 5597 5598 5599 5600
  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;
5601
  uchar *ptr;
5602 5603 5604 5605 5606 5607
  FILEINFO *file;
  uint32 i;

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

5608
  if (!(dirp = my_dir(fl_dir, MYF(MY_THREAD_SPECIFIC))))
5609 5610 5611
  {
    return HA_ITERATOR_ERROR;
  }
5612
  if ((ptr= (uchar*)my_malloc(ALIGN_SIZE(sizeof(fl_buff)) +
5613 5614
                             ((ALIGN_SIZE(sizeof(LEX_STRING)) +
                               sizeof(enum log_status) +
5615
                               + FN_REFLEN + 1) *
5616
                              (uint) dirp->number_off_files),
5617
                             MYF(MY_THREAD_SPECIFIC))) == 0)
5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642
  {
    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 -
5643
                                        buff->names[buff->entries].str);
5644 5645 5646 5647 5648 5649 5650
    buff->statuses[buff->entries]= st;
    buff->entries++;
  }

  iterator->buffer= buff;
  iterator->next= &fl_log_iterator_next;
  iterator->destroy= &fl_log_iterator_destroy;
5651
  my_dirend(dirp);
5652 5653 5654 5655 5656 5657 5658 5659 5660
  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)
{
5661
  switch(type) {
5662 5663 5664 5665 5666 5667 5668
  case HA_TRANSACTLOG_ITERATOR:
    return fl_log_iterator_buffer_init(iterator);
  default:
    return HA_ITERATOR_UNSUPPORTED;
  }
}
#endif /*TRANS_LOG_MGM_EXAMPLE_CODE*/