handler.cc 135 KB
Newer Older
1
/* Copyright (C) 2000-2006 MySQL AB
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
2

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

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

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

16
/** @file handler.cc
bk@work.mysql.com's avatar
bk@work.mysql.com committed
17

18 19 20
    @brief
  Handler-calling-functions
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
21

22
#ifdef USE_PRAGMA_IMPLEMENTATION
bk@work.mysql.com's avatar
bk@work.mysql.com committed
23 24 25 26
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
27
#include "rpl_filter.h"
28 29
#include <myisampack.h>
#include <errno.h>
30

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

35 36 37 38 39
/*
  While we have legacy_db_type, we have this array to
  check for dups and to find handlerton from legacy_db_type.
  Remove when legacy_db_type is finally gone
*/
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
40
st_plugin_int *hton2plugin[MAX_HA];
41

42
static handlerton *installed_htons[128];
43

lars@mysql.com's avatar
lars@mysql.com committed
44 45
#define BITMAP_STACKBUF_SIZE (128/8)

46
KEY_CREATE_INFO default_key_create_info= { HA_KEY_ALG_UNDEF, 0, {NullS,0} };
47

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

acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
55
static const LEX_STRING sys_table_aliases[]=
56
{
andrey@example.com's avatar
andrey@example.com committed
57 58 59
  { C_STRING_WITH_LEN("INNOBASE") },  { C_STRING_WITH_LEN("INNODB") },
  { C_STRING_WITH_LEN("NDB") },       { C_STRING_WITH_LEN("NDBCLUSTER") },
  { C_STRING_WITH_LEN("HEAP") },      { C_STRING_WITH_LEN("MEMORY") },
60
  { C_STRING_WITH_LEN("MERGE") },     { C_STRING_WITH_LEN("MRG_MYISAM") },
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
61
  {NullS, 0}
62
};
63

bk@work.mysql.com's avatar
bk@work.mysql.com committed
64
const char *ha_row_type[] = {
65
  "", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT", "PAGE", "?","?","?"
bk@work.mysql.com's avatar
bk@work.mysql.com committed
66 67
};

monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
68
const char *tx_isolation_names[] =
69 70 71
{ "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",
  NullS};
TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
72
			       tx_isolation_names, NULL};
bk@work.mysql.com's avatar
bk@work.mysql.com committed
73

74
static TYPELIB known_extensions= {0,"known_exts", NULL, NULL};
75
uint known_extensions_id= 0;
76

acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
77

antony@ppcg5.local's avatar
antony@ppcg5.local committed
78 79 80 81 82 83 84 85 86

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


87
/** @brief
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
88
  Return the default storage engine handlerton for thread
89

acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
90 91 92
  SYNOPSIS
    ha_default_handlerton(thd)
    thd         current thread
93

acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
94 95 96 97
  RETURN
    pointer to handlerton
*/
handlerton *ha_default_handlerton(THD *thd)
98
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
99 100 101 102 103
  plugin_ref plugin= ha_default_plugin(thd);
  DBUG_ASSERT(plugin);
  handlerton *hton= plugin_data(plugin, handlerton*);
  DBUG_ASSERT(hton);
  return hton;
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
104 105 106
}


107
/** @brief
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
108 109 110 111 112 113 114 115
  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
antony@ppcg5.local's avatar
antony@ppcg5.local committed
116
    pointer to storage engine plugin handle
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
117
*/
antony@ppcg5.local's avatar
antony@ppcg5.local committed
118
plugin_ref ha_resolve_by_name(THD *thd, const LEX_STRING *name)
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
119 120
{
  const LEX_STRING *table_alias;
antony@ppcg5.local's avatar
antony@ppcg5.local committed
121
  plugin_ref plugin;
122

acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
123 124 125
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,
126
                           (const uchar *)name->str, name->length,
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
127
                           (const uchar *)STRING_WITH_LEN("DEFAULT"), 0))
antony@ppcg5.local's avatar
antony@ppcg5.local committed
128
    return ha_default_plugin(thd);
129

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

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

156
  return NULL;
157
}
monty@mysql.com's avatar
monty@mysql.com committed
158 159


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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
175

176
#ifdef NOT_USED
177
static handler *create_default(TABLE_SHARE *table, MEM_ROOT *mem_root)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
178
{
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
179
  handlerton *hton= ha_default_handlerton(current_thd);
180
  return (hton && hton->create) ? hton->create(hton, table, mem_root) : NULL;
181
}
182
#endif
183 184 185 186


handlerton *ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type)
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
187
  plugin_ref plugin;
188
  switch (db_type) {
189
  case DB_TYPE_DEFAULT:
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
190
    return ha_default_handlerton(thd);
191
  default:
antony@ppcg5.local's avatar
antony@ppcg5.local committed
192 193 194 195 196
    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:
197
    return NULL;
198
  }
199 200 201
}


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

212 213 214 215
  if (no_substitute)
  {
    if (report_error)
    {
antony@ppcg5.local's avatar
antony@ppcg5.local committed
216
      const char *engine_name= ha_resolve_storage_engine_name(hton);
217 218
      my_error(ER_FEATURE_DISABLED,MYF(0),engine_name,engine_name);
    }
219
    return NULL;
220 221
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
222 223 224
  switch (database_type) {
#ifndef NO_HASH
  case DB_TYPE_HASH:
225
    return ha_resolve_by_legacy_type(thd, DB_TYPE_HASH);
226
#endif
227
  case DB_TYPE_MRG_ISAM:
228
    return ha_resolve_by_legacy_type(thd, DB_TYPE_MRG_MYISAM);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
229 230 231
  default:
    break;
  }
232

acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
233
  return ha_default_handlerton(thd);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
234 235 236
} /* ha_checktype */


237
handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc,
238
                         handlerton *db_type)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
239
{
240 241 242
  handler *file;
  DBUG_ENTER("get_new_handler");
  DBUG_PRINT("enter", ("alloc: 0x%lx", (long) alloc));
243

244
  if (db_type && db_type->state == SHOW_OPTION_YES && db_type->create)
245
  {
246
    if ((file= db_type->create(db_type, share, alloc)))
247 248
      file->init();
    DBUG_RETURN(file);
249
  }
250 251 252 253 254
  /*
    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.
  */
antony@ppcg5.local's avatar
antony@ppcg5.local committed
255
  DBUG_RETURN(get_new_handler(share, alloc, ha_default_handlerton(current_thd)));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
256 257
}

258

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


283
/**
284 285
  Register handler error messages for use with my_error().

286
  @retval
287
    0           OK
288 289
  @retval
    !=0         Error
290
*/
291 292

int ha_init_errors(void)
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
{
#define SETMSG(nr, msg) errmsgs[(nr) - HA_ERR_FIRST]= (msg)
  const char    **errmsgs;

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

  /* Set the dedicated error messages. */
  SETMSG(HA_ERR_KEY_NOT_FOUND,          ER(ER_KEY_NOT_FOUND));
  SETMSG(HA_ERR_FOUND_DUPP_KEY,         ER(ER_DUP_KEY));
  SETMSG(HA_ERR_RECORD_CHANGED,         "Update wich is recoverable");
  SETMSG(HA_ERR_WRONG_INDEX,            "Wrong index given to function");
  SETMSG(HA_ERR_CRASHED,                ER(ER_NOT_KEYFILE));
  SETMSG(HA_ERR_WRONG_IN_RECORD,        ER(ER_CRASHED_ON_USAGE));
  SETMSG(HA_ERR_OUT_OF_MEM,             "Table handler out of memory");
  SETMSG(HA_ERR_NOT_A_TABLE,            "Incorrect file format '%.64s'");
  SETMSG(HA_ERR_WRONG_COMMAND,          "Command not supported");
  SETMSG(HA_ERR_OLD_FILE,               ER(ER_OLD_KEYFILE));
  SETMSG(HA_ERR_NO_ACTIVE_RECORD,       "No record read in update");
  SETMSG(HA_ERR_RECORD_DELETED,         "Intern record deleted");
  SETMSG(HA_ERR_RECORD_FILE_FULL,       ER(ER_RECORD_FILE_FULL));
  SETMSG(HA_ERR_INDEX_FILE_FULL,        "No more room in index file '%.64s'");
  SETMSG(HA_ERR_END_OF_FILE,            "End in next/prev/first/last");
  SETMSG(HA_ERR_UNSUPPORTED,            ER(ER_ILLEGAL_HA));
  SETMSG(HA_ERR_TO_BIG_ROW,             "Too big row");
  SETMSG(HA_WRONG_CREATE_OPTION,        "Wrong create option");
  SETMSG(HA_ERR_FOUND_DUPP_UNIQUE,      ER(ER_DUP_UNIQUE));
  SETMSG(HA_ERR_UNKNOWN_CHARSET,        "Can't open charset");
  SETMSG(HA_ERR_WRONG_MRG_TABLE_DEF,    ER(ER_WRONG_MRG_TABLE));
  SETMSG(HA_ERR_CRASHED_ON_REPAIR,      ER(ER_CRASHED_ON_REPAIR));
  SETMSG(HA_ERR_CRASHED_ON_USAGE,       ER(ER_CRASHED_ON_USAGE));
  SETMSG(HA_ERR_LOCK_WAIT_TIMEOUT,      ER(ER_LOCK_WAIT_TIMEOUT));
  SETMSG(HA_ERR_LOCK_TABLE_FULL,        ER(ER_LOCK_TABLE_FULL));
  SETMSG(HA_ERR_READ_ONLY_TRANSACTION,  ER(ER_READ_ONLY_TRANSACTION));
  SETMSG(HA_ERR_LOCK_DEADLOCK,          ER(ER_LOCK_DEADLOCK));
  SETMSG(HA_ERR_CANNOT_ADD_FOREIGN,     ER(ER_CANNOT_ADD_FOREIGN));
332 333
  SETMSG(HA_ERR_NO_REFERENCED_ROW,      ER(ER_NO_REFERENCED_ROW_2));
  SETMSG(HA_ERR_ROW_IS_REFERENCED,      ER(ER_ROW_IS_REFERENCED_2));
334 335 336 337 338
  SETMSG(HA_ERR_NO_SAVEPOINT,           "No savepoint with that name");
  SETMSG(HA_ERR_NON_UNIQUE_BLOCK_SIZE,  "Non unique key block size");
  SETMSG(HA_ERR_NO_SUCH_TABLE,          "No such table: '%.64s'");
  SETMSG(HA_ERR_TABLE_EXIST,            ER(ER_TABLE_EXISTS_ERROR));
  SETMSG(HA_ERR_NO_CONNECTION,          "Could not connect to storage engine");
339
  SETMSG(HA_ERR_TABLE_DEF_CHANGED,      ER(ER_TABLE_DEF_CHANGED));
340
  SETMSG(HA_ERR_FOREIGN_DUPLICATE_KEY,  "FK constraint would lead to duplicate key");
341
  SETMSG(HA_ERR_TABLE_NEEDS_UPGRADE,    ER(ER_TABLE_NEEDS_UPGRADE));
342
  SETMSG(HA_ERR_TABLE_READONLY,         ER(ER_OPEN_AS_READONLY));
343 344
  SETMSG(HA_ERR_AUTOINC_READ_FAILED,    ER(ER_AUTOINC_READ_FAILED));
  SETMSG(HA_ERR_AUTOINC_ERANGE,         ER(ER_WARN_DATA_OUT_OF_RANGE));
345 346 347 348 349 350

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


351
/**
352 353
  Unregister handler error messages.

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

370

acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
371
int ha_finalize_handlerton(st_plugin_int *plugin)
372
{
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
373
  handlerton *hton= (handlerton *)plugin->data;
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
374 375 376 377 378 379 380 381 382 383 384 385
  DBUG_ENTER("ha_finalize_handlerton");

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

387 388 389
  if (hton->panic)
    hton->panic(hton, HA_PANIC_CLOSE);

390 391 392 393 394 395 396 397 398 399 400 401 402 403
  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));
    }
  }

404
  my_free((uchar*)hton, MYF(0));
405

acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
406
  DBUG_RETURN(0);
407
}
408

409

acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
410
int ha_initialize_handlerton(st_plugin_int *plugin)
411
{
412
  handlerton *hton;
413
  DBUG_ENTER("ha_initialize_handlerton");
414
  DBUG_PRINT("plugin", ("initialize plugin: '%s'", plugin->name.str));
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
415

416 417 418
  hton= (handlerton *)my_malloc(sizeof(handlerton),
                                MYF(MY_WME | MY_ZEROFILL));
  /* Historical Requirement */
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
419
  plugin->data= hton; // shortcut for the future
420 421 422 423 424 425 426 427 428
  if (plugin->plugin->init)
  {
    if (plugin->plugin->init(hton))
    {
      sql_print_error("Plugin '%s' init function returned error.",
                      plugin->name.str);
      goto err;
    }
  }
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
429

430 431 432 433
  /*
    the switch below and hton->state should be removed when
    command-line options for plugins will be implemented
  */
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
434
  switch (hton->state) {
435 436 437 438
  case SHOW_OPTION_NO:
    break;
  case SHOW_OPTION_YES:
    {
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
439
      uint tmp;
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
440
      /* now check the db_type for conflict */
441
      if (hton->db_type <= DB_TYPE_UNKNOWN ||
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
442 443 444 445
          hton->db_type >= DB_TYPE_DEFAULT ||
          installed_htons[hton->db_type])
      {
        int idx= (int) DB_TYPE_FIRST_DYNAMIC;
446

acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
447 448 449 450 451 452 453 454 455 456
        while (idx < (int) DB_TYPE_DEFAULT && installed_htons[idx])
          idx++;

        if (idx == (int) DB_TYPE_DEFAULT)
        {
          sql_print_warning("Too many storage engines!");
          DBUG_RETURN(1);
        }
        if (hton->db_type != DB_TYPE_UNKNOWN)
          sql_print_warning("Storage engine '%s' has conflicting typecode. "
457
                            "Assigning value %d.", plugin->plugin->name, idx);
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
458 459 460
        hton->db_type= (enum legacy_db_type) idx;
      }
      installed_htons[hton->db_type]= hton;
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
461
      tmp= hton->savepoint_offset;
462 463 464
      hton->savepoint_offset= savepoint_alloc_size;
      savepoint_alloc_size+= tmp;
      hton->slot= total_ha++;
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
465
      hton2plugin[hton->slot]=plugin;
466 467
      if (hton->prepare)
        total_ha_2pc++;
468 469 470 471 472 473 474
      break;
    }
    /* fall through */
  default:
    hton->state= SHOW_OPTION_DISABLED;
    break;
  }
475 476
  
  /* 
477 478 479
    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.
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
  */
  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;
  };

495
  DBUG_RETURN(0);
496 497
err:
  DBUG_RETURN(1);
498 499
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
500 501
int ha_init()
{
502
  int error= 0;
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
503 504
  DBUG_ENTER("ha_init");

505
  DBUG_ASSERT(total_ha < MAX_HA);
506 507 508 509 510 511
  /*
    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;
512
  savepoint_alloc_size+= sizeof(SAVEPOINT);
acurtis@xiphis.org's avatar
acurtis@xiphis.org committed
513
  DBUG_RETURN(error);
514 515
}

516
int ha_end()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
517
{
518 519
  int error= 0;
  DBUG_ENTER("ha_end");
520

521

522 523 524 525 526 527 528
  /* 
    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;
529

530 531
  DBUG_RETURN(error);
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
532

antony@ppcg5.local's avatar
antony@ppcg5.local committed
533
static my_bool dropdb_handlerton(THD *unused1, plugin_ref plugin,
534 535
                                 void *path)
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
536
  handlerton *hton= plugin_data(plugin, handlerton *);
537
  if (hton->state == SHOW_OPTION_YES && hton->drop_database)
538
    hton->drop_database(hton, (char *)path);
539 540 541 542
  return FALSE;
}


543 544
void ha_drop_database(char* path)
{
545 546
  plugin_foreach(NULL, dropdb_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, path);
}
547

548

antony@ppcg5.local's avatar
antony@ppcg5.local committed
549
static my_bool closecon_handlerton(THD *thd, plugin_ref plugin,
550 551
                                   void *unused)
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
552
  handlerton *hton= plugin_data(plugin, handlerton *);
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
553 554 555 556
  /*
    there's no need to rollback here as all transactions must
    be rolled back already
  */
557
  if (hton->state == SHOW_OPTION_YES && hton->close_connection &&
558
      thd_get_ha_data(thd, hton))
559
    hton->close_connection(hton, thd);
560
  return FALSE;
561
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
562

563

564 565 566
/**
  @note
    don't bother to rollback here, it's done already
567
*/
568 569
void ha_close_connection(THD* thd)
{
570
  plugin_foreach(thd, closecon_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, 0);
571 572 573 574 575
}

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

576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
/**
  Transaction handling in the server
  ==================================

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

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

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

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

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

  <Historical note ends>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  Rollback is handled in a similar fashion.

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

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

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

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

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

865 866
/**
  Register a storage engine for a transaction.
serg@serg.mylan's avatar
serg@serg.mylan committed
867

868 869 870 871 872
  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.
873

874
  @note
875 876 877
    trans_register_ha is idempotent - storage engine may register many
    times per transaction.

serg@serg.mylan's avatar
serg@serg.mylan committed
878
*/
879 880 881
void trans_register_ha(THD *thd, bool all, handlerton *ht_arg)
{
  THD_TRANS *trans;
882
  Ha_trx_info *ha_info;
serg@serg.mylan's avatar
serg@serg.mylan committed
883 884 885
  DBUG_ENTER("trans_register_ha");
  DBUG_PRINT("enter",("%s", all ? "all" : "stmt"));

886 887 888 889 890 891 892 893
  if (all)
  {
    trans= &thd->transaction.all;
    thd->server_status|= SERVER_STATUS_IN_TRANS;
  }
  else
    trans= &thd->transaction.stmt;

894 895 896 897 898 899
  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);
900

901
  trans->no_2pc|=(ht_arg->prepare==0);
902 903
  if (thd->transaction.xid_state.xid.is_null())
    thd->transaction.xid_state.xid.set(thd->query_id);
serg@serg.mylan's avatar
serg@serg.mylan committed
904
  DBUG_VOID_RETURN;
905 906
}

907 908 909 910 911
/**
  @retval
    0   ok
  @retval
    1   error, transaction was rolled back
912 913 914 915 916
*/
int ha_prepare(THD *thd)
{
  int error=0, all=1;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
917
  Ha_trx_info *ha_info= trans->ha_list;
918 919
  DBUG_ENTER("ha_prepare");
#ifdef USING_TRANSACTIONS
920
  if (ha_info)
921
  {
922
    for (; ha_info; ha_info= ha_info->next())
923 924
    {
      int err;
925
      handlerton *ht= ha_info->ht();
926
      status_var_increment(thd->status_var.ha_prepare_count);
927
      if (ht->prepare)
928
      {
929
        if ((err= ht->prepare(ht, thd, all)))
930 931 932 933 934 935 936 937 938 939
        {
          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,
940
                            ER_ILLEGAL_HA, ER(ER_ILLEGAL_HA),
941
                            ha_resolve_storage_engine_name(ht));
942 943 944 945 946 947 948
      }
    }
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

949 950 951 952 953 954
/**
  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.
955 956 957 958 959 960 961 962 963 964 965
  
  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.
966 967 968
*/

static
969
uint
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
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;
    }
  }
1006
  return rw_ha_count;
1007 1008 1009
}


1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
/**
  @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.
1023 1024 1025 1026
*/
int ha_commit_trans(THD *thd, bool all)
{
  int error= 0, cookie= 0;
1027 1028 1029 1030
  /*
    'all' means that this is either an explicit commit issued by
    user, or an implicit commit issued by a DDL.
  */
1031
  THD_TRANS *trans= all ? &thd->transaction.all : &thd->transaction.stmt;
1032 1033
  bool is_real_trans= all || thd->transaction.all.ha_list == 0;
  Ha_trx_info *ha_info= trans->ha_list;
1034
  my_xid xid= thd->transaction.xid_state.xid.get_my_xid();
1035
  DBUG_ENTER("ha_commit_trans");
1036

1037 1038 1039 1040 1041 1042 1043 1044 1045
  /*
    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);

1046
  if (thd->in_sub_stmt)
1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
  {
    /*
      Since we don't support nested statement transactions in 5.0,
      we can't commit or rollback stmt transactions while we are inside
      stored functions or triggers. So we simply do nothing now.
      TODO: This should be fixed in later ( >= 5.1) releases.
    */
    if (!all)
      DBUG_RETURN(0);
    /*
      We assume that all statements which commit or rollback main transaction
      are prohibited inside of stored functions or triggers. So they should
      bail out with error even before ha_commit_trans() call. To be 100% safe
      let us throw error in non-debug builds.
    */
    DBUG_ASSERT(0);
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(2);
  }
1066
#ifdef USING_TRANSACTIONS
1067
  if (ha_info)
1068
  {
1069 1070 1071 1072 1073 1074 1075 1076
    uint rw_ha_count;
    bool rw_trans;

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

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

1078 1079 1080 1081 1082 1083
    rw_ha_count= ha_check_and_coalesce_trx_read_only(thd, ha_info, all);
    /* rw_trans is TRUE when we in a transaction changing data */
    rw_trans= is_real_trans && (rw_ha_count > 0);

    if (rw_trans &&
        wait_if_global_read_lock(thd, 0, 0))
1084 1085 1086 1087
    {
      ha_rollback_trans(thd, all);
      DBUG_RETURN(1);
    }
1088

1089 1090 1091 1092
    if (rw_trans &&
        opt_readonly &&
        !(thd->security_ctx->master_access & SUPER_ACL) &&
        !thd->slave_thread)
1093 1094 1095 1096 1097 1098 1099
    {
      my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
      ha_rollback_trans(thd, all);
      error= 1;
      goto end;
    }

1100
    if (!trans->no_2pc && (rw_ha_count > 1))
1101
    {
1102
      for (; ha_info && !error; ha_info= ha_info->next())
1103 1104
      {
        int err;
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
        handlerton *ht= ha_info->ht();
        /*
          Do not call two-phase commit if this particular
          transaction is read-only. This allows for simpler
          implementation in engines that are always read-only.
        */
        if (! ha_info->is_trx_read_write())
          continue;
        /*
          Sic: we know that prepare() is not NULL since otherwise
          trans->no_2pc would have been set.
        */
        if ((err= ht->prepare(ht, thd, all)))
1118 1119
        {
          my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
1120
          error= 1;
1121
        }
1122
        status_var_increment(thd->status_var.ha_prepare_count);
1123
      }
1124
      DBUG_EXECUTE_IF("crash_commit_after_prepare", abort(););
1125
      if (error || (is_real_trans && xid &&
1126
                    (error= !(cookie= tc_log->log_xid(thd, xid)))))
1127 1128
      {
        ha_rollback_trans(thd, all);
1129 1130
        error= 1;
        goto end;
1131
      }
1132
      DBUG_EXECUTE_IF("crash_commit_after_log", abort(););
1133
    }
1134
    error=ha_commit_one_phase(thd, all) ? (cookie ? 2 : 1) : 0;
1135
    DBUG_EXECUTE_IF("crash_commit_before_unlog", abort(););
1136
    if (cookie)
1137
      tc_log->unlog(cookie, xid);
1138
    DBUG_EXECUTE_IF("crash_commit_after", abort(););
1139
end:
1140
    if (rw_trans)
1141
      start_waiting_global_read_lock(thd);
1142 1143 1144 1145 1146
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

1147 1148 1149
/**
  @note
  This function does not care about global read lock. A caller should.
1150
*/
1151 1152 1153 1154
int ha_commit_one_phase(THD *thd, bool all)
{
  int error=0;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
1155 1156
  bool is_real_trans=all || thd->transaction.all.ha_list == 0;
  Ha_trx_info *ha_info= trans->ha_list, *ha_info_next;
1157 1158
  DBUG_ENTER("ha_commit_one_phase");
#ifdef USING_TRANSACTIONS
1159
  if (ha_info)
1160
  {
1161
    for (; ha_info; ha_info= ha_info_next)
1162 1163
    {
      int err;
1164 1165
      handlerton *ht= ha_info->ht();
      if ((err= ht->commit(ht, thd, all)))
1166 1167 1168 1169
      {
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
        error=1;
      }
1170
      status_var_increment(thd->status_var.ha_commit_count);
1171 1172
      ha_info_next= ha_info->next();
      ha_info->reset(); /* keep it conveniently zero-filled */
1173
    }
1174
    trans->ha_list= 0;
1175 1176
    trans->no_2pc=0;
    if (is_real_trans)
1177
      thd->transaction.xid_state.xid.null();
1178 1179 1180 1181 1182
    if (all)
    {
#ifdef HAVE_QUERY_CACHE
      if (thd->transaction.changed_tables)
        query_cache.invalidate(thd->transaction.changed_tables);
1183
#endif
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
      thd->variables.tx_isolation=thd->session_tx_isolation;
      thd->transaction.cleanup();
    }
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}


int ha_rollback_trans(THD *thd, bool all)
{
  int error=0;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
1197 1198
  Ha_trx_info *ha_info= trans->ha_list, *ha_info_next;
  bool is_real_trans=all || thd->transaction.all.ha_list == 0;
1199
  DBUG_ENTER("ha_rollback_trans");
1200 1201 1202 1203 1204 1205 1206 1207

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

1208
  if (thd->in_sub_stmt)
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
  {
    /*
      If we are inside stored function or trigger we should not commit or
      rollback current statement transaction. See comment in ha_commit_trans()
      call for more information.
    */
    if (!all)
      DBUG_RETURN(0);
    DBUG_ASSERT(0);
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
    DBUG_RETURN(1);
  }
1221
#ifdef USING_TRANSACTIONS
1222
  if (ha_info)
1223
  {
1224 1225 1226 1227
    /* Close all cursors that can not survive ROLLBACK */
    if (is_real_trans)                          /* not a statement commit */
      thd->stmt_map.close_transient_cursors();

1228
    for (; ha_info; ha_info= ha_info_next)
1229 1230
    {
      int err;
1231 1232
      handlerton *ht= ha_info->ht();
      if ((err= ht->rollback(ht, thd, all)))
1233 1234 1235 1236
      { // cannot happen
        my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
        error=1;
      }
1237
      status_var_increment(thd->status_var.ha_rollback_count);
1238 1239
      ha_info_next= ha_info->next();
      ha_info->reset(); /* keep it conveniently zero-filled */
1240
    }
1241
    trans->ha_list= 0;
1242 1243
    trans->no_2pc=0;
    if (is_real_trans)
1244
      thd->transaction.xid_state.xid.null();
1245 1246 1247 1248 1249 1250 1251
    if (all)
    {
      thd->variables.tx_isolation=thd->session_tx_isolation;
      thd->transaction.cleanup();
    }
  }
#endif /* USING_TRANSACTIONS */
1252 1253 1254
  if (all)
    thd->transaction_rollback_request= FALSE;

1255 1256 1257 1258 1259 1260 1261 1262 1263
  /*
    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.
  */
1264
  if (is_real_trans && thd->transaction.all.modified_non_trans_table &&
1265
      !thd->slave_thread && thd->killed != THD::KILL_CONNECTION)
1266 1267 1268 1269
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                 ER_WARNING_NOT_COMPLETE_ROLLBACK,
                 ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
  DBUG_RETURN(error);
1270 1271
}

1272 1273 1274 1275 1276 1277 1278 1279 1280 1281
/**
  This is used to commit or rollback a single statement depending on
  the value of error.

  @note
    Note that if the autocommit is on, then the following call inside
    InnoDB will commit or rollback the whole transaction (= the statement). The
    autocommit mechanism built into InnoDB is based on counting locks, but if
    the user has used LOCK TABLES then that mechanism does not know to do the
    commit.
1282
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1283 1284 1285
int ha_autocommit_or_rollback(THD *thd, int error)
{
  DBUG_ENTER("ha_autocommit_or_rollback");
1286
#ifdef USING_TRANSACTIONS
1287
  if (thd->transaction.stmt.ha_list)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1288
  {
1289 1290
    if (!error)
    {
1291
      if (ha_commit_trans(thd, 0))
1292 1293
	error=1;
    }
1294 1295 1296 1297 1298 1299
    else 
    {
      (void) ha_rollback_trans(thd, 0);
      if (thd->transaction_rollback_request && !thd->in_sub_stmt)
        (void) ha_rollback(thd);
    }
monty@mashka.mysql.fi's avatar
monty@mashka.mysql.fi committed
1300

1301
    thd->variables.tx_isolation=thd->session_tx_isolation;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1302 1303 1304 1305 1306
  }
#endif
  DBUG_RETURN(error);
}

monty@mysql.com's avatar
monty@mysql.com committed
1307

1308 1309 1310 1311 1312
struct xahton_st {
  XID *xid;
  int result;
};

antony@ppcg5.local's avatar
antony@ppcg5.local committed
1313
static my_bool xacommit_handlerton(THD *unused1, plugin_ref plugin,
1314
                                   void *arg)
1315
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1316
  handlerton *hton= plugin_data(plugin, handlerton *);
1317 1318
  if (hton->state == SHOW_OPTION_YES && hton->recover)
  {
1319
    hton->commit_by_xid(hton, ((struct xahton_st *)arg)->xid);
1320 1321 1322 1323
    ((struct xahton_st *)arg)->result= 0;
  }
  return FALSE;
}
1324

antony@ppcg5.local's avatar
antony@ppcg5.local committed
1325
static my_bool xarollback_handlerton(THD *unused1, plugin_ref plugin,
1326 1327
                                     void *arg)
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1328
  handlerton *hton= plugin_data(plugin, handlerton *);
1329
  if (hton->state == SHOW_OPTION_YES && hton->recover)
monty@mysql.com's avatar
monty@mysql.com committed
1330
  {
1331
    hton->rollback_by_xid(hton, ((struct xahton_st *)arg)->xid);
1332
    ((struct xahton_st *)arg)->result= 0;
monty@mysql.com's avatar
monty@mysql.com committed
1333
  }
1334 1335 1336 1337 1338 1339 1340 1341 1342
  return FALSE;
}


int ha_commit_or_rollback_by_xid(XID *xid, bool commit)
{
  struct xahton_st xaop;
  xaop.xid= xid;
  xaop.result= 1;
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
1343

1344 1345 1346 1347
  plugin_foreach(NULL, commit ? xacommit_handlerton : xarollback_handlerton,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &xaop);

  return xaop.result;
1348
}
1349

monty@mysql.com's avatar
monty@mysql.com committed
1350

serg@serg.mylan's avatar
serg@serg.mylan committed
1351
#ifndef DBUG_OFF
1352 1353 1354 1355
/**
  @note
    This does not need to be multi-byte safe or anything
*/
serg@serg.mylan's avatar
serg@serg.mylan committed
1356 1357 1358 1359 1360 1361 1362 1363
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];
1364 1365
    /* is_next_dig is set if next character is a number */
    bool is_next_dig= FALSE;
serg@serg.mylan's avatar
serg@serg.mylan committed
1366 1367
    if (i < XIDDATASIZE)
    {
1368 1369
      char ch= xid->data[i+1];
      is_next_dig= (ch >= '0' && ch <='9');
serg@serg.mylan's avatar
serg@serg.mylan committed
1370
    }
serg@serg.mylan's avatar
serg@serg.mylan committed
1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
    if (i == xid->gtrid_length)
    {
      *s++='\'';
      if (xid->bqual_length)
      {
        *s++='.';
        *s++='\'';
      }
    }
    if (c < 32 || c > 126)
    {
      *s++='\\';
1383 1384 1385 1386 1387
      /*
        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
      */
serg@serg.mylan's avatar
serg@serg.mylan committed
1388 1389 1390 1391 1392
      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];
serg@serg.mylan's avatar
serg@serg.mylan committed
1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
    }
    else
    {
      if (c == '\'' || c == '\\')
        *s++='\\';
      *s++=c;
    }
  }
  *s++='\'';
  *s=0;
  return buf;
}
#endif

1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421
/**
  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.
1422
*/
1423 1424 1425 1426 1427 1428 1429
struct xarecover_st
{
  int len, found_foreign_xids, found_my_xids;
  XID *list;
  HASH *commit_list;
  bool dry_run;
};
1430

antony@ppcg5.local's avatar
antony@ppcg5.local committed
1431
static my_bool xarecover_handlerton(THD *unused, plugin_ref plugin,
1432 1433
                                    void *arg)
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1434
  handlerton *hton= plugin_data(plugin, handlerton *);
1435 1436
  struct xarecover_st *info= (struct xarecover_st *) arg;
  int got;
1437

1438
  if (hton->state == SHOW_OPTION_YES && hton->recover)
1439
  {
1440
    while ((got= hton->recover(hton, info->list, info->len)) > 0 )
1441
    {
serg@serg.mylan's avatar
serg@serg.mylan committed
1442
      sql_print_information("Found %d prepared transaction(s) in %s",
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1443
                            got, ha_resolve_storage_engine_name(hton));
1444 1445
      for (int i=0; i < got; i ++)
      {
1446
        my_xid x=info->list[i].get_my_xid();
1447
        if (!x) // not "mine" - that is generated by external TM
1448
        {
serg@serg.mylan's avatar
serg@serg.mylan committed
1449 1450
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
1451
          sql_print_information("ignore xid %s", xid_to_str(buf, info->list+i));
serg@serg.mylan's avatar
serg@serg.mylan committed
1452
#endif
1453 1454
          xid_cache_insert(info->list+i, XA_PREPARED);
          info->found_foreign_xids++;
1455 1456
          continue;
        }
1457
        if (info->dry_run)
1458
        {
1459
          info->found_my_xids++;
1460
          continue;
1461 1462
        }
        // recovery mode
1463
        if (info->commit_list ?
1464
            hash_search(info->commit_list, (uchar *)&x, sizeof(x)) != 0 :
1465
            tc_heuristic_recover == TC_HEURISTIC_RECOVER_COMMIT)
serg@serg.mylan's avatar
serg@serg.mylan committed
1466 1467 1468
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
1469
          sql_print_information("commit xid %s", xid_to_str(buf, info->list+i));
serg@serg.mylan's avatar
serg@serg.mylan committed
1470
#endif
1471
          hton->commit_by_xid(hton, info->list+i);
serg@serg.mylan's avatar
serg@serg.mylan committed
1472
        }
1473
        else
serg@serg.mylan's avatar
serg@serg.mylan committed
1474 1475 1476
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
1477 1478
          sql_print_information("rollback xid %s",
                                xid_to_str(buf, info->list+i));
serg@serg.mylan's avatar
serg@serg.mylan committed
1479
#endif
1480
          hton->rollback_by_xid(hton, info->list+i);
serg@serg.mylan's avatar
serg@serg.mylan committed
1481
        }
1482
      }
1483
      if (got < info->len)
1484
        break;
1485 1486
    }
  }
1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533
  return FALSE;
}

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

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

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

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

#ifndef WILL_BE_DELETED_LATER
  /*
    for now, only InnoDB supports 2pc. It means we can always safely
    rollback all pending transactions, without risking inconsistent data
  */
  DBUG_ASSERT(total_ha_2pc == (ulong) opt_bin_log+1); // only InnoDB and binlog
  tc_heuristic_recover= TC_HEURISTIC_RECOVER_ROLLBACK; // forcing ROLLBACK
  info.dry_run=FALSE;
#endif

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

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

1534
  my_free((uchar*)info.list, MYF(0));
1535 1536 1537 1538
  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)
1539 1540 1541 1542 1543 1544 1545
  {
    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.",
1546
                    info.found_my_xids, opt_tc_log_file);
1547 1548
    DBUG_RETURN(1);
  }
1549
  if (info.commit_list)
serg@serg.mylan's avatar
serg@serg.mylan committed
1550
    sql_print_information("Crash recovery finished.");
1551
  DBUG_RETURN(0);
1552
}
1553

1554 1555
/**
  return the list of XID's to a client, the same way SHOW commands do.
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1556

1557
  @note
1558 1559 1560
    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.
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1561
*/
1562
bool mysql_xa_recover(THD *thd)
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1563
{
1564 1565
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
1566 1567
  int i=0;
  XID_STATE *xs;
1568 1569
  DBUG_ENTER("mysql_xa_recover");

1570 1571 1572
  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));
1573 1574 1575 1576 1577
  field_list.push_back(new Item_empty_string("data",XIDDATASIZE));

  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
    DBUG_RETURN(1);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1578

1579
  pthread_mutex_lock(&LOCK_xid_cache);
monty@mishka.local's avatar
monty@mishka.local committed
1580
  while ((xs= (XID_STATE*)hash_element(&xid_cache, i++)))
1581
  {
1582
    if (xs->xa_state==XA_PREPARED)
1583
    {
1584 1585 1586 1587 1588 1589 1590
      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())
1591
      {
1592 1593
        pthread_mutex_unlock(&LOCK_xid_cache);
        DBUG_RETURN(1);
1594 1595
      }
    }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1596
  }
1597

1598
  pthread_mutex_unlock(&LOCK_xid_cache);
1599
  my_eof(thd);
1600
  DBUG_RETURN(0);
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1601
}
1602

1603 1604
/**
  @details
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
  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.

1616 1617 1618 1619
  @param thd           the thread handle of the current connection

  @return
    always 0
1620
*/
1621

1622 1623
int ha_release_temporary_latches(THD *thd)
{
1624
  Ha_trx_info *info;
1625

1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
  /*
    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);
  }
1638
  return 0;
1639 1640
}

1641
int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1642 1643
{
  int error=0;
1644 1645
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
1646 1647
  Ha_trx_info *ha_info, *ha_info_next;

1648
  DBUG_ENTER("ha_rollback_to_savepoint");
1649

1650 1651 1652 1653 1654
  trans->no_2pc=0;
  /*
    rolling back to savepoint in all storage engines that were part of the
    transaction when the savepoint was set
  */
1655
  for (ha_info= sv->ha_list; ha_info; ha_info= ha_info->next())
1656 1657
  {
    int err;
1658 1659 1660 1661 1662
    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)))
1663 1664 1665
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
1666
    }
1667
    status_var_increment(thd->status_var.ha_savepoint_rollback_count);
1668
    trans->no_2pc|= ht->prepare == 0;
1669
  }
1670 1671 1672 1673
  /*
    rolling back the transaction in all storage engines that were not part of
    the transaction when the savepoint was set
  */
1674 1675
  for (ha_info= trans->ha_list; ha_info != sv->ha_list;
       ha_info= ha_info_next)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1676
  {
1677
    int err;
1678 1679
    handlerton *ht= ha_info->ht();
    if ((err= ht->rollback(ht, thd, !thd->in_sub_stmt)))
1680 1681 1682
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1683
    }
1684
    status_var_increment(thd->status_var.ha_rollback_count);
1685 1686
    ha_info_next= ha_info->next();
    ha_info->reset(); /* keep it conveniently zero-filled */
1687
  }
1688
  trans->ha_list= sv->ha_list;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1689 1690 1691
  DBUG_RETURN(error);
}

1692 1693 1694
/**
  @note
  according to the sql standard (ISO/IEC 9075-2:2003)
1695 1696
  section "4.33.4 SQL-statements and transaction states",
  SAVEPOINT is *not* transaction-initiating SQL-statement
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1697
*/
1698
int ha_savepoint(THD *thd, SAVEPOINT *sv)
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1699 1700
{
  int error=0;
1701 1702
  THD_TRANS *trans= (thd->in_sub_stmt ? &thd->transaction.stmt :
                                        &thd->transaction.all);
1703
  Ha_trx_info *ha_info= trans->ha_list;
1704
  DBUG_ENTER("ha_savepoint");
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1705
#ifdef USING_TRANSACTIONS
1706
  for (; ha_info; ha_info= ha_info->next())
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1707
  {
1708
    int err;
1709 1710 1711
    handlerton *ht= ha_info->ht();
    DBUG_ASSERT(ht);
    if (! ht->savepoint_set)
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1712
    {
1713
      my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "SAVEPOINT");
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1714
      error=1;
1715
      break;
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1716
    }
1717
    if ((err= ht->savepoint_set(ht, thd, (uchar *)(sv+1)+ht->savepoint_offset)))
1718 1719
    { // cannot happen
      my_error(ER_GET_ERRNO, MYF(0), err);
1720 1721
      error=1;
    }
1722
    status_var_increment(thd->status_var.ha_savepoint_count);
1723
  }
1724 1725 1726 1727 1728
  /*
    Remember the list of registered storage engines. All new
    engines are prepended to the beginning of the list.
  */
  sv->ha_list= trans->ha_list;
1729 1730 1731 1732
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

1733
int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1734 1735
{
  int error=0;
1736
  Ha_trx_info *ha_info= sv->ha_list;
1737 1738
  DBUG_ENTER("ha_release_savepoint");

1739
  for (; ha_info; ha_info= ha_info->next())
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1740
  {
1741
    int err;
1742 1743 1744 1745
    handlerton *ht= ha_info->ht();
    /* Savepoint life time is enclosed into transaction life time. */
    DBUG_ASSERT(ht);
    if (!ht->savepoint_release)
1746
      continue;
1747 1748
    if ((err= ht->savepoint_release(ht, thd,
                                    (uchar *)(sv+1) + ht->savepoint_offset)))
1749 1750 1751
    { // cannot happen
      my_error(ER_GET_ERRNO, MYF(0), err);
      error=1;
guilhem@mysql.com's avatar
guilhem@mysql.com committed
1752
    }
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1753 1754 1755 1756
  }
  DBUG_RETURN(error);
}

1757

antony@ppcg5.local's avatar
antony@ppcg5.local committed
1758
static my_bool snapshot_handlerton(THD *thd, plugin_ref plugin,
1759 1760
                                   void *arg)
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1761
  handlerton *hton= plugin_data(plugin, handlerton *);
1762 1763 1764
  if (hton->state == SHOW_OPTION_YES &&
      hton->start_consistent_snapshot)
  {
1765
    hton->start_consistent_snapshot(hton, thd);
1766 1767 1768 1769 1770
    *((bool *)arg)= false;
  }
  return FALSE;
}

1771 1772
int ha_start_consistent_snapshot(THD *thd)
{
1773 1774
  bool warn= true;

1775 1776
  plugin_foreach(thd, snapshot_handlerton, MYSQL_STORAGE_ENGINE_PLUGIN, &warn);

1777 1778 1779 1780
  /*
    Same idea as when one wants to CREATE TABLE in one engine which does not
    exist:
  */
1781 1782 1783 1784
  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");
1785 1786 1787 1788
  return 0;
}


antony@ppcg5.local's avatar
antony@ppcg5.local committed
1789
static my_bool flush_handlerton(THD *thd, plugin_ref plugin,
1790
                                void *arg)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1791
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1792
  handlerton *hton= plugin_data(plugin, handlerton *);
1793 1794
  if (hton->state == SHOW_OPTION_YES && hton->flush_logs && 
      hton->flush_logs(hton))
1795 1796 1797 1798
    return TRUE;
  return FALSE;
}

1799

1800 1801 1802
bool ha_flush_logs(handlerton *db_type)
{
  if (db_type == NULL)
1803
  {
1804 1805 1806
    if (plugin_foreach(NULL, flush_handlerton,
                          MYSQL_STORAGE_ENGINE_PLUGIN, 0))
      return TRUE;
1807
  }
1808 1809 1810
  else
  {
    if (db_type->state != SHOW_OPTION_YES ||
1811
        (db_type->flush_logs && db_type->flush_logs(db_type)))
1812 1813 1814
      return TRUE;
  }
  return FALSE;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1815 1816
}

1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
static const char *check_lowercase_names(handler *file, const char *path,
                                         char *tmp_path)
{
  if (lower_case_table_names != 2 || (file->ha_table_flags() & HA_FILE_BASED))
    return path;

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

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


1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865
/**
  An interceptor to hijack the text of the error message without
  setting an error in the thread. We need the text to present it
  in the form of a warning to the user.
*/

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


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


1866
/** @brief
1867 1868 1869
  This should return ENOENT if the file doesn't exists.
  The .frm file will be deleted only if we return 0 or ENOENT
*/
1870
int ha_delete_table(THD *thd, handlerton *table_type, const char *path,
1871
                    const char *db, const char *alias, bool generate_warning)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1872
{
1873
  handler *file;
1874
  char tmp_path[FN_REFLEN];
1875 1876 1877 1878 1879 1880 1881 1882
  int error;
  TABLE dummy_table;
  TABLE_SHARE dummy_share;
  DBUG_ENTER("ha_delete_table");

  bzero((char*) &dummy_table, sizeof(dummy_table));
  bzero((char*) &dummy_share, sizeof(dummy_share));
  dummy_table.s= &dummy_share;
1883 1884

  /* DB_TYPE_UNKNOWN is used in ALTER TABLE when renaming only .frm files */
1885
  if (table_type == NULL ||
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1886
      ! (file=get_new_handler((TABLE_SHARE*)0, thd->mem_root, table_type)))
1887
    DBUG_RETURN(ENOENT);
1888

1889
  path= check_lowercase_names(file, path, tmp_path);
1890
  if ((error= file->ha_delete_table(path)) && generate_warning)
1891 1892 1893
  {
    /*
      Because file->print_error() use my_error() to generate the error message
1894 1895 1896
      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.
1897
    */
1898
    Ha_delete_table_error_handler ha_delete_table_error_handler;
1899 1900

    /* Fill up strucutures that print_error may need */
1901 1902 1903 1904 1905 1906
    dummy_share.path.str= (char*) path;
    dummy_share.path.length= strlen(path);
    dummy_share.db.str= (char*) db;
    dummy_share.db.length= strlen(db);
    dummy_share.table_name.str= (char*) alias;
    dummy_share.table_name.length= strlen(alias);
1907 1908
    dummy_table.alias= alias;

1909
    file->change_table_ptr(&dummy_table, &dummy_share);
1910 1911

    thd->push_internal_handler(&ha_delete_table_error_handler);
1912
    file->print_error(error, 0);
1913 1914 1915 1916 1917 1918 1919 1920 1921

    thd->pop_internal_handler();

    /*
      XXX: should we convert *all* errors to warnings here?
      What if the error is fatal?
    */
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, error,
                ha_delete_table_error_handler.buff);
1922
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1923
  delete file;
1924
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1925
}
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1926

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1927 1928 1929
/****************************************************************************
** General handler functions
****************************************************************************/
1930 1931
handler *handler::clone(MEM_ROOT *mem_root)
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1932
  handler *new_handler= get_new_handler(table->s, mem_root, table->s->db_type());
1933 1934 1935 1936 1937
  /*
    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.
  */
1938
  if (!(new_handler->ref= (uchar*) alloc_root(mem_root, ALIGN_SIZE(ref_length)*2)))
1939
    return NULL;
svoj@april.(none)'s avatar
svoj@april.(none) committed
1940 1941 1942
  if (new_handler && !new_handler->ha_open(table,
                                           table->s->normalized_path.str,
                                           table->db_stat,
1943 1944 1945 1946 1947
                                           HA_OPEN_IGNORE_IF_LOCKED))
    return new_handler;
  return NULL;
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1948

1949 1950 1951

void handler::ha_statistic_increment(ulong SSV::*offset) const
{
1952
  status_var_increment(table->in_use->status_var.*offset);
1953 1954
}

1955
void **handler::ha_data(THD *thd) const
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1956
{
1957
  return thd_ha_data(thd, ht);
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1958 1959 1960 1961
}

THD *handler::ha_thd(void) const
{
serg@janus.mylan's avatar
serg@janus.mylan committed
1962
  DBUG_ASSERT(!table || !table->in_use || table->in_use == current_thd);
antony@ppcg5.local's avatar
antony@ppcg5.local committed
1963 1964 1965
  return (table && table->in_use) ? table->in_use : current_thd;
}

1966

1967
/** @brief
1968 1969 1970 1971 1972 1973 1974 1975
  Open database-handler.

  IMPLEMENTATION
    Try O_RDONLY if cannot open as O_RDWR
    Don't wait for locks if not HA_OPEN_WAIT_IF_LOCKED is set
*/
int handler::ha_open(TABLE *table_arg, const char *name, int mode,
                     int test_if_locked)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1976 1977
{
  int error;
1978
  DBUG_ENTER("handler::ha_open");
1979 1980
  DBUG_PRINT("enter",
             ("name: %s  db_type: %d  db_stat: %d  mode: %d  lock_test: %d",
1981
              name, ht->db_type, table_arg->db_stat, mode,
1982 1983 1984 1985
              test_if_locked));

  table= table_arg;
  DBUG_ASSERT(table->s == table_share);
1986
  DBUG_ASSERT(alloc_root_inited(&table->mem_root));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998

  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)
  {
1999
    my_errno= error;                            /* Safeguard */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2000 2001 2002 2003
    DBUG_PRINT("error",("error: %d  errno: %d",error,errno));
  }
  else
  {
2004
    if (table->s->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2005
      table->db_stat|=HA_READ_ONLY;
2006 2007
    (void) extra(HA_EXTRA_NO_READCHECK);	// Not needed in SQL

2008
    /* ref is already allocated for us if we're called from handler::clone() */
2009
    if (!ref && !(ref= (uchar*) alloc_root(&table->mem_root, 
2010
                                          ALIGN_SIZE(ref_length)*2)))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2011 2012 2013 2014 2015
    {
      close();
      error=HA_ERR_OUT_OF_MEM;
    }
    else
2016 2017
      dup_ref=ref+ALIGN_SIZE(ref_length);
    cached_table_flags= table_flags();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2018 2019 2020 2021
  }
  DBUG_RETURN(error);
}

2022

2023 2024 2025
/**
  Read first row (only) from a table.

2026
  This is never called for InnoDB tables, as these table types
2027
  has the HA_STATS_RECORDS_IS_EXACT set.
2028
*/
2029
int handler::read_first_row(uchar * buf, uint primary_key)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2030 2031
{
  register int error;
2032
  DBUG_ENTER("handler::read_first_row");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2033

antony@ppcg5.local's avatar
antony@ppcg5.local committed
2034
  ha_statistic_increment(&SSV::ha_read_first_count);
2035 2036 2037 2038

  /*
    If there is very few deleted rows in the table, find the first row by
    scanning the table.
2039
    TODO remove the test for HA_READ_ORDER
2040
  */
2041
  if (stats.deleted < 10 || primary_key >= MAX_KEY ||
2042
      !(index_flags(primary_key, 0, 0) & HA_READ_ORDER))
2043
  {
2044
    (void) ha_rnd_init(1);
2045
    while ((error= rnd_next(buf)) == HA_ERR_RECORD_DELETED) ;
2046
    (void) ha_rnd_end();
2047 2048 2049 2050
  }
  else
  {
    /* Find the first row through the primary key */
2051
    (void) ha_index_init(primary_key, 0);
2052
    error=index_first(buf);
2053
    (void) ha_index_end();
2054
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2055 2056 2057
  DBUG_RETURN(error);
}

2058 2059
/**
  Generate the next auto-increment number based on increment and offset.
2060 2061 2062
  computes the lowest number
  - strictly greater than "nr"
  - of the form: auto_increment_offset + N * auto_increment_increment
serg@serg.mylan's avatar
serg@serg.mylan committed
2063

2064
  In most cases increment= offset= 1, in which case we get:
2065 2066 2067
  @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
2068 2069
*/
inline ulonglong
2070
compute_next_insert_id(ulonglong nr,struct system_variables *variables)
2071
{
2072 2073
  if (variables->auto_increment_increment == 1)
    return (nr+1); // optimization of the formula below
2074 2075 2076 2077 2078 2079 2080 2081
  nr= (((nr+ variables->auto_increment_increment -
         variables->auto_increment_offset)) /
       (ulonglong) variables->auto_increment_increment);
  return (nr* (ulonglong) variables->auto_increment_increment +
          variables->auto_increment_offset);
}


2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093
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));
}


2094
/** @brief
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120
  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",
2121
                       (ulong) nr, variables->auto_increment_offset));
2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132
    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);
}


2133 2134
/**
  Update the auto_increment field if necessary.
2135

2136
  Updates columns with type NEXT_NUMBER if:
2137 2138 2139 2140 2141 2142 2143

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

2144 2145 2146
    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:
2147

2148 2149 2150
  - 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.
2151

2152 2153 2154 2155 2156 2157
  - 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.
2158

2159 2160 2161 2162 2163
  - 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.
2164

2165 2166 2167 2168
  - In both cases, the reserved intervals are remembered in
    thd->auto_inc_intervals_in_cur_stmt_for_binlog if statement-based
    binlogging; the last reserved interval is remembered in
    auto_inc_interval_for_cur_row.
2169 2170 2171 2172 2173 2174 2175 2176 2177 2178

    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.

2179 2180 2181 2182 2183 2184 2185
    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.
2186

2187
  @todo
2188 2189 2190 2191 2192
    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).

2193 2194 2195 2196 2197 2198 2199 2200
  @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.
2201
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2202

2203 2204 2205 2206
#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)

2207
int handler::update_auto_increment()
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2208
{
2209 2210
  ulonglong nr, nb_reserved_values;
  bool append= FALSE;
2211 2212
  THD *thd= table->in_use;
  struct system_variables *variables= &thd->variables;
2213
  DBUG_ENTER("handler::update_auto_increment");
2214 2215

  /*
2216 2217
    next_insert_id is a "cursor" into the reserved interval, it may go greater
    than the interval, but not smaller.
2218
  */
2219
  DBUG_ASSERT(next_insert_id >= auto_inc_interval_for_cur_row.minimum());
2220 2221

  if ((nr= table->next_number_field->val_int()) != 0 ||
2222
      table->auto_increment_field_not_null &&
2223
      thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO)
2224
  {
2225 2226 2227 2228 2229 2230
    /*
      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).
    */
2231
    adjust_next_insert_id_after_explicit_value(nr);
2232
    insert_id_for_cur_row= 0; // didn't generate anything
2233
    DBUG_RETURN(0);
2234
  }
2235 2236

  if ((nr= next_insert_id) >= auto_inc_interval_for_cur_row.maximum())
2237
  {
2238 2239 2240 2241 2242 2243 2244 2245 2246
    /* 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
2247
    {
2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269
      /*
        handler::estimation_rows_to_insert was set by
        handler::ha_start_bulk_insert(); if 0 it means "unknown".
      */
      uint nb_already_reserved_intervals=
        thd->auto_inc_intervals_in_cur_stmt_for_binlog.nb_elements();
      ulonglong nb_desired_values;
      /*
        If an estimation was given to the engine:
        - use it.
        - if we already reserved numbers, it means the estimation was
        not accurate, then we'll reserve 2*AUTO_INC_DEFAULT_NB_ROWS the 2nd
        time, twice that the 3rd time etc.
        If no estimation was given, use those increasing defaults from the
        start, starting from AUTO_INC_DEFAULT_NB_ROWS.
        Don't go beyond a max to not reserve "way too much" (because
        reservation means potentially losing unused values).
      */
      if (nb_already_reserved_intervals == 0 &&
          (estimation_rows_to_insert > 0))
        nb_desired_values= estimation_rows_to_insert;
      else /* go with the increasing defaults */
2270
      {
2271 2272 2273 2274 2275 2276 2277 2278 2279
        /* avoid overflow in formula, with this if() */
        if (nb_already_reserved_intervals <= AUTO_INC_DEFAULT_NB_MAX_BITS)
        {
          nb_desired_values= AUTO_INC_DEFAULT_NB_ROWS * 
            (1 << nb_already_reserved_intervals);
          set_if_smaller(nb_desired_values, AUTO_INC_DEFAULT_NB_MAX);
        }
        else
          nb_desired_values= AUTO_INC_DEFAULT_NB_MAX;
2280
      }
2281 2282 2283 2284 2285 2286
      /* This call ignores all its parameters but nr, currently */
      get_auto_increment(variables->auto_increment_offset,
                         variables->auto_increment_increment,
                         nb_desired_values, &nr,
                         &nb_reserved_values);
      if (nr == ~(ulonglong) 0)
2287
        DBUG_RETURN(HA_ERR_AUTOINC_READ_FAILED);  // Mark failure
2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299
      
      /*
        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);
    }
    
2300
    if (table->s->next_number_keypart == 0)
2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
    {
      /* 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"));
2314
    }
2315 2316 2317 2318
  }

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

2319
  if (unlikely(table->next_number_field->store((longlong) nr, TRUE)))
2320
  {
2321
    /*
2322 2323 2324 2325 2326
      first test if the query was aborted due to strict mode constraints
    */
    if (thd->killed == THD::KILL_BAD_DATA)
      DBUG_RETURN(HA_ERR_AUTOINC_ERANGE);

2327
    /*
2328
      field refused this value (overflow) and truncated it, use the result of
2329 2330
      the truncation (which is going to be inserted); however we try to
      decrease it to honour auto_increment_* variables.
2331 2332 2333
      That will shift the left bound of the reserved interval, we don't
      bother shifting the right bound (anyway any other value from this
      interval will cause a duplicate key).
2334
    */
2335 2336 2337
    nr= prev_insert_id(table->next_number_field->val_int(), variables);
    if (unlikely(table->next_number_field->store((longlong) nr, TRUE)))
      nr= table->next_number_field->val_int();
2338 2339 2340 2341 2342 2343 2344 2345 2346 2347
  }
  if (append)
  {
    auto_inc_interval_for_cur_row.replace(nr, nb_reserved_values,
                                          variables->auto_increment_increment);
    /* Row-based replication does not need to store intervals in binlog */
    if (!thd->current_stmt_binlog_row_based)
        thd->auto_inc_intervals_in_cur_stmt_for_binlog.append(auto_inc_interval_for_cur_row.minimum(),
                                                              auto_inc_interval_for_cur_row.values(),
                                                              variables->auto_increment_increment);
2348
  }
2349

2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362
  /*
    Record this autogenerated value. If the caller then
    succeeds to insert this value, it will call
    record_first_successful_insert_id_in_cur_stmt()
    which will set first_successful_insert_id_in_cur_stmt if it's not
    already set.
  */
  insert_id_for_cur_row= nr;
  /*
    Set next insert id to point to next auto-increment value to be able to
    handle multi-row statements.
  */
  set_next_insert_id(compute_next_insert_id(nr, variables));
2363

2364
  DBUG_RETURN(0);
2365 2366
}

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2367

2368
/** @brief
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383
  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");
2384 2385
  DBUG_PRINT("info", ("read_set: 0x%lx  write_set: 0x%lx", (long) table->read_set,
                      (long) table->write_set));
2386 2387 2388 2389
  DBUG_VOID_RETURN;
}


2390
/** @brief
2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410
  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)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2411
{
2412
  ulonglong nr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2413
  int error;
2414

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2415
  (void) extra(HA_EXTRA_KEYREAD);
2416 2417 2418
  table->mark_columns_used_by_index_no_reset(table->s->next_number_index,
                                        table->read_set);
  column_bitmaps_signal();
2419
  index_init(table->s->next_number_index, 1);
2420
  if (table->s->next_number_keypart == 0)
2421 2422
  {						// Autoincrement at key-start
    error=index_last(table->record[1]);
2423 2424 2425 2426 2427 2428
    /*
      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;
2429 2430 2431
  }
  else
  {
2432
    uchar key[MAX_KEY_LENGTH];
2433
    key_copy(key, table->record[0],
2434 2435
             table->key_info + table->s->next_number_index,
             table->s->next_number_key_offset);
2436 2437 2438
    error= index_read_map(table->record[1], key,
                          make_prev_keypart_map(table->s->next_number_keypart),
                          HA_READ_PREFIX_LAST);
2439 2440 2441 2442 2443 2444 2445
    /*
      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;
2446 2447
  }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2448 2449 2450
  if (error)
    nr=1;
  else
2451 2452
    nr= ((ulonglong) table->next_number_field->
         val_int_offset(table->s->rec_buff_length)+1);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2453
  index_end();
2454
  (void) extra(HA_EXTRA_NO_KEYREAD);
2455
  *first_value= nr;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2456 2457
}

2458

2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475
void handler::ha_release_auto_increment()
{
  release_auto_increment();
  insert_id_for_cur_row= 0;
  auto_inc_interval_for_cur_row.replace(0, 0, 0);
  if (next_insert_id > 0)
  {
    next_insert_id= 0;
    /*
      this statement used forced auto_increment values if there were some,
      wipe them away for other statements.
    */
    table->in_use->auto_inc_intervals_forced.empty();
  }
}


2476
void handler::print_keydup_error(uint key_nr, const char *msg)
2477 2478 2479 2480
{
  /* Write the duplicated key in the error message */
  char key[MAX_KEY_LENGTH];
  String str(key,sizeof(key),system_charset_info);
2481 2482 2483 2484

  if (key_nr == MAX_KEY)
  {
    /* Key is unknown */
2485
    str.copy("", 0, system_charset_info);
2486
    my_printf_error(ER_DUP_ENTRY, msg, MYF(0), str.c_ptr(), "*UNKNOWN*");
2487 2488
  }
  else
2489
  {
2490 2491 2492 2493 2494 2495 2496 2497
    /* 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("..."));
    }
2498
    my_printf_error(ER_DUP_ENTRY, msg,
2499
		    MYF(0), str.c_ptr(), table->key_info[key_nr].name);
2500 2501 2502 2503
  }
}


2504 2505
/**
  Print error that we got from handler function.
2506

2507 2508 2509 2510 2511
  @note
    In case of delete table it's only safe to use the following parts of
    the 'table' structure:
    - table->s->path
    - table->alias
2512
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2513 2514
void handler::print_error(int error, myf errflag)
{
2515
  DBUG_ENTER("handler::print_error");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2516 2517 2518 2519
  DBUG_PRINT("enter",("error: %d",error));

  int textno=ER_GET_ERRNO;
  switch (error) {
2520 2521 2522
  case EACCES:
    textno=ER_OPEN_AS_READONLY;
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533
  case EAGAIN:
    textno=ER_FILE_USED;
    break;
  case ENOENT:
    textno=ER_FILE_NOT_FOUND;
    break;
  case HA_ERR_KEY_NOT_FOUND:
  case HA_ERR_NO_ACTIVE_RECORD:
  case HA_ERR_END_OF_FILE:
    textno=ER_KEY_NOT_FOUND;
    break;
2534
  case HA_ERR_WRONG_MRG_TABLE_DEF:
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2535 2536 2537 2538 2539 2540 2541
    textno=ER_WRONG_MRG_TABLE;
    break;
  case HA_ERR_FOUND_DUPP_KEY:
  {
    uint key_nr=get_dup_key(error);
    if ((int) key_nr >= 0)
    {
2542
      print_keydup_error(key_nr, ER(ER_DUP_ENTRY_WITH_KEY_NAME));
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2543 2544 2545 2546 2547
      DBUG_VOID_RETURN;
    }
    textno=ER_DUP_KEY;
    break;
  }
2548 2549 2550 2551 2552
  case HA_ERR_FOREIGN_DUPLICATE_KEY:
  {
    uint key_nr= get_dup_key(error);
    if ((int) key_nr >= 0)
    {
2553
      uint max_length;
2554 2555 2556 2557 2558
      /* Write the key in the error message */
      char key[MAX_KEY_LENGTH];
      String str(key,sizeof(key),system_charset_info);
      /* Table is opened and defined at this point */
      key_unpack(&str,table,(uint) key_nr);
2559 2560
      max_length= (MYSQL_ERRMSG_SIZE-
                   (uint) strlen(ER(ER_FOREIGN_DUPLICATE_KEY)));
2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572
      if (str.length() >= max_length)
      {
        str.length(max_length-4);
        str.append(STRING_WITH_LEN("..."));
      }
      my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table_share->table_name.str,
        str.c_ptr(), key_nr+1);
      DBUG_VOID_RETURN;
    }
    textno= ER_DUP_KEY;
    break;
  }
2573
  case HA_ERR_NULL_IN_SPATIAL:
2574 2575
    my_error(ER_CANT_CREATE_GEOMETRY_OBJECT, MYF(0));
    DBUG_VOID_RETURN;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2576 2577 2578 2579 2580 2581 2582 2583 2584
  case HA_ERR_FOUND_DUPP_UNIQUE:
    textno=ER_DUP_UNIQUE;
    break;
  case HA_ERR_RECORD_CHANGED:
    textno=ER_CHECKREAD;
    break;
  case HA_ERR_CRASHED:
    textno=ER_NOT_KEYFILE;
    break;
2585 2586 2587
  case HA_ERR_WRONG_IN_RECORD:
    textno= ER_CRASHED_ON_USAGE;
    break;
2588 2589 2590
  case HA_ERR_CRASHED_ON_USAGE:
    textno=ER_CRASHED_ON_USAGE;
    break;
2591 2592 2593
  case HA_ERR_NOT_A_TABLE:
    textno= error;
    break;
2594 2595 2596
  case HA_ERR_CRASHED_ON_REPAIR:
    textno=ER_CRASHED_ON_REPAIR;
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2597
  case HA_ERR_OUT_OF_MEM:
2598 2599
    textno=ER_OUT_OF_RESOURCES;
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2600 2601 2602 2603 2604 2605 2606 2607 2608 2609
  case HA_ERR_WRONG_COMMAND:
    textno=ER_ILLEGAL_HA;
    break;
  case HA_ERR_OLD_FILE:
    textno=ER_OLD_KEYFILE;
    break;
  case HA_ERR_UNSUPPORTED:
    textno=ER_UNSUPPORTED_EXTENSION;
    break;
  case HA_ERR_RECORD_FILE_FULL:
2610
  case HA_ERR_INDEX_FILE_FULL:
2611
    textno=ER_RECORD_FILE_FULL;
2612
    break;
2613 2614 2615 2616 2617 2618
  case HA_ERR_LOCK_WAIT_TIMEOUT:
    textno=ER_LOCK_WAIT_TIMEOUT;
    break;
  case HA_ERR_LOCK_TABLE_FULL:
    textno=ER_LOCK_TABLE_FULL;
    break;
2619 2620 2621
  case HA_ERR_LOCK_DEADLOCK:
    textno=ER_LOCK_DEADLOCK;
    break;
2622 2623 2624
  case HA_ERR_READ_ONLY_TRANSACTION:
    textno=ER_READ_ONLY_TRANSACTION;
    break;
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
2625 2626 2627 2628
  case HA_ERR_CANNOT_ADD_FOREIGN:
    textno=ER_CANNOT_ADD_FOREIGN;
    break;
  case HA_ERR_ROW_IS_REFERENCED:
2629 2630 2631 2632 2633 2634
  {
    String str;
    get_error_message(error, &str);
    my_error(ER_ROW_IS_REFERENCED_2, MYF(0), str.c_ptr_safe());
    DBUG_VOID_RETURN;
  }
monty@donna.mysql.fi's avatar
Merge  
monty@donna.mysql.fi committed
2635
  case HA_ERR_NO_REFERENCED_ROW:
2636 2637 2638 2639 2640 2641
  {
    String str;
    get_error_message(error, &str);
    my_error(ER_NO_REFERENCED_ROW_2, MYF(0), str.c_ptr_safe());
    DBUG_VOID_RETURN;
  }
2642 2643 2644
  case HA_ERR_TABLE_DEF_CHANGED:
    textno=ER_TABLE_DEF_CHANGED;
    break;
2645
  case HA_ERR_NO_SUCH_TABLE:
2646 2647
    my_error(ER_NO_SUCH_TABLE, MYF(0), table_share->db.str,
             table_share->table_name.str);
2648
    DBUG_VOID_RETURN;
2649 2650 2651
  case HA_ERR_RBR_LOGGING_FAILED:
    textno= ER_BINLOG_ROW_LOGGING_FAILED;
    break;
2652 2653 2654 2655 2656 2657 2658 2659 2660
  case HA_ERR_DROP_INDEX_FK:
  {
    const char *ptr= "???";
    uint key_nr= get_dup_key(error);
    if ((int) key_nr >= 0)
      ptr= table->key_info[key_nr].name;
    my_error(ER_DROP_INDEX_FK, MYF(0), ptr);
    DBUG_VOID_RETURN;
  }
2661 2662 2663
  case HA_ERR_TABLE_NEEDS_UPGRADE:
    textno=ER_TABLE_NEEDS_UPGRADE;
    break;
2664 2665 2666
  case HA_ERR_TABLE_READONLY:
    textno= ER_OPEN_AS_READONLY;
    break;
2667 2668 2669 2670 2671 2672
  case HA_ERR_AUTOINC_READ_FAILED:
    textno= ER_AUTOINC_READ_FAILED;
    break;
  case HA_ERR_AUTOINC_ERANGE:
    textno= ER_WARN_DATA_OUT_OF_RANGE;
    break;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2673 2674
  default:
    {
2675 2676 2677
      /* The error was "unknown" to this function.
	 Ask handler if it has got a message for this error */
      bool temporary= FALSE;
2678 2679 2680
      String str;
      temporary= get_error_message(error, &str);
      if (!str.is_empty())
2681
      {
2682
	const char* engine= table_type();
2683
	if (temporary)
2684
	  my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(), engine);
2685
	else
2686
	  my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine);
2687
      }
2688
      else
2689
	my_error(ER_GET_ERRNO,errflag,error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2690 2691 2692
      DBUG_VOID_RETURN;
    }
  }
2693
  my_error(textno, errflag, table_share->table_name.str, error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2694 2695 2696
  DBUG_VOID_RETURN;
}

2697

2698 2699
/**
  Return an error message specific to this handler.
2700

2701 2702
  @param error  error code previously returned by handler
  @param buf    pointer to String where to add error message
serg@serg.mylan's avatar
serg@serg.mylan committed
2703

2704 2705
  @return
    Returns true if this is a temporary error
2706
*/
2707
bool handler::get_error_message(int error, String* buf)
2708
{
2709
  return FALSE;
2710 2711 2712
}


2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731
int handler::ha_check_for_upgrade(HA_CHECK_OPT *check_opt)
{
  KEY *keyinfo, *keyend;
  KEY_PART_INFO *keypart, *keypartend;

  if (!table->s->mysql_version)
  {
    /* check for blob-in-key error */
    keyinfo= table->key_info;
    keyend= table->key_info + table->s->keys;
    for (; keyinfo < keyend; keyinfo++)
    {
      keypart= keyinfo->key_part;
      keypartend= keypart + keyinfo->key_parts;
      for (; keypart < keypartend; keypart++)
      {
        if (!keypart->fieldnr)
          continue;
        Field *field= table->field[keypart->fieldnr-1];
2732
        if (field->type() == MYSQL_TYPE_BLOB)
2733 2734 2735 2736 2737 2738 2739 2740
        {
          if (check_opt->sql_flags & TT_FOR_UPGRADE)
            check_opt->flags= T_MEDIUM;
          return HA_ADMIN_NEEDS_CHECK;
        }
      }
    }
  }
2741 2742
  if (table->s->frm_version != FRM_VER_TRUE_VARCHAR)
    return HA_ADMIN_NEEDS_ALTER;
2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755
  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++)
    {
2756
      if ((*field)->type() == MYSQL_TYPE_NEWDECIMAL)
2757 2758 2759
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
2760 2761 2762 2763
      if ((*field)->type() == MYSQL_TYPE_VAR_STRING)
      {
        return HA_ADMIN_NEEDS_ALTER;
      }
2764 2765 2766 2767 2768 2769
    }
  }
  return 0;
}


2770
static bool update_frm_version(TABLE *table)
2771 2772 2773 2774 2775 2776
{
  char path[FN_REFLEN];
  File file;
  int result= 1;
  DBUG_ENTER("update_frm_version");

2777 2778 2779 2780 2781 2782 2783
  /*
    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)
2784 2785
    DBUG_RETURN(0);

2786
  strxmov(path, table->s->normalized_path.str, reg_ext, NullS);
2787 2788 2789 2790

  if ((file= my_open(path, O_RDWR|O_BINARY, MYF(MY_WME))) >= 0)
  {
    uchar version[4];
2791 2792
    char *key= table->s->table_cache_key.str;
    uint key_length= table->s->table_cache_key.length;
2793 2794 2795 2796 2797
    TABLE *entry;
    HASH_SEARCH_STATE state;

    int4store(version, MYSQL_VERSION_ID);

2798
    if ((result= my_pwrite(file,(uchar*) version,4,51L,MYF_RW)))
2799 2800
      goto err;

2801
    for (entry=(TABLE*) hash_first(&open_cache,(uchar*) key,key_length, &state);
2802
         entry;
2803
         entry= (TABLE*) hash_next(&open_cache,(uchar*) key,key_length, &state))
2804 2805 2806 2807 2808 2809 2810 2811 2812 2813
      entry->s->mysql_version= MYSQL_VERSION_ID;
  }
err:
  if (file >= 0)
    VOID(my_close(file,MYF(MY_WME)));
  DBUG_RETURN(result);
}



2814 2815 2816 2817
/**
  @return
    key if error because of duplicated keys
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2818 2819
uint handler::get_dup_key(int error)
{
2820
  DBUG_ENTER("handler::get_dup_key");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2821
  table->file->errkey  = (uint) -1;
2822 2823 2824
  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)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2825 2826 2827 2828
    info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
  DBUG_RETURN(table->file->errkey);
}

2829

2830 2831
/**
  Delete all files with extension from bas_ext().
2832

2833
  @param name		Base name of table
2834

2835
  @note
2836 2837 2838
    We assume that the handler may return more extensions than
    was actually used for the file.

2839
  @retval
2840
    0   If we successfully deleted at least one file from base_ext and
2841 2842 2843
    didn't get any other errors than ENOENT
  @retval
    !0  Error
2844
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2845 2846
int handler::delete_table(const char *name)
{
2847 2848
  int error= 0;
  int enoent_or_zero= ENOENT;                   // Error if no file was deleted
2849
  char buff[FN_REFLEN];
2850

bk@work.mysql.com's avatar
bk@work.mysql.com committed
2851 2852
  for (const char **ext=bas_ext(); *ext ; ext++)
  {
2853
    fn_format(buff, name, "", *ext, MY_UNPACK_FILENAME|MY_APPEND_EXT);
2854
    if (my_delete_with_symlink(buff, MYF(0)))
2855
    {
2856
      if ((error= my_errno) != ENOENT)
2857 2858
	break;
    }
2859
    else
2860
      enoent_or_zero= 0;                        // No error for ENOENT
2861
    error= enoent_or_zero;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2862
  }
2863
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2864 2865 2866 2867 2868
}


int handler::rename_table(const char * from, const char * to)
{
2869 2870
  int error= 0;
  for (const char **ext= bas_ext(); *ext ; ext++)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2871
  {
2872 2873 2874 2875 2876 2877
    if (rename_file_ext(from, to, *ext))
    {
      if ((error=my_errno) != ENOENT)
	break;
      error= 0;
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2878
  }
2879
  return error;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
2880 2881
}

2882 2883 2884 2885 2886 2887 2888 2889

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


2890 2891
/**
  Performs checks upon the table.
2892

2893 2894
  @param thd                thread doing CHECK TABLE operation
  @param check_opt          options from the parser
2895

2896 2897 2898 2899 2900 2901 2902 2903
  @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
2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924
*/
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;
2925
  return update_frm_version(table);
2926 2927
}

2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957
/**
  A helper function to mark a transaction read-write,
  if it is started.
*/

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

2958

2959 2960 2961 2962 2963 2964
/**
  Repair table: public interface.

  @sa handler::repair()
*/

2965 2966 2967
int handler::ha_repair(THD* thd, HA_CHECK_OPT* check_opt)
{
  int result;
2968 2969 2970

  mark_trx_read_write();

2971 2972
  if ((result= repair(thd, check_opt)))
    return result;
2973
  return update_frm_version(table);
2974 2975 2976
}


2977 2978 2979 2980 2981 2982 2983 2984 2985 2986
/**
  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)
{
2987 2988
  mark_trx_read_write();

2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001
  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()
{
3002 3003
  mark_trx_read_write();

3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016
  return delete_all_rows();
}


/**
  Reset auto increment: public interface.

  @sa handler::reset_auto_increment()
*/

int
handler::ha_reset_auto_increment(ulonglong value)
{
3017 3018
  mark_trx_read_write();

3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031
  return reset_auto_increment(value);
}


/**
  Backup table: public interface.

  @sa handler::backup()
*/

int
handler::ha_backup(THD* thd, HA_CHECK_OPT* check_opt)
{
3032 3033
  mark_trx_read_write();

3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046
  return backup(thd, check_opt);
}


/**
  Restore table: public interface.

  @sa handler::restore()
*/

int
handler::ha_restore(THD* thd, HA_CHECK_OPT* check_opt)
{
3047 3048
  mark_trx_read_write();

3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061
  return restore(thd, check_opt);
}


/**
  Optimize table: public interface.

  @sa handler::optimize()
*/

int
handler::ha_optimize(THD* thd, HA_CHECK_OPT* check_opt)
{
3062 3063
  mark_trx_read_write();

3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076
  return optimize(thd, check_opt);
}


/**
  Analyze table: public interface.

  @sa handler::analyze()
*/

int
handler::ha_analyze(THD* thd, HA_CHECK_OPT* check_opt)
{
3077 3078
  mark_trx_read_write();

3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091
  return analyze(thd, check_opt);
}


/**
  Check and repair table: public interface.

  @sa handler::check_and_repair()
*/

bool
handler::ha_check_and_repair(THD *thd)
{
3092 3093
  mark_trx_read_write();

3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106
  return check_and_repair(thd);
}


/**
  Disable indexes: public interface.

  @sa handler::disable_indexes()
*/

int
handler::ha_disable_indexes(uint mode)
{
3107 3108
  mark_trx_read_write();

3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121
  return disable_indexes(mode);
}


/**
  Enable indexes: public interface.

  @sa handler::enable_indexes()
*/

int
handler::ha_enable_indexes(uint mode)
{
3122 3123
  mark_trx_read_write();

3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136
  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)
{
3137 3138
  mark_trx_read_write();

3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153
  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()
{
3154 3155
  mark_trx_read_write();

3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168
  prepare_for_alter();
}


/**
  Rename table: public interface.

  @sa handler::rename_table()
*/

int
handler::ha_rename_table(const char *from, const char *to)
{
3169 3170
  mark_trx_read_write();

3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183
  return rename_table(from, to);
}


/**
  Delete table: public interface.

  @sa handler::delete_table()
*/

int
handler::ha_delete_table(const char *name)
{
3184 3185
  mark_trx_read_write();

3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198
  return delete_table(name);
}


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

  @sa handler::drop_table()
*/

void
handler::ha_drop_table(const char *name)
{
3199 3200
  mark_trx_read_write();

3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213
  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)
{
3214 3215
  mark_trx_read_write();

3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229
  return create(name, form, info);
}


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

  @sa handler::create_handler_files()
*/

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

3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249
  return create_handler_files(name, old_name, action_flag, info);
}


/**
  Change partitions: public interface.

  @sa handler::change_partitions()
*/

int
handler::ha_change_partitions(HA_CREATE_INFO *create_info,
                     const char *path,
                     ulonglong *copied,
                     ulonglong *deleted,
                     const uchar *pack_frm_data,
                     size_t pack_frm_len)
{
3250 3251
  mark_trx_read_write();

3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265
  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)
{
3266 3267
  mark_trx_read_write();

3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280
  return drop_partitions(path);
}


/**
  Rename partitions: public interface.

  @sa handler::rename_partitions()
*/

int
handler::ha_rename_partitions(const char *path)
{
3281 3282
  mark_trx_read_write();

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


/**
  Optimize partitions: public interface.

  @sa handler::optimize_partitions()
*/

int
handler::ha_optimize_partitions(THD *thd)
{
3296 3297
  mark_trx_read_write();

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


/**
  Analyze partitions: public interface.

  @sa handler::analyze_partitions()
*/

int
handler::ha_analyze_partitions(THD *thd)
{
3311 3312
  mark_trx_read_write();

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


/**
  Check partitions: public interface.

  @sa handler::check_partitions()
*/

int
handler::ha_check_partitions(THD *thd)
{
3326 3327
  mark_trx_read_write();

3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340
  return check_partitions(thd);
}


/**
  Repair partitions: public interface.

  @sa handler::repair_partitions()
*/

int
handler::ha_repair_partitions(THD *thd)
{
3341 3342
  mark_trx_read_write();

3343 3344 3345 3346
  return repair_partitions(thd);
}


3347
/**
3348 3349 3350 3351 3352 3353
  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.
3354
*/
3355
int ha_enable_transaction(THD *thd, bool on)
3356 3357
{
  int error=0;
3358
  DBUG_ENTER("ha_enable_transaction");
3359 3360
  DBUG_PRINT("enter", ("on: %d", (int) on));

3361
  if ((thd->transaction.on= on))
3362 3363 3364 3365 3366 3367 3368
  {
    /*
      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.
    */
3369
    if (!(error= ha_commit_trans(thd, 0)))
3370
      error= end_trans(thd, COMMIT);
3371
  }
3372 3373 3374
  DBUG_RETURN(error);
}

3375
int handler::index_next_same(uchar *buf, const uchar *key, uint keylen)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3376 3377
{
  int error;
3378
  DBUG_ENTER("index_next_same");
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3379 3380
  if (!(error=index_next(buf)))
  {
3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412
    my_ptrdiff_t ptrdiff= buf - table->record[0];
    uchar *save_record_0;
    KEY *key_info;
    KEY_PART_INFO *key_part;
    KEY_PART_INFO *key_part_end;
    LINT_INIT(save_record_0);
    LINT_INIT(key_info);
    LINT_INIT(key_part);
    LINT_INIT(key_part_end);

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

3413
    if (key_cmp_if_same(table, key, active_index, keylen))
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3414 3415 3416 3417
    {
      table->status=STATUS_NOT_FOUND;
      error=HA_ERR_END_OF_FILE;
    }
3418 3419 3420 3421 3422 3423 3424 3425

    /* 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);
    }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3426
  }
3427
  DBUG_RETURN(error);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3428 3429 3430
}


3431 3432
void handler::get_dynamic_partition_info(PARTITION_INFO *stat_info,
                                         uint part_id)
3433 3434 3435
{
  info(HA_STATUS_CONST | HA_STATUS_TIME | HA_STATUS_VARIABLE |
       HA_STATUS_NO_LOCK);
3436 3437 3438 3439 3440 3441 3442 3443 3444 3445
  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;
3446
  if (table_flags() & (ulong) HA_HAS_CHECKSUM)
3447
    stat_info->check_sum= checksum();
3448 3449 3450 3451
  return;
}


bk@work.mysql.com's avatar
bk@work.mysql.com committed
3452 3453 3454 3455
/****************************************************************************
** Some general functions that isn't in the handler class
****************************************************************************/

3456 3457
/**
  Initiates table-file and calls appropriate database-creator.
3458

3459
  @retval
3460
   0  ok
3461
  @retval
3462
   1  error
3463
*/
3464 3465 3466
int ha_create_table(THD *thd, const char *path,
                    const char *db, const char *table_name,
                    HA_CREATE_INFO *create_info,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3467 3468
		    bool update_create_info)
{
3469
  int error= 1;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3470
  TABLE table;
3471
  char name_buff[FN_REFLEN];
3472 3473
  const char *name;
  TABLE_SHARE share;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3474
  DBUG_ENTER("ha_create_table");
3475
  
3476
  init_tmp_table_share(thd, &share, db, 0, table_name, path);
3477
  if (open_table_def(thd, &share, 0) ||
3478 3479
      open_table_from_share(thd, &share, "", 0, (uint) READ_ALL, 0, &table,
                            TRUE))
3480
    goto err;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3481 3482 3483

  if (update_create_info)
    update_create_info_from_table(create_info, &table);
3484

3485
  name= check_lowercase_names(table.file, share.path.str, name_buff);
3486

3487
  error= table.file->ha_create(name, &table, create_info);
3488
  VOID(closefrm(&table, 0));
3489
  if (error)
3490 3491 3492 3493 3494 3495
  {
    strxmov(name_buff, db, ".", table_name, NullS);
    my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), name_buff, error);
  }
err:
  free_table_share(&share);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3496 3497 3498
  DBUG_RETURN(error != 0);
}

3499 3500
/**
  Try to discover table from engine.
3501

3502
  @note
3503
    If found, write the frm file to disk.
3504

3505
  @retval
3506
  -1    Table did not exists
3507
  @retval
3508
   0    Table created ok
3509
  @retval
3510
   > 0  Error, table existed but could not be created
3511
*/
3512
int ha_create_table_from_engine(THD* thd, const char *db, const char *name)
3513
{
3514
  int error;
3515 3516
  uchar *frmblob;
  size_t frmlen;
3517 3518 3519
  char path[FN_REFLEN];
  HA_CREATE_INFO create_info;
  TABLE table;
3520
  TABLE_SHARE share;
3521
  DBUG_ENTER("ha_create_table_from_engine");
monty@mishka.local's avatar
monty@mishka.local committed
3522
  DBUG_PRINT("enter", ("name '%s'.'%s'", db, name));
3523

3524
  bzero((uchar*) &create_info,sizeof(create_info));
3525
  if ((error= ha_discover(thd, db, name, &frmblob, &frmlen)))
3526
  {
monty@mishka.local's avatar
monty@mishka.local committed
3527
    /* Table could not be discovered and thus not created */
3528
    DBUG_RETURN(error);
3529 3530
  }

3531
  /*
3532 3533
    Table exists in handler and could be discovered
    frmblob and frmlen are set, write the frm to disk
3534
  */
3535

3536
  build_table_filename(path, FN_REFLEN-1, db, name, "", 0);
3537
  // Save the frm file
monty@mishka.local's avatar
monty@mishka.local committed
3538
  error= writefrm(path, frmblob, frmlen);
3539
  my_free(frmblob, MYF(0));
monty@mishka.local's avatar
monty@mishka.local committed
3540
  if (error)
3541
    DBUG_RETURN(2);
3542

3543
  init_tmp_table_share(thd, &share, db, 0, name, path);
3544 3545 3546 3547
  if (open_table_def(thd, &share, 0))
  {
    DBUG_RETURN(3);
  }
3548
  if (open_table_from_share(thd, &share, "" ,0, 0, 0, &table, FALSE))
3549 3550
  {
    free_table_share(&share);
3551
    DBUG_RETURN(3);
3552
  }
3553

3554
  update_create_info_from_table(&create_info, &table);
3555
  create_info.table_options|= HA_OPTION_CREATE_FROM_ENGINE;
3556

3557
  check_lowercase_names(table.file, path, path);
3558
  error=table.file->ha_create(path, &table, &create_info);
3559
  VOID(closefrm(&table, 1));
3560

3561
  DBUG_RETURN(error != 0);
3562 3563
}

3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580
void st_ha_check_opt::init()
{
  flags= sql_flags= 0;
  sort_buffer_size = current_thd->variables.myisam_sort_buff_size;
}


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

  This code is only relevant for ISAM/MyISAM tables

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

3581 3582
/**
  Init a key cache if it has not been initied before.
3583
*/
3584
int ha_init_key_cache(const char *name, KEY_CACHE *key_cache)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3585
{
3586 3587
  DBUG_ENTER("ha_init_key_cache");

3588
  if (!key_cache->key_cache_inited)
3589 3590
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
3591 3592
    ulong tmp_buff_size= (ulong) key_cache->param_buff_size;
    uint tmp_block_size= (uint) key_cache->param_block_size;
3593 3594
    uint division_limit= key_cache->param_division_limit;
    uint age_threshold=  key_cache->param_age_threshold;
3595
    pthread_mutex_unlock(&LOCK_global_system_variables);
3596
    DBUG_RETURN(!init_key_cache(key_cache,
3597 3598
				tmp_block_size,
				tmp_buff_size,
3599
				division_limit, age_threshold));
3600
  }
3601
  DBUG_RETURN(0);
3602 3603
}

3604

3605 3606
/**
  Resize key cache.
3607
*/
3608
int ha_resize_key_cache(KEY_CACHE *key_cache)
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
3609
{
3610 3611
  DBUG_ENTER("ha_resize_key_cache");

3612
  if (key_cache->key_cache_inited)
3613 3614
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
3615 3616 3617 3618
    long tmp_buff_size= (long) key_cache->param_buff_size;
    long tmp_block_size= (long) key_cache->param_block_size;
    uint division_limit= key_cache->param_division_limit;
    uint age_threshold=  key_cache->param_age_threshold;
3619
    pthread_mutex_unlock(&LOCK_global_system_variables);
3620 3621 3622
    DBUG_RETURN(!resize_key_cache(key_cache, tmp_block_size,
				  tmp_buff_size,
				  division_limit, age_threshold));
3623
  }
3624
  DBUG_RETURN(0);
3625 3626
}

3627

3628
/**
3629 3630
  Change parameters for key cache (like size)
*/
3631
int ha_change_key_cache_param(KEY_CACHE *key_cache)
3632
{
3633 3634 3635 3636 3637 3638 3639 3640
  if (key_cache->key_cache_inited)
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
    uint division_limit= key_cache->param_division_limit;
    uint age_threshold=  key_cache->param_age_threshold;
    pthread_mutex_unlock(&LOCK_global_system_variables);
    change_key_cache_param(key_cache, division_limit, age_threshold);
  }
3641 3642
  return 0;
}
3643

3644 3645
/**
  Free memory allocated by a key cache.
3646
*/
3647
int ha_end_key_cache(KEY_CACHE *key_cache)
3648
{
3649
  end_key_cache(key_cache, 1);		// Can never fail
3650
  return 0;
3651
}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3652

3653 3654
/**
  Move all tables from one key cache to another one.
3655
*/
3656 3657
int ha_change_key_cache(KEY_CACHE *old_key_cache,
			KEY_CACHE *new_key_cache)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
3658
{
3659 3660
  mi_change_key_cache(old_key_cache, new_key_cache);
  return 0;
3661
}
3662 3663


3664 3665
/**
  Try to discover one table from handler(s).
3666

3667 3668 3669 3670 3671 3672
  @retval
    -1   Table did not exists
  @retval
    0   OK. In this case *frmblob and *frmlen are set
  @retval
    >0   error.  frmblob and frmlen may not be set
3673
*/
3674
struct st_discover_args
3675 3676 3677
{
  const char *db;
  const char *name;
3678 3679
  uchar **frmblob; 
  size_t *frmlen;
3680 3681
};

antony@ppcg5.local's avatar
antony@ppcg5.local committed
3682
static my_bool discover_handlerton(THD *thd, plugin_ref plugin,
3683 3684 3685
                                   void *arg)
{
  st_discover_args *vargs= (st_discover_args *)arg;
antony@ppcg5.local's avatar
antony@ppcg5.local committed
3686
  handlerton *hton= plugin_data(plugin, handlerton *);
3687
  if (hton->state == SHOW_OPTION_YES && hton->discover &&
3688 3689 3690
      (!(hton->discover(hton, thd, vargs->db, vargs->name, 
                        vargs->frmblob, 
                        vargs->frmlen))))
3691 3692 3693 3694 3695
    return TRUE;

  return FALSE;
}

3696
int ha_discover(THD *thd, const char *db, const char *name,
3697
		uchar **frmblob, size_t *frmlen)
3698
{
3699
  int error= -1; // Table does not exist in any handler
3700
  DBUG_ENTER("ha_discover");
3701
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
3702 3703
  st_discover_args args= {db, name, frmblob, frmlen};

3704 3705
  if (is_prefix(name,tmp_file_prefix)) /* skip temporary tables */
    DBUG_RETURN(error);
3706 3707 3708 3709 3710

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

3711
  if (!error)
3712
    status_var_increment(thd->status_var.ha_discover_count);
3713 3714 3715 3716
  DBUG_RETURN(error);
}


3717 3718 3719
/**
  Call this function in order to give the handler the possiblity
  to ask engine if there are any new tables that should be written to disk
3720
  or any dropped tables that need to be removed from disk
3721
*/
3722
struct st_find_files_args
3723 3724 3725 3726 3727
{
  const char *db;
  const char *path;
  const char *wild;
  bool dir;
3728
  List<LEX_STRING> *files;
3729 3730
};

antony@ppcg5.local's avatar
antony@ppcg5.local committed
3731
static my_bool find_files_handlerton(THD *thd, plugin_ref plugin,
3732 3733 3734
                                   void *arg)
{
  st_find_files_args *vargs= (st_find_files_args *)arg;
antony@ppcg5.local's avatar
antony@ppcg5.local committed
3735
  handlerton *hton= plugin_data(plugin, handlerton *);
3736 3737 3738


  if (hton->state == SHOW_OPTION_YES && hton->find_files)
3739
      if (hton->find_files(hton, thd, vargs->db, vargs->path, vargs->wild, 
3740 3741 3742 3743 3744
                          vargs->dir, vargs->files))
        return TRUE;

  return FALSE;
}
3745

3746 3747
int
ha_find_files(THD *thd,const char *db,const char *path,
3748
	      const char *wild, bool dir, List<LEX_STRING> *files)
3749 3750
{
  int error= 0;
3751
  DBUG_ENTER("ha_find_files");
3752 3753
  DBUG_PRINT("enter", ("db: '%s'  path: '%s'  wild: '%s'  dir: %d", 
		       db, path, wild ? wild : "NULL", dir));
3754 3755 3756 3757 3758
  st_find_files_args args= {db, path, wild, dir, files};

  plugin_foreach(thd, find_files_handlerton,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &args);
  /* The return value is not currently used */
3759 3760 3761
  DBUG_RETURN(error);
}

3762 3763 3764
/**
  Ask handler if the table exists in engine.
  @retval
3765
    HA_ERR_NO_SUCH_TABLE     Table does not exist
3766
  @retval
3767
    HA_ERR_TABLE_EXIST       Table exists
3768 3769 3770
  @retval
    \#                  Error code
*/
3771
struct st_table_exists_in_engine_args
3772 3773 3774
{
  const char *db;
  const char *name;
3775
  int err;
3776 3777
};

antony@ppcg5.local's avatar
antony@ppcg5.local committed
3778
static my_bool table_exists_in_engine_handlerton(THD *thd, plugin_ref plugin,
3779 3780 3781
                                   void *arg)
{
  st_table_exists_in_engine_args *vargs= (st_table_exists_in_engine_args *)arg;
antony@ppcg5.local's avatar
antony@ppcg5.local committed
3782
  handlerton *hton= plugin_data(plugin, handlerton *);
3783

3784 3785
  int err= HA_ERR_NO_SUCH_TABLE;

3786
  if (hton->state == SHOW_OPTION_YES && hton->table_exists_in_engine)
3787 3788 3789 3790 3791
    err = hton->table_exists_in_engine(hton, thd, vargs->db, vargs->name);

  vargs->err = err;
  if (vargs->err == HA_ERR_TABLE_EXIST)
    return TRUE;
3792 3793 3794 3795

  return FALSE;
}

3796
int ha_table_exists_in_engine(THD* thd, const char* db, const char* name)
3797
{
3798
  DBUG_ENTER("ha_table_exists_in_engine");
3799
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
3800 3801
  st_table_exists_in_engine_args args= {db, name, HA_ERR_NO_SUCH_TABLE};
  plugin_foreach(thd, table_exists_in_engine_handlerton,
3802
                 MYSQL_STORAGE_ENGINE_PLUGIN, &args);
3803 3804
  DBUG_PRINT("exit", ("error: %d", args.err));
  DBUG_RETURN(args.err);
3805 3806
}

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826
#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;
};

3827
/** @brief
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3828 3829
  Listing handlertons first to avoid recursive calls and deadlock
*/
antony@ppcg5.local's avatar
antony@ppcg5.local committed
3830
static my_bool binlog_func_list(THD *thd, plugin_ref plugin, void *arg)
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3831 3832
{
  hton_list_st *hton_list= (hton_list_st *)arg;
antony@ppcg5.local's avatar
antony@ppcg5.local committed
3833
  handlerton *hton= plugin_data(plugin, handlerton *);
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850
  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;
3851 3852
  uint i, sz;

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3853 3854 3855 3856
  hton_list.sz= 0;
  plugin_foreach(thd, binlog_func_list,
                 MYSQL_STORAGE_ENGINE_PLUGIN, &hton_list);

3857 3858
  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);
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891
  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);
knielsen@mysql.com's avatar
knielsen@mysql.com committed
3892
  return 0;
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903
}

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

3904
static my_bool binlog_log_query_handlerton2(THD *thd,
3905
                                            handlerton *hton,
3906
                                            void *args)
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3907 3908 3909
{
  struct binlog_log_query_st *b= (struct binlog_log_query_st*)args;
  if (hton->state == SHOW_OPTION_YES && hton->binlog_log_query)
3910
    hton->binlog_log_query(hton, thd,
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3911 3912 3913 3914 3915 3916 3917 3918
                           b->binlog_command,
                           b->query,
                           b->query_length,
                           b->db,
                           b->table_name);
  return FALSE;
}

3919
static my_bool binlog_log_query_handlerton(THD *thd,
antony@ppcg5.local's avatar
antony@ppcg5.local committed
3920
                                           plugin_ref plugin,
3921 3922
                                           void *args)
{
antony@ppcg5.local's avatar
antony@ppcg5.local committed
3923
  return binlog_log_query_handlerton2(thd, plugin_data(plugin, handlerton *), args);
3924 3925
}

3926
void ha_binlog_log_query(THD *thd, handlerton *hton,
3927
                         enum_binlog_command binlog_command,
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3928 3929 3930 3931 3932 3933 3934 3935 3936
                         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;
3937 3938 3939 3940 3941
  if (hton == 0)
    plugin_foreach(thd, binlog_log_query_handlerton,
                   MYSQL_STORAGE_ENGINE_PLUGIN, &b);
  else
    binlog_log_query_handlerton2(thd, hton, &b);
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
3942 3943
}
#endif
3944

3945
/**
ingo@mysql.com's avatar
ingo@mysql.com committed
3946 3947
  Read the first row of a multi-range set.

3948 3949 3950 3951 3952 3953 3954 3955 3956 3957
  @param found_range_p       Returns a pointer to the element in 'ranges' that
                             corresponds to the returned row.
  @param ranges              An array of KEY_MULTI_RANGE range descriptions.
  @param range_count         Number of ranges in 'ranges'.
  @param sorted	      If result should be sorted per key.
  @param buffer              A HANDLER_BUFFER for internal handler usage.

  @note
    - Record is read into table->record[0].
    - *found_range_p returns a valid value only if read_multi_range_first()
ingo@mysql.com's avatar
ingo@mysql.com committed
3958
    returns 0.
3959
    - Sorting is done within each range. If you want an overall sort, enter
ingo@mysql.com's avatar
ingo@mysql.com committed
3960 3961
    'ranges' with sorted ranges.

3962
  @retval
ingo@mysql.com's avatar
ingo@mysql.com committed
3963
    0			OK, found a row
3964
  @retval
ingo@mysql.com's avatar
ingo@mysql.com committed
3965
    HA_ERR_END_OF_FILE	No rows in range
3966 3967
  @retval
    \#			Error code
ingo@mysql.com's avatar
ingo@mysql.com committed
3968 3969 3970 3971 3972 3973 3974 3975 3976 3977
*/
int handler::read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
                                    KEY_MULTI_RANGE *ranges, uint range_count,
                                    bool sorted, HANDLER_BUFFER *buffer)
{
  int result= HA_ERR_END_OF_FILE;
  DBUG_ENTER("handler::read_multi_range_first");
  multi_range_sorted= sorted;
  multi_range_buffer= buffer;

3978 3979 3980
  table->mark_columns_used_by_index_no_reset(active_index, table->read_set);
  table->column_bitmaps_set(table->read_set, table->write_set);

ingo@mysql.com's avatar
ingo@mysql.com committed
3981 3982 3983 3984
  for (multi_range_curr= ranges, multi_range_end= ranges + range_count;
       multi_range_curr < multi_range_end;
       multi_range_curr++)
  {
3985
    result= read_range_first(multi_range_curr->start_key.keypart_map ?
ingo@mysql.com's avatar
ingo@mysql.com committed
3986
                             &multi_range_curr->start_key : 0,
3987
                             multi_range_curr->end_key.keypart_map ?
ingo@mysql.com's avatar
ingo@mysql.com committed
3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000
                             &multi_range_curr->end_key : 0,
                             test(multi_range_curr->range_flag & EQ_RANGE),
                             multi_range_sorted);
    if (result != HA_ERR_END_OF_FILE)
      break;
  }

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


4001
/**
ingo@mysql.com's avatar
ingo@mysql.com committed
4002 4003
  Read the next row of a multi-range set.

4004 4005
  @param found_range_p       Returns a pointer to the element in 'ranges' that
                             corresponds to the returned row.
ingo@mysql.com's avatar
ingo@mysql.com committed
4006

4007 4008 4009
  @note
    - Record is read into table->record[0].
    - *found_range_p returns a valid value only if read_multi_range_next()
ingo@mysql.com's avatar
ingo@mysql.com committed
4010 4011
    returns 0.

4012
  @retval
ingo@mysql.com's avatar
ingo@mysql.com committed
4013
    0			OK, found a row
4014
  @retval
ingo@mysql.com's avatar
ingo@mysql.com committed
4015
    HA_ERR_END_OF_FILE	No (more) rows in range
4016 4017
  @retval
    \#			Error code
ingo@mysql.com's avatar
ingo@mysql.com committed
4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039
*/
int handler::read_multi_range_next(KEY_MULTI_RANGE **found_range_p)
{
  int result;
  DBUG_ENTER("handler::read_multi_range_next");

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

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

      /* On success or non-EOF errors jump to the end. */
      if (result != HA_ERR_END_OF_FILE)
        break;
    }
    else
    {
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
4040 4041
      if (was_semi_consistent_read())
        goto scan_it_again;
ingo@mysql.com's avatar
ingo@mysql.com committed
4042 4043 4044 4045 4046 4047 4048
      /*
        We need to set this for the last range only, but checking this
        condition is more expensive than just setting the result code.
      */
      result= HA_ERR_END_OF_FILE;
    }

gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
4049 4050
    multi_range_curr++;
scan_it_again:
ingo@mysql.com's avatar
ingo@mysql.com committed
4051
    /* Try the next range(s) until one matches a record. */
gshchepa/uchum@gleb.loc's avatar
gshchepa/uchum@gleb.loc committed
4052
    for (; multi_range_curr < multi_range_end; multi_range_curr++)
ingo@mysql.com's avatar
ingo@mysql.com committed
4053
    {
4054
      result= read_range_first(multi_range_curr->start_key.keypart_map ?
ingo@mysql.com's avatar
ingo@mysql.com committed
4055
                               &multi_range_curr->start_key : 0,
4056
                               multi_range_curr->end_key.keypart_map ?
ingo@mysql.com's avatar
ingo@mysql.com committed
4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072
                               &multi_range_curr->end_key : 0,
                               test(multi_range_curr->range_flag & EQ_RANGE),
                               multi_range_sorted);
      if (result != HA_ERR_END_OF_FILE)
        break;
    }
  }
  while ((result == HA_ERR_END_OF_FILE) &&
         (multi_range_curr < multi_range_end));

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


4073
/**
4074
  Read first row between two ranges.
4075
  Store ranges for future calls to read_range_next.
4076

4077 4078 4079 4080 4081 4082
  @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
4083 4084
    Record is read into table->record[0]

4085
  @retval
4086
    0			Found row
4087
  @retval
4088
    HA_ERR_END_OF_FILE	No rows in range
4089 4090
  @retval
    \#			Error code
4091 4092 4093
*/
int handler::read_range_first(const key_range *start_key,
			      const key_range *end_key,
4094
			      bool eq_range_arg, bool sorted)
4095 4096 4097 4098
{
  int result;
  DBUG_ENTER("handler::read_range_first");

4099
  eq_range= eq_range_arg;
4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112
  end_range= 0;
  if (end_key)
  {
    end_range= &save_end_range;
    save_end_range= *end_key;
    key_compare_result_on_equal= ((end_key->flag == HA_READ_BEFORE_KEY) ? 1 :
				  (end_key->flag == HA_READ_AFTER_KEY) ? -1 : 0);
  }
  range_key_part= table->key_info[active_index].key_part;

  if (!start_key)			// Read first record
    result= index_first(table->record[0]);
  else
4113 4114 4115 4116
    result= index_read_map(table->record[0],
                           start_key->key,
                           start_key->keypart_map,
                           start_key->flag);
4117
  if (result)
4118 4119 4120
    DBUG_RETURN((result == HA_ERR_KEY_NOT_FOUND) 
		? HA_ERR_END_OF_FILE
		: result);
4121 4122 4123 4124 4125

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


4126
/**
4127 4128
  Read next row between two ranges.

4129
  @note
4130 4131
    Record is read into table->record[0]

4132
  @retval
4133
    0			Found row
4134
  @retval
4135
    HA_ERR_END_OF_FILE	No rows in range
4136 4137
  @retval
    \#			Error code
4138
*/
4139
int handler::read_range_next()
4140 4141 4142 4143 4144
{
  int result;
  DBUG_ENTER("handler::read_range_next");

  if (eq_range)
4145 4146 4147 4148 4149 4150 4151
  {
    /* We trust that index_next_same always gives a row in range */
    DBUG_RETURN(index_next_same(table->record[0],
                                end_range->key,
                                end_range->length));
  }
  result= index_next(table->record[0]);
4152 4153 4154 4155 4156 4157
  if (result)
    DBUG_RETURN(result);
  DBUG_RETURN(compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
}


4158 4159
/**
  Compare if found key (in row) is over max-value.
4160

4161
  @param range		range to compare to row. May be 0 for no range
4162

4163 4164 4165 4166
  @seealso
    key.cc::key_cmp()

  @return
4167 4168
    The return value is SIGN(key_in_row - range_key):

4169 4170 4171
    - 0   : Key is equal to range or 'range' == 0 (no range)
    - -1  : Key is less than range
    - 1   : Key is larger than range
4172 4173 4174
*/
int handler::compare_key(key_range *range)
{
4175
  int cmp;
4176 4177
  if (!range)
    return 0;					// No max range
4178 4179 4180 4181
  cmp= key_cmp(range_key_part, range->key, range->length);
  if (!cmp)
    cmp= key_compare_result_on_equal;
  return cmp;
4182
}
4183

4184

4185 4186 4187
int handler::index_read_idx_map(uchar * buf, uint index, const uchar * key,
                                key_part_map keypart_map,
                                enum ha_rkey_function find_flag)
4188
{
4189 4190
  int error, error1;
  error= index_init(index, 0);
4191
  if (!error)
4192
  {
4193
    error= index_read_map(buf, key, keypart_map, find_flag);
4194 4195 4196
    error1= index_end();
  }
  return error ?  error : error1;
4197 4198
}

4199

4200
/**
4201 4202 4203
  Returns a list of all known extensions.

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

4207
  @retval
4208 4209
    pointer		pointer to TYPELIB structure
*/
antony@ppcg5.local's avatar
antony@ppcg5.local committed
4210
static my_bool exts_handlerton(THD *unused, plugin_ref plugin,
4211 4212 4213
                               void *arg)
{
  List<char> *found_exts= (List<char> *) arg;
antony@ppcg5.local's avatar
antony@ppcg5.local committed
4214
  handlerton *hton= plugin_data(plugin, handlerton *);
4215 4216
  handler *file;
  if (hton->state == SHOW_OPTION_YES && hton->create &&
4217
      (file= hton->create(hton, (TABLE_SHARE*) 0, current_thd->mem_root)))
4218 4219 4220
  {
    List_iterator_fast<char> it(*found_exts);
    const char **ext, *old_ext;
4221

4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238
    for (ext= file->bas_ext(); *ext; ext++)
    {
      while ((old_ext= it++))
      {
        if (!strcmp(old_ext, *ext))
	  break;
      }
      if (!old_ext)
        found_exts->push_back((char *) *ext);

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

4239 4240
TYPELIB *ha_known_exts(void)
{
4241
  if (!known_extensions.type_names || mysys_usage_id != known_extensions_id)
4242 4243
  {
    List<char> found_exts;
4244 4245 4246
    const char **ext, *old_ext;

    known_extensions_id= mysys_usage_id;
4247 4248
    found_exts.push_back((char*) TRG_EXT);
    found_exts.push_back((char*) TRN_EXT);
4249 4250

    plugin_foreach(NULL, exts_handlerton,
4251 4252
                   MYSQL_STORAGE_ENGINE_PLUGIN, &found_exts);

4253 4254 4255
    ext= (const char **) my_once_alloc(sizeof(char *)*
                                       (found_exts.elements+1),
                                       MYF(MY_WME | MY_FAE));
4256

4257
    DBUG_ASSERT(ext != 0);
4258 4259
    known_extensions.count= found_exts.elements;
    known_extensions.type_names= ext;
4260

4261
    List_iterator_fast<char> it(found_exts);
4262 4263 4264
    while ((old_ext= it++))
      *ext++= old_ext;
    *ext= 0;
4265 4266 4267
  }
  return &known_extensions;
}
heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
4268

4269

4270 4271 4272
static bool stat_print(THD *thd, const char *type, uint type_len,
                       const char *file, uint file_len,
                       const char *status, uint status_len)
4273 4274 4275
{
  Protocol *protocol= thd->protocol;
  protocol->prepare_for_resend();
4276 4277 4278
  protocol->store(type, type_len, system_charset_info);
  protocol->store(file, file_len, system_charset_info);
  protocol->store(status, status_len, system_charset_info);
4279 4280 4281 4282 4283
  if (protocol->write())
    return TRUE;
  return FALSE;
}

4284

antony@ppcg5.local's avatar
antony@ppcg5.local committed
4285
static my_bool showstat_handlerton(THD *thd, plugin_ref plugin,
4286 4287 4288
                                   void *arg)
{
  enum ha_stat_type stat= *(enum ha_stat_type *) arg;
antony@ppcg5.local's avatar
antony@ppcg5.local committed
4289
  handlerton *hton= plugin_data(plugin, handlerton *);
4290
  if (hton->state == SHOW_OPTION_YES && hton->show_status &&
4291
      hton->show_status(hton, thd, stat_print, stat))
4292 4293 4294 4295 4296
    return TRUE;
  return FALSE;
}

bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat)
4297 4298 4299
{
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
4300
  bool result;
4301 4302 4303 4304 4305 4306 4307 4308 4309

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

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

4310
  if (db_type == NULL)
4311
  {
4312
    result= plugin_foreach(thd, showstat_handlerton,
4313 4314 4315 4316 4317
                           MYSQL_STORAGE_ENGINE_PLUGIN, &stat);
  }
  else
  {
    if (db_type->state != SHOW_OPTION_YES)
4318
    {
serg@sergbook.mysql.com's avatar
serg@sergbook.mysql.com committed
4319 4320
      const LEX_STRING *name=&hton2plugin[db_type->slot]->name;
      result= stat_print(thd, name->str, name->length,
4321
                         "", 0, "DISABLED", 8) ? 1 : 0;
4322
    }
4323
    else
4324
      result= db_type->show_status &&
4325
              db_type->show_status(db_type, thd, stat_print, stat) ? 1 : 0;
4326 4327
  }

4328
  if (!result)
4329
    my_eof(thd);
4330
  return result;
4331 4332
}

4333 4334 4335 4336 4337
/*
  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:
4338
  - Row-based replication is enabled in the current thread
4339
  - The binlog is enabled
4340 4341 4342
  - It is not a temporary table
  - The binary log is open
  - The database the table resides in shall be binlogged (binlog_*_db rules)
4343
  - table is not mysql.event
4344 4345
*/

4346 4347 4348
static bool check_table_binlog_row_based(THD *thd, TABLE *table)
{
  if (table->s->cached_row_logging_check == -1)
4349
  {
4350 4351 4352 4353
    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;
  }
4354

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

4358 4359 4360 4361
  return (thd->current_stmt_binlog_row_based &&
          table->s->cached_row_logging_check &&
          (thd->options & OPTION_BIN_LOG) &&
          mysql_bin_log.is_open());
4362 4363 4364
}


4365
/** @brief
4366 4367 4368
   Write table maps for all (manually or automatically) locked tables
   to the binary log.

4369 4370 4371 4372 4373 4374 4375 4376 4377
   SYNOPSIS
     write_locked_table_maps()
       thd     Pointer to THD structure

   DESCRIPTION
       This function will generate and write table maps for all tables
       that are locked by the thread 'thd'.  Either manually locked
       (stored in THD::locked_tables) and automatically locked (stored
       in THD::lock) are considered.
4378

4379 4380 4381 4382 4383 4384 4385
   RETURN VALUE
       0   All OK
       1   Failed to write all table maps

   SEE ALSO
       THD::lock
       THD::locked_tables
4386
*/
4387

4388
static int write_locked_table_maps(THD *thd)
4389
{
4390 4391 4392 4393 4394
  DBUG_ENTER("write_locked_table_maps");
  DBUG_PRINT("enter", ("thd: 0x%lx  thd->lock: 0x%lx  thd->locked_tables: 0x%lx  "
                       "thd->extra_lock: 0x%lx",
                       (long) thd, (long) thd->lock,
                       (long) thd->locked_tables, (long) thd->extra_lock));
4395

4396 4397 4398 4399 4400 4401 4402
  if (thd->get_binlog_table_maps() == 0)
  {
    MYSQL_LOCK *locks[3];
    locks[0]= thd->extra_lock;
    locks[1]= thd->lock;
    locks[2]= thd->locked_tables;
    for (uint i= 0 ; i < sizeof(locks)/sizeof(*locks) ; ++i )
4403
    {
4404 4405 4406 4407 4408 4409 4410 4411
      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)
4412
      {
4413 4414 4415 4416
        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))
4417
        {
4418 4419 4420 4421 4422 4423 4424 4425
          int const has_trans= table->file->has_transactions();
          int const error= thd->binlog_write_table_map(table, has_trans);
          /*
            If an error occurs, it is the responsibility of the caller to
            roll back the transaction.
          */
          if (unlikely(error))
            DBUG_RETURN(1);
4426
        }
4427 4428 4429
      }
    }
  }
4430 4431
  DBUG_RETURN(0);
}
4432

4433 4434 4435 4436

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

4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447
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))
4448
  {
4449 4450 4451 4452 4453
    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;
4454

4455 4456 4457 4458 4459 4460 4461 4462 4463
    /*
      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))))
4464
    {
4465 4466 4467 4468 4469 4470 4471 4472
      bitmap_set_all(&cols);
      if (likely(!(error= write_locked_table_maps(thd))))
        error= (*log_func)(thd, table, table->file->has_transactions(),
                           &cols, table->s->fields,
                           before_record, after_record);

      if (!use_bitbuf)
        bitmap_free(&cols);
4473 4474
    }
  }
4475
  return error ? HA_ERR_RBR_LOGGING_FAILED : 0;
4476
}
4477

4478
int handler::ha_external_lock(THD *thd, int lock_type)
4479
{
4480
  DBUG_ENTER("handler::ha_external_lock");
4481 4482 4483 4484 4485 4486
  /*
    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);
4487 4488 4489 4490 4491 4492 4493 4494 4495

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

4498

4499
/** @brief
4500 4501 4502 4503 4504
  Check handler usage and reset state of file to after 'open'
*/
int handler::ha_reset()
{
  DBUG_ENTER("ha_reset");
4505
  /* Check that we have called all proper deallocation functions */
4506
  DBUG_ASSERT((uchar*) table->def_read_set.bitmap +
4507
              table->s->column_bitmap_size ==
4508
              (uchar*) table->def_write_set.bitmap);
4509 4510 4511 4512 4513 4514
  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);
4515 4516
  /* reset the bitmaps to point to defaults */
  table->default_column_bitmaps();
4517 4518 4519 4520
  DBUG_RETURN(reset());
}


4521
int handler::ha_write_row(uchar *buf)
4522 4523
{
  int error;
4524
  Log_func *log_func= Write_rows_log_event::binlog_row_logging_function;
4525
  DBUG_ENTER("handler::ha_write_row");
4526 4527 4528

  mark_trx_read_write();

4529
  if (unlikely(error= write_row(buf)))
4530
    DBUG_RETURN(error);
4531
  if (unlikely(error= binlog_log_row(table, 0, buf, log_func)))
4532 4533
    DBUG_RETURN(error); /* purecov: inspected */
  DBUG_RETURN(0);
4534 4535
}

4536

4537
int handler::ha_update_row(const uchar *old_data, uchar *new_data)
4538 4539
{
  int error;
4540
  Log_func *log_func= Update_rows_log_event::binlog_row_logging_function;
4541 4542 4543 4544 4545 4546 4547

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

4548 4549
  mark_trx_read_write();

4550 4551
  if (unlikely(error= update_row(old_data, new_data)))
    return error;
4552
  if (unlikely(error= binlog_log_row(table, old_data, new_data, log_func)))
4553 4554
    return error;
  return 0;
4555 4556
}

4557
int handler::ha_delete_row(const uchar *buf)
4558 4559
{
  int error;
4560
  Log_func *log_func= Delete_rows_log_event::binlog_row_logging_function;
4561 4562 4563

  mark_trx_read_write();

4564 4565
  if (unlikely(error= delete_row(buf)))
    return error;
4566
  if (unlikely(error= binlog_log_row(table, buf, 0, log_func)))
4567 4568
    return error;
  return 0;
4569
}
4570

4571

4572

4573
/** @brief
4574 4575 4576 4577 4578 4579 4580 4581 4582
  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();
}
4583 4584


4585
/** @brief
4586 4587 4588 4589 4590 4591 4592 4593 4594 4595
  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;
}

4596

4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613
#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 */

4614
  if ((*hton->create_iterator)(hton, HA_TRANSACTLOG_ITERATOR, &iterator) !=
4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643
      HA_ITERATOR_OK)
  {
    /* error during creation of log iterator or iterator is not supported */
    return 1;
  }
  while((*iterator.next)(&iterator, (void*)&data) == 0)
  {
    printf("%s\n", data.filename.str);
    if (data.status == HA_LOG_STATUS_FREE &&
        my_delete(data.filename.str, MYF(MY_WME)))
      goto err;
  }
  res= 0;
err:
  (*iterator.destroy)(&iterator);
  return res;
}


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


4644
/** @brief
4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683
  Dummy function to return log status should be replaced by function which
  really detect the log status and check that the file is a log of this
  handler.
*/
enum log_status fl_get_log_status(char *log)
{
  MY_STAT stat_buff;
  if (my_stat(log, &stat_buff, MYF(0)))
    return HA_LOG_STATUS_INUSE;
  return HA_LOG_STATUS_NOSUCHLOG;
}


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


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


void fl_log_iterator_destroy(struct handler_iterator *iterator)
{
4684
  my_free((uchar*)iterator->buffer, MYF(MY_ALLOW_ZERO_PTR));
4685 4686 4687
}


4688
/** @brief
4689 4690 4691 4692 4693 4694 4695 4696
  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;
4697
  uchar *ptr;
4698 4699 4700 4701 4702 4703 4704 4705 4706 4707
  FILEINFO *file;
  uint32 i;

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

  if (!(dirp = my_dir(fl_dir, MYF(0))))
  {
    return HA_ITERATOR_ERROR;
  }
4708
  if ((ptr= (uchar*)my_malloc(ALIGN_SIZE(sizeof(fl_buff)) +
4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 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 4753 4754 4755
                             ((ALIGN_SIZE(sizeof(LEX_STRING)) +
                               sizeof(enum log_status) +
                               + FN_REFLEN) *
                              (uint) dirp->number_off_files),
                             MYF(0))) == 0)
  {
    return HA_ITERATOR_ERROR;
  }
  buff= (struct fl_buff *)ptr;
  buff->entries= buff->current= 0;
  ptr= ptr + (ALIGN_SIZE(sizeof(fl_buff)));
  buff->names= (LEX_STRING*) (ptr);
  ptr= ptr + ((ALIGN_SIZE(sizeof(LEX_STRING)) *
               (uint) dirp->number_off_files));
  buff->statuses= (enum log_status *)(ptr);
  name_ptr= (char *)(ptr + (sizeof(enum log_status) *
                            (uint) dirp->number_off_files));
  for (i=0 ; i < (uint) dirp->number_off_files  ; i++)
  {
    enum log_status st;
    file= dirp->dir_entry + i;
    if ((file->name[0] == '.' &&
         ((file->name[1] == '.' && file->name[2] == '\0') ||
            file->name[1] == '\0')))
      continue;
    if ((st= fl_get_log_status(file->name)) == HA_LOG_STATUS_NOSUCHLOG)
      continue;
    name_ptr= strxnmov(buff->names[buff->entries].str= name_ptr,
                       FN_REFLEN, fl_dir, file->name, NullS);
    buff->names[buff->entries].length= (name_ptr -
                                        buff->names[buff->entries].str) - 1;
    buff->statuses[buff->entries]= st;
    buff->entries++;
  }

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


/* An example of a iterator creator */
enum handler_create_iterator_result
fl_create_iterator(enum handler_iterator_type type,
                   struct handler_iterator *iterator)
{
4756
  switch(type) {
4757 4758 4759 4760 4761 4762 4763
  case HA_TRANSACTLOG_ITERATOR:
    return fl_log_iterator_buffer_init(iterator);
  default:
    return HA_ITERATOR_UNSUPPORTED;
  }
}
#endif /*TRANS_LOG_MGM_EXAMPLE_CODE*/