handler.cc 66.5 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
unknown's avatar
unknown committed
2

unknown's avatar
unknown committed
3 4 5 6
   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
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
unknown's avatar
unknown committed
7

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

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


/* Handler-calling-functions */

#ifdef __GNUC__
#pragma implementation				// gcc: Class implementation
#endif

#include "mysql_priv.h"
#include "ha_heap.h"
#include "ha_myisam.h"
#include "ha_myisammrg.h"
#ifdef HAVE_BERKELEY_DB
#include "ha_berkeley.h"
#endif
31 32 33
#ifdef HAVE_BLACKHOLE_DB
#include "ha_blackhole.h"
#endif
34 35 36
#ifdef HAVE_EXAMPLE_DB
#include "examples/ha_example.h"
#endif
37 38 39
#ifdef HAVE_ARCHIVE_DB
#include "examples/ha_archive.h"
#endif
40 41 42
#ifdef HAVE_CSV_DB
#include "examples/ha_tina.h"
#endif
43
#ifdef HAVE_INNOBASE_DB
44
#include "ha_innodb.h"
45
#endif
unknown's avatar
unknown committed
46 47 48
#ifdef HAVE_NDBCLUSTER_DB
#include "ha_ndbcluster.h"
#endif
49 50 51
#ifdef HAVE_FEDERATED_DB
#include "ha_federated.h"
#endif
unknown's avatar
unknown committed
52 53 54 55 56
#include <myisampack.h>
#include <errno.h>

	/* static functions defined in this file */

57
static SHOW_COMP_OPTION have_yes= SHOW_OPTION_YES;
unknown's avatar
unknown committed
58

unknown's avatar
unknown committed
59
/* list of all available storage engines (of their handlertons) */
60
handlerton *handlertons[MAX_HA]={0};
unknown's avatar
unknown committed
61 62 63 64 65 66 67

/* number of entries in handlertons[] */
ulong total_ha;
/* number of storage engines (from handlertons[]) that support 2pc */
ulong total_ha_2pc;
/* size of savepoint storage area (see ha_init) */
ulong savepoint_alloc_size;
68

69
struct show_table_type_st sys_table_types[]=
unknown's avatar
unknown committed
70
{
71
  {"MyISAM",	&have_yes,
unknown's avatar
unknown committed
72
   "Default engine as of MySQL 3.23 with great performance", DB_TYPE_MYISAM},
73
  {"MEMORY",	&have_yes,
unknown's avatar
unknown committed
74
   "Hash based, stored in memory, useful for temporary tables", DB_TYPE_HEAP},
75 76
  {"HEAP",	&have_yes,
   "Alias for MEMORY", DB_TYPE_HEAP},
77 78 79 80 81
  {"MERGE",	&have_yes,
   "Collection of identical MyISAM tables", DB_TYPE_MRG_MYISAM},
  {"MRG_MYISAM",&have_yes,
   "Alias for MERGE", DB_TYPE_MRG_MYISAM},
  {"ISAM",	&have_isam,
unknown's avatar
unknown committed
82
   "Obsolete storage engine, now replaced by MyISAM", DB_TYPE_ISAM},
83
  {"MRG_ISAM",  &have_isam,
unknown's avatar
unknown committed
84
   "Obsolete storage engine, now replaced by MERGE", DB_TYPE_MRG_ISAM},
85
  {"InnoDB",	&have_innodb,
unknown's avatar
unknown committed
86
   "Supports transactions, row-level locking, and foreign keys", DB_TYPE_INNODB},
87 88 89 90 91 92
  {"INNOBASE",	&have_innodb,
   "Alias for INNODB", DB_TYPE_INNODB},
  {"BDB",	&have_berkeley_db,
   "Supports transactions and page-level locking", DB_TYPE_BERKELEY_DB},
  {"BERKELEYDB",&have_berkeley_db,
   "Alias for BDB", DB_TYPE_BERKELEY_DB},
unknown's avatar
unknown committed
93
  {"NDBCLUSTER", &have_ndbcluster,
unknown's avatar
unknown committed
94
   "Clustered, fault-tolerant, memory-based tables", DB_TYPE_NDBCLUSTER},
unknown's avatar
unknown committed
95 96
  {"NDB", &have_ndbcluster,
   "Alias for NDBCLUSTER", DB_TYPE_NDBCLUSTER},
97 98
  {"EXAMPLE",&have_example_db,
   "Example storage engine", DB_TYPE_EXAMPLE_DB},
99 100
  {"ARCHIVE",&have_archive_db,
   "Archive storage engine", DB_TYPE_ARCHIVE_DB},
101 102
  {"CSV",&have_csv_db,
   "CSV storage engine", DB_TYPE_CSV_DB},
103 104
  {"FEDERATED",&have_federated_db,
   "Federated MySQL storage engine", DB_TYPE_FEDERATED_DB},
105
  {"BLACKHOLE",&have_blackhole_db,
106 107
   "/dev/null storage engine (anything you write to it disappears)",
   DB_TYPE_BLACKHOLE_DB},
108
  {NullS, NULL, NullS, DB_TYPE_UNKNOWN}
unknown's avatar
unknown committed
109
};
110

unknown's avatar
unknown committed
111
const char *ha_row_type[] = {
112
  "", "FIXED", "DYNAMIC", "COMPRESSED", "REDUNDANT", "COMPACT", "?","?","?"
unknown's avatar
unknown committed
113 114
};

unknown's avatar
unknown committed
115
const char *tx_isolation_names[] =
116 117 118
{ "READ-UNCOMMITTED", "READ-COMMITTED", "REPEATABLE-READ", "SERIALIZABLE",
  NullS};
TYPELIB tx_isolation_typelib= {array_elements(tx_isolation_names)-1,"",
119
			       tx_isolation_names, NULL};
unknown's avatar
unknown committed
120

121
static TYPELIB known_extensions= {0,"known_exts", NULL, NULL};
122
uint known_extensions_id= 0;
123

124 125
enum db_type ha_resolve_by_name(const char *name, uint namelen)
{
126
  THD *thd= current_thd;
127 128
  if (thd && !my_strcasecmp(&my_charset_latin1, name, "DEFAULT")) {
    return (enum db_type) thd->variables.table_type;
129
  }
unknown's avatar
unknown committed
130

131 132 133 134
  show_table_type_st *types;
  for (types= sys_table_types; types->type; types++)
  {
    if (!my_strcasecmp(&my_charset_latin1, name, types->type))
135
      return (enum db_type) types->db_type;
136 137 138 139
  }
  return DB_TYPE_UNKNOWN;
}

unknown's avatar
unknown committed
140
const char *ha_get_storage_engine(enum db_type db_type)
141 142 143 144 145 146 147
{
  show_table_type_st *types;
  for (types= sys_table_types; types->type; types++)
  {
    if (db_type == types->db_type)
      return types->type;
  }
unknown's avatar
unknown committed
148

149 150 151
  return "none";
}

unknown's avatar
unknown committed
152

153
my_bool ha_storage_engine_is_enabled(enum db_type database_type)
unknown's avatar
unknown committed
154
{
155 156 157
  show_table_type_st *types;
  for (types= sys_table_types; types->type; types++)
  {
158
    if ((database_type == types->db_type) &&
unknown's avatar
unknown committed
159
	(*types->value == SHOW_OPTION_YES))
160
      return TRUE;
161
  }
162 163 164 165
  return FALSE;
}


unknown's avatar
unknown committed
166 167 168 169
	/* Use other database handler if databasehandler is not incompiled */

enum db_type ha_checktype(enum db_type database_type)
{
unknown's avatar
unknown committed
170
  THD *thd;
171 172
  if (ha_storage_engine_is_enabled(database_type))
    return database_type;
173

unknown's avatar
unknown committed
174 175 176
  switch (database_type) {
#ifndef NO_HASH
  case DB_TYPE_HASH:
177
    return (database_type);
178
#endif
179 180
  case DB_TYPE_MRG_ISAM:
    return (DB_TYPE_MRG_MYISAM);
unknown's avatar
unknown committed
181 182 183
  default:
    break;
  }
184
  
unknown's avatar
unknown committed
185
  thd= current_thd;
186 187
  return ((enum db_type) thd->variables.table_type != DB_TYPE_UNKNOWN ?
          (enum db_type) thd->variables.table_type :
188 189 190 191
          ((enum db_type) global_system_variables.table_type !=
           DB_TYPE_UNKNOWN ?
           (enum db_type) global_system_variables.table_type : DB_TYPE_MYISAM)
          );
unknown's avatar
unknown committed
192 193 194 195 196 197 198
} /* ha_checktype */


handler *get_new_handler(TABLE *table, enum db_type db_type)
{
  switch (db_type) {
#ifndef NO_HASH
199 200
  case DB_TYPE_HASH:
    return new ha_hash(table);
unknown's avatar
unknown committed
201
#endif
202
#ifdef HAVE_ISAM
unknown's avatar
unknown committed
203 204 205 206
  case DB_TYPE_MRG_ISAM:
    return new ha_isammrg(table);
  case DB_TYPE_ISAM:
    return new ha_isam(table);
207 208 209
#else
  case DB_TYPE_MRG_ISAM:
    return new ha_myisammrg(table);
unknown's avatar
unknown committed
210 211 212 213
#endif
#ifdef HAVE_BERKELEY_DB
  case DB_TYPE_BERKELEY_DB:
    return new ha_berkeley(table);
214 215
#endif
#ifdef HAVE_INNOBASE_DB
216
  case DB_TYPE_INNODB:
217
    return new ha_innobase(table);
218 219 220 221
#endif
#ifdef HAVE_EXAMPLE_DB
  case DB_TYPE_EXAMPLE_DB:
    return new ha_example(table);
222
#endif
223 224 225
#ifdef HAVE_ARCHIVE_DB
  case DB_TYPE_ARCHIVE_DB:
    return new ha_archive(table);
unknown's avatar
Merge  
unknown committed
226
#endif
227 228 229 230
#ifdef HAVE_BLACKHOLE_DB
  case DB_TYPE_BLACKHOLE_DB:
    return new ha_blackhole(table);
#endif
231 232 233 234
#ifdef HAVE_FEDERATED_DB
  case DB_TYPE_FEDERATED_DB:
    return new ha_federated(table);
#endif
235 236 237 238
#ifdef HAVE_CSV_DB
  case DB_TYPE_CSV_DB:
    return new ha_tina(table);
#endif
unknown's avatar
unknown committed
239 240 241
#ifdef HAVE_NDBCLUSTER_DB
  case DB_TYPE_NDBCLUSTER:
    return new ha_ndbcluster(table);
unknown's avatar
unknown committed
242 243 244 245
#endif
  case DB_TYPE_HEAP:
    return new ha_heap(table);
  default:					// should never happen
246 247 248 249 250 251 252 253
  {
    enum db_type def=(enum db_type) current_thd->variables.table_type;
    /* Try first with 'default table type' */
    if (db_type != def)
      return get_new_handler(table, def);
  }
  /* Fall back to MyISAM */
  case DB_TYPE_MYISAM:
unknown's avatar
unknown committed
254 255 256 257 258 259
    return new ha_myisam(table);
  case DB_TYPE_MRG_MYISAM:
    return new ha_myisammrg(table);
  }
}

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
/*
  Register handler error messages for use with my_error().

  SYNOPSIS
    ha_init_errors()

  RETURN
    0           OK
    != 0        Error
*/

static int ha_init_errors(void)
{
#define SETMSG(nr, msg) errmsgs[(nr) - HA_ERR_FIRST]= (msg)
  const char    **errmsgs;

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

  /* Set the dedicated error messages. */
  SETMSG(HA_ERR_KEY_NOT_FOUND,          ER(ER_KEY_NOT_FOUND));
  SETMSG(HA_ERR_FOUND_DUPP_KEY,         ER(ER_DUP_KEY));
  SETMSG(HA_ERR_RECORD_CHANGED,         "Update wich is recoverable");
  SETMSG(HA_ERR_WRONG_INDEX,            "Wrong index given to function");
  SETMSG(HA_ERR_CRASHED,                ER(ER_NOT_KEYFILE));
  SETMSG(HA_ERR_WRONG_IN_RECORD,        ER(ER_CRASHED_ON_USAGE));
  SETMSG(HA_ERR_OUT_OF_MEM,             "Table handler out of memory");
  SETMSG(HA_ERR_NOT_A_TABLE,            "Incorrect file format '%.64s'");
  SETMSG(HA_ERR_WRONG_COMMAND,          "Command not supported");
  SETMSG(HA_ERR_OLD_FILE,               ER(ER_OLD_KEYFILE));
  SETMSG(HA_ERR_NO_ACTIVE_RECORD,       "No record read in update");
  SETMSG(HA_ERR_RECORD_DELETED,         "Intern record deleted");
  SETMSG(HA_ERR_RECORD_FILE_FULL,       ER(ER_RECORD_FILE_FULL));
  SETMSG(HA_ERR_INDEX_FILE_FULL,        "No more room in index file '%.64s'");
  SETMSG(HA_ERR_END_OF_FILE,            "End in next/prev/first/last");
  SETMSG(HA_ERR_UNSUPPORTED,            ER(ER_ILLEGAL_HA));
  SETMSG(HA_ERR_TO_BIG_ROW,             "Too big row");
  SETMSG(HA_WRONG_CREATE_OPTION,        "Wrong create option");
  SETMSG(HA_ERR_FOUND_DUPP_UNIQUE,      ER(ER_DUP_UNIQUE));
  SETMSG(HA_ERR_UNKNOWN_CHARSET,        "Can't open charset");
  SETMSG(HA_ERR_WRONG_MRG_TABLE_DEF,    ER(ER_WRONG_MRG_TABLE));
  SETMSG(HA_ERR_CRASHED_ON_REPAIR,      ER(ER_CRASHED_ON_REPAIR));
  SETMSG(HA_ERR_CRASHED_ON_USAGE,       ER(ER_CRASHED_ON_USAGE));
  SETMSG(HA_ERR_LOCK_WAIT_TIMEOUT,      ER(ER_LOCK_WAIT_TIMEOUT));
  SETMSG(HA_ERR_LOCK_TABLE_FULL,        ER(ER_LOCK_TABLE_FULL));
  SETMSG(HA_ERR_READ_ONLY_TRANSACTION,  ER(ER_READ_ONLY_TRANSACTION));
  SETMSG(HA_ERR_LOCK_DEADLOCK,          ER(ER_LOCK_DEADLOCK));
  SETMSG(HA_ERR_CANNOT_ADD_FOREIGN,     ER(ER_CANNOT_ADD_FOREIGN));
  SETMSG(HA_ERR_NO_REFERENCED_ROW,      ER(ER_NO_REFERENCED_ROW));
  SETMSG(HA_ERR_ROW_IS_REFERENCED,      ER(ER_ROW_IS_REFERENCED));
  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");
318
  SETMSG(HA_ERR_TABLE_DEF_CHANGED,      ER(ER_TABLE_DEF_CHANGED));
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345

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


/*
  Unregister handler error messages.

  SYNOPSIS
    ha_finish_errors()

  RETURN
    0           OK
    != 0        Error
*/

static int ha_finish_errors(void)
{
  const char    **errmsgs;

  /* Allocate a pointer array for the error message strings. */
  if (! (errmsgs= my_error_unregister(HA_ERR_FIRST, HA_ERR_LAST)))
    return 1;
  my_free((gptr) errmsgs, MYF(0));
  return 0;
}
unknown's avatar
unknown committed
346

347

348 349 350 351 352 353 354 355 356
static inline void ha_was_inited_ok(handlerton **ht)
{
  uint tmp= (*ht)->savepoint_offset;
  (*ht)->savepoint_offset= savepoint_alloc_size;
  savepoint_alloc_size+= tmp;
  (*ht)->slot= total_ha++;
  if ((*ht)->prepare)
    total_ha_2pc++;
}
357

unknown's avatar
unknown committed
358 359
int ha_init()
{
360
  int error= 0;
361 362 363
  handlerton **ht= handlertons;
  total_ha= savepoint_alloc_size= 0;

364 365
  if (ha_init_errors())
    return 1;
unknown's avatar
unknown committed
366

367 368
  if (opt_bin_log)
  {
unknown's avatar
unknown committed
369
    if (!(*ht= binlog_init()))                  // Always succeed
370
    {
unknown's avatar
unknown committed
371 372 373
      mysql_bin_log.close(LOG_CLOSE_INDEX);     // Never used
      opt_bin_log= 0;                           // Never used
      error= 1;                                 // Never used
374 375 376 377
    }
    else
      ha_was_inited_ok(ht++);
  }
unknown's avatar
unknown committed
378
#ifdef HAVE_BERKELEY_DB
379
  if (have_berkeley_db == SHOW_OPTION_YES)
unknown's avatar
unknown committed
380
  {
381
    if (!(*ht= berkeley_init()))
382 383 384 385
    {
      have_berkeley_db= SHOW_OPTION_DISABLED;	// If we couldn't use handler
      error= 1;
    }
386
    else
387
      ha_was_inited_ok(ht++);
unknown's avatar
unknown committed
388
  }
389 390
#endif
#ifdef HAVE_INNOBASE_DB
391
  if (have_innodb == SHOW_OPTION_YES)
392
  {
393
    if (!(*ht= innobase_init()))
394 395 396 397
    {
      have_innodb= SHOW_OPTION_DISABLED;	// If we couldn't use handler
      error= 1;
    }
398
    else
399
      ha_was_inited_ok(ht++);
400
  }
unknown's avatar
unknown committed
401 402 403 404
#endif
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
  {
405
    if (!(*ht= ndbcluster_init()))
unknown's avatar
unknown committed
406 407 408 409 410
    {
      have_ndbcluster= SHOW_OPTION_DISABLED;
      error= 1;
    }
    else
411
      ha_was_inited_ok(ht++);
unknown's avatar
unknown committed
412
  }
413
#endif
unknown's avatar
unknown committed
414 415 416 417 418 419 420 421 422 423
#ifdef HAVE_FEDERATED_DB
  if (have_federated_db == SHOW_OPTION_YES)
  {
    if (federated_db_init())
    {
      have_federated_db= SHOW_OPTION_DISABLED;
      error= 1;
    }
  }
#endif
424 425 426
#ifdef HAVE_ARCHIVE_DB
  if (have_archive_db == SHOW_OPTION_YES)
  {
unknown's avatar
unknown committed
427
    if (!(*ht= archive_db_init()))
428 429 430 431
    {
      have_archive_db= SHOW_OPTION_DISABLED;
      error= 1;
    }
unknown's avatar
unknown committed
432 433
    else
      ha_was_inited_ok(ht++);
434
  }
unknown's avatar
unknown committed
435
#endif
436
  DBUG_ASSERT(total_ha < MAX_HA);
437 438 439 440 441 442
  /*
    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;
443
  savepoint_alloc_size+= sizeof(SAVEPOINT);
444
  return error;
unknown's avatar
unknown committed
445 446 447 448 449 450 451 452 453 454 455
}

	/* close, flush or restart databases */
	/* Ignore this for other databases than ours */

int ha_panic(enum ha_panic_function flag)
{
  int error=0;
#ifndef NO_HASH
  error|=h_panic(flag);			/* fix hash */
#endif
456 457
#ifdef HAVE_ISAM
  error|=mrg_panic(flag);
unknown's avatar
unknown committed
458
  error|=nisam_panic(flag);
459 460
#endif
  error|=heap_panic(flag);
unknown's avatar
unknown committed
461 462 463
  error|=mi_panic(flag);
  error|=myrg_panic(flag);
#ifdef HAVE_BERKELEY_DB
464
  if (have_berkeley_db == SHOW_OPTION_YES)
unknown's avatar
unknown committed
465
    error|=berkeley_end();
466 467
#endif
#ifdef HAVE_INNOBASE_DB
468
  if (have_innodb == SHOW_OPTION_YES)
469
    error|=innobase_end();
unknown's avatar
unknown committed
470 471 472 473
#endif
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
    error|=ndbcluster_end();
474
#endif
unknown's avatar
unknown committed
475 476 477 478
#ifdef HAVE_FEDERATED_DB
  if (have_federated_db == SHOW_OPTION_YES)
    error|= federated_db_end();
#endif
479 480 481
#ifdef HAVE_ARCHIVE_DB
  if (have_archive_db == SHOW_OPTION_YES)
    error|= archive_db_end();
unknown's avatar
unknown committed
482
#endif
483 484
  if (ha_finish_errors())
    error= 1;
unknown's avatar
unknown committed
485 486 487
  return error;
} /* ha_panic */

488 489 490
void ha_drop_database(char* path)
{
#ifdef HAVE_INNOBASE_DB
491
  if (have_innodb == SHOW_OPTION_YES)
492 493
    innobase_drop_database(path);
#endif
unknown's avatar
unknown committed
494 495 496 497
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
    ndbcluster_drop_database(path);
#endif
498
}
unknown's avatar
unknown committed
499

500
/* don't bother to rollback here, it's done already */
501 502
void ha_close_connection(THD* thd)
{
503 504 505 506 507 508 509 510
  for (uint i=0; i < total_ha; i++)
    if (thd->ha_data[i])
      (*handlertons[i]->close_connection)(thd);
}

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

unknown's avatar
unknown committed
511 512 513 514 515 516 517 518 519
/*
  Register a storage engine for a transaction

  DESCRIPTION
    Every storage engine MUST call this function when it starts
    a transaction or a statement (that is it must be called both for the
    "beginning of transaction" and "beginning of statement").
    Only storage engines registered for the transaction/statement
    will know when to commit/rollback it.
520 521 522 523 524

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

unknown's avatar
unknown committed
525
*/
526 527 528
void trans_register_ha(THD *thd, bool all, handlerton *ht_arg)
{
  THD_TRANS *trans;
529
  handlerton **ht;
unknown's avatar
unknown committed
530 531 532
  DBUG_ENTER("trans_register_ha");
  DBUG_PRINT("enter",("%s", all ? "all" : "stmt"));

533 534 535 536 537 538 539 540
  if (all)
  {
    trans= &thd->transaction.all;
    thd->server_status|= SERVER_STATUS_IN_TRANS;
  }
  else
    trans= &thd->transaction.stmt;

541
  for (ht=trans->ht; *ht; ht++)
unknown's avatar
unknown committed
542 543 544
    if (*ht == ht_arg)
      DBUG_VOID_RETURN;  /* already registered, return */

545
  trans->ht[trans->nht++]=ht_arg;
546
  DBUG_ASSERT(*ht == ht_arg);
547 548 549
  trans->no_2pc|=(ht_arg->prepare==0);
  if (thd->transaction.xid.is_null())
    thd->transaction.xid.set(thd->query_id);
unknown's avatar
unknown committed
550
  DBUG_VOID_RETURN;
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
}

/*
  RETURN
      0  - ok
      1  - error, transaction was rolled back
*/
int ha_prepare(THD *thd)
{
  int error=0, all=1;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
  handlerton **ht=trans->ht;
  DBUG_ENTER("ha_prepare");
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
    for (; *ht; ht++)
    {
      int err;
      statistic_increment(thd->status_var.ha_prepare_count,&LOCK_status);
      if ((err= (*(*ht)->prepare)(thd, all)))
      {
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
        ha_rollback_trans(thd, all);
        error=1;
        break;
      }
    }
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

/*
  RETURN
      0  - ok
      1  - transaction was rolled back
      2  - error during commit, data may be inconsistent
*/
int ha_commit_trans(THD *thd, bool all)
{
  int error= 0, cookie= 0;
  THD_TRANS *trans= all ? &thd->transaction.all : &thd->transaction.stmt;
  bool is_real_trans= all || thd->transaction.all.nht == 0;
  handlerton **ht= trans->ht;
unknown's avatar
unknown committed
596
  my_xid xid= thd->transaction.xid.get_my_xid();
597 598 599 600
  DBUG_ENTER("ha_commit_trans");
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
601 602 603 604 605
    if (is_real_trans && wait_if_global_read_lock(thd, 0, 0))
    {
      ha_rollback_trans(thd, all);
      DBUG_RETURN(1);
    }
606
    DBUG_EXECUTE_IF("crash_commit_before", abort(););
607 608 609 610 611 612 613 614
    if (!trans->no_2pc && trans->nht > 1)
    {
      for (; *ht && !error; ht++)
      {
        int err;
        if ((err= (*(*ht)->prepare)(thd, all)))
        {
          my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
615
          error= 1;
616 617 618
        }
        statistic_increment(thd->status_var.ha_prepare_count,&LOCK_status);
      }
619
      DBUG_EXECUTE_IF("crash_commit_after_prepare", abort(););
unknown's avatar
unknown committed
620 621
      if (error || (is_real_trans && xid &&
                    (error= !(cookie= tc_log->log(thd, xid)))))
622 623
      {
        ha_rollback_trans(thd, all);
624 625
        error= 1;
        goto end;
626
      }
627
      DBUG_EXECUTE_IF("crash_commit_after_log", abort(););
628 629
    }
    error=ha_commit_one_phase(thd, all) ? cookie ? 2 : 1 : 0;
630
    DBUG_EXECUTE_IF("crash_commit_before_unlog", abort(););
631
    if (cookie)
unknown's avatar
unknown committed
632
      tc_log->unlog(cookie, xid);
633
    DBUG_EXECUTE_IF("crash_commit_after", abort(););
634 635 636
end:
    if (is_real_trans)
      start_waiting_global_read_lock(thd);
637 638 639 640 641
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

642 643 644 645
/*
  NOTE - this function does not care about global read lock.
  A caller should.
*/
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
int ha_commit_one_phase(THD *thd, bool all)
{
  int error=0;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
  bool is_real_trans=all || thd->transaction.all.nht == 0;
  handlerton **ht=trans->ht;
  DBUG_ENTER("ha_commit_one_phase");
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
    for (ht=trans->ht; *ht; ht++)
    {
      int err;
      if ((err= (*(*ht)->commit)(thd, all)))
      {
        my_error(ER_ERROR_DURING_COMMIT, MYF(0), err);
        error=1;
      }
      statistic_increment(thd->status_var.ha_commit_count,&LOCK_status);
      *ht= 0;
    }
    trans->nht=0;
    trans->no_2pc=0;
    if (is_real_trans)
      thd->transaction.xid.null();
    if (all)
    {
#ifdef HAVE_QUERY_CACHE
      if (thd->transaction.changed_tables)
        query_cache.invalidate(thd->transaction.changed_tables);
unknown's avatar
unknown committed
676
#endif
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
      thd->variables.tx_isolation=thd->session_tx_isolation;
      thd->transaction.cleanup();
    }
  }
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}


int ha_rollback_trans(THD *thd, bool all)
{
  int error=0;
  THD_TRANS *trans=all ? &thd->transaction.all : &thd->transaction.stmt;
  bool is_real_trans=all || thd->transaction.all.nht == 0;
  DBUG_ENTER("ha_rollback_trans");
#ifdef USING_TRANSACTIONS
  if (trans->nht)
  {
    for (handlerton **ht=trans->ht; *ht; ht++)
    {
      int err;
      if ((err= (*(*ht)->rollback)(thd, all)))
      { // cannot happen
        my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
        error=1;
      }
      statistic_increment(thd->status_var.ha_rollback_count,&LOCK_status);
      *ht= 0;
    }
    trans->nht=0;
    trans->no_2pc=0;
    if (is_real_trans)
      thd->transaction.xid.null();
    if (all)
    {
      thd->variables.tx_isolation=thd->session_tx_isolation;
      thd->transaction.cleanup();
    }
  }
#endif /* USING_TRANSACTIONS */
  /*
    If a non-transactional table was updated, warn; don't warn if this is a
    slave thread (because when a slave thread executes a ROLLBACK, it has
    been read from the binary log, so it's 100% sure and normal to produce
    error ER_WARNING_NOT_COMPLETE_ROLLBACK. If we sent the warning to the
    slave SQL thread, it would not stop the thread but just be printed in
    the error log; but we don't want users to wonder why they have this
    message in the error log, so we don't send it.
  */
  if (is_real_trans && (thd->options & OPTION_STATUS_NO_TRANS_UPDATE) &&
      !thd->slave_thread)
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                 ER_WARNING_NOT_COMPLETE_ROLLBACK,
                 ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
  DBUG_RETURN(error);
732 733
}

734
/*
unknown's avatar
unknown committed
735
  This is used to commit or rollback a single statement depending on the value
unknown's avatar
unknown committed
736 737 738 739 740
  of error. Note that if the autocommit is on, then the following call inside
  InnoDB will commit or rollback the whole transaction (= the statement). The
  autocommit mechanism built into InnoDB is based on counting locks, but if
  the user has used LOCK TABLES then that mechanism does not know to do the
  commit.
741 742
*/

unknown's avatar
unknown committed
743 744 745
int ha_autocommit_or_rollback(THD *thd, int error)
{
  DBUG_ENTER("ha_autocommit_or_rollback");
746
#ifdef USING_TRANSACTIONS
747
  if (thd->transaction.stmt.nht)
unknown's avatar
unknown committed
748
  {
749 750 751 752 753 754 755
    if (!error)
    {
      if (ha_commit_stmt(thd))
	error=1;
    }
    else
      (void) ha_rollback_stmt(thd);
unknown's avatar
unknown committed
756

unknown's avatar
unknown committed
757
    thd->variables.tx_isolation=thd->session_tx_isolation;
unknown's avatar
unknown committed
758 759 760 761 762
  }
#endif
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
763
int ha_commit_or_rollback_by_xid(XID *xid, bool commit)
764 765 766 767 768 769 770
{
  handlerton **ht= handlertons, **end_ht=ht+total_ha;
  int res= 1;

  for ( ; ht < end_ht ; ht++)
    if ((*ht)->recover)
      res= res &&
unknown's avatar
unknown committed
771
        (*(commit ? (*ht)->commit_by_xid : (*ht)->rollback_by_xid))(xid);
772 773
  return res;
}
unknown's avatar
unknown committed
774

unknown's avatar
unknown committed
775 776 777 778 779 780 781 782 783 784
#ifndef DBUG_OFF
/* this does not need to be multi-byte safe or anything */
static char* xid_to_str(char *buf, XID *xid)
{
  int i;
  char *s=buf;
  *s++='\'';
  for (i=0; i < xid->gtrid_length+xid->bqual_length; i++)
  {
    uchar c=(uchar)xid->data[i];
unknown's avatar
unknown committed
785 786
    /* is_next_dig is set if next character is a number */
    bool is_next_dig= FALSE;
unknown's avatar
unknown committed
787 788
    if (i < XIDDATASIZE)
    {
unknown's avatar
unknown committed
789 790
      char ch= xid->data[i+1];
      is_next_dig= (ch >= '0' && ch <='9');
unknown's avatar
unknown committed
791
    }
unknown's avatar
unknown committed
792 793 794 795 796 797 798 799 800 801 802 803
    if (i == xid->gtrid_length)
    {
      *s++='\'';
      if (xid->bqual_length)
      {
        *s++='.';
        *s++='\'';
      }
    }
    if (c < 32 || c > 126)
    {
      *s++='\\';
unknown's avatar
unknown committed
804 805 806 807 808
      /*
        If next character is a number, write current character with
        3 octal numbers to ensure that the next number is not seen
        as part of the octal number
      */
unknown's avatar
unknown committed
809 810 811 812 813
      if (c > 077 || is_next_dig)
        *s++=_dig_vec_lower[c >> 6];
      if (c > 007 || is_next_dig)
        *s++=_dig_vec_lower[(c >> 3) & 7];
      *s++=_dig_vec_lower[c & 7];
unknown's avatar
unknown committed
814 815 816 817 818 819 820 821 822 823 824 825 826 827
    }
    else
    {
      if (c == '\'' || c == '\\')
        *s++='\\';
      *s++=c;
    }
  }
  *s++='\'';
  *s=0;
  return buf;
}
#endif

828 829
/*
  recover() step of xa
unknown's avatar
unknown committed
830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845

  NOTE
   there are three modes of operation:

   - automatic recover after a crash
     in this case commit_list != 0, tc_heuristic_recover==0
     all xids from commit_list are committed, others are rolled back

   - manual (heuristic) recover
     in this case commit_list==0, tc_heuristic_recover != 0
     DBA has explicitly specified that all prepared transactions should
     be committed (or rolled back).

   - no recovery (MySQL did not detect a crash)
     in this case commit_list==0, tc_heuristic_recover == 0
     there should be no prepared transactions in this case.
unknown's avatar
unknown committed
846
*/
847
int ha_recover(HASH *commit_list)
848
{
unknown's avatar
unknown committed
849
  int len, got, found_foreign_xids=0, found_my_xids=0;
850 851
  handlerton **ht= handlertons, **end_ht=ht+total_ha;
  XID *list=0;
unknown's avatar
unknown committed
852
  bool dry_run=(commit_list==0 && tc_heuristic_recover==0);
853 854
  DBUG_ENTER("ha_recover");

unknown's avatar
unknown committed
855 856 857
  /* commit_list and tc_heuristic_recover cannot be set both */
  DBUG_ASSERT(commit_list==0 || tc_heuristic_recover==0);
  /* if either is set, total_ha_2pc must be set too */
858
  DBUG_ASSERT(dry_run || total_ha_2pc>(ulong)opt_bin_log);
unknown's avatar
unknown committed
859

860
  if (total_ha_2pc <= (ulong)opt_bin_log)
unknown's avatar
unknown committed
861 862
    DBUG_RETURN(0);

unknown's avatar
unknown committed
863 864 865
  if (commit_list)
    sql_print_information("Starting crash recovery...");

unknown's avatar
unknown committed
866 867 868 869 870
#ifndef WILL_BE_DELETED_LATER
  /*
    for now, only InnoDB supports 2pc. It means we can always safely
    rollback all pending transactions, without risking inconsistent data
  */
unknown's avatar
unknown committed
871
  DBUG_ASSERT(total_ha_2pc == (ulong) opt_bin_log+1); // only InnoDB and binlog
unknown's avatar
unknown committed
872 873 874
  tc_heuristic_recover= TC_HEURISTIC_RECOVER_ROLLBACK; // forcing ROLLBACK
  dry_run=FALSE;
#endif
875

876
  for (len= MAX_XID_LIST_SIZE ; list==0 && len > MIN_XID_LIST_SIZE; len/=2)
877
  {
878 879 880 881
    list=(XID *)my_malloc(len*sizeof(XID), MYF(0));
  }
  if (!list)
  {
unknown's avatar
unknown committed
882
    sql_print_error(ER(ER_OUTOFMEMORY), len*sizeof(XID));
883 884 885 886 887 888 889 890
    DBUG_RETURN(1);
  }

  for ( ; ht < end_ht ; ht++)
  {
    if (!(*ht)->recover)
      continue;
    while ((got=(*(*ht)->recover)(list, len)) > 0 )
891
    {
unknown's avatar
unknown committed
892 893
      sql_print_information("Found %d prepared transaction(s) in %s",
                            got, (*ht)->name);
894 895 896 897
      for (int i=0; i < got; i ++)
      {
        my_xid x=list[i].get_my_xid();
        if (!x) // not "mine" - that is generated by external TM
unknown's avatar
unknown committed
898
        {
unknown's avatar
unknown committed
899 900 901 902
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
          sql_print_information("ignore xid %s", xid_to_str(buf, list+i));
#endif
unknown's avatar
unknown committed
903 904 905 906 907 908
          found_foreign_xids++;
          continue;
        }
        if (dry_run)
        {
          found_my_xids++;
909
          continue;
unknown's avatar
unknown committed
910 911
        }
        // recovery mode
912
        if (commit_list ?
unknown's avatar
unknown committed
913
            hash_search(commit_list, (byte *)&x, sizeof(x)) != 0 :
914
            tc_heuristic_recover == TC_HEURISTIC_RECOVER_COMMIT)
unknown's avatar
unknown committed
915 916 917 918 919
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
          sql_print_information("commit xid %s", xid_to_str(buf, list+i));
#endif
920
          (*(*ht)->commit_by_xid)(list+i);
unknown's avatar
unknown committed
921
        }
922
        else
unknown's avatar
unknown committed
923 924 925 926 927
        {
#ifndef DBUG_OFF
          char buf[XIDDATASIZE*4+6]; // see xid_to_str
          sql_print_information("rollback xid %s", xid_to_str(buf, list+i));
#endif
928
          (*(*ht)->rollback_by_xid)(list+i);
unknown's avatar
unknown committed
929
        }
930 931 932
      }
      if (got < len)
        break;
933 934
    }
  }
935
  my_free((gptr)list, MYF(0));
unknown's avatar
unknown committed
936 937 938 939 940 941 942 943 944 945 946 947 948
  if (found_foreign_xids)
    sql_print_warning("Found %d prepared XA transactions", found_foreign_xids);
  if (dry_run && found_my_xids)
  {
    sql_print_error("Found %d prepared transactions! It means that mysqld was "
                    "not shut down properly last time and critical recovery "
                    "information (last binlog or %s file) was manually deleted "
                    "after a crash. You have to start mysqld with "
                    "--tc-heuristic-recover switch to commit or rollback "
                    "pending transactions.",
                    found_my_xids, opt_tc_log_file);
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
949 950
  if (commit_list)
    sql_print_information("Crash recovery finished.");
951
  DBUG_RETURN(0);
952
}
953

unknown's avatar
unknown committed
954
/*
955
  return the list of XID's to a client, the same way SHOW commands do
unknown's avatar
unknown committed
956

957 958 959 960
  NOTE
    I didn't find in XA specs that an RM cannot return the same XID twice,
    so mysql_xa_recover does not filter XID's to ensure uniqueness.
    It can be easily fixed later, if necessary.
unknown's avatar
unknown committed
961
*/
962
bool mysql_xa_recover(THD *thd)
unknown's avatar
unknown committed
963
{
964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981
  List<Item> field_list;
  Protocol *protocol= thd->protocol;
  handlerton **ht= handlertons, **end_ht=ht+total_ha;
  bool error=TRUE;
  int len, got;
  XID *list=0;
  DBUG_ENTER("mysql_xa_recover");

  field_list.push_back(new Item_int("formatID",0,11));
  field_list.push_back(new Item_int("gtrid_length",0,11));
  field_list.push_back(new Item_int("bqual_length",0,11));
  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(TRUE);

  for (len= MAX_XID_LIST_SIZE ; list==0 && len > MIN_XID_LIST_SIZE; len/=2)
unknown's avatar
unknown committed
982
  {
983 984 985
    list=(XID *)my_malloc(len*sizeof(XID), MYF(0));
  }
  if (!list)
unknown's avatar
unknown committed
986
  {
987 988 989
    my_error(ER_OUTOFMEMORY, MYF(0), len);
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
990

991 992 993 994 995 996 997 998 999 1000 1001 1002
  for ( ; ht < end_ht ; ht++)
  {
    if (!(*ht)->recover)
      continue;
    while ((got=(*(*ht)->recover)(list, len)) > 0 )
    {
      XID *xid, *end;
      for (xid=list, end=list+got; xid < end; xid++)
      {
        if (xid->get_my_xid())
          continue; // skip "our" xids
        protocol->prepare_for_resend();
unknown's avatar
unknown committed
1003 1004 1005
        protocol->store_longlong((longlong)xid->formatID, FALSE);
        protocol->store_longlong((longlong)xid->gtrid_length, FALSE);
        protocol->store_longlong((longlong)xid->bqual_length, FALSE);
1006 1007 1008 1009 1010 1011 1012 1013
        protocol->store(xid->data, xid->gtrid_length+xid->bqual_length,
                        &my_charset_bin);
        if (protocol->write())
          goto err;
      }
      if (got < len)
        break;
    }
unknown's avatar
unknown committed
1014
  }
1015 1016 1017 1018 1019 1020

  error=FALSE;
  send_eof(thd);
err:
  my_free((gptr)list, MYF(0));
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1021
}
1022

1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
/*
  This function should be called when MySQL sends rows of a SELECT result set
  or the EOF mark to the client. It releases a possible adaptive hash index
  S-latch held by thd in InnoDB and also releases a possible InnoDB query
  FIFO ticket to enter InnoDB. To save CPU time, InnoDB allows a thd to
  keep them over several calls of the InnoDB handler interface when a join
  is executed. But when we let the control to pass to the client they have
  to be released because if the application program uses mysql_use_result(),
  it may deadlock on the S-latch if the application on another connection
  performs another SQL query. In MySQL-4.1 this is even more important because
  there a connection can have several SELECT queries open at the same time.

  arguments:
  thd:           the thread handle of the current connection
  return value:  always 0
*/

int ha_release_temporary_latches(THD *thd)
{
#ifdef HAVE_INNOBASE_DB
1043 1044
  if (opt_innodb)
    innobase_release_temporary_latches(thd);
1045 1046 1047 1048
#endif
  return 0;
}

1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063

/* 
  Export statistics for different engines. Currently we use it only for
  InnoDB.
*/

int ha_update_statistics()
{
#ifdef HAVE_INNOBASE_DB
  if (opt_innodb)
    innodb_export_status();
#endif
  return 0;
}

1064
int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1065 1066
{
  int error=0;
1067 1068 1069 1070
  THD_TRANS *trans=&thd->transaction.all;
  handlerton **ht=trans->ht, **end_ht;
  DBUG_ENTER("ha_rollback_to_savepoint");
  DBUG_ASSERT(thd->transaction.stmt.ht[0] == 0);
1071

1072 1073 1074 1075 1076 1077 1078 1079 1080 1081
  trans->nht=sv->nht;
  trans->no_2pc=0;
  end_ht=ht+sv->nht;
  /*
    rolling back to savepoint in all storage engines that were part of the
    transaction when the savepoint was set
  */
  for (; ht < end_ht; ht++)
  {
    int err;
1082
    DBUG_ASSERT((*ht)->savepoint_set != 0);
1083 1084 1085 1086
    if ((err= (*(*ht)->savepoint_rollback)(thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
1087
    }
1088 1089
    statistic_increment(thd->status_var.ha_savepoint_rollback_count,&LOCK_status);
    trans->no_2pc|=(*ht)->prepare == 0;
1090
  }
1091 1092 1093 1094 1095
  /*
    rolling back the transaction in all storage engines that were not part of
    the transaction when the savepoint was set
  */
  for (; *ht ; ht++)
unknown's avatar
unknown committed
1096
  {
1097 1098 1099 1100 1101
    int err;
    if ((err= (*(*ht)->rollback)(thd, 1)))
    { // cannot happen
      my_error(ER_ERROR_DURING_ROLLBACK, MYF(0), err);
      error=1;
unknown's avatar
unknown committed
1102
    }
1103 1104
    statistic_increment(thd->status_var.ha_rollback_count,&LOCK_status);
    *ht=0; // keep it conveniently zero-filled
1105
  }
unknown's avatar
unknown committed
1106 1107 1108
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
1109
/*
1110 1111 1112
  note, that according to the sql standard (ISO/IEC 9075-2:2003)
  section "4.33.4 SQL-statements and transaction states",
  SAVEPOINT is *not* transaction-initiating SQL-statement
unknown's avatar
unknown committed
1113 1114
*/

1115
int ha_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1116 1117
{
  int error=0;
1118 1119 1120 1121
  THD_TRANS *trans=&thd->transaction.all;
  handlerton **ht=trans->ht;
  DBUG_ENTER("ha_savepoint");
  DBUG_ASSERT(thd->transaction.stmt.ht[0] == 0);
unknown's avatar
unknown committed
1122
#ifdef USING_TRANSACTIONS
1123
  for (; *ht; ht++)
unknown's avatar
unknown committed
1124
  {
1125 1126
    int err;
    if (! (*ht)->savepoint_set)
unknown's avatar
unknown committed
1127
    {
1128
      my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), "SAVEPOINT");
unknown's avatar
unknown committed
1129
      error=1;
1130
      break;
unknown's avatar
unknown committed
1131
    }
1132 1133 1134
    if ((err= (*(*ht)->savepoint_set)(thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
    { // cannot happen
      my_error(ER_GET_ERRNO, MYF(0), err);
unknown's avatar
unknown committed
1135 1136
      error=1;
    }
1137
    statistic_increment(thd->status_var.ha_savepoint_count,&LOCK_status);
unknown's avatar
unknown committed
1138
  }
1139
  sv->nht=trans->nht;
unknown's avatar
unknown committed
1140 1141 1142 1143
#endif /* USING_TRANSACTIONS */
  DBUG_RETURN(error);
}

1144
int ha_release_savepoint(THD *thd, SAVEPOINT *sv)
unknown's avatar
unknown committed
1145 1146
{
  int error=0;
1147 1148 1149 1150 1151 1152
  handlerton **ht=thd->transaction.all.ht, **end_ht;
  DBUG_ENTER("ha_release_savepoint");
  DBUG_ASSERT(thd->transaction.stmt.ht[0] == 0);

  end_ht=ht+sv->nht;
  for (; ht < end_ht; ht++)
unknown's avatar
unknown committed
1153
  {
1154 1155 1156 1157 1158 1159 1160
    int err;
    if (!(*ht)->savepoint_release)
      continue;
    if ((err= (*(*ht)->savepoint_release)(thd, (byte *)(sv+1)+(*ht)->savepoint_offset)))
    { // cannot happen
      my_error(ER_GET_ERRNO, MYF(0), err);
      error=1;
unknown's avatar
unknown committed
1161
    }
unknown's avatar
unknown committed
1162 1163 1164 1165
  }
  DBUG_RETURN(error);
}

1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177

int ha_start_consistent_snapshot(THD *thd)
{
#ifdef HAVE_INNOBASE_DB
  if ((have_innodb == SHOW_OPTION_YES) &&
      !innobase_start_trx_and_assign_read_view(thd))
    return 0;
#endif
  /*
    Same idea as when one wants to CREATE TABLE in one engine which does not
    exist:
  */
1178 1179 1180
  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, ER_UNKNOWN_ERROR,
               "This MySQL server does not support any "
               "consistent-read capable storage engine");
1181 1182 1183 1184
  return 0;
}


unknown's avatar
unknown committed
1185 1186 1187 1188
bool ha_flush_logs()
{
  bool result=0;
#ifdef HAVE_BERKELEY_DB
1189
  if ((have_berkeley_db == SHOW_OPTION_YES) &&
1190
      berkeley_flush_logs())
unknown's avatar
unknown committed
1191
    result=1;
1192 1193
#endif
#ifdef HAVE_INNOBASE_DB
1194
  if ((have_innodb == SHOW_OPTION_YES) &&
1195
      innobase_flush_logs())
1196
    result=1;
unknown's avatar
unknown committed
1197 1198 1199 1200
#endif
  return result;
}

unknown's avatar
unknown committed
1201 1202 1203 1204
/*
  This should return ENOENT if the file doesn't exists.
  The .frm file will be deleted only if we return 0 or ENOENT
*/
unknown's avatar
unknown committed
1205

1206 1207
int ha_delete_table(THD *thd, enum db_type table_type, const char *path,
                    const char *alias, bool generate_warning)
unknown's avatar
unknown committed
1208
{
1209
  handler *file;
unknown's avatar
unknown committed
1210
  char tmp_path[FN_REFLEN];
1211 1212 1213 1214 1215 1216 1217 1218
  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;
1219 1220 1221

  /* DB_TYPE_UNKNOWN is used in ALTER TABLE when renaming only .frm files */
  if (table_type == DB_TYPE_UNKNOWN ||
1222 1223
      ! (file=get_new_handler(&dummy_table, table_type)))
    DBUG_RETURN(ENOENT);
1224

unknown's avatar
unknown committed
1225 1226 1227 1228
  if (lower_case_table_names == 2 && !(file->table_flags() & HA_FILE_BASED))
  {
    /* Ensure that table handler get path in lower case */
    strmov(tmp_path, path);
1229
    my_casedn_str(files_charset_info, tmp_path);
unknown's avatar
unknown committed
1230 1231
    path= tmp_path;
  }
1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268
  if ((error= file->delete_table(path)) && generate_warning)
  {
    /*
      Because file->print_error() use my_error() to generate the error message
      we must store the error state in thd, reset it and restore it to
      be able to get hold of the error message.
      (We should in the future either rewrite handler::print_error() or make
      a nice method of this.
    */
    bool query_error= thd->query_error;
    sp_rcontext *spcont= thd->spcont;
    SELECT_LEX *current_select= thd->lex->current_select;
    char buff[sizeof(thd->net.last_error)];
    char new_error[sizeof(thd->net.last_error)];
    int last_errno= thd->net.last_errno;

    strmake(buff, thd->net.last_error, sizeof(buff)-1);
    thd->query_error= 0;
    thd->spcont= 0;
    thd->lex->current_select= 0;
    thd->net.last_error[0]= 0;

    /* Fill up strucutures that print_error may need */
    dummy_table.s->path= path;
    dummy_table.alias= alias;

    file->print_error(error, 0);
    strmake(new_error, thd->net.last_error, sizeof(buff)-1);

    /* restore thd */
    thd->query_error= query_error;
    thd->spcont= spcont;
    thd->lex->current_select= current_select;
    thd->net.last_errno= last_errno;
    strmake(thd->net.last_error, buff, sizeof(buff)-1);
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_ERROR, error, new_error);
  }
unknown's avatar
unknown committed
1269
  delete file;
1270
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1271
}
unknown's avatar
unknown committed
1272

unknown's avatar
unknown committed
1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
/****************************************************************************
** General handler functions
****************************************************************************/

	/* Open database-handler. Try O_RDONLY if can't open as O_RDWR */
	/* Don't wait for locks if not HA_OPEN_WAIT_IF_LOCKED is set */

int handler::ha_open(const char *name, int mode, int test_if_locked)
{
  int error;
1283
  DBUG_ENTER("handler::ha_open");
1284
  DBUG_PRINT("enter",("name: %s  db_type: %d  db_stat: %d  mode: %d  lock_test: %d",
unknown's avatar
unknown committed
1285 1286
                      name, table->s->db_type, table->db_stat, mode,
                      test_if_locked));
unknown's avatar
unknown committed
1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303

  if ((error=open(name,mode,test_if_locked)))
  {
    if ((error == EACCES || error == EROFS) && mode == O_RDWR &&
	(table->db_stat & HA_TRY_READ_ONLY))
    {
      table->db_stat|=HA_READ_ONLY;
      error=open(name,O_RDONLY,test_if_locked);
    }
  }
  if (error)
  {
    my_errno=error;			/* Safeguard */
    DBUG_PRINT("error",("error: %d  errno: %d",error,errno));
  }
  else
  {
1304
    if (table->s->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
unknown's avatar
unknown committed
1305
      table->db_stat|=HA_READ_ONLY;
1306 1307
    (void) extra(HA_EXTRA_NO_READCHECK);	// Not needed in SQL

unknown's avatar
unknown committed
1308
    if (!alloc_root_inited(&table->mem_root))	// If temporary table
1309
      ref=(byte*) sql_alloc(ALIGN_SIZE(ref_length)*2);
unknown's avatar
unknown committed
1310 1311 1312
    else
      ref=(byte*) alloc_root(&table->mem_root, ALIGN_SIZE(ref_length)*2);
    if (!ref)
unknown's avatar
unknown committed
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
    {
      close();
      error=HA_ERR_OUT_OF_MEM;
    }
    else
      dupp_ref=ref+ALIGN_SIZE(ref_length);
  }
  DBUG_RETURN(error);
}

1323 1324 1325 1326 1327
/*
  Read first row (only) from a table
  This is never called for InnoDB or BDB tables, as these table types
  has the HA_NOT_EXACT_COUNT set.
*/
unknown's avatar
unknown committed
1328

1329
int handler::read_first_row(byte * buf, uint primary_key)
unknown's avatar
unknown committed
1330 1331
{
  register int error;
1332
  DBUG_ENTER("handler::read_first_row");
unknown's avatar
unknown committed
1333

1334
  statistic_increment(current_thd->status_var.ha_read_first_count,&LOCK_status);
1335 1336 1337 1338

  /*
    If there is very few deleted rows in the table, find the first row by
    scanning the table.
1339
    TODO remove the test for HA_READ_ORDER
1340
  */
1341 1342
  if (deleted < 10 || primary_key >= MAX_KEY ||
      !(index_flags(primary_key, 0, 0) & HA_READ_ORDER))
1343
  {
unknown's avatar
unknown committed
1344
    (void) ha_rnd_init(1);
1345
    while ((error= rnd_next(buf)) == HA_ERR_RECORD_DELETED) ;
unknown's avatar
unknown committed
1346
    (void) ha_rnd_end();
1347 1348 1349 1350
  }
  else
  {
    /* Find the first row through the primary key */
unknown's avatar
unknown committed
1351
    (void) ha_index_init(primary_key);
1352
    error=index_first(buf);
unknown's avatar
unknown committed
1353
    (void) ha_index_end();
1354
  }
unknown's avatar
unknown committed
1355 1356 1357
  DBUG_RETURN(error);
}

1358
/*
1359
  Generate the next auto-increment number based on increment and offset
unknown's avatar
unknown committed
1360

1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
  In most cases increment= offset= 1, in which case we get:
  1,2,3,4,5,...
  If increment=10 and offset=5 and previous number is 1, we get:
  1,5,15,25,35,...
*/

inline ulonglong
next_insert_id(ulonglong nr,struct system_variables *variables)
{
  nr= (((nr+ variables->auto_increment_increment -
         variables->auto_increment_offset)) /
       (ulonglong) variables->auto_increment_increment);
  return (nr* (ulonglong) variables->auto_increment_increment +
          variables->auto_increment_offset);
}


/*
  Updates columns with type NEXT_NUMBER if:

  - If column value is set to NULL (in which case
    auto_increment_field_not_null is 0)
  - If column is set to 0 and (sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO) is not
    set. In the future we will only set NEXT_NUMBER fields if one sets them
    to NULL (or they are not included in the insert list).


  There are two different cases when the above is true:

  - thd->next_insert_id == 0  (This is the normal case)
    In this case we set the set the column for the first row to the value
    next_insert_id(get_auto_increment(column))) which is normally
    max-used-column-value +1.

    We call get_auto_increment() only for the first row in a multi-row
    statement. For the following rows we generate new numbers based on the
    last used number.

  - thd->next_insert_id != 0.  This happens when we have read a statement
    from the binary log or when one has used SET LAST_INSERT_ID=#.

    In this case we will set the column to the value of next_insert_id.
    The next row will be given the id
    next_insert_id(next_insert_id)

    The idea is that generated auto_increment values are predictable and
    independent of the column values in the table.  This is needed to be
    able to replicate into a table that already has rows with a higher
    auto-increment value than the one that is inserted.

    After we have already generated an auto-increment number and the user
    inserts a column with a higher value than the last used one, we will
    start counting from the inserted value.

    thd->next_insert_id is cleared after it's been used for a statement.
1416
*/
unknown's avatar
unknown committed
1417 1418 1419

void handler::update_auto_increment()
{
1420 1421 1422
  ulonglong nr;
  THD *thd= table->in_use;
  struct system_variables *variables= &thd->variables;
unknown's avatar
unknown committed
1423
  bool auto_increment_field_not_null;
1424
  DBUG_ENTER("handler::update_auto_increment");
1425 1426 1427 1428 1429 1430

  /*
    We must save the previous value to be able to restore it if the
    row was not inserted
  */
  thd->prev_insert_id= thd->next_insert_id;
unknown's avatar
unknown committed
1431 1432
  auto_increment_field_not_null= table->auto_increment_field_not_null;
  table->auto_increment_field_not_null= FALSE;
1433 1434

  if ((nr= table->next_number_field->val_int()) != 0 ||
unknown's avatar
unknown committed
1435
      auto_increment_field_not_null &&
1436
      thd->variables.sql_mode & MODE_NO_AUTO_VALUE_ON_ZERO)
1437
  {
1438 1439
    /* Clear flag for next row */
    /* Mark that we didn't generate a new value **/
1440
    auto_increment_column_changed=0;
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451

    /* Update next_insert_id if we have already generated a value */
    if (thd->clear_next_insert_id && nr >= thd->next_insert_id)
    {
      if (variables->auto_increment_increment != 1)
        nr= next_insert_id(nr, variables);
      else
        nr++;
      thd->next_insert_id= nr;
      DBUG_PRINT("info",("next_insert_id: %lu", (ulong) nr));
    }
unknown's avatar
unknown committed
1452
    DBUG_VOID_RETURN;
1453
  }
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472
  if (!(nr= thd->next_insert_id))
  {
    nr= get_auto_increment();
    if (variables->auto_increment_increment != 1)
      nr= next_insert_id(nr-1, variables);
    /*
      Update next row based on the found value. This way we don't have to
      call the handler for every generated auto-increment value on a
      multi-row statement
    */
    thd->next_insert_id= nr;
  }

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

  /* Mark that we should clear next_insert_id before next stmt */
  thd->clear_next_insert_id= 1;

  if (!table->next_number_field->store((longlong) nr))
1473
    thd->insert_id((ulonglong) nr);
1474 1475
  else
    thd->insert_id(table->next_number_field->val_int());
1476 1477 1478 1479 1480 1481

  /*
    We can't set next_insert_id if the auto-increment key is not the
    first key part, as there is no guarantee that the first parts will be in
    sequence
  */
1482
  if (!table->s->next_number_key_offset)
1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494
  {
    /*
      Set next insert id to point to next auto-increment value to be able to
      handle multi-row statements
      This works even if auto_increment_increment > 1
    */
    thd->next_insert_id= next_insert_id(nr, variables);
  }
  else
    thd->next_insert_id= 0;

  /* Mark that we generated a new value */
1495
  auto_increment_column_changed=1;
unknown's avatar
unknown committed
1496 1497 1498
  DBUG_VOID_RETURN;
}

1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
/*
  restore_auto_increment

  In case of error on write, we restore the last used next_insert_id value
  because the previous value was not used.
*/

void handler::restore_auto_increment()
{
  THD *thd= table->in_use;
  if (thd->next_insert_id)
    thd->next_insert_id= thd->prev_insert_id;
}

unknown's avatar
unknown committed
1513

1514
ulonglong handler::get_auto_increment()
unknown's avatar
unknown committed
1515
{
1516
  ulonglong nr;
unknown's avatar
unknown committed
1517
  int error;
unknown's avatar
unknown committed
1518

unknown's avatar
unknown committed
1519
  (void) extra(HA_EXTRA_KEYREAD);
1520 1521
  index_init(table->s->next_number_index);
  if (!table->s->next_number_key_offset)
unknown's avatar
unknown committed
1522 1523 1524 1525 1526 1527
  {						// Autoincrement at key-start
    error=index_last(table->record[1]);
  }
  else
  {
    byte key[MAX_KEY_LENGTH];
1528
    key_copy(key, table->record[0],
1529 1530 1531 1532
             table->key_info + table->s->next_number_index,
             table->s->next_number_key_offset);
    error= index_read(table->record[1], key, table->s->next_number_key_offset,
                      HA_READ_PREFIX_LAST);
unknown's avatar
unknown committed
1533 1534
  }

unknown's avatar
unknown committed
1535 1536 1537
  if (error)
    nr=1;
  else
1538 1539
    nr= ((ulonglong) table->next_number_field->
         val_int_offset(table->s->rec_buff_length)+1);
unknown's avatar
unknown committed
1540
  index_end();
unknown's avatar
unknown committed
1541
  (void) extra(HA_EXTRA_NO_KEYREAD);
unknown's avatar
unknown committed
1542 1543 1544
  return nr;
}

1545 1546 1547 1548

/*
  Print error that we got from handler function

unknown's avatar
unknown committed
1549
  NOTE
1550 1551 1552 1553 1554
   In case of delete table it's only safe to use the following parts of
   the 'table' structure:
     table->s->path
     table->alias
*/
unknown's avatar
unknown committed
1555 1556 1557

void handler::print_error(int error, myf errflag)
{
1558
  DBUG_ENTER("handler::print_error");
unknown's avatar
unknown committed
1559 1560 1561 1562
  DBUG_PRINT("enter",("error: %d",error));

  int textno=ER_GET_ERRNO;
  switch (error) {
1563 1564 1565
  case EACCES:
    textno=ER_OPEN_AS_READONLY;
    break;
unknown's avatar
unknown committed
1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
  case EAGAIN:
    textno=ER_FILE_USED;
    break;
  case ENOENT:
    textno=ER_FILE_NOT_FOUND;
    break;
  case HA_ERR_KEY_NOT_FOUND:
  case HA_ERR_NO_ACTIVE_RECORD:
  case HA_ERR_END_OF_FILE:
    textno=ER_KEY_NOT_FOUND;
    break;
unknown's avatar
unknown committed
1577
  case HA_ERR_WRONG_MRG_TABLE_DEF:
unknown's avatar
unknown committed
1578 1579 1580 1581 1582 1583 1584 1585 1586
    textno=ER_WRONG_MRG_TABLE;
    break;
  case HA_ERR_FOUND_DUPP_KEY:
  {
    uint key_nr=get_dup_key(error);
    if ((int) key_nr >= 0)
    {
      /* Write the dupplicated key in the error message */
      char key[MAX_KEY_LENGTH];
1587
      String str(key,sizeof(key),system_charset_info);
unknown's avatar
unknown committed
1588
      key_unpack(&str,table,(uint) key_nr);
unknown's avatar
unknown committed
1589
      uint max_length=MYSQL_ERRMSG_SIZE-(uint) strlen(ER(ER_DUP_ENTRY));
unknown's avatar
unknown committed
1590 1591 1592 1593 1594
      if (str.length() >= max_length)
      {
	str.length(max_length-4);
	str.append("...");
      }
1595
      my_error(ER_DUP_ENTRY, MYF(0), str.c_ptr(), key_nr+1);
unknown's avatar
unknown committed
1596 1597 1598 1599 1600
      DBUG_VOID_RETURN;
    }
    textno=ER_DUP_KEY;
    break;
  }
1601 1602 1603
  case HA_ERR_NULL_IN_SPATIAL:
    textno= ER_UNKNOWN_ERROR;
    DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1604 1605 1606 1607 1608 1609 1610 1611 1612
  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;
1613 1614 1615
  case HA_ERR_WRONG_IN_RECORD:
    textno= ER_CRASHED_ON_USAGE;
    break;
1616 1617 1618
  case HA_ERR_CRASHED_ON_USAGE:
    textno=ER_CRASHED_ON_USAGE;
    break;
1619 1620 1621
  case HA_ERR_NOT_A_TABLE:
    textno= error;
    break;
1622 1623 1624
  case HA_ERR_CRASHED_ON_REPAIR:
    textno=ER_CRASHED_ON_REPAIR;
    break;
unknown's avatar
unknown committed
1625
  case HA_ERR_OUT_OF_MEM:
unknown's avatar
unknown committed
1626
    my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), errflag);
unknown's avatar
unknown committed
1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
    DBUG_VOID_RETURN;
  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:
    textno=ER_RECORD_FILE_FULL;
    break;
1640 1641 1642
  case HA_ERR_INDEX_FILE_FULL:
    textno= errno;
    break;
1643 1644 1645 1646 1647 1648
  case HA_ERR_LOCK_WAIT_TIMEOUT:
    textno=ER_LOCK_WAIT_TIMEOUT;
    break;
  case HA_ERR_LOCK_TABLE_FULL:
    textno=ER_LOCK_TABLE_FULL;
    break;
1649 1650 1651
  case HA_ERR_LOCK_DEADLOCK:
    textno=ER_LOCK_DEADLOCK;
    break;
1652 1653 1654
  case HA_ERR_READ_ONLY_TRANSACTION:
    textno=ER_READ_ONLY_TRANSACTION;
    break;
unknown's avatar
Merge  
unknown committed
1655 1656 1657 1658 1659 1660 1661 1662 1663
  case HA_ERR_CANNOT_ADD_FOREIGN:
    textno=ER_CANNOT_ADD_FOREIGN;
    break;
  case HA_ERR_ROW_IS_REFERENCED:
    textno=ER_ROW_IS_REFERENCED;
    break;
  case HA_ERR_NO_REFERENCED_ROW:
    textno=ER_NO_REFERENCED_ROW;
    break;
1664 1665 1666
  case HA_ERR_TABLE_DEF_CHANGED:
    textno=ER_TABLE_DEF_CHANGED;
    break;
1667 1668
  case HA_ERR_NO_SUCH_TABLE:
  {
unknown's avatar
unknown committed
1669 1670 1671 1672 1673
    /*
      We have to use path to find database name instead of using
      table->table_cache_key because if the table didn't exist, then
      table_cache_key was not set up
    */
1674 1675
    char *db;
    char buff[FN_REFLEN];
1676
    uint length= dirname_part(buff,table->s->path);
1677 1678
    buff[length-1]=0;
    db=buff+dirname_length(buff);
1679
    my_error(ER_NO_SUCH_TABLE, MYF(0), db, table->alias);
1680 1681
    break;
  }
unknown's avatar
unknown committed
1682 1683
  default:
    {
1684 1685 1686
      /* The error was "unknown" to this function.
	 Ask handler if it has got a message for this error */
      bool temporary= FALSE;
1687 1688 1689
      String str;
      temporary= get_error_message(error, &str);
      if (!str.is_empty())
1690
      {
1691
	const char* engine= table_type();
1692
	if (temporary)
1693
	  my_error(ER_GET_TEMPORARY_ERRMSG, MYF(0), error, str.ptr(), engine);
1694
	else
1695
	  my_error(ER_GET_ERRMSG, MYF(0), error, str.ptr(), engine);
1696
      }
1697
      else
1698
	my_error(ER_GET_ERRNO,errflag,error);
unknown's avatar
unknown committed
1699 1700 1701
      DBUG_VOID_RETURN;
    }
  }
1702
  my_error(textno, errflag, table->alias, error);
unknown's avatar
unknown committed
1703 1704 1705
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
1706

1707
/*
1708
   Return an error message specific to this handler
1709

1710
   SYNOPSIS
1711 1712
   error        error code previously returned by handler
   buf          Pointer to String where to add error message
unknown's avatar
unknown committed
1713

1714
   Returns true if this is a temporary error
1715 1716
 */

1717
bool handler::get_error_message(int error, String* buf)
1718
{
unknown's avatar
unknown committed
1719
  return FALSE;
1720 1721 1722
}


unknown's avatar
unknown committed
1723
/* Return key if error because of duplicated keys */
unknown's avatar
unknown committed
1724 1725 1726

uint handler::get_dup_key(int error)
{
1727
  DBUG_ENTER("handler::get_dup_key");
unknown's avatar
unknown committed
1728
  table->file->errkey  = (uint) -1;
1729 1730
  if (error == HA_ERR_FOUND_DUPP_KEY || error == HA_ERR_FOUND_DUPP_UNIQUE ||
      error == HA_ERR_NULL_IN_SPATIAL)
unknown's avatar
unknown committed
1731 1732 1733 1734
    info(HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK);
  DBUG_RETURN(table->file->errkey);
}

unknown's avatar
unknown committed
1735

1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748
/*
  Delete all files with extension from bas_ext()

  SYNOPSIS
    delete_table()
    name		Base name of table

  NOTES
    We assume that the handler may return more extensions than
    was actually used for the file.

  RETURN
    0   If we successfully deleted at least one file from base_ext and
unknown's avatar
unknown committed
1749
	didn't get any other errors than ENOENT
1750
    #   Error
1751 1752
*/

unknown's avatar
unknown committed
1753 1754
int handler::delete_table(const char *name)
{
1755 1756
  int error= 0;
  int enoent_or_zero= ENOENT;                   // Error if no file was deleted
1757
  char buff[FN_REFLEN];
1758

unknown's avatar
unknown committed
1759 1760
  for (const char **ext=bas_ext(); *ext ; ext++)
  {
1761 1762
    fn_format(buff, name, "", *ext, 2 | 4);
    if (my_delete_with_symlink(buff, MYF(0)))
unknown's avatar
unknown committed
1763
    {
1764
      if ((error= my_errno) != ENOENT)
unknown's avatar
unknown committed
1765 1766
	break;
    }
1767
    else
1768
      enoent_or_zero= 0;                        // No error for ENOENT
1769
    error= enoent_or_zero;
unknown's avatar
unknown committed
1770
  }
unknown's avatar
unknown committed
1771
  return error;
unknown's avatar
unknown committed
1772 1773 1774 1775 1776
}


int handler::rename_table(const char * from, const char * to)
{
unknown's avatar
unknown committed
1777 1778
  int error= 0;
  for (const char **ext= bas_ext(); *ext ; ext++)
unknown's avatar
unknown committed
1779
  {
unknown's avatar
unknown committed
1780 1781 1782 1783 1784 1785
    if (rename_file_ext(from, to, *ext))
    {
      if ((error=my_errno) != ENOENT)
	break;
      error= 0;
    }
unknown's avatar
unknown committed
1786
  }
unknown's avatar
unknown committed
1787
  return error;
unknown's avatar
unknown committed
1788 1789
}

unknown's avatar
unknown committed
1790
/*
1791 1792 1793 1794 1795 1796
  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.
1797
*/
unknown's avatar
unknown committed
1798

1799
int ha_enable_transaction(THD *thd, bool on)
1800 1801 1802
{
  int error=0;

1803 1804
  DBUG_ENTER("ha_enable_transaction");
  thd->transaction.on= on;
unknown's avatar
unknown committed
1805
  if (on)
1806 1807 1808 1809 1810 1811 1812 1813 1814
  {
    /*
      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.
    */
    error= end_trans(thd, COMMIT);
  }
1815 1816 1817
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
1818 1819 1820 1821 1822
int handler::index_next_same(byte *buf, const byte *key, uint keylen)
{
  int error;
  if (!(error=index_next(buf)))
  {
unknown's avatar
unknown committed
1823
    if (key_cmp_if_same(table, key, active_index, keylen))
unknown's avatar
unknown committed
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836
    {
      table->status=STATUS_NOT_FOUND;
      error=HA_ERR_END_OF_FILE;
    }
  }
  return error;
}


/****************************************************************************
** Some general functions that isn't in the handler class
****************************************************************************/

unknown's avatar
unknown committed
1837 1838 1839 1840
/*
  Initiates table-file and calls apropriate database-creator
  Returns 1 if something got wrong
*/
unknown's avatar
unknown committed
1841 1842 1843 1844 1845 1846

int ha_create_table(const char *name, HA_CREATE_INFO *create_info,
		    bool update_create_info)
{
  int error;
  TABLE table;
unknown's avatar
unknown committed
1847
  char name_buff[FN_REFLEN];
unknown's avatar
unknown committed
1848 1849
  DBUG_ENTER("ha_create_table");

1850
  if (openfrm(current_thd, name,"",0,(uint) READ_ALL, 0, &table))
unknown's avatar
unknown committed
1851 1852 1853 1854 1855
    DBUG_RETURN(1);
  if (update_create_info)
  {
    update_create_info_from_table(create_info, &table);
  }
unknown's avatar
unknown committed
1856 1857 1858 1859 1860
  if (lower_case_table_names == 2 &&
      !(table.file->table_flags() & HA_FILE_BASED))
  {
    /* Ensure that handler gets name in lower case */
    strmov(name_buff, name);
1861
    my_casedn_str(files_charset_info, name_buff);
unknown's avatar
unknown committed
1862 1863 1864
    name= name_buff;
  }

unknown's avatar
unknown committed
1865 1866
  error=table.file->create(name,&table,create_info);
  VOID(closefrm(&table));
unknown's avatar
unknown committed
1867
  if (error)
1868
    my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), name,error);
unknown's avatar
unknown committed
1869 1870 1871
  DBUG_RETURN(error != 0);
}

1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888
/*
  Try to discover table from engine and 
  if found, write the frm file to disk.
  
  RETURN VALUES:
   0 : Table existed in engine and created 
       on disk if so requested
   1 : Table does not exist
  >1 : error

*/

int ha_create_table_from_engine(THD* thd, 
				const char *db, 
				const char *name,
				bool create_if_found)
{
unknown's avatar
unknown committed
1889 1890 1891
  int error;
  const void *frmblob;
  uint frmlen;
1892 1893 1894 1895
  char path[FN_REFLEN];
  HA_CREATE_INFO create_info;
  TABLE table;
  DBUG_ENTER("ha_create_table_from_engine");
unknown's avatar
unknown committed
1896 1897
  DBUG_PRINT("enter", ("name '%s'.'%s'  create_if_found: %d",
                       db, name, create_if_found));
1898 1899 1900 1901 1902

  bzero((char*) &create_info,sizeof(create_info));

  if ((error= ha_discover(thd, db, name, &frmblob, &frmlen)))
    DBUG_RETURN(error); 
unknown's avatar
unknown committed
1903 1904 1905 1906
  /*
    Table exists in handler
    frmblob and frmlen are set
  */
1907

unknown's avatar
unknown committed
1908
  if (create_if_found)
1909 1910 1911 1912 1913 1914
  {
    (void)strxnmov(path,FN_REFLEN,mysql_data_home,"/",db,"/",name,NullS);
    // Save the frm file    
    if ((error = writefrm(path, frmblob, frmlen)))
      goto err_end;

1915
    if (openfrm(thd, path,"",0,(uint) READ_ALL, 0, &table))
1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
      DBUG_RETURN(1);

    update_create_info_from_table(&create_info, &table);
    create_info.table_options|= HA_CREATE_FROM_ENGINE;

    if (lower_case_table_names == 2 &&
	!(table.file->table_flags() & HA_FILE_BASED))
    {
      /* Ensure that handler gets name in lower case */
      my_casedn_str(files_charset_info, path);
    }
    
    error=table.file->create(path,&table,&create_info);
    VOID(closefrm(&table));
  }

err_end:
1933
  my_free((char*) frmblob, MYF(MY_ALLOW_ZERO_PTR));
1934 1935 1936
  DBUG_RETURN(error);  
}

1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954
void st_ha_check_opt::init()
{
  flags= sql_flags= 0;
  sort_buffer_size = current_thd->variables.myisam_sort_buff_size;
}


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

  This code is only relevant for ISAM/MyISAM tables

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

/* Init a key cache if it has not been initied before */
unknown's avatar
unknown committed
1955

1956

unknown's avatar
unknown committed
1957
int ha_init_key_cache(const char *name, KEY_CACHE *key_cache)
unknown's avatar
unknown committed
1958
{
1959 1960
  DBUG_ENTER("ha_init_key_cache");

unknown's avatar
unknown committed
1961
  if (!key_cache->key_cache_inited)
1962 1963
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
1964 1965 1966 1967
    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;
1968
    pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
1969
    DBUG_RETURN(!init_key_cache(key_cache,
1970 1971
				tmp_block_size,
				tmp_buff_size,
unknown's avatar
unknown committed
1972
				division_limit, age_threshold));
1973
  }
1974
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1975 1976
}

1977 1978 1979

/* Resize key cache */

unknown's avatar
unknown committed
1980
int ha_resize_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
1981
{
1982 1983
  DBUG_ENTER("ha_resize_key_cache");

unknown's avatar
unknown committed
1984
  if (key_cache->key_cache_inited)
1985 1986
  {
    pthread_mutex_lock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
1987 1988 1989 1990
    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;
1991
    pthread_mutex_unlock(&LOCK_global_system_variables);
unknown's avatar
unknown committed
1992 1993 1994
    DBUG_RETURN(!resize_key_cache(key_cache, tmp_block_size,
				  tmp_buff_size,
				  division_limit, age_threshold));
1995
  }
1996
  DBUG_RETURN(0);
1997 1998
}

1999 2000 2001

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

unknown's avatar
unknown committed
2002
int ha_change_key_cache_param(KEY_CACHE *key_cache)
2003
{
unknown's avatar
unknown committed
2004 2005 2006 2007 2008 2009 2010 2011
  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);
  }
2012 2013
  return 0;
}
unknown's avatar
unknown committed
2014

2015 2016
/* Free memory allocated by a key cache */

unknown's avatar
unknown committed
2017
int ha_end_key_cache(KEY_CACHE *key_cache)
unknown's avatar
unknown committed
2018
{
unknown's avatar
unknown committed
2019
  end_key_cache(key_cache, 1);		// Can never fail
2020
  return 0;
unknown's avatar
unknown committed
2021
}
unknown's avatar
unknown committed
2022

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

unknown's avatar
unknown committed
2025 2026
int ha_change_key_cache(KEY_CACHE *old_key_cache,
			KEY_CACHE *new_key_cache)
unknown's avatar
unknown committed
2027
{
2028 2029
  mi_change_key_cache(old_key_cache, new_key_cache);
  return 0;
unknown's avatar
unknown committed
2030
}
2031 2032


unknown's avatar
unknown committed
2033 2034
/*
  Try to discover one table from handler(s)
unknown's avatar
unknown committed
2035 2036 2037 2038

  RETURN
    0  ok. In this case *frmblob and *frmlen are set
    1  error.  frmblob and frmlen may not be set
unknown's avatar
unknown committed
2039 2040
*/

unknown's avatar
unknown committed
2041 2042
int ha_discover(THD *thd, const char *db, const char *name,
		const void **frmblob, uint *frmlen)
unknown's avatar
unknown committed
2043 2044 2045
{
  int error= 1; // Table does not exist in any handler
  DBUG_ENTER("ha_discover");
2046
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
unknown's avatar
unknown committed
2047 2048
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
2049
    error= ndbcluster_discover(thd, db, name, frmblob, frmlen);
unknown's avatar
unknown committed
2050 2051
#endif
  if (!error)
2052
    statistic_increment(thd->status_var.ha_discover_count,&LOCK_status);
unknown's avatar
unknown committed
2053 2054 2055 2056
  DBUG_RETURN(error);
}


2057
/*
2058 2059 2060
  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 
  or any dropped tables that need to be removed from disk
2061 2062
*/

2063 2064
int
ha_find_files(THD *thd,const char *db,const char *path,
unknown's avatar
unknown committed
2065
	      const char *wild, bool dir, List<char> *files)
2066 2067
{
  int error= 0;
2068 2069 2070
  DBUG_ENTER("ha_find_files");
  DBUG_PRINT("enter", ("db: %s, path: %s, wild: %s, dir: %d", 
		       db, path, wild, dir));
2071 2072
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
unknown's avatar
unknown committed
2073
    error= ndbcluster_find_files(thd, db, path, wild, dir, files);
2074 2075
#endif
  DBUG_RETURN(error);
2076 2077
  
  
2078 2079
}

unknown's avatar
unknown committed
2080 2081
#ifdef NOT_YET_USED

2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102
/*
  Ask handler if the table exists in engine

  RETURN
    0                   Table does not exist
    1                   Table exists
    #                   Error code

 */
int ha_table_exists(THD* thd, const char* db, const char* name)
{
  int error= 2;
  DBUG_ENTER("ha_table_exists");
  DBUG_PRINT("enter", ("db: %s, name: %s", db, name));
#ifdef HAVE_NDBCLUSTER_DB
  if (have_ndbcluster == SHOW_OPTION_YES)
    error= ndbcluster_table_exists(thd, db, name);
#endif
  DBUG_RETURN(error);
}

unknown's avatar
unknown committed
2103
#endif
2104 2105


unknown's avatar
unknown committed
2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230
/*
  Read the first row of a multi-range set.

  SYNOPSIS
    read_multi_range_first()
    found_range_p       Returns a pointer to the element in 'ranges' that
                        corresponds to the returned row.
    ranges              An array of KEY_MULTI_RANGE range descriptions.
    range_count         Number of ranges in 'ranges'.
    sorted		If result should be sorted per key.
    buffer              A HANDLER_BUFFER for internal handler usage.

  NOTES
    Record is read into table->record[0].
    *found_range_p returns a valid value only if read_multi_range_first()
    returns 0.
    Sorting is done within each range. If you want an overall sort, enter
    'ranges' with sorted ranges.

  RETURN
    0			OK, found a row
    HA_ERR_END_OF_FILE	No rows in range
    #			Error code
*/

int handler::read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
                                    KEY_MULTI_RANGE *ranges, uint range_count,
                                    bool sorted, HANDLER_BUFFER *buffer)
{
  int result= HA_ERR_END_OF_FILE;
  DBUG_ENTER("handler::read_multi_range_first");
  multi_range_sorted= sorted;
  multi_range_buffer= buffer;

  for (multi_range_curr= ranges, multi_range_end= ranges + range_count;
       multi_range_curr < multi_range_end;
       multi_range_curr++)
  {
    result= read_range_first(multi_range_curr->start_key.length ?
                             &multi_range_curr->start_key : 0,
                             multi_range_curr->end_key.length ?
                             &multi_range_curr->end_key : 0,
                             test(multi_range_curr->range_flag & EQ_RANGE),
                             multi_range_sorted);
    if (result != HA_ERR_END_OF_FILE)
      break;
  }

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


/*
  Read the next row of a multi-range set.

  SYNOPSIS
    read_multi_range_next()
    found_range_p       Returns a pointer to the element in 'ranges' that
                        corresponds to the returned row.

  NOTES
    Record is read into table->record[0].
    *found_range_p returns a valid value only if read_multi_range_next()
    returns 0.

  RETURN
    0			OK, found a row
    HA_ERR_END_OF_FILE	No (more) rows in range
    #			Error code
*/

int handler::read_multi_range_next(KEY_MULTI_RANGE **found_range_p)
{
  int result;
  DBUG_ENTER("handler::read_multi_range_next");

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

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

      /* On success or non-EOF errors jump to the end. */
      if (result != HA_ERR_END_OF_FILE)
        break;
    }
    else
    {
      /*
        We need to set this for the last range only, but checking this
        condition is more expensive than just setting the result code.
      */
      result= HA_ERR_END_OF_FILE;
    }

    /* Try the next range(s) until one matches a record. */
    for (multi_range_curr++;
         multi_range_curr < multi_range_end;
         multi_range_curr++)
    {
      result= read_range_first(multi_range_curr->start_key.length ?
                               &multi_range_curr->start_key : 0,
                               multi_range_curr->end_key.length ?
                               &multi_range_curr->end_key : 0,
                               test(multi_range_curr->range_flag & EQ_RANGE),
                               multi_range_sorted);
      if (result != HA_ERR_END_OF_FILE)
        break;
    }
  }
  while ((result == HA_ERR_END_OF_FILE) &&
         (multi_range_curr < multi_range_end));

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


2231 2232 2233 2234 2235 2236 2237 2238
/*
  Read first row between two ranges.
  Store ranges for future calls to read_range_next

  SYNOPSIS
    read_range_first()
    start_key		Start key. Is 0 if no min range
    end_key		End key.  Is 0 if no max range
unknown's avatar
unknown committed
2239
    eq_range_arg	Set to 1 if start_key == end_key		
2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252
    sorted		Set to 1 if result should be sorted per key

  NOTES
    Record is read into table->record[0]

  RETURN
    0			Found row
    HA_ERR_END_OF_FILE	No rows in range
    #			Error code
*/

int handler::read_range_first(const key_range *start_key,
			      const key_range *end_key,
unknown's avatar
unknown committed
2253
			      bool eq_range_arg, bool sorted)
2254 2255 2256 2257
{
  int result;
  DBUG_ENTER("handler::read_range_first");

unknown's avatar
unknown committed
2258
  eq_range= eq_range_arg;
2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276
  end_range= 0;
  if (end_key)
  {
    end_range= &save_end_range;
    save_end_range= *end_key;
    key_compare_result_on_equal= ((end_key->flag == HA_READ_BEFORE_KEY) ? 1 :
				  (end_key->flag == HA_READ_AFTER_KEY) ? -1 : 0);
  }
  range_key_part= table->key_info[active_index].key_part;

  if (!start_key)			// Read first record
    result= index_first(table->record[0]);
  else
    result= index_read(table->record[0],
		       start_key->key,
		       start_key->length,
		       start_key->flag);
  if (result)
unknown's avatar
unknown committed
2277 2278 2279
    DBUG_RETURN((result == HA_ERR_KEY_NOT_FOUND) 
		? HA_ERR_END_OF_FILE
		: result);
2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299

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


/*
  Read next row between two ranges.

  SYNOPSIS
    read_range_next()

  NOTES
    Record is read into table->record[0]

  RETURN
    0			Found row
    HA_ERR_END_OF_FILE	No rows in range
    #			Error code
*/

unknown's avatar
unknown committed
2300
int handler::read_range_next()
2301 2302 2303 2304 2305
{
  int result;
  DBUG_ENTER("handler::read_range_next");

  if (eq_range)
unknown's avatar
unknown committed
2306 2307 2308 2309 2310 2311 2312
  {
    /* 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]);
2313 2314 2315 2316 2317 2318 2319
  if (result)
    DBUG_RETURN(result);
  DBUG_RETURN(compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
}


/*
unknown's avatar
unknown committed
2320
  Compare if found key (in row) is over max-value
2321 2322 2323

  SYNOPSIS
    compare_key
unknown's avatar
unknown committed
2324
    range		range to compare to row. May be 0 for no range
2325 2326
 
  NOTES
unknown's avatar
unknown committed
2327
    See key.cc::key_cmp() for details
2328 2329

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

2332 2333 2334 2335 2336 2337 2338
    0			Key is equal to range or 'range' == 0 (no range)
   -1			Key is less than range
    1			Key is larger than range
*/

int handler::compare_key(key_range *range)
{
unknown's avatar
unknown committed
2339
  int cmp;
2340 2341
  if (!range)
    return 0;					// No max range
unknown's avatar
unknown committed
2342 2343 2344 2345
  cmp= key_cmp(range_key_part, range->key, range->length);
  if (!cmp)
    cmp= key_compare_result_on_equal;
  return cmp;
2346
}
unknown's avatar
unknown committed
2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358

int handler::index_read_idx(byte * buf, uint index, const byte * key,
			     uint key_len, enum ha_rkey_function find_flag)
{
  int error= ha_index_init(index);
  if (!error)
    error= index_read(buf, key, key_len, find_flag);
  if (!error)
    error= ha_index_end();
  return error;
}

2359

2360 2361 2362 2363 2364 2365 2366 2367
/*
  Returns a list of all known extensions.

  SYNOPSIS
    ha_known_exts()
 
  NOTES
    No mutexes, worst case race is a minor surplus memory allocation
2368 2369
    We have to recreate the extension map if mysqld is restarted (for example
    within libmysqld)
2370 2371 2372 2373

  RETURN VALUE
    pointer		pointer to TYPELIB structure
*/
2374

2375 2376
TYPELIB *ha_known_exts(void)
{
2377
  if (!known_extensions.type_names || mysys_usage_id != known_extensions_id)
2378 2379 2380 2381
  {
    show_table_type_st *types;
    List<char> found_exts;
    List_iterator_fast<char> it(found_exts);
2382 2383 2384
    const char **ext, *old_ext;

    known_extensions_id= mysys_usage_id;
2385
    found_exts.push_back((char*) triggers_file_ext);
2386
    for (types= sys_table_types; types->type; types++)
unknown's avatar
unknown committed
2387
    {
2388 2389 2390 2391 2392
      if (*types->value == SHOW_OPTION_YES)
      {
	handler *file= get_new_handler(0,(enum db_type) types->db_type);
	for (ext= file->bas_ext(); *ext; ext++)
	{
2393 2394 2395
	  while ((old_ext= it++))
          {
	    if (!strcmp(old_ext, *ext))
2396
	      break;
2397 2398 2399
          }
	  if (!old_ext)
	    found_exts.push_back((char *) *ext);
2400 2401 2402 2403 2404 2405

	  it.rewind();
	}
	delete file;
      }
    }
2406 2407 2408
    ext= (const char **) my_once_alloc(sizeof(char *)*
                                       (found_exts.elements+1),
                                       MYF(MY_WME | MY_FAE));
2409
    
2410
    DBUG_ASSERT(ext != 0);
2411 2412
    known_extensions.count= found_exts.elements;
    known_extensions.type_names= ext;
2413 2414 2415 2416

    while ((old_ext= it++))
      *ext++= old_ext;
    *ext= 0;
2417 2418 2419
  }
  return &known_extensions;
}
unknown's avatar
unknown committed
2420

unknown's avatar
unknown committed
2421

unknown's avatar
unknown committed
2422
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2423 2424 2425 2426 2427 2428
/*
  Reports to table handlers up to which position we have sent the binlog
  to a slave in replication

  SYNOPSIS
    ha_repl_report_sent_binlog()
unknown's avatar
unknown committed
2429 2430 2431 2432
    thd             thread doing the binlog communication to the slave
    log_file_name   binlog file name
    end_offse t     the offset in the binlog file up to which we sent the
		    contents to the slave
unknown's avatar
unknown committed
2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450

  NOTES
    Only works for InnoDB at the moment

  RETURN VALUE
    Always 0 (= success)  
*/

int ha_repl_report_sent_binlog(THD *thd, char *log_file_name,
                               my_off_t end_offset)
{
#ifdef HAVE_INNOBASE_DB
  return innobase_repl_report_sent_binlog(thd,log_file_name,end_offset);
#else
  return 0;
#endif
}

unknown's avatar
unknown committed
2451

unknown's avatar
unknown committed
2452 2453 2454 2455 2456
/*
  Reports to table handlers that we stop replication to a specific slave

  SYNOPSIS
    ha_repl_report_replication_stop()
unknown's avatar
unknown committed
2457
    thd              thread doing the binlog communication to the slave
unknown's avatar
unknown committed
2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471

  NOTES
    Does nothing at the moment

  RETURN VALUE
    Always 0 (= success)  

  PARAMETERS
*/

int ha_repl_report_replication_stop(THD *thd)
{
  return 0;
}
unknown's avatar
unknown committed
2472
#endif /* HAVE_REPLICATION */