ha_maria.cc 109 KB
Newer Older
Sergei Golubchik's avatar
Sergei Golubchik committed
1 2
/* Copyright (C) 2004-2008 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
   Copyright (C) 2008-2009 Sun Microsystems, Inc.
3 4 5

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
6
   the Free Software Foundation; version 2 of the License.
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   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.

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


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

22
#define MYSQL_SERVER 1
23
#include "mysql_priv.h"
24
#include <mysql/plugin.h>
25
#include <m_ctype.h>
26
#include <my_dir.h>
27
#include <myisampack.h>
unknown's avatar
unknown committed
28
#include <my_bit.h>
29
#include "ha_maria.h"
30
#include "trnman_public.h"
31
#include "trnman.h"
32

33
C_MODE_START
34 35
#include "maria_def.h"
#include "ma_rt_index.h"
36
#include "ma_blockrec.h"
unknown's avatar
unknown committed
37 38
#include "ma_checkpoint.h"
#include "ma_recovery.h"
39
C_MODE_END
40

unknown's avatar
unknown committed
41 42 43 44
/*
  Note that in future versions, only *transactional* Maria tables can
  rollback, so this flag should be up or down conditionally.
*/
unknown's avatar
unknown committed
45
#ifdef MARIA_CANNOT_ROLLBACK
Sergei Golubchik's avatar
Sergei Golubchik committed
46
#define CANNOT_ROLLBACK_FLAG HA_NO_TRANSACTIONS
unknown's avatar
unknown committed
47
#define trans_register_ha(A, B, C)  do { /* nothing */ } while(0)
Sergei Golubchik's avatar
Sergei Golubchik committed
48 49
#else
#define CANNOT_ROLLBACK_FLAG 0
unknown's avatar
unknown committed
50
#endif
51
#define THD_TRN (*(TRN **)thd_ha_data(thd, maria_hton))
unknown's avatar
unknown committed
52

unknown's avatar
unknown committed
53 54 55
ulong pagecache_division_limit, pagecache_age_threshold;
ulonglong pagecache_buffer_size;

unknown's avatar
unknown committed
56
/**
57 58 59 60 61
   As the auto-repair is initiated when opened from the SQL layer
   (open_unireg_entry(), check_and_repair()), it does not happen when Maria's
   Recovery internally opens the table to apply log records to it, which is
   good. It would happen only after Recovery, if the table is still
   corrupted.
unknown's avatar
unknown committed
62
*/
63
ulong maria_recover_options= HA_RECOVER_NONE;
unknown's avatar
unknown committed
64
handlerton *maria_hton;
65 66 67 68

/* bits in maria_recover_options */
const char *maria_recover_names[]=
{
69 70 71 72 73 74 75 76
  /*
    Compared to MyISAM, "default" was renamed to "normal" as it collided with
    SET var=default which sets to the var's default i.e. what happens when the
    var is not set i.e. HA_RECOVER_NONE.
    Another change is that OFF is used to disable, not ""; this is to have OFF
    display in SHOW VARIABLES which is better than "".
  */
  "OFF", "NORMAL", "BACKUP", "FORCE", "QUICK", NullS
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
};
TYPELIB maria_recover_typelib=
{
  array_elements(maria_recover_names) - 1, "",
  maria_recover_names, NULL
};

const char *maria_stats_method_names[]=
{
  "nulls_unequal", "nulls_equal",
  "nulls_ignored", NullS
};
TYPELIB maria_stats_method_typelib=
{
  array_elements(maria_stats_method_names) - 1, "",
  maria_stats_method_names, NULL
};

95 96 97 98 99 100 101 102 103 104
/* transactions log purge mode */
const char *maria_translog_purge_type_names[]=
{
  "immediate", "external", "at_flush", NullS
};
TYPELIB maria_translog_purge_type_typelib=
{
  array_elements(maria_translog_purge_type_names) - 1, "",
  maria_translog_purge_type_names, NULL
};
105 106 107 108 109 110 111 112 113 114 115
const char *maria_sync_log_dir_names[]=
{
  "NEVER", "NEWFILE", "ALWAYS", NullS
};

TYPELIB maria_sync_log_dir_typelib=
{
  array_elements(maria_sync_log_dir_names) - 1, "",
  maria_sync_log_dir_names, NULL
};

116
/** Interval between background checkpoints in seconds */
unknown's avatar
unknown committed
117 118 119
static ulong checkpoint_interval;
static void update_checkpoint_interval(MYSQL_THD thd,
                                       struct st_mysql_sys_var *var,
unknown's avatar
unknown committed
120
                                       void *var_ptr, const void *save);
121 122
/** After that many consecutive recovery failures, remove logs */
static ulong force_start_after_recovery_failures;
123 124
static void update_log_file_size(MYSQL_THD thd,
                                 struct st_mysql_sys_var *var,
unknown's avatar
unknown committed
125
                                 void *var_ptr, const void *save);
unknown's avatar
unknown committed
126

127 128 129 130 131 132
static MYSQL_SYSVAR_ULONG(block_size, maria_block_size,
       PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
       "Block size to be used for MARIA index pages.", 0, 0,
       MARIA_KEY_BLOCK_LENGTH, MARIA_MIN_KEY_BLOCK_LENGTH,
       MARIA_MAX_KEY_BLOCK_LENGTH, MARIA_MIN_KEY_BLOCK_LENGTH);

unknown's avatar
unknown committed
133
static MYSQL_SYSVAR_ULONG(checkpoint_interval, checkpoint_interval,
unknown's avatar
unknown committed
134
       PLUGIN_VAR_RQCMDARG,
unknown's avatar
unknown committed
135 136
       "Interval between automatic checkpoints, in seconds; 0 means"
       " 'no automatic checkpoints' which makes sense only for testing.",
unknown's avatar
unknown committed
137
       NULL, update_checkpoint_interval, 30, 0, UINT_MAX, 1);
unknown's avatar
unknown committed
138

139 140 141 142 143 144 145 146 147 148 149
static MYSQL_SYSVAR_ULONG(force_start_after_recovery_failures,
       force_start_after_recovery_failures,
       /*
         Read-only because setting it on the fly has no useful effect,
         should be set on command-line.
       */
       PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
       "Number of consecutive log recovery failures after which logs will be"
       " automatically deleted to cure the problem; 0 (the default) disables"
       " the feature.", NULL, NULL, 0, 0, UINT_MAX8, 1);

unknown's avatar
unknown committed
150 151 152 153
static MYSQL_SYSVAR_BOOL(page_checksum, maria_page_checksums, 0,
       "Maintain page checksums (can be overridden per table "
       "with PAGE_CHECKSUM clause in CREATE TABLE)", 0, 0, 1);

154 155
/* It is only command line argument */
static MYSQL_SYSVAR_STR(log_dir_path, maria_data_root,
156
       PLUGIN_VAR_NOSYSVAR | PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
157 158 159 160
       "Path to the directory where to store transactional log",
       NULL, NULL, mysql_real_data_home);


161 162 163 164 165 166 167 168 169 170 171 172 173 174
static MYSQL_SYSVAR_ULONG(log_file_size, log_file_size,
       PLUGIN_VAR_RQCMDARG,
       "Limit for transaction log size",
       NULL, update_log_file_size, TRANSLOG_FILE_SIZE,
       TRANSLOG_MIN_FILE_SIZE, 0xffffffffL, TRANSLOG_PAGE_SIZE);

static MYSQL_SYSVAR_ENUM(log_purge_type, log_purge_type,
       PLUGIN_VAR_RQCMDARG,
       "Specifies how maria transactional log will be purged. "
       "Possible values of name are \"immediate\", \"external\" "
       "and \"at_flush\"",
       NULL, NULL, TRANSLOG_PURGE_IMMIDIATE,
       &maria_translog_purge_type_typelib);

175 176 177 178 179 180
static MYSQL_SYSVAR_ULONGLONG(max_sort_file_size,
       maria_max_temp_length, PLUGIN_VAR_RQCMDARG,
       "Don't use the fast sort index method to created index if the "
       "temporary file would get bigger than this.",
       0, 0, MAX_FILE_SIZE, 0, MAX_FILE_SIZE, 1024*1024);

unknown's avatar
unknown committed
181 182 183 184 185 186 187 188 189 190 191
static MYSQL_SYSVAR_ULONG(pagecache_age_threshold,
       pagecache_age_threshold, PLUGIN_VAR_RQCMDARG,
       "This characterizes the number of hits a hot block has to be untouched "
       "until it is considered aged enough to be downgraded to a warm block. "
       "This specifies the percentage ratio of that number of hits to the "
       "total number of blocks in the page cache.", 0, 0,
        300, 100, ~0L, 100);

static MYSQL_SYSVAR_ULONGLONG(pagecache_buffer_size, pagecache_buffer_size,
       PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
       "The size of the buffer used for index blocks for Maria tables. "
unknown's avatar
unknown committed
192 193
       "Increase this to get better index handling (for all reads and "
       "multiple writes) to as much as you can afford.", 0, 0,
unknown's avatar
unknown committed
194 195 196 197 198 199 200
       KEY_CACHE_SIZE, MALLOC_OVERHEAD, ~(ulong) 0, IO_SIZE);

static MYSQL_SYSVAR_ULONG(pagecache_division_limit, pagecache_division_limit,
       PLUGIN_VAR_RQCMDARG,
       "The minimum percentage of warm blocks in key cache", 0, 0,
       100,  1, 100, 1);

201 202 203 204 205 206
static MYSQL_SYSVAR_ENUM(recover, maria_recover_options, PLUGIN_VAR_OPCMDARG,
       "Specifies how corrupted tables should be automatically repaired."
       " Possible values are \"NORMAL\" (the default), \"BACKUP\", \"FORCE\","
       " \"QUICK\", or \"OFF\" which is like not using the option.",
       NULL, NULL, HA_RECOVER_NONE, &maria_recover_typelib);

207 208 209 210 211 212 213 214 215 216 217
static MYSQL_THDVAR_ULONG(repair_threads, PLUGIN_VAR_RQCMDARG,
       "Number of threads to use when repairing maria tables. The value of 1 "
       "disables parallel repair.",
       0, 0, 1, 1, ~0L, 1);

static MYSQL_THDVAR_ULONG(sort_buffer_size, PLUGIN_VAR_RQCMDARG,
       "The buffer that is allocated when sorting the index when doing a "
       "REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE.",
       0, 0, 8192*1024, 4, ~0L, 1);

static MYSQL_THDVAR_ENUM(stats_method, PLUGIN_VAR_RQCMDARG,
218
       "Specifies how maria index statistics collection code should treat "
unknown's avatar
unknown committed
219
       "NULLs. Possible values are \"nulls_unequal\", \"nulls_equal\", "
220
       "and \"nulls_ignored\".", 0, 0, 0, &maria_stats_method_typelib);
221

222 223
static MYSQL_SYSVAR_ENUM(sync_log_dir, sync_log_dir, PLUGIN_VAR_RQCMDARG,
       "Controls syncing directory after log file growth and new file "
unknown's avatar
unknown committed
224 225
       "creation. Possible values are \"never\", \"newfile\" and "
       "\"always\").", NULL, NULL, TRANSLOG_SYNC_DIR_NEWFILE,
226 227
       &maria_sync_log_dir_typelib);

Sergey Petrunya's avatar
Sergey Petrunya committed
228 229 230 231 232 233 234 235 236 237 238
#ifdef USE_MARIA_FOR_TMP_TABLES
static my_bool use_maria_for_temp_tables= 1;
#else
static my_bool use_maria_for_temp_tables= 0;
#endif

static MYSQL_SYSVAR_BOOL(used_for_temp_tables, 
       use_maria_for_temp_tables, PLUGIN_VAR_READONLY | PLUGIN_VAR_NOCMDOPT,
       "Whether temporary tables should be MyISAM or Maria", 0, 0,
       1);

239 240 241 242
/*****************************************************************************
** MARIA tables
*****************************************************************************/

243 244 245
static handler *maria_create_handler(handlerton *hton,
                                     TABLE_SHARE * table,
                                     MEM_ROOT *mem_root)
246
{
247
  return new (mem_root) ha_maria(hton, table);
248 249 250 251 252 253 254 255 256 257 258
}


// collect errors printed by maria_check routines

static void _ma_check_print_msg(HA_CHECK *param, const char *msg_type,
                                const char *fmt, va_list args)
{
  THD *thd= (THD *) param->thd;
  Protocol *protocol= thd->protocol;
  uint length, msg_length;
259
  char msgbuf[HA_MAX_MSG_BUF];
260 261 262 263 264 265 266 267 268
  char name[NAME_LEN * 2 + 2];

  msg_length= my_vsnprintf(msgbuf, sizeof(msgbuf), fmt, args);
  msgbuf[sizeof(msgbuf) - 1]= 0;                // healthy paranoia

  DBUG_PRINT(msg_type, ("message: %s", msgbuf));

  if (!thd->vio_ok())
  {
269
    sql_print_error(fmt, args);
270 271 272 273 274 275 276 277 278 279 280
    return;
  }

  if (param->testflag &
      (T_CREATE_MISSING_KEYS | T_SAFE_REPAIR | T_AUTO_REPAIR))
  {
    my_message(ER_NOT_KEYFILE, msgbuf, MYF(MY_WME));
    return;
  }
  length= (uint) (strxmov(name, param->db_name, ".", param->table_name,
                          NullS) - name);
281 282 283 284 285 286 287 288
  /*
    TODO: switch from protocol to push_warning here. The main reason we didn't
    it yet is parallel repair. Due to following trace:
    ma_check_print_msg/push_warning/sql_alloc/my_pthread_getspecific_ptr.

    Also we likely need to lock mutex here (in both cases with protocol and
    push_warning).
  */
289 290 291 292 293 294 295 296 297 298 299
  protocol->prepare_for_resend();
  protocol->store(name, length, system_charset_info);
  protocol->store(param->op_name, system_charset_info);
  protocol->store(msg_type, system_charset_info);
  protocol->store(msgbuf, msg_length, system_charset_info);
  if (protocol->write())
    sql_print_error("Failed on my_net_write, writing to stderr instead: %s\n",
                    msgbuf);
  return;
}

300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315

/*
  Convert TABLE object to Maria key and column definition

  SYNOPSIS
    table2maria()
      table_arg   in     TABLE object.
      keydef_out  out    Maria key definition.
      recinfo_out out    Maria column definition.
      records_out out    Number of fields.

  DESCRIPTION
    This function will allocate and initialize Maria key and column
    definition for further use in ma_create or for a check for underlying
    table conformance in merge engine.

316 317 318 319
    The caller needs to free *recinfo_out after use. Since *recinfo_out
    and *keydef_out are allocated with a my_multi_malloc, *keydef_out
    is freed automatically when *recinfo_out is freed.

320 321
  RETURN VALUE
    0  OK
322
    # error code
323 324
*/

325 326 327 328
static int table2maria(TABLE *table_arg, data_file_type row_type,
                       MARIA_KEYDEF **keydef_out,
                       MARIA_COLUMNDEF **recinfo_out, uint *records_out,
                       MARIA_CREATE_INFO *create_info)
329 330 331
{
  uint i, j, recpos, minpos, fieldpos, temp_length, length;
  enum ha_base_keytype type= HA_KEYTYPE_BINARY;
unknown's avatar
unknown committed
332
  uchar *record;
333 334 335 336 337 338 339
  KEY *pos;
  MARIA_KEYDEF *keydef;
  MARIA_COLUMNDEF *recinfo, *recinfo_pos;
  HA_KEYSEG *keyseg;
  TABLE_SHARE *share= table_arg->s;
  uint options= share->db_options_in_use;
  DBUG_ENTER("table2maria");
340

341 342 343
  if (row_type == BLOCK_RECORD)
    options|= HA_OPTION_PACK_RECORD;

344 345 346 347 348 349 350 351 352 353 354 355
  if (!(my_multi_malloc(MYF(MY_WME),
          recinfo_out, (share->fields * 2 + 2) * sizeof(MARIA_COLUMNDEF),
          keydef_out, share->keys * sizeof(MARIA_KEYDEF),
          &keyseg,
          (share->key_parts + share->keys) * sizeof(HA_KEYSEG),
          NullS)))
    DBUG_RETURN(HA_ERR_OUT_OF_MEM); /* purecov: inspected */
  keydef= *keydef_out;
  recinfo= *recinfo_out;
  pos= table_arg->key_info;
  for (i= 0; i < share->keys; i++, pos++)
  {
356 357
    keydef[i].flag= (uint16) (pos->flags & (HA_NOSAME | HA_FULLTEXT |
                                            HA_SPATIAL));
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
    keydef[i].key_alg= pos->algorithm == HA_KEY_ALG_UNDEF ?
      (pos->flags & HA_SPATIAL ? HA_KEY_ALG_RTREE : HA_KEY_ALG_BTREE) :
      pos->algorithm;
    keydef[i].block_length= pos->block_size;
    keydef[i].seg= keyseg;
    keydef[i].keysegs= pos->key_parts;
    for (j= 0; j < pos->key_parts; j++)
    {
      Field *field= pos->key_part[j].field;
      type= field->key_type();
      keydef[i].seg[j].flag= pos->key_part[j].key_part_flag;

      if (options & HA_OPTION_PACK_KEYS ||
          (pos->flags & (HA_PACK_KEY | HA_BINARY_PACK_KEY |
                         HA_SPACE_PACK_USED)))
      {
        if (pos->key_part[j].length > 8 &&
            (type == HA_KEYTYPE_TEXT ||
             type == HA_KEYTYPE_NUM ||
             (type == HA_KEYTYPE_BINARY && !field->zero_pack())))
        {
          /* No blobs here */
          if (j == 0)
            keydef[i].flag|= HA_PACK_KEY;
          if (!(field->flags & ZEROFILL_FLAG) &&
              (field->type() == MYSQL_TYPE_STRING ||
               field->type() == MYSQL_TYPE_VAR_STRING ||
               ((int) (pos->key_part[j].length - field->decimals())) >= 4))
            keydef[i].seg[j].flag|= HA_SPACE_PACK;
        }
        else if (j == 0 && (!(pos->flags & HA_NOSAME) || pos->key_length > 16))
          keydef[i].flag|= HA_BINARY_PACK_KEY;
      }
      keydef[i].seg[j].type= (int) type;
      keydef[i].seg[j].start= pos->key_part[j].offset;
      keydef[i].seg[j].length= pos->key_part[j].length;
      keydef[i].seg[j].bit_start= keydef[i].seg[j].bit_end=
        keydef[i].seg[j].bit_length= 0;
      keydef[i].seg[j].bit_pos= 0;
      keydef[i].seg[j].language= field->charset()->number;

      if (field->null_ptr)
      {
        keydef[i].seg[j].null_bit= field->null_bit;
        keydef[i].seg[j].null_pos= (uint) (field->null_ptr-
                                           (uchar*) table_arg->record[0]);
      }
      else
      {
        keydef[i].seg[j].null_bit= 0;
        keydef[i].seg[j].null_pos= 0;
      }
      if (field->type() == MYSQL_TYPE_BLOB ||
          field->type() == MYSQL_TYPE_GEOMETRY)
      {
        keydef[i].seg[j].flag|= HA_BLOB_PART;
        /* save number of bytes used to pack length */
        keydef[i].seg[j].bit_start= (uint) (field->pack_length() -
                                            share->blob_ptr_size);
      }
      else if (field->type() == MYSQL_TYPE_BIT)
      {
        keydef[i].seg[j].bit_length= ((Field_bit *) field)->bit_len;
        keydef[i].seg[j].bit_start= ((Field_bit *) field)->bit_ofs;
        keydef[i].seg[j].bit_pos= (uint) (((Field_bit *) field)->bit_ptr -
                                          (uchar*) table_arg->record[0]);
      }
    }
    keyseg+= pos->key_parts;
  }
  if (table_arg->found_next_number_field)
    keydef[share->next_number_index].flag|= HA_AUTO_KEY;
  record= table_arg->record[0];
  recpos= 0;
  recinfo_pos= recinfo;
433 434
  create_info->null_bytes= table_arg->s->null_bytes;

435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
  while (recpos < (uint) share->reclength)
  {
    Field **field, *found= 0;
    minpos= share->reclength;
    length= 0;

    for (field= table_arg->field; *field; field++)
    {
      if ((fieldpos= (*field)->offset(record)) >= recpos &&
          fieldpos <= minpos)
      {
        /* skip null fields */
        if (!(temp_length= (*field)->pack_length_in_rec()))
          continue; /* Skip null-fields */
        if (! found || fieldpos < minpos ||
            (fieldpos == minpos && temp_length < length))
        {
          minpos= fieldpos;
          found= *field;
          length= temp_length;
        }
      }
    }
    DBUG_PRINT("loop", ("found: 0x%lx  recpos: %d  minpos: %d  length: %d",
                        (long) found, recpos, minpos, length));
    if (!found)
      break;

    if (found->flags & BLOB_FLAG)
      recinfo_pos->type= FIELD_BLOB;
    else if (found->type() == MYSQL_TYPE_VARCHAR)
      recinfo_pos->type= FIELD_VARCHAR;
467 468
    else if (!(options & HA_OPTION_PACK_RECORD) ||
             (found->zero_pack() && (found->flags & PRI_KEY_FLAG)))
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
      recinfo_pos->type= FIELD_NORMAL;
    else if (found->zero_pack())
      recinfo_pos->type= FIELD_SKIP_ZERO;
    else
      recinfo_pos->type= ((length <= 3 ||
                           (found->flags & ZEROFILL_FLAG)) ?
                          FIELD_NORMAL :
                          found->type() == MYSQL_TYPE_STRING ||
                          found->type() == MYSQL_TYPE_VAR_STRING ?
                          FIELD_SKIP_ENDSPACE :
                          FIELD_SKIP_PRESPACE);
    if (found->null_ptr)
    {
      recinfo_pos->null_bit= found->null_bit;
      recinfo_pos->null_pos= (uint) (found->null_ptr -
                                     (uchar*) table_arg->record[0]);
    }
    else
    {
      recinfo_pos->null_bit= 0;
      recinfo_pos->null_pos= 0;
    }
    (recinfo_pos++)->length= (uint16) length;
    recpos= minpos + length;
    DBUG_PRINT("loop", ("length: %d  type: %d",
                        recinfo_pos[-1].length,recinfo_pos[-1].type));
  }
  *records_out= (uint) (recinfo_pos - recinfo);
  DBUG_RETURN(0);
}


/*
  Check for underlying table conformance

  SYNOPSIS
    maria_check_definition()
      t1_keyinfo       in    First table key definition
      t1_recinfo       in    First table record definition
      t1_keys          in    Number of keys in first table
      t1_recs          in    Number of records in first table
      t2_keyinfo       in    Second table key definition
      t2_recinfo       in    Second table record definition
      t2_keys          in    Number of keys in second table
      t2_recs          in    Number of records in second table
      strict           in    Strict check switch

  DESCRIPTION
    This function compares two Maria definitions. By intention it was done
    to compare merge table definition against underlying table definition.
    It may also be used to compare dot-frm and MAI definitions of Maria
    table as well to compare different Maria table definitions.

    For merge table it is not required that number of keys in merge table
    must exactly match number of keys in underlying table. When calling this
    function for underlying table conformance check, 'strict' flag must be
    set to false, and converted merge definition must be passed as t1_*.

    Otherwise 'strict' flag must be set to 1 and it is not required to pass
    converted dot-frm definition as t1_*.

  RETURN VALUE
    0 - Equal definitions.
    1 - Different definitions.

534 535 536 537
  TODO
    - compare FULLTEXT keys;
    - compare SPATIAL keys;
    - compare FIELD_SKIP_ZERO which is converted to FIELD_NORMAL correctly
538
      (should be correctly detected in table2maria).
539
*/
540

541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
int maria_check_definition(MARIA_KEYDEF *t1_keyinfo,
                           MARIA_COLUMNDEF *t1_recinfo,
                           uint t1_keys, uint t1_recs,
                           MARIA_KEYDEF *t2_keyinfo,
                           MARIA_COLUMNDEF *t2_recinfo,
                           uint t2_keys, uint t2_recs, bool strict)
{
  uint i, j;
  DBUG_ENTER("maria_check_definition");
  if ((strict ? t1_keys != t2_keys : t1_keys > t2_keys))
  {
    DBUG_PRINT("error", ("Number of keys differs: t1_keys=%u, t2_keys=%u",
                         t1_keys, t2_keys));
    DBUG_RETURN(1);
  }
  if (t1_recs != t2_recs)
  {
    DBUG_PRINT("error", ("Number of recs differs: t1_recs=%u, t2_recs=%u",
                         t1_recs, t2_recs));
    DBUG_RETURN(1);
  }
  for (i= 0; i < t1_keys; i++)
  {
    HA_KEYSEG *t1_keysegs= t1_keyinfo[i].seg;
    HA_KEYSEG *t2_keysegs= t2_keyinfo[i].seg;
566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
    if (t1_keyinfo[i].flag & HA_FULLTEXT && t2_keyinfo[i].flag & HA_FULLTEXT)
      continue;
    else if (t1_keyinfo[i].flag & HA_FULLTEXT ||
             t2_keyinfo[i].flag & HA_FULLTEXT)
    {
       DBUG_PRINT("error", ("Key %d has different definition", i));
       DBUG_PRINT("error", ("t1_fulltext= %d, t2_fulltext=%d",
                            test(t1_keyinfo[i].flag & HA_FULLTEXT),
                            test(t2_keyinfo[i].flag & HA_FULLTEXT)));
       DBUG_RETURN(1);
    }
    if (t1_keyinfo[i].flag & HA_SPATIAL && t2_keyinfo[i].flag & HA_SPATIAL)
      continue;
    else if (t1_keyinfo[i].flag & HA_SPATIAL ||
             t2_keyinfo[i].flag & HA_SPATIAL)
    {
       DBUG_PRINT("error", ("Key %d has different definition", i));
       DBUG_PRINT("error", ("t1_spatial= %d, t2_spatial=%d",
                            test(t1_keyinfo[i].flag & HA_SPATIAL),
                            test(t2_keyinfo[i].flag & HA_SPATIAL)));
       DBUG_RETURN(1);
    }
588 589 590 591 592 593 594 595 596 597 598 599
    if (t1_keyinfo[i].keysegs != t2_keyinfo[i].keysegs ||
        t1_keyinfo[i].key_alg != t2_keyinfo[i].key_alg)
    {
      DBUG_PRINT("error", ("Key %d has different definition", i));
      DBUG_PRINT("error", ("t1_keysegs=%d, t1_key_alg=%d",
                           t1_keyinfo[i].keysegs, t1_keyinfo[i].key_alg));
      DBUG_PRINT("error", ("t2_keysegs=%d, t2_key_alg=%d",
                           t2_keyinfo[i].keysegs, t2_keyinfo[i].key_alg));
      DBUG_RETURN(1);
    }
    for (j=  t1_keyinfo[i].keysegs; j--;)
    {
600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
      uint8 t1_keysegs_j__type= t1_keysegs[j].type;
      /*
        Table migration from 4.1 to 5.1. In 5.1 a *TEXT key part is
        always HA_KEYTYPE_VARTEXT2. In 4.1 we had only the equivalent of
        HA_KEYTYPE_VARTEXT1. Since we treat both the same on MyISAM
        level, we can ignore a mismatch between these types.
      */
      if ((t1_keysegs[j].flag & HA_BLOB_PART) &&
          (t2_keysegs[j].flag & HA_BLOB_PART))
      {
        if ((t1_keysegs_j__type == HA_KEYTYPE_VARTEXT2) &&
            (t2_keysegs[j].type == HA_KEYTYPE_VARTEXT1))
          t1_keysegs_j__type= HA_KEYTYPE_VARTEXT1; /* purecov: tested */
        else if ((t1_keysegs_j__type == HA_KEYTYPE_VARBINARY2) &&
                 (t2_keysegs[j].type == HA_KEYTYPE_VARBINARY1))
          t1_keysegs_j__type= HA_KEYTYPE_VARBINARY1; /* purecov: inspected */
      }

      if (t1_keysegs_j__type != t2_keysegs[j].type ||
619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
          t1_keysegs[j].language != t2_keysegs[j].language ||
          t1_keysegs[j].null_bit != t2_keysegs[j].null_bit ||
          t1_keysegs[j].length != t2_keysegs[j].length)
      {
        DBUG_PRINT("error", ("Key segment %d (key %d) has different "
                             "definition", j, i));
        DBUG_PRINT("error", ("t1_type=%d, t1_language=%d, t1_null_bit=%d, "
                             "t1_length=%d",
                             t1_keysegs[j].type, t1_keysegs[j].language,
                             t1_keysegs[j].null_bit, t1_keysegs[j].length));
        DBUG_PRINT("error", ("t2_type=%d, t2_language=%d, t2_null_bit=%d, "
                             "t2_length=%d",
                             t2_keysegs[j].type, t2_keysegs[j].language,
                             t2_keysegs[j].null_bit, t2_keysegs[j].length));

        DBUG_RETURN(1);
      }
    }
  }
638

639 640 641 642
  for (i= 0; i < t1_recs; i++)
  {
    MARIA_COLUMNDEF *t1_rec= &t1_recinfo[i];
    MARIA_COLUMNDEF *t2_rec= &t2_recinfo[i];
643 644 645 646 647 648 649 650
    /*
      FIELD_SKIP_ZERO can be changed to FIELD_NORMAL in maria_create,
      see NOTE1 in ma_create.c
    */
    if ((t1_rec->type != t2_rec->type &&
         !(t1_rec->type == (int) FIELD_SKIP_ZERO &&
           t1_rec->length == 1 &&
           t2_rec->type == (int) FIELD_NORMAL)) ||
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665
        t1_rec->length != t2_rec->length ||
        t1_rec->null_bit != t2_rec->null_bit)
    {
      DBUG_PRINT("error", ("Field %d has different definition", i));
      DBUG_PRINT("error", ("t1_type=%d, t1_length=%d, t1_null_bit=%d",
                           t1_rec->type, t1_rec->length, t1_rec->null_bit));
      DBUG_PRINT("error", ("t2_type=%d, t2_length=%d, t2_null_bit=%d",
                           t2_rec->type, t2_rec->length, t2_rec->null_bit));
      DBUG_RETURN(1);
    }
  }
  DBUG_RETURN(0);
}


666 667 668 669 670 671 672 673 674 675 676
extern "C" {

volatile int *_ma_killed_ptr(HA_CHECK *param)
{
  /* In theory Unsafe conversion, but should be ok for now */
  return (int*) &(((THD *) (param->thd))->killed);
}


void _ma_check_print_error(HA_CHECK *param, const char *fmt, ...)
{
677 678
  va_list args;
  DBUG_ENTER("_ma_check_print_error");
679 680 681 682 683
  param->error_printed |= 1;
  param->out_flag |= O_DATA_LOST;
  va_start(args, fmt);
  _ma_check_print_msg(param, "error", fmt, args);
  va_end(args);
684
  DBUG_VOID_RETURN;
685 686 687 688 689 690
}


void _ma_check_print_info(HA_CHECK *param, const char *fmt, ...)
{
  va_list args;
691
  DBUG_ENTER("_ma_check_print_info");
692 693 694
  va_start(args, fmt);
  _ma_check_print_msg(param, "info", fmt, args);
  va_end(args);
695
  DBUG_VOID_RETURN;
696 697 698 699 700
}


void _ma_check_print_warning(HA_CHECK *param, const char *fmt, ...)
{
701 702
  va_list args;
  DBUG_ENTER("_ma_check_print_warning");
703 704 705 706 707
  param->warning_printed= 1;
  param->out_flag |= O_DATA_LOST;
  va_start(args, fmt);
  _ma_check_print_msg(param, "warning", fmt, args);
  va_end(args);
708
  DBUG_VOID_RETURN;
709 710 711 712
}

}

713 714 715 716 717 718 719
/**
  Transactional table doing bulk insert with one single UNDO
  (UNDO_BULK_INSERT) and with repair.
*/
#define BULK_INSERT_SINGLE_UNDO_AND_REPAIR    1
/**
  Transactional table doing bulk insert with one single UNDO
720
  (UNDO_BULK_INSERT) and without repair.
721 722 723 724 725 726 727
*/
#define BULK_INSERT_SINGLE_UNDO_AND_NO_REPAIR 2
/**
  None of BULK_INSERT_SINGLE_UNDO_AND_REPAIR and
  BULK_INSERT_SINGLE_UNDO_AND_NO_REPAIR.
*/
#define BULK_INSERT_NONE      0
728

729 730
ha_maria::ha_maria(handlerton *hton, TABLE_SHARE *table_arg):
handler(hton, table_arg), file(0),
731
int_table_flags(HA_NULL_IN_KEY | HA_CAN_FULLTEXT | HA_CAN_SQL_HANDLER |
732
                HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE |
733
                HA_DUPLICATE_POS | HA_CAN_INDEX_BLOBS | HA_AUTO_PART_KEY |
Sergei Golubchik's avatar
Sergei Golubchik committed
734
                HA_FILE_BASED | HA_CAN_GEOMETRY | CANNOT_ROLLBACK_FLAG |
unknown's avatar
unknown committed
735
                HA_CAN_BIT_FIELD | HA_CAN_RTREEKEYS |
736
                HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT),
737
can_enable_indexes(1), bulk_insert_single_undo(BULK_INSERT_NONE)
738 739 740
{}


741 742 743 744 745 746 747 748 749
handler *ha_maria::clone(MEM_ROOT *mem_root)
{
  ha_maria *new_handler= static_cast <ha_maria *>(handler::clone(mem_root));
  if (new_handler)
    new_handler->file->state= file->state;
  return new_handler;
}


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
static const char *ha_maria_exts[]=
{
  MARIA_NAME_IEXT,
  MARIA_NAME_DEXT,
  NullS
};


const char **ha_maria::bas_ext() const
{
  return ha_maria_exts;
}


const char *ha_maria::index_type(uint key_number)
{
  return ((table->key_info[key_number].flags & HA_FULLTEXT) ?
          "FULLTEXT" :
          (table->key_info[key_number].flags & HA_SPATIAL) ?
          "SPATIAL" :
          (table->key_info[key_number].algorithm == HA_KEY_ALG_RTREE) ?
          "RTREE" : "BTREE");
}


unknown's avatar
unknown committed
775 776 777 778 779 780 781
double ha_maria::scan_time()
{
  if (file->s->data_file_type == BLOCK_RECORD)
    return ulonglong2double(stats.data_file_length - file->s->block_size) / max(file->s->block_size / 2, IO_SIZE) + 2;
  return handler::scan_time();
}

782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
/*
  We need to be able to store at least two keys on an index page as the
  splitting algorithms depends on this. (With only one key on a page
  we also can't use any compression, which may make the index file much
  larger)
  We use HA_MAX_KEY_BUFF as this is a stack restriction imposed by the
  handler interface.

  We also need to reserve place for a record pointer (8) and 3 bytes
  per key segment to store the length of the segment + possible null bytes.
  These extra bytes are required here so that maria_create() will surely
  accept any keys created which the returned key data storage length.
*/

uint ha_maria::max_supported_key_length() const
{
  uint tmp= (maria_max_key_length() - 8 - HA_MAX_KEY_SEG*3);
  return min(HA_MAX_KEY_BUFF, tmp);
}

unknown's avatar
unknown committed
802

803 804 805
#ifdef HAVE_REPLICATION
int ha_maria::net_read_dump(NET * net)
{
unknown's avatar
unknown committed
806
  int data_fd= file->dfile.file;
807 808 809 810 811 812 813 814 815 816 817 818 819 820
  int error= 0;

  my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
  for (;;)
  {
    ulong packet_len= my_net_read(net);
    if (!packet_len)
      break;                                    // end of file
    if (packet_len == packet_error)
    {
      sql_print_error("ha_maria::net_read_dump - read error ");
      error= -1;
      goto err;
    }
unknown's avatar
unknown committed
821
    if (my_write(data_fd, (uchar *) net->read_pos, (uint) packet_len,
822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
                 MYF(MY_WME | MY_FNABP)))
    {
      error= errno;
      goto err;
    }
  }
err:
  return error;
}


int ha_maria::dump(THD * thd, int fd)
{
  MARIA_SHARE *share= file->s;
  NET *net= &thd->net;
unknown's avatar
unknown committed
837
  uint block_size= share->block_size;
838
  my_off_t bytes_to_read= share->state.state.data_file_length;
unknown's avatar
unknown committed
839
  int data_fd= file->dfile.file;
unknown's avatar
unknown committed
840
  uchar *buf= (uchar *) my_malloc(block_size, MYF(MY_WME));
841 842 843 844 845 846 847
  if (!buf)
    return ENOMEM;

  int error= 0;
  my_seek(data_fd, 0L, MY_SEEK_SET, MYF(MY_WME));
  for (; bytes_to_read > 0;)
  {
848
    size_t bytes= my_read(data_fd, buf, block_size, MYF(MY_WME));
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
    if (bytes == MY_FILE_ERROR)
    {
      error= errno;
      goto err;
    }

    if (fd >= 0)
    {
      if (my_write(fd, buf, bytes, MYF(MY_WME | MY_FNABP)))
      {
        error= errno ? errno : EPIPE;
        goto err;
      }
    }
    else
    {
unknown's avatar
unknown committed
865
      if (my_net_write(net, buf, bytes))
866 867 868 869 870 871 872 873 874 875
      {
        error= errno ? errno : EPIPE;
        goto err;
      }
    }
    bytes_to_read -= bytes;
  }

  if (fd < 0)
  {
unknown's avatar
unknown committed
876
    if (my_net_write(net, (uchar*) "", 0))
877 878 879 880 881
      error= errno ? errno : EPIPE;
    net_flush(net);
  }

err:
unknown's avatar
unknown committed
882
  my_free((uchar*) buf, MYF(0));
883 884 885 886 887 888 889 890 891
  return error;
}
#endif                                          /* HAVE_REPLICATION */

        /* Name is here without an extension */

int ha_maria::open(const char *name, int mode, uint test_if_locked)
{
  uint i;
892 893 894 895 896 897 898 899 900 901

#ifdef NOT_USED
  /*
    If the user wants to have memory mapped data files, add an
    open_flag. Do not memory map temporary tables because they are
    expected to be inserted and thus extended a lot. Memory mapping is
    efficient for files that keep their size, but very inefficient for
    growing files. Using an open_flag instead of calling ma_extra(...
    HA_EXTRA_MMAP ...) after maxs_open() has the advantage that the
    mapping is not repeated for every open, but just done on the initial
unknown's avatar
unknown committed
902
    open, when the MyISAM share is created. Every time the server
903 904 905 906 907 908 909 910 911 912
    requires to open a new instance of a table it calls this method. We
    will always supply HA_OPEN_MMAP for a permanent table. However, the
    Maria storage engine will ignore this flag if this is a secondary
    open of a table that is in use by other threads already (if the
    Maria share exists already).
  */
  if (!(test_if_locked & HA_OPEN_TMP_TABLE) && opt_maria_use_mmap)
    test_if_locked|= HA_OPEN_MMAP;
#endif

913 914 915 916 917 918
  if (unlikely(maria_recover_options != HA_RECOVER_NONE))
  {
    /* user asked to trigger a repair if table was not properly closed */
    test_if_locked|= HA_OPEN_ABORT_IF_CRASHED;
  }

919 920 921
  if (!(file= maria_open(name, mode, test_if_locked | HA_OPEN_FROM_SQL_LAYER)))
    return (my_errno ? my_errno : -1);

922 923
  file->s->chst_invalidator= query_cache_invalidate_by_MyISAM_filename_ref;

924 925 926 927 928 929
  if (test_if_locked & (HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_TMP_TABLE))
    VOID(maria_extra(file, HA_EXTRA_NO_WAIT_LOCK, 0));

  info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
  if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))
    VOID(maria_extra(file, HA_EXTRA_WAIT_LOCK, 0));
930
  if ((data_file_type= file->s->data_file_type) != STATIC_RECORD)
931
    int_table_flags |= HA_REC_NOT_IN_SEQ;
unknown's avatar
unknown committed
932 933 934 935 936 937 938 939 940 941 942
  if (!file->s->base.born_transactional)
  {
    /*
      INSERT DELAYED cannot work with transactional tables (because it cannot
      stand up to "when client gets ok the data is safe on disk": the record
      may not even be inserted). In the future, we could enable it back (as a
      client doing INSERT DELAYED knows the specificities; but we then should
      make sure to regularly commit in the delayed_insert thread). 
    */
    int_table_flags|= HA_CAN_INSERT_DELAYED;
  }
943
  if (file->s->options & (HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD))
944
    int_table_flags |= HA_HAS_NEW_CHECKSUM;
945 946 947

  for (i= 0; i < table->s->keys; i++)
  {
unknown's avatar
unknown committed
948
    plugin_ref parser= table->key_info[i].parser;
949 950
    if (table->key_info[i].flags & HA_USES_PARSER)
      file->s->keyinfo[i].parser=
unknown's avatar
unknown committed
951
        (struct st_mysql_ftparser *)plugin_decl(parser)->info;
952
    table->key_info[i].block_size= file->s->keyinfo[i].block_length;
953
  }
954 955
  my_errno= 0;
  return my_errno;
956 957 958 959 960 961 962 963 964 965 966
}


int ha_maria::close(void)
{
  MARIA_HA *tmp= file;
  file= 0;
  return maria_close(tmp);
}


unknown's avatar
unknown committed
967
int ha_maria::write_row(uchar * buf)
968
{
969
  ha_statistic_increment(&SSV::ha_write_count);
970 971 972 973 974 975 976 977 978 979

  /* If we have a timestamp column, update it to the current time */
  if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
    table->timestamp_field->set_time();

  /*
     If we have an auto_increment column and we are writing a changed row
     or a new row, then update the auto_increment value in the record.
  */
  if (table->next_number_field && buf == table->record[0])
980 981 982 983 984
  {
    int error;
    if ((error= update_auto_increment()))
      return error;
  }
985 986 987 988 989 990 991 992 993 994 995
  return maria_write(file, buf);
}


int ha_maria::check(THD * thd, HA_CHECK_OPT * check_opt)
{
  if (!file)
    return HA_ADMIN_INTERNAL_ERROR;
  int error;
  HA_CHECK param;
  MARIA_SHARE *share= file->s;
unknown's avatar
unknown committed
996
  const char *old_proc_info= thd_proc_info(thd, "Checking table");
997

unknown's avatar
unknown committed
998
  maria_chk_init(&param);
999 1000 1001 1002 1003
  param.thd= thd;
  param.op_name= "check";
  param.db_name= table->s->db.str;
  param.table_name= table->alias;
  param.testflag= check_opt->flags | T_CHECK | T_SILENT;
1004
  param.stats_method= (enum_handler_stats_method)THDVAR(thd,stats_method);
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019

  if (!(table->db_stat & HA_READ_ONLY))
    param.testflag |= T_STATISTICS;
  param.using_global_keycache= 1;

  if (!maria_is_crashed(file) &&
      (((param.testflag & T_CHECK_ONLY_CHANGED) &&
        !(share->state.changed & (STATE_CHANGED | STATE_CRASHED |
                                  STATE_CRASHED_ON_REPAIR)) &&
        share->state.open_count == 0) ||
       ((param.testflag & T_FAST) && (share->state.open_count ==
                                      (uint) (share->global_changed ? 1 :
                                              0)))))
    return HA_ADMIN_ALREADY_DONE;

unknown's avatar
unknown committed
1020 1021
  maria_chk_init_for_check(&param, file);
  (void) maria_chk_status(&param, file);                // Not fatal
1022 1023
  error= maria_chk_size(&param, file);
  if (!error)
1024
    error|= maria_chk_del(&param, file, param.testflag);
1025 1026 1027 1028 1029 1030 1031 1032 1033
  if (!error)
    error= maria_chk_key(&param, file);
  if (!error)
  {
    if ((!(param.testflag & T_QUICK) &&
         ((share->options &
           (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ||
          (param.testflag & (T_EXTEND | T_MEDIUM)))) || maria_is_crashed(file))
    {
1034
      ulonglong old_testflag= param.testflag;
1035
      param.testflag |= T_MEDIUM;
unknown's avatar
unknown committed
1036
      if (!(error= init_io_cache(&param.read_cache, file->dfile.file,
1037 1038 1039
                                 my_default_record_cache_size, READ_CACHE,
                                 share->pack.header_length, 1, MYF(MY_WME))))
      {
1040 1041
        error= maria_chk_data_link(&param, file,
                                   test(param.testflag & T_EXTEND));
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
        end_io_cache(&(param.read_cache));
      }
      param.testflag= old_testflag;
    }
  }
  if (!error)
  {
    if ((share->state.changed & (STATE_CHANGED |
                                 STATE_CRASHED_ON_REPAIR |
                                 STATE_CRASHED | STATE_NOT_ANALYZED)) ||
        (param.testflag & T_STATISTICS) || maria_is_crashed(file))
    {
      file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
      pthread_mutex_lock(&share->intern_lock);
      share->state.changed &= ~(STATE_CHANGED | STATE_CRASHED |
                                STATE_CRASHED_ON_REPAIR);
      if (!(table->db_stat & HA_READ_ONLY))
1059 1060 1061
        error= maria_update_state_info(&param, file,
                                       UPDATE_TIME | UPDATE_OPEN_COUNT |
                                       UPDATE_STAT);
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
      pthread_mutex_unlock(&share->intern_lock);
      info(HA_STATUS_NO_LOCK | HA_STATUS_TIME | HA_STATUS_VARIABLE |
           HA_STATUS_CONST);
    }
  }
  else if (!maria_is_crashed(file) && !thd->killed)
  {
    maria_mark_crashed(file);
    file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
  }

unknown's avatar
unknown committed
1073
  thd_proc_info(thd, old_proc_info);
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089
  return error ? HA_ADMIN_CORRUPT : HA_ADMIN_OK;
}


/*
  Analyze the key distribution in the table
  As the table may be only locked for read, we have to take into account that
  two threads may do an analyze at the same time!
*/

int ha_maria::analyze(THD *thd, HA_CHECK_OPT * check_opt)
{
  int error= 0;
  HA_CHECK param;
  MARIA_SHARE *share= file->s;

unknown's avatar
unknown committed
1090
  maria_chk_init(&param);
1091 1092 1093 1094 1095 1096 1097
  param.thd= thd;
  param.op_name= "analyze";
  param.db_name= table->s->db.str;
  param.table_name= table->alias;
  param.testflag= (T_FAST | T_CHECK | T_SILENT | T_STATISTICS |
                   T_DONT_CHECK_CHECKSUM);
  param.using_global_keycache= 1;
1098
  param.stats_method= (enum_handler_stats_method)THDVAR(thd,stats_method);
1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120

  if (!(share->state.changed & STATE_NOT_ANALYZED))
    return HA_ADMIN_ALREADY_DONE;

  error= maria_chk_key(&param, file);
  if (!error)
  {
    pthread_mutex_lock(&share->intern_lock);
    error= maria_update_state_info(&param, file, UPDATE_STAT);
    pthread_mutex_unlock(&share->intern_lock);
  }
  else if (!maria_is_crashed(file) && !thd->killed)
    maria_mark_crashed(file);
  return error ? HA_ADMIN_CORRUPT : HA_ADMIN_OK;
}


int ha_maria::restore(THD * thd, HA_CHECK_OPT *check_opt)
{
  HA_CHECK_OPT tmp_check_opt;
  char *backup_dir= thd->lex->backup_dir;
  char src_path[FN_REFLEN], dst_path[FN_REFLEN];
1121
  char table_name[FN_REFLEN];
1122 1123 1124 1125
  int error;
  const char *errmsg;
  DBUG_ENTER("restore");

1126 1127 1128
  VOID(tablename_to_filename(table->s->table_name.str, table_name,
                             sizeof(table_name)));

1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
  if (fn_format_relative_to_data_home(src_path, table_name, backup_dir,
                                      MARIA_NAME_DEXT))
    DBUG_RETURN(HA_ADMIN_INVALID);

  strxmov(dst_path, table->s->normalized_path.str, MARIA_NAME_DEXT, NullS);
  if (my_copy(src_path, dst_path, MYF(MY_WME)))
  {
    error= HA_ADMIN_FAILED;
    errmsg= "Failed in my_copy (Error %d)";
    goto err;
  }

  tmp_check_opt.init();
  tmp_check_opt.flags |= T_VERY_SILENT | T_CALC_CHECKSUM | T_QUICK;
  DBUG_RETURN(repair(thd, &tmp_check_opt));

err:
  {
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
    /*
      Don't allocate param on stack here as this may be huge and it's
      also allocated by repair()
    */
    HA_CHECK *param;
    if (!(param= (HA_CHECK*) my_malloc(sizeof(*param), MYF(MY_WME | MY_FAE))))
      DBUG_RETURN(error);
    maria_chk_init(param);
    param->thd= thd;
    param->op_name= "restore";
    param->db_name= table->s->db.str;
    param->table_name= table->s->table_name.str;
    param->testflag= 0;
    _ma_check_print_error(param, errmsg, my_errno);
    my_free(param, MYF(0));
1162 1163 1164 1165 1166 1167 1168 1169 1170
    DBUG_RETURN(error);
  }
}


int ha_maria::backup(THD * thd, HA_CHECK_OPT *check_opt)
{
  char *backup_dir= thd->lex->backup_dir;
  char src_path[FN_REFLEN], dst_path[FN_REFLEN];
1171
  char table_name[FN_REFLEN];
1172 1173 1174 1175
  int error;
  const char *errmsg;
  DBUG_ENTER("ha_maria::backup");

1176 1177 1178
  VOID(tablename_to_filename(table->s->table_name.str, table_name,
                             sizeof(table_name)));

1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
  if (fn_format_relative_to_data_home(dst_path, table_name, backup_dir,
                                      reg_ext))
  {
    errmsg= "Failed in fn_format() for .frm file (errno: %d)";
    error= HA_ADMIN_INVALID;
    goto err;
  }

  strxmov(src_path, table->s->normalized_path.str, reg_ext, NullS);
  if (my_copy(src_path, dst_path,
              MYF(MY_WME | MY_HOLD_ORIGINAL_MODES | MY_DONT_OVERWRITE_FILE)))
  {
    error= HA_ADMIN_FAILED;
    errmsg= "Failed copying .frm file (errno: %d)";
    goto err;
  }

  /* Change extension */
  if (fn_format_relative_to_data_home(dst_path, table_name, backup_dir,
                                      MARIA_NAME_DEXT))
  {
    errmsg= "Failed in fn_format() for .MYD file (errno: %d)";
    error= HA_ADMIN_INVALID;
    goto err;
  }

  strxmov(src_path, table->s->normalized_path.str, MARIA_NAME_DEXT, NullS);
unknown's avatar
unknown committed
1206 1207 1208 1209 1210 1211 1212
  if (_ma_flush_table_files(file, MARIA_FLUSH_DATA, FLUSH_FORCE_WRITE,
                            FLUSH_KEEP))
  {
    error= HA_ADMIN_FAILED;
    errmsg= "Failed in flush (Error %d)";
    goto err;
  }
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
  if (my_copy(src_path, dst_path,
              MYF(MY_WME | MY_HOLD_ORIGINAL_MODES | MY_DONT_OVERWRITE_FILE)))
  {
    errmsg= "Failed copying .MYD file (errno: %d)";
    error= HA_ADMIN_FAILED;
    goto err;
  }
  DBUG_RETURN(HA_ADMIN_OK);

err:
  {
    HA_CHECK param;
unknown's avatar
unknown committed
1225
    maria_chk_init(&param);
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
    param.thd= thd;
    param.op_name= "backup";
    param.db_name= table->s->db.str;
    param.table_name= table->s->table_name.str;
    param.testflag= 0;
    _ma_check_print_error(&param, errmsg, my_errno);
    DBUG_RETURN(error);
  }
}


int ha_maria::repair(THD * thd, HA_CHECK_OPT *check_opt)
{
  int error;
  HA_CHECK param;
  ha_rows start_records;

  if (!file)
    return HA_ADMIN_INTERNAL_ERROR;

unknown's avatar
unknown committed
1246
  maria_chk_init(&param);
1247 1248 1249 1250 1251
  param.thd= thd;
  param.op_name= "repair";
  param.testflag= ((check_opt->flags & ~(T_EXTEND)) |
                   T_SILENT | T_FORCE_CREATE | T_CALC_CHECKSUM |
                   (check_opt->flags & T_EXTEND ? T_REP : T_REP_BY_SORT));
1252
  param.sort_buffer_length= THDVAR(thd, sort_buffer_size);
1253
  start_records= file->state->records;
1254
  while ((error= repair(thd, &param, 0)) && param.retry_repair)
1255 1256 1257 1258 1259
  {
    param.retry_repair= 0;
    if (test_all_bits(param.testflag,
                      (uint) (T_RETRY_WITHOUT_QUICK | T_QUICK)))
    {
1260 1261 1262 1263 1264 1265 1266 1267
      param.testflag&= ~(T_RETRY_WITHOUT_QUICK | T_QUICK);
      /* Ensure we don't loose any rows when retrying without quick */
      param.testflag|= T_SAFE_REPAIR;
      if (thd->vio_ok())
        _ma_check_print_info(&param, "Retrying repair without quick");
      else
        sql_print_information("Retrying repair of: '%s' without quick",
                              table->s->path.str);
1268 1269 1270 1271 1272 1273 1274
      continue;
    }
    param.testflag &= ~T_QUICK;
    if ((param.testflag & T_REP_BY_SORT))
    {
      param.testflag= (param.testflag & ~T_REP_BY_SORT) | T_REP;
      sql_print_information("Retrying repair of: '%s' with keycache",
1275
                            table->s->path.str);
1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
      continue;
    }
    break;
  }
  if (!error && start_records != file->state->records &&
      !(check_opt->flags & T_VERY_SILENT))
  {
    char llbuff[22], llbuff2[22];
    sql_print_information("Found %s of %s rows when repairing '%s'",
                          llstr(file->state->records, llbuff),
1286 1287
                          llstr(start_records, llbuff2),
                          table->s->path.str);
1288 1289 1290 1291
  }
  return error;
}

1292 1293 1294 1295
int ha_maria::zerofill(THD * thd, HA_CHECK_OPT *check_opt)
{
  int error;
  HA_CHECK param;
1296
  MARIA_SHARE *share= file->s;
1297 1298 1299 1300 1301 1302 1303 1304

  if (!file)
    return HA_ADMIN_INTERNAL_ERROR;

  maria_chk_init(&param);
  param.thd= thd;
  param.op_name= "zerofill";
  param.testflag= check_opt->flags | T_SILENT | T_ZEROFILL;
1305
  param.sort_buffer_length= THDVAR(thd, sort_buffer_size);
1306
  error=maria_zerofill(&param, file, share->open_file_name.str);
1307

1308 1309 1310 1311 1312 1313
  if (!error)
  {
    pthread_mutex_lock(&share->intern_lock);
    maria_update_state_info(&param, file, UPDATE_TIME | UPDATE_OPEN_COUNT);
    pthread_mutex_unlock(&share->intern_lock);
  }
1314 1315 1316
  return error;
}

1317 1318 1319
int ha_maria::optimize(THD * thd, HA_CHECK_OPT *check_opt)
{
  int error;
1320
  HA_CHECK param;
1321 1322 1323
  if (!file)
    return HA_ADMIN_INTERNAL_ERROR;

unknown's avatar
unknown committed
1324
  maria_chk_init(&param);
1325 1326 1327 1328
  param.thd= thd;
  param.op_name= "optimize";
  param.testflag= (check_opt->flags | T_SILENT | T_FORCE_CREATE |
                   T_REP_BY_SORT | T_STATISTICS | T_SORT_INDEX);
1329
  param.sort_buffer_length= THDVAR(thd, sort_buffer_size);
1330
  if ((error= repair(thd, &param, 1)) && param.retry_repair)
1331
  {
1332 1333
    sql_print_warning("Warning: Optimize table got errno %d on %s.%s, retrying",
                      my_errno, param.db_name, param.table_name);
1334
    param.testflag &= ~T_REP_BY_SORT;
1335
    error= repair(thd, &param, 1);
1336 1337 1338 1339 1340
  }
  return error;
}


1341
int ha_maria::repair(THD *thd, HA_CHECK *param, bool do_optimize)
1342 1343
{
  int error= 0;
1344
  ulonglong local_testflag= param->testflag;
1345
  bool optimize_done= !do_optimize, statistics_done= 0;
1346 1347 1348 1349 1350 1351
  const char *old_proc_info= thd->proc_info;
  char fixed_name[FN_REFLEN];
  MARIA_SHARE *share= file->s;
  ha_rows rows= file->state->records;
  DBUG_ENTER("ha_maria::repair");

1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
  /*
    Normally this method is entered with a properly opened table. If the
    repair fails, it can be repeated with more elaborate options. Under
    special circumstances it can happen that a repair fails so that it
    closed the data file and cannot re-open it. In this case file->dfile
    is set to -1. We must not try another repair without an open data
    file. (Bug #25289)
  */
  if (file->dfile.file == -1)
  {
    sql_print_information("Retrying repair of: '%s' failed. "
                          "Please try REPAIR EXTENDED or maria_chk",
                          table->s->path.str);
    DBUG_RETURN(HA_ADMIN_FAILED);
  }

1368 1369 1370 1371 1372 1373 1374 1375
  /*
    If transactions was not enabled for a transactional table then
    file->s->status is not up to date. This is needed for repair_by_sort
    to work
  */
  if (share->base.born_transactional && !share->now_transactional)
    _ma_copy_nontrans_state_information(file);

1376 1377 1378 1379 1380 1381 1382
  param->db_name= table->s->db.str;
  param->table_name= table->alias;
  param->tmpfile_createflag= O_RDWR | O_TRUNC;
  param->using_global_keycache= 1;
  param->thd= thd;
  param->tmpdir= &mysql_tmpdir_list;
  param->out_flag= 0;
1383
  strmov(fixed_name, share->open_file_name.str);
1384 1385 1386 1387 1388

  // Don't lock tables if we have used LOCK TABLE
  if (!thd->locked_tables &&
      maria_lock_database(file, table->s->tmp_table ? F_EXTRA_LCK : F_WRLCK))
  {
1389
    _ma_check_print_error(param, ER(ER_CANT_LOCK), my_errno);
1390 1391 1392
    DBUG_RETURN(HA_ADMIN_FAILED);
  }

1393
  if (!do_optimize ||
1394 1395 1396 1397 1398 1399 1400
      (((share->data_file_type == BLOCK_RECORD) ?
        (share->state.changed & STATE_NOT_OPTIMIZED_ROWS) :
        (file->state->del ||
         share->state.split != file->state->records)) &&
       (!(param->testflag & T_QUICK) ||
        (share->state.changed & (STATE_NOT_OPTIMIZED_KEYS |
                                 STATE_NOT_OPTIMIZED_ROWS)))))
1401 1402 1403 1404
  {
    ulonglong key_map= ((local_testflag & T_CREATE_MISSING_KEYS) ?
                        maria_get_mask_all_keys_active(share->base.keys) :
                        share->state.key_map);
1405
    ulonglong save_testflag= param->testflag;
1406 1407 1408 1409
    if (maria_test_if_sort_rep(file, file->state->records, key_map, 0) &&
        (local_testflag & T_REP_BY_SORT))
    {
      local_testflag |= T_STATISTICS;
1410
      param->testflag |= T_STATISTICS;           // We get this for free
1411
      statistics_done= 1;
1412
      /* TODO: Remove BLOCK_RECORD test when parallel works with blocks */
1413
      if (THDVAR(thd,repair_threads) > 1 &&
1414
          share->data_file_type != BLOCK_RECORD)
1415 1416 1417 1418
      {
        char buf[40];
        /* TODO: respect maria_repair_threads variable */
        my_snprintf(buf, 40, "Repair with %d threads", my_count_bits(key_map));
unknown's avatar
unknown committed
1419
        thd_proc_info(thd, buf);
1420 1421 1422
        param->testflag|= T_REP_PARALLEL;
        error= maria_repair_parallel(param, file, fixed_name,
                                     test(param->testflag & T_QUICK));
unknown's avatar
unknown committed
1423 1424
        /* to reset proc_info, as it was pointing to local buffer */
        thd_proc_info(thd, "Repair done");
1425 1426 1427
      }
      else
      {
unknown's avatar
unknown committed
1428
        thd_proc_info(thd, "Repair by sorting");
1429 1430 1431
        param->testflag|= T_REP_BY_SORT;
        error= maria_repair_by_sort(param, file, fixed_name,
                                    test(param->testflag & T_QUICK));
1432 1433 1434 1435
      }
    }
    else
    {
unknown's avatar
unknown committed
1436
      thd_proc_info(thd, "Repair with keycache");
1437 1438 1439
      param->testflag &= ~(T_REP_BY_SORT | T_REP_PARALLEL);
      error= maria_repair(param, file, fixed_name,
                          test(param->testflag & T_QUICK));
1440
    }
1441
    param->testflag= save_testflag | (param->testflag & T_RETRY_WITHOUT_QUICK);
1442 1443 1444 1445 1446 1447 1448 1449
    optimize_done= 1;
  }
  if (!error)
  {
    if ((local_testflag & T_SORT_INDEX) &&
        (share->state.changed & STATE_NOT_SORTED_PAGES))
    {
      optimize_done= 1;
unknown's avatar
unknown committed
1450
      thd_proc_info(thd, "Sorting index");
1451
      error= maria_sort_index(param, file, fixed_name);
1452 1453 1454 1455 1456 1457
    }
    if (!statistics_done && (local_testflag & T_STATISTICS))
    {
      if (share->state.changed & STATE_NOT_ANALYZED)
      {
        optimize_done= 1;
unknown's avatar
unknown committed
1458
        thd_proc_info(thd, "Analyzing");
1459
        error= maria_chk_key(param, file);
1460 1461 1462 1463 1464
      }
      else
        local_testflag &= ~T_STATISTICS;        // Don't update statistics
    }
  }
unknown's avatar
unknown committed
1465
  thd_proc_info(thd, "Saving state");
unknown's avatar
unknown committed
1466
  pthread_mutex_lock(&share->intern_lock);
1467 1468 1469 1470 1471 1472 1473 1474 1475
  if (!error)
  {
    if ((share->state.changed & STATE_CHANGED) || maria_is_crashed(file))
    {
      share->state.changed &= ~(STATE_CHANGED | STATE_CRASHED |
                                STATE_CRASHED_ON_REPAIR);
      file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
    }
    /*
1476
      repair updates share->state.state. Ensure that file->state is up to date
1477
    */
1478 1479 1480
    if (file->state != &share->state.state)
      *file->state= share->state.state;
    if (share->base.auto_key)
1481
      _ma_update_auto_increment_key(param, file, 1);
1482
    if (optimize_done)
1483
      error= maria_update_state_info(param, file,
1484 1485 1486
                                     UPDATE_TIME | UPDATE_OPEN_COUNT |
                                     (local_testflag &
                                      T_STATISTICS ? UPDATE_STAT : 0));
1487
    info(HA_STATUS_NO_LOCK | HA_STATUS_TIME | HA_STATUS_VARIABLE |
1488
         HA_STATUS_CONST, 0);
1489
    if (rows != file->state->records && !(param->testflag & T_VERY_SILENT))
1490 1491
    {
      char llbuff[22], llbuff2[22];
1492
      _ma_check_print_warning(param, "Number of rows changed from %s to %s",
1493 1494
                              llstr(rows, llbuff),
                              llstr(file->state->records, llbuff2));
unknown's avatar
unknown committed
1495 1496 1497
      /* Abort if warning was converted to error */
      if (current_thd->is_error())
        error= 1;
1498 1499 1500 1501 1502 1503
    }
  }
  else
  {
    maria_mark_crashed_on_repair(file);
    file->update |= HA_STATE_CHANGED | HA_STATE_ROW_CHANGED;
1504
    maria_update_state_info(param, file, 0);
1505
  }
unknown's avatar
unknown committed
1506
  pthread_mutex_unlock(&share->intern_lock);
unknown's avatar
unknown committed
1507
  thd_proc_info(thd, old_proc_info);
1508 1509
  if (!thd->locked_tables)
    maria_lock_database(file, F_UNLCK);
unknown's avatar
unknown committed
1510 1511
  error= error ? HA_ADMIN_FAILED :
    (optimize_done ?
1512
     (write_log_record_for_repair(param, file) ? HA_ADMIN_FAILED :
unknown's avatar
unknown committed
1513 1514
      HA_ADMIN_OK) : HA_ADMIN_ALREADY_DONE);
  DBUG_RETURN(error);
1515 1516 1517 1518 1519 1520 1521 1522 1523
}


/*
  Assign table indexes to a specific key cache.
*/

int ha_maria::assign_to_keycache(THD * thd, HA_CHECK_OPT *check_opt)
{
unknown's avatar
unknown committed
1524
#if 0 && NOT_IMPLEMENTED
unknown's avatar
unknown committed
1525
  PAGECACHE *new_pagecache= check_opt->pagecache;
1526 1527
  const char *errmsg= 0;
  int error= HA_ADMIN_OK;
1528
  ulonglong map;
1529 1530 1531
  TABLE_LIST *table_list= table->pos_in_table_list;
  DBUG_ENTER("ha_maria::assign_to_keycache");

unknown's avatar
unknown committed
1532

unknown's avatar
unknown committed
1533 1534 1535 1536 1537 1538 1539 1540
  table->keys_in_use_for_query.clear_all();

  if (table_list->process_index_hints(table))
    DBUG_RETURN(HA_ADMIN_FAILED);
  map= ~(ulonglong) 0;
  if (!table->keys_in_use_for_query.is_clear_all())
    /* use all keys if there's no list specified by the user through hints */
    map= table->keys_in_use_for_query.to_ulonglong();
1541

unknown's avatar
unknown committed
1542
  if ((error= maria_assign_to_pagecache(file, map, new_pagecache)))
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554
  {
    char buf[STRING_BUFFER_USUAL_SIZE];
    my_snprintf(buf, sizeof(buf),
                "Failed to flush to index file (errno: %d)", error);
    errmsg= buf;
    error= HA_ADMIN_CORRUPT;
  }

  if (error != HA_ADMIN_OK)
  {
    /* Send error to user */
    HA_CHECK param;
unknown's avatar
unknown committed
1555
    maria_chk_init(&param);
1556 1557 1558 1559 1560 1561 1562 1563
    param.thd= thd;
    param.op_name= "assign_to_keycache";
    param.db_name= table->s->db.str;
    param.table_name= table->s->table_name.str;
    param.testflag= 0;
    _ma_check_print_error(&param, errmsg);
  }
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1564 1565 1566
#else
  return  HA_ADMIN_NOT_IMPLEMENTED;
#endif
1567 1568 1569 1570 1571 1572 1573 1574 1575
}


/*
  Preload pages of the index file for a table into the key cache.
*/

int ha_maria::preload_keys(THD * thd, HA_CHECK_OPT *check_opt)
{
1576
  ulonglong map;
1577 1578 1579 1580
  TABLE_LIST *table_list= table->pos_in_table_list;

  DBUG_ENTER("ha_maria::preload_keys");

unknown's avatar
unknown committed
1581 1582 1583 1584 1585 1586
  table->keys_in_use_for_query.clear_all();

  if (table_list->process_index_hints(table))
    DBUG_RETURN(HA_ADMIN_FAILED);

  map= ~(ulonglong) 0;
1587
  /* Check validity of the index references */
unknown's avatar
unknown committed
1588 1589 1590
  if (!table->keys_in_use_for_query.is_clear_all())
    /* use all keys if there's no list specified by the user through hints */
    map= table->keys_in_use_for_query.to_ulonglong();
1591 1592 1593 1594

  maria_extra(file, HA_EXTRA_PRELOAD_BUFFER_SIZE,
              (void*) &thd->variables.preload_buff_size);

unknown's avatar
unknown committed
1595 1596 1597
  int error;

  if ((error= maria_preload(file, map, table_list->ignore_leaves)))
1598
  {
1599
    char buf[MYSQL_ERRMSG_SIZE+20];
unknown's avatar
unknown committed
1600 1601
    const char *errmsg;

1602 1603 1604 1605 1606 1607 1608 1609
    switch (error) {
    case HA_ERR_NON_UNIQUE_BLOCK_SIZE:
      errmsg= "Indexes use different block sizes";
      break;
    case HA_ERR_OUT_OF_MEM:
      errmsg= "Failed to allocate buffer";
      break;
    default:
1610
      my_snprintf(buf, sizeof(buf),
1611 1612 1613 1614 1615
                  "Failed to read from index file (errno: %d)", my_errno);
      errmsg= buf;
    }

    HA_CHECK param;
unknown's avatar
unknown committed
1616
    maria_chk_init(&param);
1617 1618 1619 1620 1621
    param.thd= thd;
    param.op_name= "preload_keys";
    param.db_name= table->s->db.str;
    param.table_name= table->s->table_name.str;
    param.testflag= 0;
1622
    _ma_check_print_error(&param, "%s", errmsg);
unknown's avatar
unknown committed
1623
    DBUG_RETURN(HA_ADMIN_FAILED);
1624
  }
unknown's avatar
unknown committed
1625
  DBUG_RETURN(HA_ADMIN_OK);
1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
}


/*
  Disable indexes, making it persistent if requested.

  SYNOPSIS
    disable_indexes()
    mode        mode of operation:
                HA_KEY_SWITCH_NONUNIQ      disable all non-unique keys
                HA_KEY_SWITCH_ALL          disable all keys
                HA_KEY_SWITCH_NONUNIQ_SAVE dis. non-uni. and make persistent
                HA_KEY_SWITCH_ALL_SAVE     dis. all keys and make persistent

  IMPLEMENTATION
    HA_KEY_SWITCH_NONUNIQ       is not implemented.
    HA_KEY_SWITCH_ALL_SAVE      is not implemented.

  RETURN
    0  ok
    HA_ERR_WRONG_COMMAND  mode not implemented.
*/

int ha_maria::disable_indexes(uint mode)
{
  int error;

  if (mode == HA_KEY_SWITCH_ALL)
  {
    /* call a storage engine function to switch the key map */
    error= maria_disable_indexes(file);
  }
  else if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE)
  {
    maria_extra(file, HA_EXTRA_NO_KEYS, 0);
    info(HA_STATUS_CONST);                      // Read new key info
    error= 0;
  }
  else
  {
    /* mode not implemented */
    error= HA_ERR_WRONG_COMMAND;
  }
  return error;
}


/*
  Enable indexes, making it persistent if requested.

  SYNOPSIS
    enable_indexes()
    mode        mode of operation:
                HA_KEY_SWITCH_NONUNIQ      enable all non-unique keys
                HA_KEY_SWITCH_ALL          enable all keys
                HA_KEY_SWITCH_NONUNIQ_SAVE en. non-uni. and make persistent
                HA_KEY_SWITCH_ALL_SAVE     en. all keys and make persistent

  DESCRIPTION
    Enable indexes, which might have been disabled by disable_index() before.
    The modes without _SAVE work only if both data and indexes are empty,
    since the MARIA repair would enable them persistently.
    To be sure in these cases, call handler::delete_all_rows() before.

  IMPLEMENTATION
    HA_KEY_SWITCH_NONUNIQ       is not implemented.
    HA_KEY_SWITCH_ALL_SAVE      is not implemented.

  RETURN
    0  ok
    !=0  Error, among others:
    HA_ERR_CRASHED  data or index is non-empty. Delete all rows and retry.
    HA_ERR_WRONG_COMMAND  mode not implemented.
*/

int ha_maria::enable_indexes(uint mode)
{
  int error;
1704
  DBUG_PRINT("info", ("ha_maria::enable_indexes mode: %d", mode));
1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723
  if (maria_is_all_keys_active(file->s->state.key_map, file->s->base.keys))
  {
    /* All indexes are enabled already. */
    return 0;
  }

  if (mode == HA_KEY_SWITCH_ALL)
  {
    error= maria_enable_indexes(file);
    /*
       Do not try to repair on error,
       as this could make the enabled state persistent,
       but mode==HA_KEY_SWITCH_ALL forbids it.
    */
  }
  else if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE)
  {
    THD *thd= current_thd;
    HA_CHECK param;
unknown's avatar
unknown committed
1724
    const char *save_proc_info= thd_proc_info(thd, "Creating index");
unknown's avatar
unknown committed
1725
    maria_chk_init(&param);
1726 1727
    param.op_name= "recreating_index";
    param.testflag= (T_SILENT | T_REP_BY_SORT | T_QUICK |
unknown's avatar
unknown committed
1728
                     T_CREATE_MISSING_KEYS | T_SAFE_REPAIR);
1729
    if (bulk_insert_single_undo == BULK_INSERT_SINGLE_UNDO_AND_NO_REPAIR)
unknown's avatar
unknown committed
1730
    {
1731
      bulk_insert_single_undo= BULK_INSERT_SINGLE_UNDO_AND_REPAIR;
unknown's avatar
unknown committed
1732
      /*
1733
        Don't bump create_rename_lsn, because UNDO_BULK_INSERT
unknown's avatar
unknown committed
1734 1735 1736 1737
        should not be skipped in case of crash during repair.
      */
      param.testflag|= T_NO_CREATE_RENAME_LSN;
    }
1738
    param.myf_rw &= ~MY_WAIT_IF_FULL;
1739 1740
    param.sort_buffer_length= THDVAR(thd,sort_buffer_size);
    param.stats_method= (enum_handler_stats_method)THDVAR(thd,stats_method);
1741
    param.tmpdir= &mysql_tmpdir_list;
1742
    if ((error= (repair(thd, &param, 0) != HA_ADMIN_OK)) && param.retry_repair)
1743
    {
1744 1745
      sql_print_warning("Warning: Enabling keys got errno %d on %s.%s, "
                        "retrying",
1746
                        my_errno, param.db_name, param.table_name);
1747 1748
      /* This should never fail normally */
      DBUG_ASSERT(0);
1749
      /* Repairing by sort failed. Now try standard repair method. */
Michael Widenius's avatar
Michael Widenius committed
1750
      param.testflag &= ~T_REP_BY_SORT;
1751
      error= (repair(thd, &param, 0) != HA_ADMIN_OK);
1752
      /*
1753 1754 1755
        If the standard repair succeeded, clear all error messages which
        might have been set by the first repair. They can still be seen
        with SHOW WARNINGS then.
1756 1757 1758 1759 1760
      */
      if (!error)
        thd->clear_error();
    }
    info(HA_STATUS_CONST);
unknown's avatar
unknown committed
1761
    thd_proc_info(thd, save_proc_info);
1762 1763 1764 1765 1766 1767
  }
  else
  {
    /* mode not implemented */
    error= HA_ERR_WRONG_COMMAND;
  }
unknown's avatar
unknown committed
1768 1769 1770 1771 1772 1773 1774 1775
  DBUG_EXECUTE_IF("maria_flush_whole_log",
                  {
                    DBUG_PRINT("maria_flush_whole_log", ("now"));
                    translog_flush(translog_get_horizon());
                  });
  DBUG_EXECUTE_IF("maria_crash_enable_index",
                  {
                    DBUG_PRINT("maria_crash_enable_index", ("now"));
1776
                    DBUG_ABORT();
unknown's avatar
unknown committed
1777
                  });
1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
  return error;
}


/*
  Test if indexes are disabled.


  SYNOPSIS
    indexes_are_disabled()
      no parameters


  RETURN
    0  indexes are not disabled
    1  all indexes are disabled
   [2  non-unique indexes are disabled - NOT YET IMPLEMENTED]
*/

int ha_maria::indexes_are_disabled(void)
{
  return maria_indexes_are_disabled(file);
}


/*
  prepare for a many-rows insert operation
  e.g. - disable indexes (if they can be recreated fast) or
  activate special bulk-insert optimizations

  SYNOPSIS
    start_bulk_insert(rows)
    rows        Rows to be inserted
                0 if we don't know

  NOTICE
    Do not forget to call end_bulk_insert() later!
*/

void ha_maria::start_bulk_insert(ha_rows rows)
{
  DBUG_ENTER("ha_maria::start_bulk_insert");
  THD *thd= current_thd;
  ulong size= min(thd->variables.read_buff_size,
1822
                  (ulong) (table->s->avg_row_length * rows));
1823
  MARIA_SHARE *share= file->s;
1824 1825 1826 1827 1828 1829 1830
  DBUG_PRINT("info", ("start_bulk_insert: rows %lu size %lu",
                      (ulong) rows, size));

  /* don't enable row cache if too few rows */
  if (!rows || (rows > MARIA_MIN_ROWS_TO_USE_WRITE_CACHE))
    maria_extra(file, HA_EXTRA_WRITE_CACHE, (void*) &size);

1831 1832
  can_enable_indexes= (maria_is_all_keys_active(share->state.key_map,
                                                share->base.keys));
1833
  bulk_insert_single_undo= BULK_INSERT_NONE;
1834 1835 1836 1837 1838 1839 1840 1841

  if (!(specialflag & SPECIAL_SAFE_MODE))
  {
    /*
       Only disable old index if the table was empty and we are inserting
       a lot of rows.
       We should not do this for only a few rows as this is slower and
       we don't want to update the key statistics based of only a few rows.
1842 1843
       Index file rebuild requires an exclusive lock, so if versioning is on
       don't do it (see how ha_maria::store_lock() tries to predict repair).
1844 1845 1846 1847 1848 1849 1850 1851
       We can repair index only if we have an exclusive (TL_WRITE) lock. To
       see if table is empty, we shouldn't rely on the old records' count from
       our transaction's start (if that old count is 0 but now there are
       records in the table, we would wrongly destroy them).
       So we need to look at share->state.state.records.
       As a safety net for now, we don't remove the test of
       file->state->records, because there is uncertainty on what will happen
       during repair if the two states disagree.
1852
    */
1853 1854
    if ((file->state->records == 0) &&
        (share->state.state.records == 0) && can_enable_indexes &&
1855 1856
        (!rows || rows >= MARIA_MIN_ROWS_TO_DISABLE_INDEXES) &&
        (file->lock.type == TL_WRITE))
unknown's avatar
unknown committed
1857
    {
1858 1859 1860 1861
      /**
         @todo for a single-row INSERT SELECT, we will go into repair, which
         is more costly (flushes, syncs) than a row write.
      */
1862
      maria_disable_non_unique_index(file, rows);
1863
      if (share->now_transactional)
unknown's avatar
unknown committed
1864
      {
1865 1866
        bulk_insert_single_undo= BULK_INSERT_SINGLE_UNDO_AND_NO_REPAIR;
        write_log_record_for_bulk_insert(file);
1867
        _ma_tmp_disable_logging_for_table(file, TRUE);
unknown's avatar
unknown committed
1868 1869 1870 1871
        /*
          Pages currently in the page cache have type PAGECACHE_LSN_PAGE, we
          are not allowed to overwrite them with PAGECACHE_PLAIN_PAGE, so
          throw them away. It is not losing data, because we just wrote and
1872 1873 1874
          forced an UNDO which will for sure empty the table if we crash. The
          upcoming unique-key insertions however need a proper index, so we
          cannot leave the corrupted on-disk index file, thus we truncate it.
unknown's avatar
unknown committed
1875
        */
1876
        maria_delete_all_rows(file);
unknown's avatar
unknown committed
1877 1878
      }
    }
1879 1880
    else if (!file->bulk_insert &&
             (!rows || rows >= MARIA_MIN_ROWS_TO_USE_BULK_INSERT))
1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901
    {
      maria_init_bulk_insert(file, thd->variables.bulk_insert_buff_size, rows);
    }
  }
  DBUG_VOID_RETURN;
}


/*
  end special bulk-insert optimizations,
  which have been activated by start_bulk_insert().

  SYNOPSIS
    end_bulk_insert()
    no arguments

  RETURN
    0     OK
    != 0  Error
*/

1902
int ha_maria::end_bulk_insert(bool table_will_be_deleted)
1903
{
unknown's avatar
unknown committed
1904 1905
  int err;
  DBUG_ENTER("ha_maria::end_bulk_insert");
1906
  maria_end_bulk_insert(file, table_will_be_deleted);
unknown's avatar
unknown committed
1907 1908
  if ((err= maria_extra(file, HA_EXTRA_NO_CACHE, 0)))
    goto end;
1909
  if (can_enable_indexes && !table_will_be_deleted)
unknown's avatar
unknown committed
1910 1911
    err= enable_indexes(HA_KEY_SWITCH_NONUNIQ_SAVE);
end:
1912
  if (bulk_insert_single_undo != BULK_INSERT_NONE)
unknown's avatar
unknown committed
1913 1914
  {
    DBUG_ASSERT(can_enable_indexes);
1915 1916 1917 1918 1919 1920 1921 1922
    /*
      Table was transactional just before start_bulk_insert().
      No need to flush pages if we did a repair (which already flushed).
    */
    err|=
      _ma_reenable_logging_for_table(file,
                                     bulk_insert_single_undo ==
                                     BULK_INSERT_SINGLE_UNDO_AND_NO_REPAIR);
unknown's avatar
unknown committed
1923 1924
  }
  DBUG_RETURN(err);
1925 1926 1927 1928 1929
}


bool ha_maria::check_and_repair(THD *thd)
{
1930
  int error, crashed;
1931 1932 1933 1934 1935 1936
  char *old_query;
  uint old_query_length;
  HA_CHECK_OPT check_opt;
  DBUG_ENTER("ha_maria::check_and_repair");

  check_opt.init();
1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954

  if (file->s->state.changed & STATE_MOVED)
  {
    sql_print_information("Zerofilling table:   '%s'", table->s->path.str);
    if (!(error= zerofill(thd, &check_opt)))
      DBUG_RETURN(0);
  }
  else
    error= 1;

  /*
    if we got this far - the table is crashed.
    but don't auto-repair if maria_recover_options is not set
  */
  if (!maria_recover_options)
    DBUG_RETURN(error);

  error= 0;
1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966
  check_opt.flags= T_MEDIUM | T_AUTO_REPAIR;
  // Don't use quick if deleted rows
  if (!file->state->del && (maria_recover_options & HA_RECOVER_QUICK))
    check_opt.flags |= T_QUICK;

  old_query= thd->query;
  old_query_length= thd->query_length;
  pthread_mutex_lock(&LOCK_thread_count);
  thd->query= table->s->table_name.str;
  thd->query_length= table->s->table_name.length;
  pthread_mutex_unlock(&LOCK_thread_count);

1967 1968 1969 1970 1971 1972 1973
  if (!(crashed= maria_is_crashed(file)))
  {
    sql_print_warning("Checking table:   '%s'", table->s->path.str);
    crashed= check(thd, &check_opt);
  }

  if (crashed)
1974
  {
1975
    sql_print_warning("Recovering table: '%s'", table->s->path.str);
1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
    check_opt.flags=
      ((maria_recover_options & HA_RECOVER_BACKUP ? T_BACKUP_DATA : 0) |
       (maria_recover_options & HA_RECOVER_FORCE ? 0 : T_SAFE_REPAIR) |
       T_AUTO_REPAIR);
    if (repair(thd, &check_opt))
      error= 1;
  }
  pthread_mutex_lock(&LOCK_thread_count);
  thd->query= old_query;
  thd->query_length= old_query_length;
  pthread_mutex_unlock(&LOCK_thread_count);
  DBUG_RETURN(error);
}


bool ha_maria::is_crashed() const
{
1993
  return (file->s->state.changed & (STATE_CRASHED | STATE_MOVED) ||
1994 1995 1996
          (my_disable_locking && file->s->state.open_count));
}

1997 1998 1999 2000 2001 2002 2003 2004
#define CHECK_UNTIL_WE_FULLY_IMPLEMENTED_VERSIONING(msg) \
  do { \
    if (file->lock.type == TL_WRITE_CONCURRENT_INSERT) \
    { \
      my_error(ER_CHECK_NOT_IMPLEMENTED, MYF(0), msg); \
      return 1; \
    } \
  } while(0)
2005

unknown's avatar
unknown committed
2006
int ha_maria::update_row(const uchar * old_data, uchar * new_data)
2007
{
2008
  CHECK_UNTIL_WE_FULLY_IMPLEMENTED_VERSIONING("UPDATE in WRITE CONCURRENT");
2009
  ha_statistic_increment(&SSV::ha_update_count);
2010 2011 2012 2013 2014 2015
  if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
    table->timestamp_field->set_time();
  return maria_update(file, old_data, new_data);
}


unknown's avatar
unknown committed
2016
int ha_maria::delete_row(const uchar * buf)
2017
{
2018
  CHECK_UNTIL_WE_FULLY_IMPLEMENTED_VERSIONING("DELETE in WRITE CONCURRENT");
2019
  ha_statistic_increment(&SSV::ha_delete_count);
2020 2021 2022 2023
  return maria_delete(file, buf);
}


2024 2025 2026
int ha_maria::index_read_map(uchar * buf, const uchar * key,
			     key_part_map keypart_map,
			     enum ha_rkey_function find_flag)
2027 2028
{
  DBUG_ASSERT(inited == INDEX);
2029 2030
  ha_statistic_increment(&SSV::ha_read_key_count);
  int error= maria_rkey(file, buf, active_index, key, keypart_map, find_flag);
2031 2032 2033 2034 2035
  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}


2036 2037 2038
int ha_maria::index_read_idx_map(uchar * buf, uint index, const uchar * key,
				 key_part_map keypart_map,
				 enum ha_rkey_function find_flag)
2039
{
2040 2041
  ha_statistic_increment(&SSV::ha_read_key_count);
  int error= maria_rkey(file, buf, index, key, keypart_map, find_flag);
2042 2043 2044 2045 2046
  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}


2047 2048
int ha_maria::index_read_last_map(uchar * buf, const uchar * key,
				  key_part_map keypart_map)
2049
{
2050
  DBUG_ENTER("ha_maria::index_read_last_map");
2051
  DBUG_ASSERT(inited == INDEX);
2052 2053
  ha_statistic_increment(&SSV::ha_read_key_count);
  int error= maria_rkey(file, buf, active_index, key, keypart_map,
2054 2055
                        HA_READ_PREFIX_LAST);
  table->status= error ? STATUS_NOT_FOUND : 0;
2056
  DBUG_RETURN(error);
2057 2058 2059
}


unknown's avatar
unknown committed
2060
int ha_maria::index_next(uchar * buf)
2061 2062
{
  DBUG_ASSERT(inited == INDEX);
2063
  ha_statistic_increment(&SSV::ha_read_next_count);
2064 2065 2066 2067 2068 2069
  int error= maria_rnext(file, buf, active_index);
  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}


unknown's avatar
unknown committed
2070
int ha_maria::index_prev(uchar * buf)
2071 2072
{
  DBUG_ASSERT(inited == INDEX);
2073
  ha_statistic_increment(&SSV::ha_read_prev_count);
2074 2075 2076 2077 2078 2079
  int error= maria_rprev(file, buf, active_index);
  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}


unknown's avatar
unknown committed
2080
int ha_maria::index_first(uchar * buf)
2081 2082
{
  DBUG_ASSERT(inited == INDEX);
2083
  ha_statistic_increment(&SSV::ha_read_first_count);
2084 2085 2086 2087 2088 2089
  int error= maria_rfirst(file, buf, active_index);
  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}


unknown's avatar
unknown committed
2090
int ha_maria::index_last(uchar * buf)
2091 2092
{
  DBUG_ASSERT(inited == INDEX);
2093
  ha_statistic_increment(&SSV::ha_read_last_count);
2094 2095 2096 2097 2098 2099
  int error= maria_rlast(file, buf, active_index);
  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}


unknown's avatar
unknown committed
2100 2101
int ha_maria::index_next_same(uchar * buf,
                              const uchar *key __attribute__ ((unused)),
2102 2103
                              uint length __attribute__ ((unused)))
{
2104
  int error;
2105
  DBUG_ASSERT(inited == INDEX);
2106
  ha_statistic_increment(&SSV::ha_read_next_count);
2107 2108 2109 2110 2111 2112 2113 2114
  /*
    TODO: Delete this loop in Maria 1.5 as versioning will ensure this never
    happens
  */
  do
  {
    error= maria_rnext_same(file,buf);
  } while (error == HA_ERR_RECORD_DELETED);
2115 2116 2117 2118 2119 2120 2121 2122 2123
  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}


int ha_maria::rnd_init(bool scan)
{
  if (scan)
    return maria_scan_init(file);
2124
  return maria_reset(file);                        // Free buffers
2125 2126 2127
}


unknown's avatar
unknown committed
2128 2129 2130 2131 2132 2133 2134 2135
int ha_maria::rnd_end()
{
  /* Safe to call even if we don't have started a scan */
  maria_scan_end(file);
  return 0;
}


unknown's avatar
unknown committed
2136
int ha_maria::rnd_next(uchar *buf)
2137
{
2138
  ha_statistic_increment(&SSV::ha_read_rnd_next_count);
2139 2140 2141 2142 2143 2144
  int error= maria_scan(file, buf);
  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}


2145
int ha_maria::remember_rnd_pos()
2146
{
2147
  return (*file->s->scan_remember_pos)(file, &remember_pos);
2148 2149 2150
}


2151 2152 2153 2154 2155 2156 2157 2158
int ha_maria::restart_rnd_next(uchar *buf)
{
  (*file->s->scan_restore_pos)(file, remember_pos);
  return rnd_next(buf);
}


int ha_maria::rnd_pos(uchar *buf, uchar *pos)
2159
{
2160
  ha_statistic_increment(&SSV::ha_read_rnd_count);
2161 2162 2163 2164 2165 2166
  int error= maria_rrnd(file, buf, my_get_ptr(pos, ref_length));
  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}


2167
void ha_maria::position(const uchar *record)
2168
{
2169 2170
  my_off_t row_position= maria_position(file);
  my_store_ptr(ref, ref_length, row_position);
2171 2172 2173
}


2174
int ha_maria::info(uint flag)
2175 2176 2177 2178 2179
{
  return info(flag, table->s->tmp_table == NO_TMP_TABLE);
}

int ha_maria::info(uint flag, my_bool lock_table_share)
2180
{
2181
  MARIA_INFO maria_info;
2182 2183
  char name_buff[FN_REFLEN];

2184
  (void) maria_status(file, &maria_info, flag);
2185 2186
  if (flag & HA_STATUS_VARIABLE)
  {
2187 2188 2189 2190 2191 2192 2193
    stats.records=           maria_info.records;
    stats.deleted=           maria_info.deleted;
    stats.data_file_length=  maria_info.data_file_length;
    stats.index_file_length= maria_info.index_file_length;
    stats.delete_length=     maria_info.delete_length;
    stats.check_time=        maria_info.check_time;
    stats.mean_rec_length=   maria_info.mean_reclength;
2194 2195 2196 2197
  }
  if (flag & HA_STATUS_CONST)
  {
    TABLE_SHARE *share= table->s;
2198 2199 2200 2201 2202
    stats.max_data_file_length=  maria_info.max_data_file_length;
    stats.max_index_file_length= maria_info.max_index_file_length;
    stats.create_time= maria_info.create_time;
    ref_length= maria_info.reflength;
    share->db_options_in_use= maria_info.options;
2203
    stats.block_size= maria_block_size;
2204 2205

    /* Update share */
2206
    if (lock_table_share)
2207 2208
      pthread_mutex_lock(&share->mutex);
    share->keys_in_use.set_prefix(share->keys);
2209
    share->keys_in_use.intersect_extended(maria_info.key_map);
2210
    share->keys_for_keyread.intersect(share->keys_in_use);
2211
    share->db_record_offset= maria_info.record_offset;
2212
    if (share->key_parts)
2213 2214 2215 2216 2217 2218
    {
      ulong *to= table->key_info[0].rec_per_key, *end;
      double *from= maria_info.rec_per_key;
      for (end= to+ share->key_parts ; to < end ; to++, from++)
        *to= (ulong) (*from + 0.5);
    }
2219
    if (lock_table_share)
2220 2221 2222 2223 2224 2225 2226
      pthread_mutex_unlock(&share->mutex);

    /*
       Set data_file_name and index_file_name to point at the symlink value
       if table is symlinked (Ie;  Real name is not same as generated name)
    */
    data_file_name= index_file_name= 0;
2227
    fn_format(name_buff, file->s->open_file_name.str, "", MARIA_NAME_DEXT,
2228 2229
              MY_APPEND_EXT | MY_UNPACK_FILENAME);
    if (strcmp(name_buff, maria_info.data_file_name))
2230 2231
      data_file_name =maria_info.data_file_name;
    fn_format(name_buff, file->s->open_file_name.str, "", MARIA_NAME_IEXT,
2232 2233 2234
              MY_APPEND_EXT | MY_UNPACK_FILENAME);
    if (strcmp(name_buff, maria_info.index_file_name))
      index_file_name=maria_info.index_file_name;
2235 2236 2237
  }
  if (flag & HA_STATUS_ERRKEY)
  {
2238 2239
    errkey= maria_info.errkey;
    my_store_ptr(dup_ref, ref_length, maria_info.dup_key_pos);
2240 2241
  }
  /* Faster to always update, than to do it based on flag */
2242 2243
  stats.update_time= maria_info.update_time;
  stats.auto_increment_value= maria_info.auto_increment;
2244 2245

  return 0;
2246 2247 2248 2249 2250 2251 2252
}


int ha_maria::extra(enum ha_extra_function operation)
{
  if ((specialflag & SPECIAL_SAFE_MODE) && operation == HA_EXTRA_KEYREAD)
    return 0;
2253 2254 2255 2256
#ifdef NOT_USED
  if (operation == HA_EXTRA_MMAP && !opt_maria_use_mmap)
    return 0;
#endif
2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269

  /*
    We have to set file->trn here because in some cases we call
    extern_lock(F_UNLOCK) (which resets file->trn) followed by maria_close()
    without calling commit/rollback in between.  If file->trn is not set
    we can't remove file->share from the transaction list in the extra() call.
  */

  if (!file->trn &&
      (operation == HA_EXTRA_PREPARE_FOR_DROP ||
       operation == HA_EXTRA_PREPARE_FOR_RENAME))
  {
    THD *thd= table->in_use;
2270 2271
    TRN *trn= THD_TRN;
    _ma_set_trn_for_table(file, trn);
2272
  }
2273 2274 2275
  return maria_extra(file, operation, 0);
}

2276 2277 2278 2279
int ha_maria::reset(void)
{
  return maria_reset(file);
}
2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292

/* To be used with WRITE_CACHE and EXTRA_CACHE */

int ha_maria::extra_opt(enum ha_extra_function operation, ulong cache_size)
{
  if ((specialflag & SPECIAL_SAFE_MODE) && operation == HA_EXTRA_WRITE_CACHE)
    return 0;
  return maria_extra(file, operation, (void*) &cache_size);
}


int ha_maria::delete_all_rows()
{
2293 2294 2295
  THD *thd= current_thd;
  (void) translog_log_debug_info(file->trn, LOGREC_DEBUG_INFO_QUERY,
                                 (uchar*) thd->query, thd->query_length);
unknown's avatar
unknown committed
2296 2297 2298 2299 2300 2301 2302 2303 2304 2305
  if (file->s->now_transactional &&
      ((table->in_use->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) ||
       table->in_use->locked_tables))
  {
    /*
      We are not in autocommit mode or user have done LOCK TABLES.
      We must do the delete row by row to be able to rollback the command
    */
    return HA_ERR_WRONG_COMMAND;
  }
2306 2307 2308 2309 2310 2311
  return maria_delete_all_rows(file);
}


int ha_maria::delete_table(const char *name)
{
2312 2313 2314
  THD *thd= current_thd;
  (void) translog_log_debug_info(0, LOGREC_DEBUG_INFO_QUERY,
                                 (uchar*) thd->query, thd->query_length);
2315 2316 2317 2318 2319
  return maria_delete_table(name);
}

int ha_maria::external_lock(THD *thd, int lock_type)
{
2320 2321
  TRN *trn= THD_TRN;
  DBUG_ENTER("ha_maria::external_lock");
unknown's avatar
unknown committed
2322 2323 2324 2325 2326 2327 2328 2329
  /*
    We don't test now_transactional because it may vary between lock/unlock
    and thus confuse our reference counting.
    It is critical to skip non-transactional tables: user-visible temporary
    tables get an external_lock() when read/written for the first time, but no
    corresponding unlock (they just stay locked and are later dropped while
    locked); if a tmp table was transactional, "SELECT FROM non_tmp, tmp"
    would never commit as its "locked_tables" count would stay 1.
unknown's avatar
unknown committed
2330 2331 2332 2333
    When Maria has has_transactions()==TRUE, open_temporary_table()
    (sql_base.cc) will use TRANSACTIONAL_TMP_TABLE and thus the
    external_lock(F_UNLCK) will happen and we can then allow the user to
    create transactional temporary tables.
unknown's avatar
unknown committed
2334
  */
2335
  if (file->s->base.born_transactional)
2336
  {
2337 2338
    /* Transactional table */
    if (lock_type != F_UNLCK)
unknown's avatar
unknown committed
2339
    {
2340 2341 2342
      /* Start of new statement */
      if (!trn)  /* no transaction yet - open it now */
      {
2343
        trn= trnman_new_trn(& thd->transaction.wt);
2344 2345 2346 2347 2348 2349
        if (unlikely(!trn))
          DBUG_RETURN(HA_ERR_OUT_OF_MEM);
        THD_TRN= trn;
        if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))
          trans_register_ha(thd, TRUE, maria_hton);
      }
2350
      _ma_set_trn_for_table(file, trn);
2351 2352 2353 2354 2355 2356
      if (!trnman_increment_locked_tables(trn))
      {
        trans_register_ha(thd, FALSE, maria_hton);
        trnman_new_statement(trn);
      }

2357
      if (!file->s->lock_key_trees)             // If we don't use versioning
2358 2359
      {
        /*
2360 2361 2362 2363 2364 2365 2366 2367 2368
          We come here in the following cases:
           - The table is a temporary table
           - It's a table which is crash safe but not yet versioned, for
             example a table with fulltext or rtree keys

          Set the current state to point to save_state so that the
          block_format code don't count the same record twice.
          Copy also the current state. This may have been wrong if the
          same file was used several times in the last statement
2369
        */
2370
        file->state=  file->state_start;
2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387
        *file->state= file->s->state.state;
      }

      if (!thd->transaction.on)
      {
        /*
          No need to log REDOs/UNDOs. If this is an internal temporary table
          which will be renamed to a permanent table (like in ALTER TABLE),
          the rename happens after unlocking so will be durable (and the table
          will get its create_rename_lsn).
          Note: if we wanted to enable users to have an old backup and apply
          tons of archived logs to roll-forward, we could then not disable
          REDOs/UNDOs in this case.
        */
        DBUG_PRINT("info", ("Disabling logging for table"));
        _ma_tmp_disable_logging_for_table(file, TRUE);
      }
2388 2389
#ifdef EXTRA_DEBUG
      if (lock_type == F_WRLCK &&
Sergei Golubchik's avatar
Sergei Golubchik committed
2390
          ! (trnman_get_flags(trn) & TRN_STATE_INFO_LOGGED))
2391
      {
Sergei Golubchik's avatar
Sergei Golubchik committed
2392
        trnman_set_flags(trn, trnman_get_flags(trn) | TRN_STATE_INFO_LOGGED |
2393 2394 2395 2396 2397
                         TRN_STATE_TABLES_CAN_CHANGE);
        (void) translog_log_debug_info(trn, LOGREC_DEBUG_INFO_QUERY,
                                       (uchar*) thd->query, thd->query_length);
      }
#endif
2398
    }
2399
    else
unknown's avatar
unknown committed
2400
    {
2401 2402
      /* End of transaction */

unknown's avatar
unknown committed
2403
      /*
2404 2405 2406
        We always re-enable, don't rely on thd->transaction.on as it is
        sometimes reset to true after unlocking (see mysql_truncate() for a
        partitioned table based on Maria).
2407 2408 2409
        Note that we can come here without having an exclusive lock on the
        table, for example in this case:
        external_lock(F_(WR|RD)LCK); thr_lock() which fails due to lock
2410 2411
        abortion; external_lock(F_UNLCK). Fortunately, the re-enabling happens
        only if we were the thread which disabled logging.
unknown's avatar
unknown committed
2412
      */
2413 2414 2415
      if (_ma_reenable_logging_for_table(file, TRUE))
        DBUG_RETURN(1);
      /** @todo zero file->trn also in commit and rollback */
2416
      _ma_set_trn_for_table(file, NULL);        // Safety
2417 2418 2419 2420 2421 2422
      /*
        Ensure that file->state points to the current number of rows. This
        is needed if someone calls maria_info() without first doing an
        external lock of the table
      */
      file->state= &file->s->state.state;
2423
      if (trn)
2424
      {
2425 2426
        if (trnman_has_locked_tables(trn) &&
            !trnman_decrement_locked_tables(trn))
2427
        {
2428 2429 2430 2431 2432
          /*
            OK should not have been sent to client yet (ACID).
            This is a bit excessive, ACID requires this only if there are some
            changes to commit (rollback shouldn't be tested).
          */
2433 2434
          DBUG_ASSERT(!thd->main_da.is_sent ||
                      thd->killed == THD::KILL_CONNECTION);
2435 2436 2437 2438
          /* autocommit ? rollback a transaction */
#ifdef MARIA_CANNOT_ROLLBACK
          if (ma_commit(trn))
            DBUG_RETURN(1);
2439
          THD_TRN= 0;
2440 2441 2442 2443 2444 2445 2446
#else
          if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)))
          {
            trnman_rollback_trn(trn);
            DBUG_PRINT("info", ("THD_TRN set to 0x0"));
            THD_TRN= 0;
          }
unknown's avatar
unknown committed
2447
#endif
2448
        }
Sergei Golubchik's avatar
Sergei Golubchik committed
2449
        trnman_set_flags(trn, trnman_get_flags(trn) & ~ TRN_STATE_INFO_LOGGED);
2450 2451
      }
    }
2452
  } /* if transactional table */
2453 2454 2455
  DBUG_RETURN(maria_lock_database(file, !table->s->tmp_table ?
                                  lock_type : ((lock_type == F_UNLCK) ?
                                               F_UNLCK : F_EXTRA_LCK)));
2456 2457
}

2458 2459
int ha_maria::start_stmt(THD *thd, thr_lock_type lock_type)
{
unknown's avatar
unknown committed
2460
  TRN *trn;
unknown's avatar
unknown committed
2461
  if (file->s->base.born_transactional)
2462
  {
unknown's avatar
unknown committed
2463
    trn= THD_TRN;
2464
    DBUG_ASSERT(trn); // this may be called only after external_lock()
2465
    DBUG_ASSERT(trnman_has_locked_tables(trn));
unknown's avatar
unknown committed
2466
    DBUG_ASSERT(lock_type != TL_UNLOCK);
2467 2468
    DBUG_ASSERT(file->trn == trn);

unknown's avatar
unknown committed
2469 2470 2471 2472 2473 2474
    /*
      If there was an implicit commit under this LOCK TABLES by a previous
      statement (like a DDL), at least if that previous statement was about a
      different ha_maria than 'this' then this->file->trn is a stale
      pointer. We fix it:
    */
2475
    _ma_set_trn_for_table(file, trn);
2476 2477 2478 2479 2480 2481 2482
    /*
      As external_lock() was already called, don't increment locked_tables.
      Note that we call the function below possibly several times when
      statement starts (once per table). This is ok as long as that function
      does cheap operations. Otherwise, we will need to do it only on first
      call to start_stmt().
    */
2483
    trnman_new_statement(trn);
2484 2485

#ifdef EXTRA_DEBUG
Sergei Golubchik's avatar
Sergei Golubchik committed
2486 2487
    if (!(trnman_get_flags(trn) & TRN_STATE_INFO_LOGGED) &&
        trnman_get_flags(trn) & TRN_STATE_TABLES_CAN_CHANGE)
2488
    {
Sergei Golubchik's avatar
Sergei Golubchik committed
2489
      trnman_set_flags(trn, trnman_get_flags(trn) | TRN_STATE_INFO_LOGGED);
2490 2491 2492 2493
      (void) translog_log_debug_info(trn, LOGREC_DEBUG_INFO_QUERY,
                                     (uchar*) thd->query, thd->query_length);
    }
#endif
2494 2495 2496
  }
  return 0;
}
2497

unknown's avatar
unknown committed
2498 2499 2500 2501 2502 2503 2504 2505 2506

/**
  Performs an implicit commit of the Maria transaction and creates a new
  one.

  This can be considered a hack. When Maria loses HA_NO_TRANSACTIONS it will
  be participant in the connection's transaction and so the implicit commits
  (ha_commit()) (like in end_active_trans()) will do the implicit commit
  without need to call this function which can then be removed.
2507 2508 2509 2510 2511

  @param  thd              THD object
  @param  new_trn          if a new transaction should be created; a new
                           transaction is not needed when we know that the
                           tables will be unlocked very soon.
unknown's avatar
unknown committed
2512 2513
*/

2514
int ha_maria::implicit_commit(THD *thd, bool new_trn)
unknown's avatar
unknown committed
2515 2516 2517 2518 2519 2520
{
#ifndef MARIA_CANNOT_ROLLBACK
#error this method should be removed
#endif
  TRN *trn;
  int error= 0;
2521
  TABLE *table;
unknown's avatar
unknown committed
2522
  DBUG_ENTER("ha_maria::implicit_commit");
2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540
  if (!new_trn && thd->locked_tables)
  {
    /*
      "we are under LOCK TABLES" <=> "we shouldn't commit".
      As thd->locked_tables is true, we are either under LOCK TABLES, or in
      prelocking; prelocking can be under LOCK TABLES, or not (and in this
      latter case only we should commit).
      Note that we come here only at the end of the top statement
      (dispatch_command()), we are never committing inside a sub-statement./
    */
    enum prelocked_mode_type prelocked_mode= thd->prelocked_mode;
    if ((prelocked_mode == NON_PRELOCKED) ||
        (prelocked_mode == PRELOCKED_UNDER_LOCK_TABLES))
    {
      DBUG_PRINT("info", ("locked_tables, skipping"));
      DBUG_RETURN(0);
    }
  }
unknown's avatar
unknown committed
2541 2542 2543 2544 2545
  if ((trn= THD_TRN) != NULL)
  {
    uint locked_tables= trnman_has_locked_tables(trn);
    if (unlikely(ma_commit(trn)))
      error= 1;
2546 2547 2548 2549 2550
    if (!new_trn)
    {
      THD_TRN= NULL;
      goto end;
    }
unknown's avatar
unknown committed
2551 2552 2553 2554 2555
    /*
      We need to create a new transaction and put it in THD_TRN. Indeed,
      tables may be under LOCK TABLES, and so they will start the next
      statement assuming they have a trn (see ha_maria::start_stmt()).
    */
2556
    trn= trnman_new_trn(& thd->transaction.wt);
unknown's avatar
unknown committed
2557 2558 2559 2560 2561
    /* This is just a commit, tables stay locked if they were: */
    trnman_reset_locked_tables(trn, locked_tables);
    THD_TRN= trn;
    if (unlikely(trn == NULL))
      error= HA_ERR_OUT_OF_MEM;
2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576

    /*
      Move all locked tables to the new transaction
      We must do it here as otherwise file->thd and file->state may be
      stale pointers. We can't do this in start_stmt() as we don't know
      when we should call _ma_setup_live_state() and in some cases, like
      in check table, we use the table without calling start_stmt().
     */
    for (table=thd->open_tables; table ; table=table->next)
    {
      if (table->db_stat && table->file->ht == maria_hton)
      {
        MARIA_HA *handler= ((ha_maria*) table->file)->file;
        if (handler->s->base.born_transactional)
        {
2577
          _ma_set_trn_for_table(handler, trn);
2578 2579
          /* If handler uses versioning */
          if (handler->s->lock_key_trees)
2580 2581 2582 2583 2584 2585 2586
          {
            if (_ma_setup_live_state(handler))
              error= HA_ERR_OUT_OF_MEM;
          }
        }
      }
    }
unknown's avatar
unknown committed
2587
  }
2588
end:
unknown's avatar
unknown committed
2589 2590 2591 2592
  DBUG_RETURN(error);
}


2593 2594 2595 2596
THR_LOCK_DATA **ha_maria::store_lock(THD *thd,
                                     THR_LOCK_DATA **to,
                                     enum thr_lock_type lock_type)
{
2597 2598 2599
  /* Test if we can fix test below */
  DBUG_ASSERT(lock_type != TL_UNLOCK &&
              (lock_type == TL_IGNORE || file->lock.type == TL_UNLOCK));
2600
  if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK)
2601
  {
2602
    const enum enum_sql_command sql_command= thd->lex->sql_command;
2603 2604 2605 2606 2607 2608 2609 2610
    /*
      We have to disable concurrent inserts for INSERT ... SELECT or
      INSERT/UPDATE/DELETE with sub queries if we are using statement based
      logging.  We take the safe route here and disable this for all commands
      that only does reading that are not SELECT.
    */
    if (lock_type <= TL_READ_HIGH_PRIORITY &&
        !thd->current_stmt_binlog_row_based &&
2611 2612
        (sql_command != SQLCOM_SELECT &&
         sql_command != SQLCOM_LOCK_TABLES) &&
2613
        (thd->options & OPTION_BIN_LOG) &&
2614 2615
        mysql_bin_log.is_open())
      lock_type= TL_READ_NO_INSERT;
2616
    else if (lock_type == TL_WRITE_CONCURRENT_INSERT)
2617
    {
2618
      const enum enum_duplicates duplicates= thd->lex->duplicates;
2619
      /*
2620 2621 2622
        Explanation for the 3 conditions below, in order:

        - Bulk insert may use repair, which will cause problems if other
2623 2624 2625 2626 2627 2628
        threads try to read/insert to the table: disable versioning.
        Note that our read of file->state->records is incorrect, as such
        variable may have changed when we come to start_bulk_insert() (worse
        case: we see != 0 so allow versioning, start_bulk_insert() sees 0 and
        uses repair). This is prevented because start_bulk_insert() will not
        try repair if we enabled versioning.
2629 2630 2631 2632
        - INSERT SELECT ON DUPLICATE KEY UPDATE comes here with
        TL_WRITE_CONCURRENT_INSERT but shouldn't because it can do
        update/delete of a row and versioning doesn't support that
        - same for LOAD DATA CONCURRENT REPLACE.
2633
      */
2634 2635 2636 2637
      if ((file->state->records == 0) ||
          (sql_command == SQLCOM_INSERT_SELECT && duplicates == DUP_UPDATE) ||
          (sql_command == SQLCOM_LOAD && duplicates == DUP_REPLACE))
        lock_type= TL_WRITE;
2638
    }
2639
    file->lock.type= lock_type;
2640
  }
2641 2642 2643 2644 2645 2646 2647 2648 2649 2650
  *to++= &file->lock;
  return to;
}


void ha_maria::update_create_info(HA_CREATE_INFO *create_info)
{
  ha_maria::info(HA_STATUS_AUTO | HA_STATUS_CONST);
  if (!(create_info->used_fields & HA_CREATE_USED_AUTO))
  {
2651
    create_info->auto_increment_value= stats.auto_increment_value;
2652 2653 2654
  }
  create_info->data_file_name= data_file_name;
  create_info->index_file_name= index_file_name;
2655 2656 2657 2658
  /* We need to restore the row type as Maria can change it */
  if (create_info->row_type != ROW_TYPE_DEFAULT &&
      !(create_info->used_fields & HA_CREATE_USED_ROW_FORMAT))
    create_info->row_type= get_row_type();
2659 2660 2661 2662
  /*
    Show always page checksums, as this can be forced with
    maria_page_checksums variable
  */
2663 2664 2665 2666
  if (create_info->page_checksum == HA_CHOICE_UNDEF)
    create_info->page_checksum=
      (file->s->options & HA_OPTION_PAGE_CHECKSUM) ? HA_CHOICE_YES :
      HA_CHOICE_NO;
2667 2668 2669
}


unknown's avatar
unknown committed
2670 2671 2672 2673 2674
enum row_type ha_maria::get_row_type() const
{
  switch (file->s->data_file_type) {
  case STATIC_RECORD:     return ROW_TYPE_FIXED;
  case DYNAMIC_RECORD:    return ROW_TYPE_DYNAMIC;
2675
  case BLOCK_RECORD:      return ROW_TYPE_PAGE;
unknown's avatar
unknown committed
2676 2677 2678 2679 2680 2681
  case COMPRESSED_RECORD: return ROW_TYPE_COMPRESSED;
  default:                return ROW_TYPE_NOT_USED;
  }
}


2682
static enum data_file_type maria_row_type(HA_CREATE_INFO *info)
unknown's avatar
unknown committed
2683
{
2684
  if (info->transactional == HA_CHOICE_YES)
2685
    return BLOCK_RECORD;
unknown's avatar
unknown committed
2686 2687 2688 2689 2690 2691 2692 2693
  switch (info->row_type) {
  case ROW_TYPE_FIXED:   return STATIC_RECORD;
  case ROW_TYPE_DYNAMIC: return DYNAMIC_RECORD;
  default:               return BLOCK_RECORD;
  }
}


2694
int ha_maria::create(const char *name, register TABLE *table_arg,
2695
                     HA_CREATE_INFO *ha_create_info)
2696 2697
{
  int error;
2698
  uint create_flags= 0, record_count, i;
2699 2700
  char buff[FN_REFLEN];
  MARIA_KEYDEF *keydef;
2701 2702
  MARIA_COLUMNDEF *recinfo;
  MARIA_CREATE_INFO create_info;
2703 2704
  TABLE_SHARE *share= table_arg->s;
  uint options= share->db_options_in_use;
unknown's avatar
unknown committed
2705
  enum data_file_type row_type;
2706
  THD *thd= current_thd;
2707 2708
  DBUG_ENTER("ha_maria::create");

2709
  for (i= 0; i < share->keys; i++)
2710
  {
2711
    if (table_arg->key_info[i].flags & HA_USES_PARSER)
2712
    {
2713
      create_flags|= HA_CREATE_RELIES_ON_SQL_LAYER;
2714 2715 2716
      break;
    }
  }
2717
  /* Note: BLOCK_RECORD is used if table is transactional */
2718
  row_type= maria_row_type(ha_create_info);
2719 2720 2721 2722 2723 2724 2725 2726
  if (ha_create_info->transactional == HA_CHOICE_YES &&
      ha_create_info->row_type != ROW_TYPE_PAGE &&
      ha_create_info->row_type != ROW_TYPE_NOT_USED &&
      ha_create_info->row_type != ROW_TYPE_DEFAULT)
    push_warning(current_thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                 ER_ILLEGAL_HA_CREATE_OPTION,
                 "Row format set to PAGE because of TRANSACTIONAL=1 option");

2727
  bzero((char*) &create_info, sizeof(create_info));
2728 2729 2730
  if ((error= table2maria(table_arg, row_type, &keydef, &recinfo,
                          &record_count, &create_info)))
    DBUG_RETURN(error); /* purecov: inspected */
2731 2732
  create_info.max_rows= share->max_rows;
  create_info.reloc_rows= share->min_rows;
2733 2734 2735 2736
  create_info.with_auto_increment= share->next_number_key_offset == 0;
  create_info.auto_increment= (ha_create_info->auto_increment_value ?
                               ha_create_info->auto_increment_value -1 :
                               (ulonglong) 0);
2737 2738
  create_info.data_file_length= ((ulonglong) share->max_rows *
                                 share->avg_row_length);
2739 2740
  create_info.data_file_name= ha_create_info->data_file_name;
  create_info.index_file_name= ha_create_info->index_file_name;
2741
  create_info.language= share->table_charset->number;
2742 2743 2744 2745 2746 2747

  /*
    Table is transactional:
    - If the user specify that table is transactional (in this case
      row type is forced to BLOCK_RECORD)
    - If they specify BLOCK_RECORD without specifying transactional behaviour
2748

unknown's avatar
unknown committed
2749 2750 2751
    Shouldn't this test be pushed down to maria_create()? Because currently,
    ma_test1 -T crashes: it creates a table with DYNAMIC_RECORD but has
    born_transactional==1, which confuses some recovery-related code.
2752
  */
2753 2754
  create_info.transactional= (row_type == BLOCK_RECORD &&
                              ha_create_info->transactional != HA_CHOICE_NO);
2755

2756 2757
  if (ha_create_info->options & HA_LEX_CREATE_TMP_TABLE)
    create_flags|= HA_CREATE_TMP_TABLE;
2758 2759
  if (ha_create_info->options & HA_CREATE_KEEP_FILES)
    create_flags|= HA_CREATE_KEEP_FILES;
2760
  if (options & HA_OPTION_PACK_RECORD)
2761
    create_flags|= HA_PACK_RECORD;
2762
  if (options & HA_OPTION_CHECKSUM)
2763
    create_flags|= HA_CREATE_CHECKSUM;
2764
  if (options & HA_OPTION_DELAY_KEY_WRITE)
2765
    create_flags|= HA_CREATE_DELAY_KEY_WRITE;
2766 2767
  if ((ha_create_info->page_checksum == HA_CHOICE_UNDEF &&
       maria_page_checksums) ||
unknown's avatar
unknown committed
2768
       ha_create_info->page_checksum ==  HA_CHOICE_YES)
2769
    create_flags|= HA_CREATE_PAGE_CHECKSUM;
2770

2771 2772 2773
  (void) translog_log_debug_info(0, LOGREC_DEBUG_INFO_QUERY,
                                 (uchar*) thd->query, thd->query_length);

2774 2775
  /* TODO: Check that the following fn_format is really needed */
  error=
unknown's avatar
unknown committed
2776 2777
    maria_create(fn_format(buff, name, "", "",
                           MY_UNPACK_FILENAME | MY_APPEND_EXT),
2778
                 row_type, share->keys, keydef,
2779
                 record_count,  recinfo,
2780 2781
                 0, (MARIA_UNIQUEDEF *) 0,
                 &create_info, create_flags);
2782

unknown's avatar
unknown committed
2783
  my_free((uchar*) recinfo, MYF(0));
2784 2785 2786 2787 2788 2789
  DBUG_RETURN(error);
}


int ha_maria::rename_table(const char *from, const char *to)
{
2790 2791 2792
  THD *thd= current_thd;
  (void) translog_log_debug_info(0, LOGREC_DEBUG_INFO_QUERY,
                                 (uchar*) thd->query, thd->query_length);
2793 2794 2795 2796
  return maria_rename(from, to);
}


2797 2798 2799 2800
void ha_maria::get_auto_increment(ulonglong offset, ulonglong increment,
                                  ulonglong nb_desired_values,
                                  ulonglong *first_value,
                                  ulonglong *nb_reserved_values)
2801 2802 2803
{
  ulonglong nr;
  int error;
unknown's avatar
unknown committed
2804
  uchar key[HA_MAX_KEY_LENGTH];
2805 2806 2807 2808

  if (!table->s->next_number_key_offset)
  {                                             // Autoincrement at key-start
    ha_maria::info(HA_STATUS_AUTO);
2809 2810 2811 2812
    *first_value= stats.auto_increment_value;
    /* Maria has only table-level lock for now, so reserves to +inf */
    *nb_reserved_values= ULONGLONG_MAX;
    return;
2813 2814 2815 2816 2817 2818 2819 2820 2821 2822
  }

  /* it's safe to call the following if bulk_insert isn't on */
  maria_flush_bulk_insert(file, table->s->next_number_index);

  (void) extra(HA_EXTRA_KEYREAD);
  key_copy(key, table->record[0],
           table->key_info + table->s->next_number_index,
           table->s->next_number_key_offset);
  error= maria_rkey(file, table->record[1], (int) table->s->next_number_index,
2823 2824
                    key, make_prev_keypart_map(table->s->next_number_keypart),
                    HA_READ_PREFIX_LAST);
2825 2826 2827 2828 2829 2830 2831 2832 2833
  if (error)
    nr= 1;
  else
  {
    /* Get data from record[1] */
    nr= ((ulonglong) table->next_number_field->
         val_int_offset(table->s->rec_buff_length) + 1);
  }
  extra(HA_EXTRA_NO_KEYREAD);
2834 2835 2836 2837 2838 2839 2840 2841
  *first_value= nr;
  /*
    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;
2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876
}


/*
  Find out how many rows there is in the given range

  SYNOPSIS
    records_in_range()
    inx                 Index to use
    min_key             Start of range.  Null pointer if from first key
    max_key             End of range. Null pointer if to last key

  NOTES
    min_key.flag can have one of the following values:
      HA_READ_KEY_EXACT         Include the key in the range
      HA_READ_AFTER_KEY         Don't include key in range

    max_key.flag can have one of the following values:
      HA_READ_BEFORE_KEY        Don't include key in range
      HA_READ_AFTER_KEY         Include all 'end_key' values in the range

  RETURN
   HA_POS_ERROR         Something is wrong with the index tree.
   0                    There is no matching keys in the given range
   number > 0           There is approximately 'number' matching rows in
                        the range.
*/

ha_rows ha_maria::records_in_range(uint inx, key_range *min_key,
                                   key_range *max_key)
{
  return (ha_rows) maria_records_in_range(file, (int) inx, min_key, max_key);
}


unknown's avatar
unknown committed
2877
int ha_maria::ft_read(uchar * buf)
2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899
{
  int error;

  if (!ft_handler)
    return -1;

  thread_safe_increment(table->in_use->status_var.ha_read_next_count,
                        &LOCK_status);  // why ?

  error= ft_handler->please->read_next(ft_handler, (char*) buf);

  table->status= error ? STATUS_NOT_FOUND : 0;
  return error;
}


uint ha_maria::checksum() const
{
  return (uint) file->state->checksum;
}


2900
bool ha_maria::check_if_incompatible_data(HA_CREATE_INFO *create_info,
2901 2902
                                          uint table_changes)
{
2903
  DBUG_ENTER("check_if_incompatible_data");
2904 2905
  uint options= table->s->db_options_in_use;

2906 2907 2908
  if (create_info->auto_increment_value != stats.auto_increment_value ||
      create_info->data_file_name != data_file_name ||
      create_info->index_file_name != index_file_name ||
2909
      (maria_row_type(create_info) != data_file_type &&
2910
       create_info->row_type != ROW_TYPE_DEFAULT) ||
2911
      table_changes == IS_EQUAL_NO ||
2912 2913
      (table_changes & IS_EQUAL_PACK_LENGTH)) // Not implemented yet
    DBUG_RETURN(COMPATIBLE_DATA_NO);
2914

2915
  if ((options & (HA_OPTION_CHECKSUM |
2916
                  HA_OPTION_DELAY_KEY_WRITE)) !=
2917
      (create_info->table_options & (HA_OPTION_CHECKSUM |
2918
                              HA_OPTION_DELAY_KEY_WRITE)))
2919 2920
    DBUG_RETURN(COMPATIBLE_DATA_NO);
  DBUG_RETURN(COMPATIBLE_DATA_YES);
2921
}
unknown's avatar
unknown committed
2922

2923 2924

static int maria_hton_panic(handlerton *hton, ha_panic_function flag)
2925
{
unknown's avatar
unknown committed
2926 2927 2928
  /* If no background checkpoints, we need to do one now */
  return ((checkpoint_interval == 0) ?
          ma_checkpoint_execute(CHECKPOINT_FULL, FALSE) : 0) | maria_panic(flag);
2929
}
2930

2931 2932 2933

static int maria_commit(handlerton *hton __attribute__ ((unused)),
                        THD *thd, bool all)
2934
{
2935 2936
  TRN *trn= THD_TRN;
  DBUG_ENTER("maria_commit");
unknown's avatar
unknown committed
2937
  trnman_reset_locked_tables(trn, 0);
Sergei Golubchik's avatar
Sergei Golubchik committed
2938
  trnman_set_flags(trn, trnman_get_flags(trn) & ~TRN_STATE_INFO_LOGGED);
2939

2940 2941 2942 2943 2944
  /* statement or transaction ? */
  if ((thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) && !all)
    DBUG_RETURN(0); // end of statement
  DBUG_PRINT("info", ("THD_TRN set to 0x0"));
  THD_TRN= 0;
2945
  DBUG_RETURN(ma_commit(trn)); // end of transaction
2946
}
2947

2948 2949 2950 2951 2952 2953

static int maria_rollback(handlerton *hton __attribute__ ((unused)),
                          THD *thd, bool all)
{
  TRN *trn= THD_TRN;
  DBUG_ENTER("maria_rollback");
unknown's avatar
unknown committed
2954
  trnman_reset_locked_tables(trn, 0);
2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
  /* statement or transaction ? */
  if ((thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) && !all)
  {
    trnman_rollback_statement(trn);
    DBUG_RETURN(0); // end of statement
  }
  DBUG_PRINT("info", ("THD_TRN set to 0x0"));
  THD_TRN= 0;
  DBUG_RETURN(trnman_rollback_trn(trn) ?
              HA_ERR_OUT_OF_MEM : 0); // end of transaction
}


2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998

/**
  @brief flush log handler

  @param hton            maria handlerton (unused)

  @retval FALSE OK
  @retval TRUE  Error
*/

bool maria_flush_logs(handlerton *hton)
{
  return test(translog_purge_at_flush());
}


#define SHOW_MSG_LEN (FN_REFLEN + 20)
/**
  @brief show status handler

  @param hton            maria handlerton
  @param thd             thread handler
  @param print           print function
  @param stat            type of status
*/

bool maria_show_status(handlerton *hton,
                       THD *thd,
                       stat_print_fn *print,
                       enum ha_stat_type stat)
{
2999
  const LEX_STRING *engine_name= hton_name(hton);
3000
  switch (stat) {
3001
  case HA_ENGINE_LOGS:
3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015
  {
    TRANSLOG_ADDRESS horizon= translog_get_horizon();
    uint32 last_file= LSN_FILE_NO(horizon);
    uint32 first_needed= translog_get_first_needed_file();
    uint32 first_file= translog_get_first_file(horizon);
    uint32 i;
    const char unknown[]= "unknown";
    const char needed[]= "in use";
    const char unneeded[]= "free";
    char path[FN_REFLEN];

    if (first_file == 0)
    {
      const char error[]= "error";
3016 3017
      print(thd, engine_name->str, engine_name->length,
            STRING_WITH_LEN(""), error, sizeof(error) - 1);
3018 3019 3020 3021
      break;
    }

    for (i= first_file; i <= last_file; i++)
3022
    {
3023 3024 3025 3026 3027 3028 3029
      char *file;
      const char *status;
      uint length, status_len;
      MY_STAT stat_buff, *stat;
      const char error[]= "can't stat";
      char object[SHOW_MSG_LEN];
      file= translog_filename_by_fileno(i, path);
3030
      if (!(stat= my_stat(file, &stat_buff, MYF(0))))
3031
      {
3032
        status= error;
3033
        status_len= sizeof(error) - 1;
3034
        length= my_snprintf(object, SHOW_MSG_LEN, "Size unknown ; %s", file);
3035
      }
3036
      else
3037
      {
3038
        if (first_needed == 0)
3039
        {
3040
          status= unknown;
3041
          status_len= sizeof(unknown) - 1;
3042 3043 3044 3045
        }
        else if (i < first_needed)
        {
          status= unneeded;
3046
          status_len= sizeof(unneeded) - 1;
3047 3048 3049
        }
        else
        {
3050
          status= needed;
3051
          status_len= sizeof(needed) - 1;
3052
        }
3053 3054
        length= my_snprintf(object, SHOW_MSG_LEN, "Size %12lu ; %s",
                            (ulong) stat->st_size, file);
3055
      }
3056

3057
      print(thd, engine_name->str, engine_name->length,
3058
            object, length, status, status_len);
3059
    }
3060 3061
    break;
  }
3062 3063 3064 3065 3066 3067 3068 3069
  case HA_ENGINE_STATUS:
  case HA_ENGINE_MUTEX:
  default:
    break;
  }
  return 0;
}

3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149

/**
  Callback to delete all logs in directory. This is lower-level than other
  functions in ma_loghandler.c which delete logs, as it does not rely on
  translog_init() having been called first.

  @param  directory        directory where file is
  @param  filename         base name of the file to delete
*/

static my_bool translog_callback_delete_all(const char *directory,
                                            const char *filename)
{
  char complete_name[FN_REFLEN];
  fn_format(complete_name, filename, directory, "", MYF(MY_UNPACK_FILENAME));
  return my_delete(complete_name, MYF(MY_WME));
}


/**
  Helper function for option maria-force-start-after-recovery-failures.
  Deletes logs if too many failures. Otherwise, increments the counter of
  failures in the control file.
  Notice how this has to be called _before_ translog_init() (if log is
  corrupted, translog_init() might crash the server, so we need to remove logs
  before).

  @param  log_dir          directory where logs to be deleted are
*/

static int mark_recovery_start(const char* log_dir)
{
  int res;
  DBUG_ENTER("mark_recovery_start");
  if (unlikely(maria_recover_options == HA_RECOVER_NONE))
    ma_message_no_user(ME_JUST_WARNING, "Please consider using option"
                       " --maria-recover[=...] to automatically check and"
                       " repair tables when logs are removed by option"
                       " --maria-force-start-after-recovery-failures=#");
  if (recovery_failures >= force_start_after_recovery_failures)
  {
    /*
      Remove logs which cause the problem; keep control file which has
      critical info like uuid, max_trid (removing control file may make
      correct tables look corrupted!).
    */
    char msg[100];
    res= translog_walk_filenames(log_dir, &translog_callback_delete_all);
    my_snprintf(msg, sizeof(msg),
                "%s logs after %u consecutive failures of"
                " recovery from logs",
                (res ? "failed to remove some" : "removed all"),
                recovery_failures);
    ma_message_no_user((res ? 0 : ME_JUST_WARNING), msg);
  }
  else
    res= ma_control_file_write_and_force(last_checkpoint_lsn, last_logno,
                                         max_trid_in_control_file,
                                         recovery_failures + 1);
  DBUG_RETURN(res);
}


/**
  Helper function for option maria-force-start-after-recovery-failures.
  Records in the control file that recovery was a success, so that it's not
  counted for maria-force-start-after-recovery-failures.
*/

static int mark_recovery_success(void)
{
  /* success of recovery, reset recovery_failures: */
  int res;
  DBUG_ENTER("mark_recovery_success");
  res= ma_control_file_write_and_force(last_checkpoint_lsn, last_logno,
                                       max_trid_in_control_file, 0);
  DBUG_RETURN(res);
}


3150 3151 3152 3153 3154 3155 3156 3157 3158 3159
/*
  Return 1 if table has changed during the current transaction
*/

bool ha_maria::is_changed() const
{
  return file->state->changed;
}


3160 3161
static int ha_maria_init(void *p)
{
3162
  int res;
3163
  const char *log_dir= maria_data_root;
3164 3165
  maria_hton= (handlerton *)p;
  maria_hton->state= SHOW_OPTION_YES;
unknown's avatar
unknown committed
3166
  maria_hton->db_type= DB_TYPE_UNKNOWN;
3167
  maria_hton->create= maria_create_handler;
3168 3169 3170
  maria_hton->panic= maria_hton_panic;
  maria_hton->commit= maria_commit;
  maria_hton->rollback= maria_rollback;
3171 3172
  maria_hton->flush_logs= maria_flush_logs;
  maria_hton->show_status= maria_show_status;
3173 3174
  /* TODO: decide if we support Maria being used for log tables */
  maria_hton->flags= HTON_CAN_RECREATE | HTON_SUPPORT_LOG_TABLES;
3175
  bzero(maria_log_pagecache, sizeof(*maria_log_pagecache));
3176
  maria_tmpdir= &mysql_tmpdir_list;             /* For REDO */
unknown's avatar
unknown committed
3177
  res= maria_init() || ma_control_file_open(TRUE, TRUE) ||
3178 3179
    ((force_start_after_recovery_failures != 0) &&
     mark_recovery_start(log_dir)) ||
3180
    !init_pagecache(maria_pagecache,
3181
                    (size_t) pagecache_buffer_size, pagecache_division_limit,
3182
                    pagecache_age_threshold, maria_block_size, 0) ||
3183
    !init_pagecache(maria_log_pagecache,
3184
                    TRANSLOG_PAGECACHE_SIZE, 0, 0,
3185
                    TRANSLOG_PAGE_SIZE, 0) ||
3186
    translog_init(maria_data_root, log_file_size,
3187
                  MYSQL_VERSION_ID, server_id, maria_log_pagecache,
3188
                  TRANSLOG_DEFAULT_FLAGS, 0) ||
3189 3190
    maria_recovery_from_log() ||
    ((force_start_after_recovery_failures != 0) && mark_recovery_success()) ||
unknown's avatar
unknown committed
3191
    ma_checkpoint_init(checkpoint_interval);
3192
  maria_multi_threaded= maria_in_ha_maria= TRUE;
3193

3194
#if defined(HAVE_REALPATH) && !defined(HAVE_valgrind) && !defined(HAVE_BROKEN_REALPATH)
3195 3196 3197
  /*  We can only test for sub paths if my_symlink.c is using realpath */
  maria_test_invalid_symlink= test_if_data_home_dir;
#endif
3198
  return res ? HA_ERR_INITIALIZATION : 0;
3199 3200
}

3201

3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219
#ifdef HAVE_QUERY_CACHE
/**
  @brief Register a named table with a call back function to the query cache.

  @param thd The thread handle
  @param table_key A pointer to the table name in the table cache
  @param key_length The length of the table name
  @param[out] engine_callback The pointer to the storage engine call back
    function, currently 0
  @param[out] engine_data Engine data will be set to 0.

  @note Despite the name of this function, it is used to check each statement
    before it is cached and not to register a table or callback function.

  @see handler::register_query_cache_table

  @return The error code. The engine_data and engine_callback will be set to 0.
    @retval TRUE Success
unknown's avatar
unknown committed
3220
    @retval FALSE An error occurred
3221 3222 3223 3224 3225 3226 3227 3228
*/

my_bool ha_maria::register_query_cache_table(THD *thd, char *table_name,
					     uint table_name_len,
					     qc_engine_callback
					     *engine_callback,
					     ulonglong *engine_data)
{
unknown's avatar
unknown committed
3229 3230
  ulonglong actual_data_file_length;
  ulonglong current_data_file_length;
3231
  DBUG_ENTER("ha_maria::register_query_cache_table");
3232

3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243
  /*
    No call back function is needed to determine if a cached statement
    is valid or not.
  */
  *engine_callback= 0;

  /*
    No engine data is needed.
  */
  *engine_data= 0;

3244 3245 3246
  if (file->s->now_transactional && file->s->have_versioning)
    return (file->trn->trid >= file->s->state.last_change_trn);

3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268
  /*
    If a concurrent INSERT has happened just before the currently processed
    SELECT statement, the total size of the table is unknown.

    To determine if the table size is known, the current thread's snap shot of
    the table size with the actual table size are compared.

    If the table size is unknown the SELECT statement can't be cached.
  */

  /*
    POSIX visibility rules specify that "2. Whatever memory values a
    thread can see when it unlocks a mutex <...> can also be seen by any
    thread that later locks the same mutex". In this particular case,
    concurrent insert thread had modified the data_file_length in
    MYISAM_SHARE before it has unlocked (or even locked)
    structure_guard_mutex. So, here we're guaranteed to see at least that
    value after we've locked the same mutex. We can see a later value
    (modified by some other thread) though, but it's ok, as we only want
    to know if the variable was changed, the actual new value doesn't matter
  */
  actual_data_file_length= file->s->state.state.data_file_length;
3269
  current_data_file_length= file->state->data_file_length;
3270

3271 3272 3273
  /* Return whether is ok to try to cache current statement. */
  DBUG_RETURN(!(file->s->non_transactional_concurrent_insert &&
                current_data_file_length != actual_data_file_length));
3274 3275 3276
}
#endif

3277 3278
static struct st_mysql_sys_var* system_variables[]= {
  MYSQL_SYSVAR(block_size),
unknown's avatar
unknown committed
3279
  MYSQL_SYSVAR(checkpoint_interval),
3280
  MYSQL_SYSVAR(force_start_after_recovery_failures),
unknown's avatar
unknown committed
3281
  MYSQL_SYSVAR(page_checksum),
3282
  MYSQL_SYSVAR(log_dir_path),
3283 3284
  MYSQL_SYSVAR(log_file_size),
  MYSQL_SYSVAR(log_purge_type),
3285
  MYSQL_SYSVAR(max_sort_file_size),
unknown's avatar
unknown committed
3286 3287 3288
  MYSQL_SYSVAR(pagecache_age_threshold),
  MYSQL_SYSVAR(pagecache_buffer_size),
  MYSQL_SYSVAR(pagecache_division_limit),
3289
  MYSQL_SYSVAR(recover),
3290 3291 3292
  MYSQL_SYSVAR(repair_threads),
  MYSQL_SYSVAR(sort_buffer_size),
  MYSQL_SYSVAR(stats_method),
3293
  MYSQL_SYSVAR(sync_log_dir),
Sergey Petrunya's avatar
Sergey Petrunya committed
3294
  MYSQL_SYSVAR(used_for_temp_tables),
3295 3296 3297 3298
  NULL
};


unknown's avatar
unknown committed
3299
/**
unknown's avatar
unknown committed
3300
   @brief Updates the checkpoint interval and restarts the background thread.
unknown's avatar
unknown committed
3301
*/
unknown's avatar
unknown committed
3302

unknown's avatar
unknown committed
3303
static void update_checkpoint_interval(MYSQL_THD thd,
unknown's avatar
unknown committed
3304
                                        struct st_mysql_sys_var *var,
unknown's avatar
unknown committed
3305
                                        void *var_ptr, const void *save)
unknown's avatar
unknown committed
3306
{
unknown's avatar
unknown committed
3307 3308
  ma_checkpoint_end();
  ma_checkpoint_init(*(ulong *)var_ptr= (ulong)(*(long *)save));
unknown's avatar
unknown committed
3309 3310
}

3311 3312 3313 3314 3315 3316
/**
   @brief Updates the transaction log file limit.
*/

static void update_log_file_size(MYSQL_THD thd,
                                 struct st_mysql_sys_var *var,
unknown's avatar
unknown committed
3317
                                 void *var_ptr, const void *save)
3318 3319
{
  uint32 size= (uint32)((ulong)(*(long *)save));
unknown's avatar
unknown committed
3320
  translog_set_file_size(size);
3321 3322 3323
  *(ulong *)var_ptr= size;
}

3324

unknown's avatar
unknown committed
3325
static SHOW_VAR status_variables[]= {
3326 3327 3328
  {"Maria_pagecache_blocks_not_flushed", (char*) &maria_pagecache_var.global_blocks_changed, SHOW_LONG_NOFLUSH},
  {"Maria_pagecache_blocks_unused",      (char*) &maria_pagecache_var.blocks_unused, SHOW_LONG_NOFLUSH},
  {"Maria_pagecache_blocks_used",        (char*) &maria_pagecache_var.blocks_used, SHOW_LONG_NOFLUSH},
unknown's avatar
unknown committed
3329 3330 3331 3332 3333 3334
  {"Maria_pagecache_read_requests",      (char*) &maria_pagecache_var.global_cache_r_requests, SHOW_LONGLONG},
  {"Maria_pagecache_reads",              (char*) &maria_pagecache_var.global_cache_read, SHOW_LONGLONG},
  {"Maria_pagecache_write_requests",     (char*) &maria_pagecache_var.global_cache_w_requests, SHOW_LONGLONG},
  {"Maria_pagecache_writes",             (char*) &maria_pagecache_var.global_cache_write, SHOW_LONGLONG},
  {NullS, NullS, SHOW_LONG}
};
3335

3336
struct st_mysql_storage_engine maria_storage_engine=
3337
{ MYSQL_HANDLERTON_INTERFACE_VERSION };
3338

unknown's avatar
unknown committed
3339 3340 3341
mysql_declare_plugin(maria)
{
  MYSQL_STORAGE_ENGINE_PLUGIN,
3342
  &maria_storage_engine,
unknown's avatar
unknown committed
3343
  "MARIA",
3344
  "Monty Program Ab",
3345
  "Crash-safe tables with MyISAM heritage",
3346
  PLUGIN_LICENSE_GPL,
3347 3348 3349
  ha_maria_init,              /* Plugin Init                     */
  NULL,                       /* Plugin Deinit                   */
  0x0100,                     /* 1.0                             */
unknown's avatar
unknown committed
3350
  status_variables,           /* status variables                */
3351 3352
  system_variables,           /* system variables                */
  NULL
unknown's avatar
unknown committed
3353 3354
}
mysql_declare_plugin_end;