table.cc 142 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000-2006 MySQL AB
unknown's avatar
unknown committed
2

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

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

unknown's avatar
unknown committed
12 13 14 15 16 17 18 19
   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 */


/* Some general useful functions */

#include "mysql_priv.h"
20
#include "sql_trigger.h"
unknown's avatar
unknown committed
21
#include <m_ctype.h>
22
#include "my_md5.h"
unknown's avatar
unknown committed
23 24 25

	/* Functions defined in this file */

unknown's avatar
unknown committed
26 27
void open_table_error(TABLE_SHARE *share, int error, int db_errno,
                      myf errortype, int errarg);
28 29
static int open_binary_frm(THD *thd, TABLE_SHARE *share,
                           uchar *head, File file);
unknown's avatar
unknown committed
30 31
static void fix_type_pointers(const char ***array, TYPELIB *point_to_type,
			      uint types, char **names);
32
static uint find_field(Field **fields, uchar *record, uint start, uint length);
unknown's avatar
unknown committed
33 34


unknown's avatar
unknown committed
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
/**************************************************************************
  Object_creation_ctx implementation.
**************************************************************************/

Object_creation_ctx *Object_creation_ctx::set_n_backup(THD *thd)
{
  Object_creation_ctx *backup_ctx= create_backup_ctx(thd);

  change_env(thd);

  return backup_ctx;
}

void Object_creation_ctx::restore_env(THD *thd, Object_creation_ctx *backup_ctx)
{
  if (!backup_ctx)
    return;

  backup_ctx->change_env(thd);

  delete backup_ctx;
}

/**************************************************************************
  Default_object_creation_ctx implementation.
**************************************************************************/

Default_object_creation_ctx::Default_object_creation_ctx(THD *thd)
  : m_client_cs(thd->variables.character_set_client),
    m_connection_cl(thd->variables.collation_connection)
{ }

Default_object_creation_ctx::Default_object_creation_ctx(
  CHARSET_INFO *client_cs, CHARSET_INFO *connection_cl)
  : m_client_cs(client_cs),
    m_connection_cl(connection_cl)
{ }

Object_creation_ctx *
Default_object_creation_ctx::create_backup_ctx(THD *thd)
{
  return new Default_object_creation_ctx(thd);
}

void Default_object_creation_ctx::change_env(THD *thd) const
{
  thd->variables.character_set_client= m_client_cs;
  thd->variables.collation_connection= m_connection_cl;

  thd->update_charset();
}

/**************************************************************************
  View_creation_ctx implementation.
**************************************************************************/

View_creation_ctx *View_creation_ctx::create(THD *thd)
{
  View_creation_ctx *ctx= new (thd->mem_root) View_creation_ctx(thd);

  return ctx;
}

/*************************************************************************/

View_creation_ctx * View_creation_ctx::create(THD *thd,
101
                                              TABLE_LIST *view)
unknown's avatar
unknown committed
102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
{
  View_creation_ctx *ctx= new (thd->mem_root) View_creation_ctx(thd);

  /* Throw a warning if there is NULL cs name. */

  if (!view->view_client_cs_name.str ||
      !view->view_connection_cl_name.str)
  {
    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                        ER_VIEW_NO_CREATION_CTX,
                        ER(ER_VIEW_NO_CREATION_CTX),
                        (const char *) view->db,
                        (const char *) view->table_name);

    ctx->m_client_cs= system_charset_info;
    ctx->m_connection_cl= system_charset_info;

    return ctx;
  }

  /* Resolve cs names. Throw a warning if there is unknown cs name. */

  bool invalid_creation_ctx;

  invalid_creation_ctx= resolve_charset(view->view_client_cs_name.str,
                                        system_charset_info,
                                        &ctx->m_client_cs);

  invalid_creation_ctx= resolve_collation(view->view_connection_cl_name.str,
                                          system_charset_info,
                                          &ctx->m_connection_cl) ||
                        invalid_creation_ctx;

  if (invalid_creation_ctx)
  {
    sql_print_warning("View '%s'.'%s': there is unknown charset/collation "
                      "names (client: '%s'; connection: '%s').",
                      (const char *) view->db,
                      (const char *) view->table_name,
                      (const char *) view->view_client_cs_name.str,
                      (const char *) view->view_connection_cl_name.str);

    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
                        ER_VIEW_INVALID_CREATION_CTX,
                        ER(ER_VIEW_INVALID_CREATION_CTX),
                        (const char *) view->db,
                        (const char *) view->table_name);
  }

  return ctx;
}

/*************************************************************************/

unknown's avatar
unknown committed
156 157
/* Get column name from column hash */

158 159
static uchar *get_field_name(Field **buff, size_t *length,
                             my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
160
{
161
  *length= (uint) strlen((*buff)->field_name);
162
  return (uchar*) (*buff)->field_name;
unknown's avatar
unknown committed
163 164
}

unknown's avatar
unknown committed
165

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
/*
  Returns pointer to '.frm' extension of the file name.

  SYNOPSIS
    fn_rext()
    name       file name

  DESCRIPTION
    Checks file name part starting with the rightmost '.' character,
    and returns it if it is equal to '.frm'. 

  TODO
    It is a good idea to get rid of this function modifying the code
    to garantee that the functions presently calling fn_rext() always
    get arguments in the same format: either with '.frm' or without '.frm'.

  RETURN VALUES
    Pointer to the '.frm' extension. If there is no extension,
    or extension is not '.frm', pointer at the end of file name.
*/

char *fn_rext(char *name)
{
  char *res= strrchr(name, '.');
190
  if (res && !strcmp(res, reg_ext))
191 192 193 194 195
    return res;
  return name + strlen(name);
}


unknown's avatar
unknown committed
196 197 198 199 200 201 202 203 204 205 206 207 208 209
/*
  Allocate a setup TABLE_SHARE structure

  SYNOPSIS
    alloc_table_share()
    TABLE_LIST		Take database and table name from there
    key			Table cache key (db \0 table_name \0...)
    key_length		Length of key

  RETURN
    0  Error (out of memory)
    #  Share
*/

210
TABLE_SHARE *alloc_table_share(TABLE_LIST *table_list, char *key,
unknown's avatar
unknown committed
211 212 213 214
                               uint key_length)
{
  MEM_ROOT mem_root;
  TABLE_SHARE *share;
215
  char *key_buff, *path_buff;
216 217
  char path[FN_REFLEN];
  uint path_length;
218 219 220
  DBUG_ENTER("alloc_table_share");
  DBUG_PRINT("enter", ("table: '%s'.'%s'",
                       table_list->db, table_list->table_name));
unknown's avatar
unknown committed
221

222 223
  path_length= build_table_filename(path, sizeof(path) - 1,
                                    table_list->db,
224
                                    table_list->table_name, "", 0);
unknown's avatar
unknown committed
225
  init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
226 227 228 229 230
  if (multi_alloc_root(&mem_root,
                       &share, sizeof(*share),
                       &key_buff, key_length,
                       &path_buff, path_length + 1,
                       NULL))
unknown's avatar
unknown committed
231 232 233
  {
    bzero((char*) share, sizeof(*share));

234
    share->set_table_cache_key(key_buff, key, key_length);
unknown's avatar
unknown committed
235

236
    share->path.str= path_buff;
unknown's avatar
unknown committed
237 238
    share->path.length= path_length;
    strmov(share->path.str, path);
239 240
    share->normalized_path.str=    share->path.str;
    share->normalized_path.length= path_length;
unknown's avatar
unknown committed
241 242 243

    share->version=       refresh_version;

244 245 246 247 248 249 250 251 252 253 254 255 256 257
    /*
      This constant is used to mark that no table map version has been
      assigned.  No arithmetic is done on the value: it will be
      overwritten with a value taken from MYSQL_BIN_LOG.
    */
    share->table_map_version= ~(ulonglong)0;

    /*
      Since alloc_table_share() can be called without any locking (for
      example, ha_create_table... functions), we do not assign a table
      map id here.  Instead we assign a value that is not used
      elsewhere, and then assign a table map id inside open_table()
      under the protection of the LOCK_open mutex.
    */
258
    share->table_map_id= ~0UL;
259 260
    share->cached_row_logging_check= -1;

unknown's avatar
unknown committed
261 262 263 264
    memcpy((char*) &share->mem_root, (char*) &mem_root, sizeof(mem_root));
    pthread_mutex_init(&share->mutex, MY_MUTEX_INIT_FAST);
    pthread_cond_init(&share->cond, NULL);
  }
265
  DBUG_RETURN(share);
unknown's avatar
unknown committed
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
}


/*
  Initialize share for temporary tables

  SYNOPSIS
    init_tmp_table_share()
    share	Share to fill
    key		Table_cache_key, as generated from create_table_def_key.
		must start with db name.    
    key_length	Length of key
    table_name	Table name
    path	Path to file (possible in lower case) without .frm

  NOTES
    This is different from alloc_table_share() because temporary tables
    don't have to be shared between threads or put into the table def
    cache, so we can do some things notable simpler and faster

    If table is not put in thd->temporary_tables (happens only when
    one uses OPEN TEMPORARY) then one can specify 'db' as key and
    use key_length= 0 as neither table_cache_key or key_length will be used).
*/

void init_tmp_table_share(TABLE_SHARE *share, const char *key,
                          uint key_length, const char *table_name,
                          const char *path)
{
  DBUG_ENTER("init_tmp_table_share");
296
  DBUG_PRINT("enter", ("table: '%s'.'%s'", key, table_name));
unknown's avatar
unknown committed
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311

  bzero((char*) share, sizeof(*share));
  init_sql_alloc(&share->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
  share->tmp_table=  	         INTERNAL_TMP_TABLE;
  share->db.str=                 (char*) key;
  share->db.length=		 strlen(key);
  share->table_cache_key.str=    (char*) key;
  share->table_cache_key.length= key_length;
  share->table_name.str=         (char*) table_name;
  share->table_name.length=      strlen(table_name);
  share->path.str=               (char*) path;
  share->normalized_path.str=    (char*) path;
  share->path.length= share->normalized_path.length= strlen(path);
  share->frm_version= 		 FRM_VER_TRUE_VARCHAR;

312 313 314 315 316
  /*
    Temporary tables are not replicated, but we set up these fields
    anyway to be able to catch errors.
   */
  share->table_map_version= ~(ulonglong)0;
317
  share->table_map_id= ~0UL;
318
  share->cached_row_logging_check= -1;
319

unknown's avatar
unknown committed
320 321 322 323
  DBUG_VOID_RETURN;
}


324
/*
unknown's avatar
unknown committed
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
  Free table share and memory used by it

  SYNOPSIS
    free_table_share()
    share		Table share

  NOTES
    share->mutex must be locked when we come here if it's not a temp table
*/

void free_table_share(TABLE_SHARE *share)
{
  MEM_ROOT mem_root;
  DBUG_ENTER("free_table_share");
  DBUG_PRINT("enter", ("table: %s.%s", share->db.str, share->table_name.str));
  DBUG_ASSERT(share->ref_count == 0);

  /*
    If someone is waiting for this to be deleted, inform it about this.
    Don't do a delete until we know that no one is refering to this anymore.
  */
  if (share->tmp_table == NO_TMP_TABLE)
  {
    /* share->mutex is locked in release_table_share() */
    while (share->waiting_on_cond)
    {
      pthread_cond_broadcast(&share->cond);
      pthread_cond_wait(&share->cond, &share->mutex);
    }
    /* No thread refers to this anymore */
    pthread_mutex_unlock(&share->mutex);
    pthread_mutex_destroy(&share->mutex);
    pthread_cond_destroy(&share->cond);
  }
  hash_free(&share->name_hash);
unknown's avatar
unknown committed
360 361 362
  
  plugin_unlock(NULL, share->db_plugin);
  share->db_plugin= NULL;
unknown's avatar
unknown committed
363 364 365 366 367 368

  /* We must copy mem_root from share because share is allocated through it */
  memcpy((char*) &mem_root, (char*) &share->mem_root, sizeof(mem_root));
  free_root(&mem_root, MYF(0));                 // Free's share
  DBUG_VOID_RETURN;
}
369

unknown's avatar
unknown committed
370

371 372 373 374 375
/**
  Return TRUE if a table name matches one of the system table names.
  Currently these are:

  help_category, help_keyword, help_relation, help_topic,
376
  proc, event
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
  time_zone, time_zone_leap_second, time_zone_name, time_zone_transition,
  time_zone_transition_type

  This function trades accuracy for speed, so may return false
  positives. Presumably mysql.* database is for internal purposes only
  and should not contain user tables.
*/

inline bool is_system_table_name(const char *name, uint length)
{
  CHARSET_INFO *ci= system_charset_info;

  return (
          /* mysql.proc table */
          length == 4 &&
          my_tolower(ci, name[0]) == 'p' && 
          my_tolower(ci, name[1]) == 'r' &&
          my_tolower(ci, name[2]) == 'o' &&
          my_tolower(ci, name[3]) == 'c' ||

          length > 4 &&
          (
           /* one of mysql.help* tables */
           my_tolower(ci, name[0]) == 'h' &&
           my_tolower(ci, name[1]) == 'e' &&
           my_tolower(ci, name[2]) == 'l' &&
           my_tolower(ci, name[3]) == 'p' ||

           /* one of mysql.time_zone* tables */
           my_tolower(ci, name[0]) == 't' &&
           my_tolower(ci, name[1]) == 'i' &&
           my_tolower(ci, name[2]) == 'm' &&
409 410 411 412 413 414 415 416
           my_tolower(ci, name[3]) == 'e' ||

           /* mysql.event table */
           my_tolower(ci, name[0]) == 'e' &&
           my_tolower(ci, name[1]) == 'v' &&
           my_tolower(ci, name[2]) == 'e' &&
           my_tolower(ci, name[3]) == 'n' &&
           my_tolower(ci, name[4]) == 't'
417 418 419 420 421
          )
         );
}


unknown's avatar
unknown committed
422 423 424
/*
  Read table definition from a binary / text based .frm file
  
425
  SYNOPSIS
unknown's avatar
unknown committed
426 427 428 429
  open_table_def()
  thd		Thread handler
  share		Fill this with table definition
  db_flags	Bit mask of the following flags: OPEN_VIEW
430

unknown's avatar
unknown committed
431 432 433 434 435
  NOTES
    This function is called when the table definition is not cached in
    table_def_cache
    The data is returned in 'share', which is alloced by
    alloc_table_share().. The code assumes that share is initialized.
436 437 438

  RETURN VALUES
   0	ok
unknown's avatar
unknown committed
439 440
   1	Error (see open_table_error)
   2    Error (see open_table_error)
441
   3    Wrong data in .frm file
unknown's avatar
unknown committed
442 443
   4    Error (see open_table_error)
   5    Error (see open_table_error: charset unavailable)
444
   6    Unknown .frm version
445
*/
unknown's avatar
unknown committed
446

unknown's avatar
unknown committed
447 448 449 450 451 452 453
int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags)
{
  int error, table_type;
  bool error_given;
  File file;
  uchar head[288], *disk_buff;
  char	path[FN_REFLEN];
unknown's avatar
unknown committed
454
  MEM_ROOT **root_ptr, *old_root;
unknown's avatar
unknown committed
455
  DBUG_ENTER("open_table_def");
456 457
  DBUG_PRINT("enter", ("table: '%s'.'%s'  path: '%s'", share->db.str,
                       share->table_name.str, share->normalized_path.str));
unknown's avatar
unknown committed
458

459
  error= 1;
unknown's avatar
unknown committed
460
  error_given= 0;
461
  disk_buff= NULL;
unknown's avatar
VIEW  
unknown committed
462

unknown's avatar
unknown committed
463 464
  strxmov(path, share->normalized_path.str, reg_ext, NullS);
  if ((file= my_open(path, O_RDONLY | O_SHARE, MYF(0))) < 0)
unknown's avatar
unknown committed
465
  {
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
    /*
      We don't try to open 5.0 unencoded name, if
      - non-encoded name contains '@' signs, 
        because '@' can be misinterpreted.
        It is not clear if '@' is escape character in 5.1,
        or a normal character in 5.0.
        
      - non-encoded db or table name contain "#mysql50#" prefix.
        This kind of tables must have been opened only by the
        my_open() above.
    */
    if (strchr(share->table_name.str, '@') ||
        !strncmp(share->db.str, MYSQL50_TABLE_NAME_PREFIX,
                 MYSQL50_TABLE_NAME_PREFIX_LENGTH) ||
        !strncmp(share->table_name.str, MYSQL50_TABLE_NAME_PREFIX,
                 MYSQL50_TABLE_NAME_PREFIX_LENGTH))
482 483
      goto err_not_open;

484
    /* Try unencoded 5.0 name */
unknown's avatar
unknown committed
485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
    uint length;
    strxnmov(path, sizeof(path)-1,
             mysql_data_home, "/", share->db.str, "/",
             share->table_name.str, reg_ext, NullS);
    length= unpack_filename(path, path) - reg_ext_length;
    /*
      The following is a safety test and should never fail
      as the old file name should never be longer than the new one.
    */
    DBUG_ASSERT(length <= share->normalized_path.length);
    /*
      If the old and the new names have the same length,
      then table name does not have tricky characters,
      so no need to check the old file name.
    */
    if (length == share->normalized_path.length ||
        ((file= my_open(path, O_RDONLY | O_SHARE, MYF(0))) < 0))
      goto err_not_open;

    /* Unencoded 5.0 table name found */
    path[length]= '\0'; // Remove .frm extension
    strmov(share->normalized_path.str, path);
    share->normalized_path.length= length;
  }
unknown's avatar
VIEW  
unknown committed
509

510
  error= 4;
511
  if (my_read(file, head, 64, MYF(MY_NABP)))
512
    goto err;
unknown's avatar
VIEW  
unknown committed
513

unknown's avatar
unknown committed
514
  if (head[0] == (uchar) 254 && head[1] == 1)
unknown's avatar
VIEW  
unknown committed
515
  {
unknown's avatar
unknown committed
516 517 518 519 520 521 522 523 524
    if (head[2] == FRM_VER || head[2] == FRM_VER+1 ||
        (head[2] >= FRM_VER+3 && head[2] <= FRM_VER+4))
      table_type= 1;
    else
    {
      error= 6;                                 // Unkown .frm version
      goto err;
    }
  }
unknown's avatar
unknown committed
525
  else if (memcmp(head, STRING_WITH_LEN("TYPE=")) == 0)
unknown's avatar
unknown committed
526 527 528 529 530 531 532 533 534 535 536
  {
    error= 5;
    if (memcmp(head+5,"VIEW",4) == 0)
    {
      share->is_view= 1;
      if (db_flags & OPEN_VIEW)
        error= 0;
    }
    goto err;
  }
  else
537
    goto err;
unknown's avatar
VIEW  
unknown committed
538

unknown's avatar
unknown committed
539 540 541 542 543 544 545 546 547
  /* No handling of text based files yet */
  if (table_type == 1)
  {
    root_ptr= my_pthread_getspecific_ptr(MEM_ROOT**, THR_MALLOC);
    old_root= *root_ptr;
    *root_ptr= &share->mem_root;
    error= open_binary_frm(thd, share, head, file);
    *root_ptr= old_root;

548 549 550
    if (share->db.length == 5 && !(lower_case_table_names ?
        my_strcasecmp(system_charset_info, share->db.str, "mysql") :
        strcmp(share->db.str, "mysql")))
551 552 553 554 555 556
    {
      /*
        We can't mark all tables in 'mysql' database as system since we don't
        allow to lock such tables for writing with any other tables (even with
        other system tables) and some privilege tables need this.
      */
557 558 559
      share->system_table= is_system_table_name(share->table_name.str,
                                                share->table_name.length);
      if (!share->system_table)
560
      {
561 562 563
        share->log_table= check_if_log_table(share->db.length, share->db.str,
                                             share->table_name.length,
                                             share->table_name.str, 0);
564 565
      }
    }
unknown's avatar
unknown committed
566
    error_given= 1;
unknown's avatar
VIEW  
unknown committed
567 568
  }

unknown's avatar
unknown committed
569 570
  if (!error)
    thd->status_var.opened_shares++;
unknown's avatar
unknown committed
571

unknown's avatar
unknown committed
572 573
err:
  my_close(file, MYF(MY_WME));
unknown's avatar
unknown committed
574

unknown's avatar
unknown committed
575 576
err_not_open:
  if (error && !error_given)
577
  {
unknown's avatar
unknown committed
578 579
    share->error= error;
    open_table_error(share, error, (share->open_errno= my_errno), 0);
580
  }
581

unknown's avatar
unknown committed
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
  DBUG_RETURN(error);
}


/*
  Read data from a binary .frm file from MySQL 3.23 - 5.0 into TABLE_SHARE
*/

static int open_binary_frm(THD *thd, TABLE_SHARE *share, uchar *head,
                           File file)
{
  int error, errarg= 0;
  uint new_frm_ver, field_pack_length, new_field_pack_flag;
  uint interval_count, interval_parts, read_length, int_length;
  uint db_create_options, keys, key_parts, n_length;
  uint key_info_length, com_length, null_bit_pos;
  uint extra_rec_buf_length;
  uint i,j;
  bool use_hash;
601 602
  char *keynames, *names, *comment_pos;
  uchar *record;
unknown's avatar
unknown committed
603 604 605 606 607 608 609 610
  uchar *disk_buff, *strpos, *null_flags, *null_pos;
  ulong pos, record_offset, *rec_per_key, rec_buff_length;
  handler *handler_file= 0;
  KEY	*keyinfo;
  KEY_PART_INFO *key_part;
  SQL_CRYPT *crypted=0;
  Field  **field_ptr, *reg_field;
  const char **interval_array;
unknown's avatar
unknown committed
611
  enum legacy_db_type legacy_db_type;
612
  my_bitmap_map *bitmaps;
unknown's avatar
unknown committed
613 614 615
  DBUG_ENTER("open_binary_frm");

  new_field_pack_flag= head[27];
616
  new_frm_ver= (head[2] - FRM_VER);
617
  field_pack_length= new_frm_ver < 2 ? 11 : 17;
unknown's avatar
unknown committed
618
  disk_buff= 0;
unknown's avatar
unknown committed
619

unknown's avatar
unknown committed
620
  error= 3;
unknown's avatar
unknown committed
621
  if (!(pos=get_form_pos(file,head,(TYPELIB*) 0)))
622
    goto err;                                   /* purecov: inspected */
unknown's avatar
unknown committed
623

624
  share->frm_version= head[2];
625 626 627 628 629 630 631 632 633
  /*
    Check if .frm file created by MySQL 5.0. In this case we want to
    display CHAR fields as CHAR and not as VARCHAR.
    We do it this way as we want to keep the old frm version to enable
    MySQL 4.1 to read these files.
  */
  if (share->frm_version == FRM_VER_TRUE_VARCHAR -1 && head[33] == 5)
    share->frm_version= FRM_VER_TRUE_VARCHAR;

unknown's avatar
unknown committed
634
#ifdef WITH_PARTITION_STORAGE_ENGINE
635 636 637 638
  if (*(head+61) &&
      !(share->default_part_db_type= 
        ha_checktype(thd, (enum legacy_db_type) (uint) *(head+61), 1, 0)))
    goto err;
unknown's avatar
unknown committed
639
  DBUG_PRINT("info", ("default_part_db_type = %u", head[61]));
unknown's avatar
unknown committed
640
#endif
unknown's avatar
unknown committed
641
  legacy_db_type= (enum legacy_db_type) (uint) *(head+3);
unknown's avatar
unknown committed
642 643 644 645 646 647 648 649 650
  DBUG_ASSERT(share->db_plugin == NULL);
  /*
    if the storage engine is dynamic, no point in resolving it by its
    dynamically allocated legacy_db_type. We will resolve it later by name.
  */
  if (legacy_db_type > DB_TYPE_UNKNOWN && 
      legacy_db_type < DB_TYPE_FIRST_DYNAMIC)
    share->db_plugin= ha_lock_engine(NULL, 
                                     ha_checktype(thd, legacy_db_type, 0, 0));
unknown's avatar
unknown committed
651
  share->db_create_options= db_create_options= uint2korr(head+30);
652
  share->db_options_in_use= share->db_create_options;
653
  share->mysql_version= uint4korr(head+51);
unknown's avatar
unknown committed
654
  share->null_field_first= 0;
unknown's avatar
unknown committed
655 656
  if (!head[32])				// New frm file in 3.23
  {
657 658 659
    share->avg_row_length= uint4korr(head+34);
    share-> row_type= (row_type) head[40];
    share->table_charset= get_charset((uint) head[38],MYF(0));
unknown's avatar
unknown committed
660
    share->null_field_first= 1;
661 662 663 664
  }
  if (!share->table_charset)
  {
    /* unknown charset in head[38] or pre-3.23 frm */
665 666 667 668 669 670
    if (use_mb(default_charset_info))
    {
      /* Warn that we may be changing the size of character columns */
      sql_print_warning("'%s' had no or invalid character set, "
                        "and default character set is multi-byte, "
                        "so character column sizes may have changed",
671
                        share->path.str);
672
    }
673
    share->table_charset= default_charset_info;
unknown's avatar
unknown committed
674
  }
675
  share->db_record_offset= 1;
unknown's avatar
unknown committed
676
  if (db_create_options & HA_OPTION_LONG_BLOB_PTR)
677
    share->blob_ptr_size= portable_sizeof_char_ptr;
678
  /* Set temporarily a good value for db_low_byte_first */
unknown's avatar
unknown committed
679
  share->db_low_byte_first= test(legacy_db_type != DB_TYPE_ISAM);
unknown's avatar
unknown committed
680
  error=4;
681 682
  share->max_rows= uint4korr(head+18);
  share->min_rows= uint4korr(head+22);
unknown's avatar
unknown committed
683 684

  /* Read keyinformation */
685
  key_info_length= (uint) uint2korr(head+28);
unknown's avatar
unknown committed
686
  VOID(my_seek(file,(ulong) uint2korr(head+6),MY_SEEK_SET,MYF(0)));
687
  if (read_string(file,(uchar**) &disk_buff,key_info_length))
688
    goto err;                                   /* purecov: inspected */
unknown's avatar
unknown committed
689
  if (disk_buff[0] & 0x80)
unknown's avatar
unknown committed
690
  {
691 692
    share->keys=      keys=      (disk_buff[1] << 7) | (disk_buff[0] & 0x7f);
    share->key_parts= key_parts= uint2korr(disk_buff+2);
unknown's avatar
unknown committed
693 694 695
  }
  else
  {
696 697
    share->keys=      keys=      disk_buff[0];
    share->key_parts= key_parts= disk_buff[1];
unknown's avatar
unknown committed
698
  }
699 700
  share->keys_for_keyread.init(0);
  share->keys_in_use.init(keys);
unknown's avatar
unknown committed
701 702

  n_length=keys*sizeof(KEY)+key_parts*sizeof(KEY_PART_INFO);
unknown's avatar
unknown committed
703 704
  if (!(keyinfo = (KEY*) alloc_root(&share->mem_root,
				    n_length + uint2korr(disk_buff+4))))
705
    goto err;                                   /* purecov: inspected */
unknown's avatar
unknown committed
706
  bzero((char*) keyinfo,n_length);
unknown's avatar
unknown committed
707
  share->key_info= keyinfo;
unknown's avatar
unknown committed
708
  key_part= my_reinterpret_cast(KEY_PART_INFO*) (keyinfo+keys);
unknown's avatar
unknown committed
709 710
  strpos=disk_buff+6;

unknown's avatar
unknown committed
711
  if (!(rec_per_key= (ulong*) alloc_root(&share->mem_root,
unknown's avatar
unknown committed
712
					 sizeof(ulong*)*key_parts)))
713
    goto err;
unknown's avatar
unknown committed
714 715 716

  for (i=0 ; i < keys ; i++, keyinfo++)
  {
unknown's avatar
unknown committed
717
    keyinfo->table= 0;                           // Updated in open_frm
718
    if (new_frm_ver >= 3)
719 720 721 722 723
    {
      keyinfo->flags=	   (uint) uint2korr(strpos) ^ HA_NOSAME;
      keyinfo->key_length= (uint) uint2korr(strpos+2);
      keyinfo->key_parts=  (uint) strpos[4];
      keyinfo->algorithm=  (enum ha_key_alg) strpos[5];
724
      keyinfo->block_size= uint2korr(strpos+6);
725 726 727 728 729 730 731 732 733 734
      strpos+=8;
    }
    else
    {
      keyinfo->flags=	 ((uint) strpos[0]) ^ HA_NOSAME;
      keyinfo->key_length= (uint) uint2korr(strpos+1);
      keyinfo->key_parts=  (uint) strpos[3];
      keyinfo->algorithm= HA_KEY_ALG_UNDEF;
      strpos+=4;
    }
unknown's avatar
unknown committed
735

unknown's avatar
unknown committed
736 737 738 739 740 741 742 743 744
    keyinfo->key_part=	 key_part;
    keyinfo->rec_per_key= rec_per_key;
    for (j=keyinfo->key_parts ; j-- ; key_part++)
    {
      *rec_per_key++=0;
      key_part->fieldnr=	(uint16) (uint2korr(strpos) & FIELD_NR_MASK);
      key_part->offset= (uint) uint2korr(strpos+2)-1;
      key_part->key_type=	(uint) uint2korr(strpos+5);
      // key_part->field=	(Field*) 0;	// Will be fixed later
745
      if (new_frm_ver >= 1)
unknown's avatar
unknown committed
746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764
      {
	key_part->key_part_flag= *(strpos+4);
	key_part->length=	(uint) uint2korr(strpos+7);
	strpos+=9;
      }
      else
      {
	key_part->length=	*(strpos+4);
	key_part->key_part_flag=0;
	if (key_part->length > 128)
	{
	  key_part->length&=127;		/* purecov: inspected */
	  key_part->key_part_flag=HA_REVERSE_SORT; /* purecov: inspected */
	}
	strpos+=7;
      }
      key_part->store_length=key_part->length;
    }
  }
765 766
  keynames=(char*) key_part;
  strpos+= (strmov(keynames, (char *) strpos) - keynames)+1;
767

768
  share->reclength = uint2korr((head+16));
unknown's avatar
unknown committed
769
  if (*(head+26) == 1)
770
    share->system= 1;				/* one-record-database */
unknown's avatar
unknown committed
771 772 773
#ifdef HAVE_CRYPTED_FRM
  else if (*(head+26) == 2)
  {
unknown's avatar
unknown committed
774 775
    crypted= get_crypt_for_frm();
    share->crypted= 1;
unknown's avatar
unknown committed
776 777 778
  }
#endif

779 780 781 782
  record_offset= (ulong) (uint2korr(head+6)+
                          ((uint2korr(head+14) == 0xffff ?
                            uint4korr(head+47) : uint2korr(head+14))));
 
unknown's avatar
unknown committed
783
  if ((n_length= uint4korr(head+55)))
784 785
  {
    /* Read extra data segment */
786
    uchar *buff, *next_chunk, *buff_end;
787
    DBUG_PRINT("info", ("extra segment size is %u bytes", n_length));
788
    if (!(next_chunk= buff= (uchar*) my_malloc(n_length, MYF(MY_WME))))
789
      goto err;
790
    if (my_pread(file, buff, n_length, record_offset + share->reclength,
791 792 793 794 795
                 MYF(MY_NABP)))
    {
      my_free(buff, MYF(0));
      goto err;
    }
796
    share->connect_string.length= uint2korr(buff);
797 798 799 800
    if (!(share->connect_string.str= strmake_root(&share->mem_root,
                                                  (char*) next_chunk + 2,
                                                  share->connect_string.
                                                  length)))
801
    {
802 803
      my_free(buff, MYF(0));
      goto err;
804
    }
805
    next_chunk+= share->connect_string.length + 2;
806
    buff_end= buff + n_length;
807 808 809
    if (next_chunk + 2 < buff_end)
    {
      uint str_db_type_length= uint2korr(next_chunk);
810 811 812 813
      LEX_STRING name;
      name.str= (char*) next_chunk + 2;
      name.length= str_db_type_length;

unknown's avatar
unknown committed
814
      plugin_ref tmp_plugin= ha_resolve_by_name(thd, &name);
unknown's avatar
unknown committed
815
      if (tmp_plugin != NULL && !plugin_equals(tmp_plugin, share->db_plugin))
816
      {
unknown's avatar
unknown committed
817 818 819 820 821 822 823 824 825
        if (legacy_db_type > DB_TYPE_UNKNOWN &&
            legacy_db_type < DB_TYPE_FIRST_DYNAMIC &&
            legacy_db_type != ha_legacy_type(
                plugin_data(tmp_plugin, handlerton *)))
        {
          /* bad file, legacy_db_type did not match the name */
          my_free(buff, MYF(0));
          goto err;
        }
unknown's avatar
unknown committed
826 827 828 829 830 831 832
        /*
          tmp_plugin is locked with a local lock.
          we unlock the old value of share->db_plugin before
          replacing it with a globally locked version of tmp_plugin
        */
        plugin_unlock(NULL, share->db_plugin);
        share->db_plugin= my_plugin_lock(NULL, &tmp_plugin);
833 834
        DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",
                            str_db_type_length, next_chunk + 2,
unknown's avatar
unknown committed
835
                            ha_legacy_type(share->db_type())));
836
      }
837
#ifdef WITH_PARTITION_STORAGE_ENGINE
838 839
      else
      {
unknown's avatar
unknown committed
840 841
        LEX_STRING pname= { C_STRING_WITH_LEN( "partition" ) };
        if (str_db_type_length == pname.length &&
unknown's avatar
unknown committed
842
            !strncmp((char *) next_chunk + 2, pname.str, pname.length))
843
        {
unknown's avatar
unknown committed
844 845 846 847 848 849 850 851
          /*
            Use partition handler
            tmp_plugin is locked with a local lock.
            we unlock the old value of share->db_plugin before
            replacing it with a globally locked version of tmp_plugin
          */
          plugin_unlock(NULL, share->db_plugin);
          share->db_plugin= ha_lock_engine(NULL, partition_hton);
852 853
          DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",
                              str_db_type_length, next_chunk + 2,
unknown's avatar
unknown committed
854
                              ha_legacy_type(share->db_type())));
855 856 857
        }
      }
#endif
858 859
      next_chunk+= str_db_type_length + 2;
    }
unknown's avatar
unknown committed
860
    if (next_chunk + 5 < buff_end)
861
    {
862 863
      uint32 partition_info_len = uint4korr(next_chunk);
#ifdef WITH_PARTITION_STORAGE_ENGINE
864 865
      if ((share->partition_info_buffer_size=
             share->partition_info_len= partition_info_len))
866
      {
867
        if (!(share->partition_info= (char*)
868 869
              memdup_root(&share->mem_root, next_chunk + 4,
                          partition_info_len + 1)))
870 871 872 873
        {
          my_free(buff, MYF(0));
          goto err;
        }
874 875 876 877 878 879 880
      }
#else
      if (partition_info_len)
      {
        DBUG_PRINT("info", ("WITH_PARTITION_STORAGE_ENGINE is not defined"));
        my_free(buff, MYF(0));
        goto err;
881
      }
882
#endif
unknown's avatar
unknown committed
883
      next_chunk+= 5 + partition_info_len;
884
    }
885 886
#if MYSQL_VERSION_ID < 50200
    if (share->mysql_version >= 50106 && share->mysql_version <= 50109)
unknown's avatar
unknown committed
887 888
    {
      /*
889 890 891 892 893
         Partition state array was here in version 5.1.6 to 5.1.9, this code
         makes it possible to load a 5.1.6 table in later versions. Can most
         likely be removed at some point in time. Will only be used for
         upgrades within 5.1 series of versions. Upgrade to 5.2 can only be
         done from newer 5.1 versions.
unknown's avatar
unknown committed
894
      */
unknown's avatar
unknown committed
895
      next_chunk+= 4;
unknown's avatar
unknown committed
896
    }
897
    else if (share->mysql_version >= 50110)
unknown's avatar
unknown committed
898
#endif
899 900 901 902 903 904 905
    {
      /* New auto_partitioned indicator introduced in 5.1.11 */
#ifdef WITH_PARTITION_STORAGE_ENGINE
      share->auto_partitioned= *next_chunk;
#endif
      next_chunk++;
    }
unknown's avatar
unknown committed
906
    keyinfo= share->key_info;
907 908 909 910 911 912 913
    for (i= 0; i < keys; i++, keyinfo++)
    {
      if (keyinfo->flags & HA_USES_PARSER)
      {
        LEX_STRING parser_name;
        if (next_chunk >= buff_end)
        {
unknown's avatar
unknown committed
914 915
          DBUG_PRINT("error",
                     ("fulltext key uses parser that is not defined in .frm"));
916 917 918
          my_free(buff, MYF(0));
          goto err;
        }
919 920
        parser_name.str= (char*) next_chunk;
        parser_name.length= strlen((char*) next_chunk);
unknown's avatar
unknown committed
921 922
        keyinfo->parser= my_plugin_lock_by_name(NULL, &parser_name,
                                                MYSQL_FTPARSER_PLUGIN);
923 924 925
        if (! keyinfo->parser)
        {
          my_error(ER_PLUGIN_IS_NOT_LOADED, MYF(0), parser_name.str);
926
          my_free(buff, MYF(0));
927 928 929 930
          goto err;
        }
      }
    }
931 932
    my_free(buff, MYF(0));
  }
933
  share->key_block_size= uint2korr(head+62);
unknown's avatar
unknown committed
934 935

  error=4;
936
  extra_rec_buf_length= uint2korr(head+59);
unknown's avatar
unknown committed
937
  rec_buff_length= ALIGN_SIZE(share->reclength + 1 + extra_rec_buf_length);
938
  share->rec_buff_length= rec_buff_length;
939 940
  if (!(record= (uchar *) alloc_root(&share->mem_root,
                                     rec_buff_length)))
941
    goto err;                                   /* purecov: inspected */
942 943
  share->default_values= record;
  if (my_pread(file, record, (size_t) share->reclength,
944
               record_offset, MYF(MY_NABP)))
unknown's avatar
unknown committed
945
    goto err;                                   /* purecov: inspected */
unknown's avatar
unknown committed
946 947

  VOID(my_seek(file,pos,MY_SEEK_SET,MYF(0)));
948
  if (my_read(file, head,288,MYF(MY_NABP)))
949
    goto err;
950
#ifdef HAVE_CRYPTED_FRM
unknown's avatar
unknown committed
951 952 953 954
  if (crypted)
  {
    crypted->decode((char*) head+256,288-256);
    if (sint2korr(head+284) != 0)		// Should be 0
955
      goto err;                                 // Wrong password
unknown's avatar
unknown committed
956
  }
957
#endif
unknown's avatar
unknown committed
958

959 960 961 962 963 964 965 966
  share->fields= uint2korr(head+258);
  pos= uint2korr(head+260);			/* Length of all screens */
  n_length= uint2korr(head+268);
  interval_count= uint2korr(head+270);
  interval_parts= uint2korr(head+272);
  int_length= uint2korr(head+274);
  share->null_fields= uint2korr(head+282);
  com_length= uint2korr(head+284);
967
  share->comment.length=  (int) (head[46]);
968
  share->comment.str= strmake_root(&share->mem_root, (char*) head+47,
969
                                   share->comment.length);
unknown's avatar
unknown committed
970

971
  DBUG_PRINT("info",("i_count: %d  i_parts: %d  index: %d  n_length: %d  int_length: %d  com_length: %d", interval_count,interval_parts, share->keys,n_length,int_length, com_length));
unknown's avatar
unknown committed
972 973

  if (!(field_ptr = (Field **)
unknown's avatar
unknown committed
974
	alloc_root(&share->mem_root,
975
		   (uint) ((share->fields+1)*sizeof(Field*)+
unknown's avatar
unknown committed
976
			   interval_count*sizeof(TYPELIB)+
977
			   (share->fields+interval_parts+
978
			    keys+3)*sizeof(char *)+
979
			   (n_length+int_length+com_length)))))
980
    goto err;                                   /* purecov: inspected */
unknown's avatar
unknown committed
981

unknown's avatar
unknown committed
982
  share->field= field_ptr;
983
  read_length=(uint) (share->fields * field_pack_length +
unknown's avatar
unknown committed
984
		      pos+ (uint) (n_length+int_length+com_length));
985
  if (read_string(file,(uchar**) &disk_buff,read_length))
986
    goto err;                                   /* purecov: inspected */
987
#ifdef HAVE_CRYPTED_FRM
unknown's avatar
unknown committed
988 989 990 991 992 993
  if (crypted)
  {
    crypted->decode((char*) disk_buff,read_length);
    delete crypted;
    crypted=0;
  }
994
#endif
unknown's avatar
unknown committed
995 996
  strpos= disk_buff+pos;

997
  share->intervals= (TYPELIB*) (field_ptr+share->fields+1);
unknown's avatar
unknown committed
998 999
  interval_array= (const char **) (share->intervals+interval_count);
  names= (char*) (interval_array+share->fields+interval_parts+keys+3);
unknown's avatar
unknown committed
1000
  if (!interval_count)
1001 1002
    share->intervals= 0;			// For better debugging
  memcpy((char*) names, strpos+(share->fields*field_pack_length),
unknown's avatar
unknown committed
1003
	 (uint) (n_length+int_length));
1004
  comment_pos= names+(n_length+int_length);
unknown's avatar
unknown committed
1005
  memcpy(comment_pos, disk_buff+read_length-com_length, com_length);
unknown's avatar
unknown committed
1006

unknown's avatar
unknown committed
1007
  fix_type_pointers(&interval_array, &share->fieldnames, 1, &names);
1008 1009
  if (share->fieldnames.count != share->fields)
    goto err;
unknown's avatar
unknown committed
1010
  fix_type_pointers(&interval_array, share->intervals, interval_count,
unknown's avatar
unknown committed
1011
		    &names);
1012 1013 1014 1015

  {
    /* Set ENUM and SET lengths */
    TYPELIB *interval;
1016 1017
    for (interval= share->intervals;
         interval < share->intervals + interval_count;
1018 1019 1020
         interval++)
    {
      uint count= (uint) (interval->count + 1) * sizeof(uint);
unknown's avatar
unknown committed
1021
      if (!(interval->type_lengths= (uint *) alloc_root(&share->mem_root,
1022
                                                        count)))
1023
        goto err;
1024
      for (count= 0; count < interval->count; count++)
1025 1026 1027 1028
      {
        char *val= (char*) interval->type_names[count];
        interval->type_lengths[count]= strlen(val);
      }
1029 1030 1031 1032
      interval->type_lengths[count]= 0;
    }
  }

unknown's avatar
unknown committed
1033
  if (keynames)
unknown's avatar
unknown committed
1034
    fix_type_pointers(&interval_array, &share->keynames, 1, &keynames);
unknown's avatar
unknown committed
1035

unknown's avatar
unknown committed
1036 1037
 /* Allocate handler */
  if (!(handler_file= get_new_handler(share, thd->mem_root,
unknown's avatar
unknown committed
1038
                                      share->db_type())))
1039 1040
    goto err;

1041
  record= share->default_values-1;              /* Fieldstart = 1 */
unknown's avatar
unknown committed
1042
  if (share->null_field_first)
unknown's avatar
unknown committed
1043
  {
unknown's avatar
unknown committed
1044
    null_flags= null_pos= (uchar*) record+1;
unknown's avatar
unknown committed
1045
    null_bit_pos= (db_create_options & HA_OPTION_PACK_RECORD) ? 0 : 1;
1046 1047 1048 1049 1050
    /*
      null_bytes below is only correct under the condition that
      there are no bit fields.  Correct values is set below after the
      table struct is initialized
    */
1051
    share->null_bytes= (share->null_fields + null_bit_pos + 7) / 8;
unknown's avatar
unknown committed
1052
  }
unknown's avatar
unknown committed
1053
#ifndef WE_WANT_TO_SUPPORT_VERY_OLD_FRM_FILES
unknown's avatar
unknown committed
1054 1055
  else
  {
1056
    share->null_bytes= (share->null_fields+7)/8;
unknown's avatar
unknown committed
1057 1058
    null_flags= null_pos= (uchar*) (record + 1 +share->reclength -
                                    share->null_bytes);
unknown's avatar
unknown committed
1059
    null_bit_pos= 0;
unknown's avatar
unknown committed
1060
  }
unknown's avatar
unknown committed
1061
#endif
unknown's avatar
unknown committed
1062

1063
  use_hash= share->fields >= MAX_FIELDS_BEFORE_HASH;
unknown's avatar
unknown committed
1064
  if (use_hash)
1065
    use_hash= !hash_init(&share->name_hash,
unknown's avatar
unknown committed
1066
			 system_charset_info,
1067
			 share->fields,0,0,
unknown's avatar
unknown committed
1068
			 (hash_get_key) get_field_name,0,0);
unknown's avatar
unknown committed
1069

1070
  for (i=0 ; i < share->fields; i++, strpos+=field_pack_length, field_ptr++)
unknown's avatar
unknown committed
1071
  {
1072
    uint pack_flag, interval_nr, unireg_type, recpos, field_length;
1073
    enum_field_types field_type;
1074
    CHARSET_INFO *charset=NULL;
unknown's avatar
unknown committed
1075
    Field::geometry_type geom_type= Field::GEOM_GEOMETRY;
1076
    LEX_STRING comment;
unknown's avatar
unknown committed
1077

1078
    if (new_frm_ver >= 3)
1079 1080
    {
      /* new frm file in 4.1 */
1081 1082 1083 1084 1085 1086 1087
      field_length= uint2korr(strpos+3);
      recpos=	    uint3korr(strpos+5);
      pack_flag=    uint2korr(strpos+8);
      unireg_type=  (uint) strpos[10];
      interval_nr=  (uint) strpos[12];
      uint comment_length=uint2korr(strpos+15);
      field_type=(enum_field_types) (uint) strpos[13];
unknown's avatar
unknown committed
1088

1089
      /* charset and geometry_type share the same byte in frm */
1090
      if (field_type == MYSQL_TYPE_GEOMETRY)
unknown's avatar
unknown committed
1091
      {
unknown's avatar
unknown committed
1092
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
1093 1094
	geom_type= (Field::geometry_type) strpos[14];
	charset= &my_charset_bin;
unknown's avatar
unknown committed
1095 1096
#else
	error= 4;  // unsupported field type
1097
	goto err;
unknown's avatar
unknown committed
1098
#endif
unknown's avatar
unknown committed
1099 1100 1101
      }
      else
      {
1102 1103 1104 1105 1106 1107
        if (!strpos[14])
          charset= &my_charset_bin;
        else if (!(charset=get_charset((uint) strpos[14], MYF(0))))
        {
          error= 5; // Unknown or unavailable charset
          errarg= (int) strpos[14];
1108
          goto err;
1109
        }
unknown's avatar
unknown committed
1110
      }
1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124
      if (!comment_length)
      {
	comment.str= (char*) "";
	comment.length=0;
      }
      else
      {
	comment.str=    (char*) comment_pos;
	comment.length= comment_length;
	comment_pos+=   comment_length;
      }
    }
    else
    {
1125 1126 1127
      field_length= (uint) strpos[3];
      recpos=	    uint2korr(strpos+4),
      pack_flag=    uint2korr(strpos+6);
unknown's avatar
unknown committed
1128
      pack_flag&=   ~FIELDFLAG_NO_DEFAULT;     // Safety for old files
1129 1130 1131
      unireg_type=  (uint) strpos[8];
      interval_nr=  (uint) strpos[10];

1132 1133
      /* old frm file */
      field_type= (enum_field_types) f_packtype(pack_flag);
unknown's avatar
unknown committed
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
      if (f_is_binary(pack_flag))
      {
        /*
          Try to choose the best 4.1 type:
          - for 4.0 "CHAR(N) BINARY" or "VARCHAR(N) BINARY" 
            try to find a binary collation for character set.
          - for other types (e.g. BLOB) just use my_charset_bin. 
        */
        if (!f_is_blob(pack_flag))
        {
          // 3.23 or 4.0 string
1145
          if (!(charset= get_charset_by_csname(share->table_charset->csname,
unknown's avatar
unknown committed
1146 1147 1148 1149 1150 1151 1152
                                               MY_CS_BINSORT, MYF(0))))
            charset= &my_charset_bin;
        }
        else
          charset= &my_charset_bin;
      }
      else
1153
        charset= share->table_charset;
1154 1155
      bzero((char*) &comment, sizeof(comment));
    }
1156 1157 1158 1159

    if (interval_nr && charset->mbminlen > 1)
    {
      /* Unescape UCS2 intervals from HEX notation */
1160
      TYPELIB *interval= share->intervals + interval_nr - 1;
1161
      unhex_type2(interval);
1162 1163
    }
    
1164
#ifndef TO_BE_DELETED_ON_PRODUCTION
1165
    if (field_type == MYSQL_TYPE_NEWDECIMAL && !share->mysql_version)
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
    {
      /*
        Fix pack length of old decimal values from 5.0.3 -> 5.0.4
        The difference is that in the old version we stored precision
        in the .frm table while we now store the display_length
      */
      uint decimals= f_decimals(pack_flag);
      field_length= my_decimal_precision_to_length(field_length,
                                                   decimals,
                                                   f_is_dec(pack_flag) == 0);
unknown's avatar
unknown committed
1176 1177 1178 1179
      sql_print_error("Found incompatible DECIMAL field '%s' in %s; "
                      "Please do \"ALTER TABLE '%s' FORCE\" to fix it!",
                      share->fieldnames.type_names[i], share->table_name.str,
                      share->table_name.str);
1180 1181
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                          ER_CRASHED_ON_USAGE,
unknown's avatar
unknown committed
1182 1183 1184 1185 1186
                          "Found incompatible DECIMAL field '%s' in %s; "
                          "Please do \"ALTER TABLE '%s' FORCE\" to fix it!",
                          share->fieldnames.type_names[i],
                          share->table_name.str,
                          share->table_name.str);
1187 1188 1189 1190
      share->crashed= 1;                        // Marker for CHECK TABLE
    }
#endif

unknown's avatar
unknown committed
1191 1192
    *field_ptr= reg_field=
      make_field(share, record+recpos,
1193
		 (uint32) field_length,
unknown's avatar
unknown committed
1194
		 null_pos, null_bit_pos,
unknown's avatar
unknown committed
1195
		 pack_flag,
1196
		 field_type,
1197
		 charset,
unknown's avatar
unknown committed
1198
		 geom_type,
1199
		 (Field::utype) MTYP_TYPENR(unireg_type),
unknown's avatar
unknown committed
1200
		 (interval_nr ?
1201
		  share->intervals+interval_nr-1 :
unknown's avatar
unknown committed
1202
		  (TYPELIB*) 0),
unknown's avatar
unknown committed
1203
		 share->fieldnames.type_names[i]);
unknown's avatar
unknown committed
1204
    if (!reg_field)				// Not supported field type
1205 1206
    {
      error= 4;
1207
      goto err;			/* purecov: inspected */
1208
    }
1209

1210
    reg_field->field_index= i;
1211
    reg_field->comment=comment;
1212
    if (field_type == MYSQL_TYPE_BIT && !f_bit_as_char(pack_flag))
unknown's avatar
unknown committed
1213
    {
unknown's avatar
unknown committed
1214
      if ((null_bit_pos+= field_length & 7) > 7)
unknown's avatar
unknown committed
1215
      {
unknown's avatar
unknown committed
1216 1217
        null_pos++;
        null_bit_pos-= 8;
unknown's avatar
unknown committed
1218 1219
      }
    }
unknown's avatar
unknown committed
1220 1221 1222 1223 1224
    if (!(reg_field->flags & NOT_NULL_FLAG))
    {
      if (!(null_bit_pos= (null_bit_pos + 1) & 7))
        null_pos++;
    }
unknown's avatar
unknown committed
1225 1226
    if (f_no_default(pack_flag))
      reg_field->flags|= NO_DEFAULT_VALUE_FLAG;
unknown's avatar
unknown committed
1227

unknown's avatar
unknown committed
1228
    if (reg_field->unireg_check == Field::NEXT_NUMBER)
unknown's avatar
unknown committed
1229 1230
      share->found_next_number_field= field_ptr;
    if (share->timestamp_field == reg_field)
1231
      share->timestamp_field_offset= i;
unknown's avatar
unknown committed
1232

unknown's avatar
unknown committed
1233
    if (use_hash)
unknown's avatar
unknown committed
1234
      (void) my_hash_insert(&share->name_hash,
1235
                            (uchar*) field_ptr); // never fail
unknown's avatar
unknown committed
1236 1237 1238 1239 1240 1241
  }
  *field_ptr=0;					// End marker

  /* Fix key->name and key_part->field */
  if (key_parts)
  {
1242
    uint primary_key=(uint) (find_type((char*) primary_key_name,
1243
				       &share->keynames, 3) - 1);
1244
    longlong ha_option= handler_file->ha_table_flags();
unknown's avatar
unknown committed
1245 1246
    keyinfo= share->key_info;
    key_part= keyinfo->key_part;
unknown's avatar
unknown committed
1247

1248
    for (uint key=0 ; key < share->keys ; key++,keyinfo++)
unknown's avatar
unknown committed
1249
    {
unknown's avatar
unknown committed
1250
      uint usable_parts= 0;
1251
      keyinfo->name=(char*) share->keynames.type_names[key];
1252
      /* Fix fulltext keys for old .frm files */
unknown's avatar
unknown committed
1253 1254
      if (share->key_info[key].flags & HA_FULLTEXT)
	share->key_info[key].algorithm= HA_KEY_ALG_FULLTEXT;
1255

unknown's avatar
unknown committed
1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276
      if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
      {
	/*
	  If the UNIQUE key doesn't have NULL columns and is not a part key
	  declare this as a primary key.
	*/
	primary_key=key;
	for (i=0 ; i < keyinfo->key_parts ;i++)
	{
	  uint fieldnr= key_part[i].fieldnr;
	  if (!fieldnr ||
	      share->field[fieldnr-1]->null_ptr ||
	      share->field[fieldnr-1]->key_length() !=
	      key_part[i].length)
	  {
	    primary_key=MAX_KEY;		// Can't be used
	    break;
	  }
	}
      }

unknown's avatar
unknown committed
1277 1278
      for (i=0 ; i < keyinfo->key_parts ; key_part++,i++)
      {
unknown's avatar
unknown committed
1279
        Field *field;
unknown's avatar
unknown committed
1280
	if (new_field_pack_flag <= 1)
unknown's avatar
unknown committed
1281
	  key_part->fieldnr= (uint16) find_field(share->field,
1282
                                                 share->default_values,
unknown's avatar
unknown committed
1283 1284 1285 1286 1287 1288 1289 1290
                                                 (uint) key_part->offset,
                                                 (uint) key_part->length);
	if (!key_part->fieldnr)
        {
          error= 4;                             // Wrong file
          goto err;
        }
        field= key_part->field= share->field[key_part->fieldnr-1];
unknown's avatar
unknown committed
1291
        key_part->type= field->key_type();
unknown's avatar
unknown committed
1292 1293
        if (field->null_ptr)
        {
1294
          key_part->null_offset=(uint) ((uchar*) field->null_ptr -
unknown's avatar
unknown committed
1295 1296 1297 1298 1299 1300 1301
                                        share->default_values);
          key_part->null_bit= field->null_bit;
          key_part->store_length+=HA_KEY_NULL_LENGTH;
          keyinfo->flags|=HA_NULL_PART_KEY;
          keyinfo->extra_length+= HA_KEY_NULL_LENGTH;
          keyinfo->key_length+= HA_KEY_NULL_LENGTH;
        }
1302
        if (field->type() == MYSQL_TYPE_BLOB ||
unknown's avatar
unknown committed
1303 1304
            field->real_type() == MYSQL_TYPE_VARCHAR)
        {
1305
          if (field->type() == MYSQL_TYPE_BLOB)
unknown's avatar
unknown committed
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334
            key_part->key_part_flag|= HA_BLOB_PART;
          else
            key_part->key_part_flag|= HA_VAR_LENGTH_PART;
          keyinfo->extra_length+=HA_KEY_BLOB_LENGTH;
          key_part->store_length+=HA_KEY_BLOB_LENGTH;
          keyinfo->key_length+= HA_KEY_BLOB_LENGTH;
          /*
            Mark that there may be many matching values for one key
            combination ('a', 'a ', 'a  '...)
          */
          if (!(field->flags & BINARY_FLAG))
            keyinfo->flags|= HA_END_SPACE_KEY;
        }
        if (field->type() == MYSQL_TYPE_BIT)
          key_part->key_part_flag|= HA_BIT_PART;

        if (i == 0 && key != primary_key)
          field->flags |= (((keyinfo->flags & HA_NOSAME) &&
                           (keyinfo->key_parts == 1)) ?
                           UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
        if (i == 0)
          field->key_start.set_bit(key);
        if (field->key_length() == key_part->length &&
            !(field->flags & BLOB_FLAG))
        {
          if (handler_file->index_flags(key, i, 0) & HA_KEYREAD_ONLY)
          {
            share->keys_for_keyread.set_bit(key);
            field->part_of_key.set_bit(key);
1335
            field->part_of_key_not_clustered.set_bit(key);
unknown's avatar
unknown committed
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
          }
          if (handler_file->index_flags(key, i, 1) & HA_READ_ORDER)
            field->part_of_sortkey.set_bit(key);
        }
        if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&
            usable_parts == i)
          usable_parts++;			// For FILESORT
        field->flags|= PART_KEY_FLAG;
        if (key == primary_key)
        {
          field->flags|= PRI_KEY_FLAG;
          /*
            If this field is part of the primary key and all keys contains
            the primary key, then we can use any key to find this column
          */
          if (ha_option & HA_PRIMARY_KEY_IN_READ_INDEX)
1352
          {
unknown's avatar
unknown committed
1353
            field->part_of_key= share->keys_in_use;
unknown's avatar
unknown committed
1354
            if (ha_legacy_type(share->db_type()) == DB_TYPE_INNODB &&
1355 1356 1357
                field->part_of_sortkey.is_set(key))
              field->part_of_sortkey= share->keys_in_use;
          }
unknown's avatar
unknown committed
1358 1359 1360
        }
        if (field->key_length() != key_part->length)
        {
1361
#ifndef TO_BE_DELETED_ON_PRODUCTION
1362
          if (field->type() == MYSQL_TYPE_NEWDECIMAL)
unknown's avatar
unknown committed
1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388
          {
            /*
              Fix a fatal error in decimal key handling that causes crashes
              on Innodb. We fix it by reducing the key length so that
              InnoDB never gets a too big key when searching.
              This allows the end user to do an ALTER TABLE to fix the
              error.
            */
            keyinfo->key_length-= (key_part->length - field->key_length());
            key_part->store_length-= (uint16)(key_part->length -
                                              field->key_length());
            key_part->length= (uint16)field->key_length();
            sql_print_error("Found wrong key definition in %s; "
                            "Please do \"ALTER TABLE '%s' FORCE \" to fix it!",
                            share->table_name.str,
                            share->table_name.str);
            push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                                ER_CRASHED_ON_USAGE,
                                "Found wrong key definition in %s; "
                                "Please do \"ALTER TABLE '%s' FORCE\" to fix "
                                "it!",
                                share->table_name.str,
                                share->table_name.str);
            share->crashed= 1;                // Marker for CHECK TABLE
            goto to_be_deleted;
          }
1389
#endif
unknown's avatar
unknown committed
1390 1391
          key_part->key_part_flag|= HA_PART_KEY_SEG;
        }
1392 1393 1394

	to_be_deleted:

unknown's avatar
unknown committed
1395 1396 1397 1398 1399 1400
        /*
          If the field can be NULL, don't optimize away the test
          key_part_column = expression from the WHERE clause
          as we need to test for NULL = NULL.
        */
        if (field->real_maybe_null())
1401
          key_part->key_part_flag|= HA_NULL_PART;
unknown's avatar
unknown committed
1402
      }
unknown's avatar
unknown committed
1403
      keyinfo->usable_key_parts= usable_parts; // Filesort
1404

1405
      set_if_bigger(share->max_key_length,keyinfo->key_length+
1406
                    keyinfo->key_parts);
1407
      share->total_key_length+= keyinfo->key_length;
1408 1409 1410 1411 1412 1413
      /*
        MERGE tables do not have unique indexes. But every key could be
        an unique index on the underlying MyISAM table. (Bug #10400)
      */
      if ((keyinfo->flags & HA_NOSAME) ||
          (ha_option & HA_ANY_INDEX_MAY_BE_UNIQUE))
unknown's avatar
unknown committed
1414
        set_if_bigger(share->max_unique_length,keyinfo->key_length);
unknown's avatar
unknown committed
1415
    }
1416
    if (primary_key < MAX_KEY &&
1417
	(share->keys_in_use.is_set(primary_key)))
unknown's avatar
unknown committed
1418
    {
1419
      share->primary_key= primary_key;
1420 1421 1422 1423
      /*
	If we are using an integer as the primary key then allow the user to
	refer to it as '_rowid'
      */
unknown's avatar
unknown committed
1424
      if (share->key_info[primary_key].key_parts == 1)
unknown's avatar
unknown committed
1425
      {
unknown's avatar
unknown committed
1426
	Field *field= share->key_info[primary_key].key_part[0].field;
unknown's avatar
unknown committed
1427
	if (field && field->result_type() == INT_RESULT)
unknown's avatar
unknown committed
1428 1429 1430 1431 1432
        {
          /* note that fieldnr here (and rowid_field_offset) starts from 1 */
	  share->rowid_field_offset= (share->key_info[primary_key].key_part[0].
                                      fieldnr);
        }
unknown's avatar
unknown committed
1433 1434 1435
      }
    }
    else
1436
      share->primary_key = MAX_KEY; // we do not have a primary key
unknown's avatar
unknown committed
1437
  }
1438
  else
1439
    share->primary_key= MAX_KEY;
1440
  x_free((uchar*) disk_buff);
1441
  disk_buff=0;
unknown's avatar
unknown committed
1442
  if (new_field_pack_flag <= 1)
1443 1444 1445
  {
    /* Old file format with default as not null */
    uint null_length= (share->null_fields+7)/8;
unknown's avatar
unknown committed
1446
    bfill(share->default_values + (null_flags - (uchar*) record),
1447
          null_length, 255);
unknown's avatar
unknown committed
1448 1449
  }

unknown's avatar
unknown committed
1450
  if (share->found_next_number_field)
unknown's avatar
unknown committed
1451
  {
unknown's avatar
unknown committed
1452
    reg_field= *share->found_next_number_field;
1453
    if ((int) (share->next_number_index= (uint)
1454 1455
	       find_ref_key(share->key_info, share->keys,
                            share->default_values, reg_field,
1456 1457
			    &share->next_number_key_offset,
                            &share->next_number_keypart)) < 0)
unknown's avatar
unknown committed
1458
    {
1459
      /* Wrong field definition */
1460 1461
      error= 4;
      goto err;
unknown's avatar
unknown committed
1462 1463
    }
    else
unknown's avatar
unknown committed
1464
      reg_field->flags |= AUTO_INCREMENT_FLAG;
unknown's avatar
unknown committed
1465 1466
  }

1467
  if (share->blob_fields)
unknown's avatar
unknown committed
1468 1469
  {
    Field **ptr;
1470
    uint k, *save;
unknown's avatar
unknown committed
1471

1472 1473
    /* Store offsets to blob fields to find them fast */
    if (!(share->blob_field= save=
unknown's avatar
unknown committed
1474
	  (uint*) alloc_root(&share->mem_root,
1475
                             (uint) (share->blob_fields* sizeof(uint)))))
1476
      goto err;
unknown's avatar
unknown committed
1477
    for (k=0, ptr= share->field ; *ptr ; ptr++, k++)
unknown's avatar
unknown committed
1478 1479
    {
      if ((*ptr)->flags & BLOB_FLAG)
1480
	(*save++)= k;
unknown's avatar
unknown committed
1481 1482 1483
    }
  }

1484 1485 1486 1487
  /*
    the correct null_bytes can now be set, since bitfields have been taken
    into account
  */
unknown's avatar
unknown committed
1488
  share->null_bytes= (null_pos - (uchar*) null_flags +
1489
                      (null_bit_pos + 7) / 8);
unknown's avatar
unknown committed
1490
  share->last_null_bit_pos= null_bit_pos;
unknown's avatar
unknown committed
1491

unknown's avatar
unknown committed
1492
  share->db_low_byte_first= handler_file->low_byte_first();
1493 1494 1495
  share->column_bitmap_size= bitmap_buffer_size(share->fields);

  if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
unknown's avatar
unknown committed
1496
                                             share->column_bitmap_size)))
1497 1498 1499 1500
    goto err;
  bitmap_init(&share->all_set, bitmaps, share->fields, FALSE);
  bitmap_set_all(&share->all_set);

unknown's avatar
unknown committed
1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
  delete handler_file;
#ifndef DBUG_OFF
  if (use_hash)
    (void) hash_check(&share->name_hash);
#endif
  DBUG_RETURN (0);

 err:
  share->error= error;
  share->open_errno= my_errno;
  share->errarg= errarg;
1512
  x_free((uchar*) disk_buff);
unknown's avatar
unknown committed
1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548
  delete crypted;
  delete handler_file;
  hash_free(&share->name_hash);

  open_table_error(share, error, share->open_errno, errarg);
  DBUG_RETURN(error);
} /* open_binary_frm */


/*
  Open a table based on a TABLE_SHARE

  SYNOPSIS
    open_table_from_share()
    thd			Thread handler
    share		Table definition
    alias       	Alias for table
    db_stat		open flags (for example HA_OPEN_KEYFILE|
    			HA_OPEN_RNDFILE..) can be 0 (example in
                        ha_example_table)
    prgflag   		READ_ALL etc..
    ha_open_flags	HA_OPEN_ABORT_IF_LOCKED etc..
    outparam       	result table

  RETURN VALUES
   0	ok
   1	Error (see open_table_error)
   2    Error (see open_table_error)
   3    Wrong data in .frm file
   4    Error (see open_table_error)
   5    Error (see open_table_error: charset unavailable)
   7    Table definition has changed in engine
*/

int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
                          uint db_stat, uint prgflag, uint ha_open_flags,
unknown's avatar
unknown committed
1549
                          TABLE *outparam, bool is_create_table)
unknown's avatar
unknown committed
1550 1551
{
  int error;
1552
  uint records, i, bitmap_size;
unknown's avatar
unknown committed
1553
  bool error_reported= FALSE;
1554
  uchar *record, *bitmaps;
unknown's avatar
unknown committed
1555 1556 1557
  Field **field_ptr;
  DBUG_ENTER("open_table_from_share");
  DBUG_PRINT("enter",("name: '%s.%s'  form: 0x%lx", share->db.str,
unknown's avatar
unknown committed
1558
                      share->table_name.str, (long) outparam));
unknown's avatar
unknown committed
1559 1560 1561 1562 1563 1564

  error= 1;
  bzero((char*) outparam, sizeof(*outparam));
  outparam->in_use= thd;
  outparam->s= share;
  outparam->db_stat= db_stat;
1565
  outparam->write_row_record= NULL;
unknown's avatar
unknown committed
1566 1567 1568 1569 1570 1571

  init_sql_alloc(&outparam->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);

  if (!(outparam->alias= my_strdup(alias, MYF(MY_WME))))
    goto err;
  outparam->quick_keys.init();
1572
  outparam->covering_keys.init();
unknown's avatar
unknown committed
1573 1574 1575 1576
  outparam->keys_in_use_for_query.init();

  /* Allocate handler */
  if (!(outparam->file= get_new_handler(share, &outparam->mem_root,
unknown's avatar
unknown committed
1577
                                        share->db_type())))
unknown's avatar
unknown committed
1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588
    goto err;

  error= 4;
  outparam->reginfo.lock_type= TL_UNLOCK;
  outparam->current_lock= F_UNLCK;
  records=0;
  if ((db_stat & HA_OPEN_KEYFILE) || (prgflag & DELAYED_OPEN))
    records=1;
  if (prgflag & (READ_ALL+EXTRA_RECORD))
    records++;

1589
  if (!(record= (uchar*) alloc_root(&outparam->mem_root,
unknown's avatar
unknown committed
1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
                                   share->rec_buff_length * records)))
    goto err;                                   /* purecov: inspected */

  if (records == 0)
  {
    /* We are probably in hard repair, and the buffers should not be used */
    outparam->record[0]= outparam->record[1]= share->default_values;
  }
  else
  {
    outparam->record[0]= record;
    if (records > 1)
      outparam->record[1]= record+ share->rec_buff_length;
    else
      outparam->record[1]= outparam->record[0];   // Safety
  }

#ifdef HAVE_purify
  /*
    We need this because when we read var-length rows, we are not updating
    bytes after end of varchar
  */
  if (records > 1)
  {
    memcpy(outparam->record[0], share->default_values, share->rec_buff_length);
1615
    memcpy(outparam->record[1], share->default_values, share->null_bytes);
unknown's avatar
unknown committed
1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
    if (records > 2)
      memcpy(outparam->record[1], share->default_values,
             share->rec_buff_length);
  }
#endif

  if (!(field_ptr = (Field **) alloc_root(&outparam->mem_root,
                                          (uint) ((share->fields+1)*
                                                  sizeof(Field*)))))
    goto err;                                   /* purecov: inspected */

  outparam->field= field_ptr;

1629
  record= (uchar*) outparam->record[0]-1;	/* Fieldstart = 1 */
unknown's avatar
unknown committed
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
  if (share->null_field_first)
    outparam->null_flags= (uchar*) record+1;
  else
    outparam->null_flags= (uchar*) (record+ 1+ share->reclength -
                                    share->null_bytes);

  /* Setup copy of fields from share, but use the right alias and record */
  for (i=0 ; i < share->fields; i++, field_ptr++)
  {
    if (!((*field_ptr)= share->field[i]->clone(&outparam->mem_root, outparam)))
      goto err;
  }
  (*field_ptr)= 0;                              // End marker

  if (share->found_next_number_field)
    outparam->found_next_number_field=
      outparam->field[(uint) (share->found_next_number_field - share->field)];
  if (share->timestamp_field)
    outparam->timestamp_field= (Field_timestamp*) outparam->field[share->timestamp_field_offset];


  /* Fix key->name and key_part->field */
  if (share->key_parts)
  {
    KEY	*key_info, *key_info_end;
    KEY_PART_INFO *key_part;
    uint n_length;
    n_length= share->keys*sizeof(KEY) + share->key_parts*sizeof(KEY_PART_INFO);
    if (!(key_info= (KEY*) alloc_root(&outparam->mem_root, n_length)))
      goto err;
    outparam->key_info= key_info;
    key_part= (my_reinterpret_cast(KEY_PART_INFO*) (key_info+share->keys));
    
    memcpy(key_info, share->key_info, sizeof(*key_info)*share->keys);
    memcpy(key_part, share->key_info[0].key_part, (sizeof(*key_part) *
                                                   share->key_parts));

    for (key_info_end= key_info + share->keys ;
         key_info < key_info_end ;
         key_info++)
    {
      KEY_PART_INFO *key_part_end;

      key_info->table= outparam;
      key_info->key_part= key_part;

      for (key_part_end= key_part+ key_info->key_parts ;
           key_part < key_part_end ;
           key_part++)
      {
        Field *field= key_part->field= outparam->field[key_part->fieldnr-1];

        if (field->key_length() != key_part->length &&
            !(field->flags & BLOB_FLAG))
        {
          /*
            We are using only a prefix of the column as a key:
            Create a new field for the key part that matches the index
          */
          field= key_part->field=field->new_field(&outparam->mem_root,
unknown's avatar
unknown committed
1690
                                                  outparam, 0);
unknown's avatar
unknown committed
1691 1692 1693 1694 1695 1696 1697 1698 1699
          field->field_length= key_part->length;
        }
      }
    }
  }

#ifdef WITH_PARTITION_STORAGE_ENGINE
  if (share->partition_info_len)
  {
1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
  /*
    In this execution we must avoid calling thd->change_item_tree since
    we might release memory before statement is completed. We do this
    by changing to a new statement arena. As part of this arena we also
    set the memory root to be the memory root of the table since we
    call the parser and fix_fields which both can allocate memory for
    item objects. We keep the arena to ensure that we can release the
    free_list when closing the table object.
    SEE Bug #21658
  */

    Query_arena *backup_stmt_arena_ptr= thd->stmt_arena;
    Query_arena backup_arena;
    Query_arena part_func_arena(&outparam->mem_root, Query_arena::INITIALIZED);
    thd->set_n_backup_active_arena(&part_func_arena, &backup_arena);
    thd->stmt_arena= &part_func_arena;
1716
    bool tmp;
1717
    bool work_part_info_used;
1718

1719 1720
    tmp= mysql_unpack_partition(thd, share->partition_info,
                                share->partition_info_len,
1721
                                share->part_state,
1722 1723
                                share->part_state_len,
                                outparam, is_create_table,
1724 1725
                                share->default_part_db_type,
                                &work_part_info_used);
1726
    outparam->part_info->is_auto_partitioned= share->auto_partitioned;
1727
    DBUG_PRINT("info", ("autopartitioned: %u", share->auto_partitioned));
1728 1729 1730 1731
    /* we should perform the fix_partition_func in either local or
       caller's arena depending on work_part_info_used value
    */
    if (!tmp && !work_part_info_used)
1732
      tmp= fix_partition_func(thd, outparam, is_create_table);
1733 1734
    thd->stmt_arena= backup_stmt_arena_ptr;
    thd->restore_active_arena(&part_func_arena, &backup_arena);
1735
    if (!tmp)
1736 1737 1738
    {
      if (work_part_info_used)
        tmp= fix_partition_func(thd, outparam, is_create_table);
1739
      outparam->part_info->item_free_list= part_func_arena.free_list;
1740
    }
1741
    if (tmp)
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751
    {
      if (is_create_table)
      {
        /*
          During CREATE/ALTER TABLE it is ok to receive errors here.
          It is not ok if it happens during the opening of an frm
          file as part of a normal query.
        */
        error_reported= TRUE;
      }
unknown's avatar
unknown committed
1752
      goto err;
1753
    }
unknown's avatar
unknown committed
1754 1755 1756
  }
#endif

1757 1758 1759
  /* Allocate bitmaps */

  bitmap_size= share->column_bitmap_size;
1760
  if (!(bitmaps= (uchar*) alloc_root(&outparam->mem_root, bitmap_size*3)))
1761 1762 1763 1764 1765 1766 1767 1768 1769
    goto err;
  bitmap_init(&outparam->def_read_set,
              (my_bitmap_map*) bitmaps, share->fields, FALSE);
  bitmap_init(&outparam->def_write_set,
              (my_bitmap_map*) (bitmaps+bitmap_size), share->fields, FALSE);
  bitmap_init(&outparam->tmp_set,
              (my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields, FALSE);
  outparam->default_column_bitmaps();

1770
  /* The table struct is now initialized;  Open the table */
unknown's avatar
unknown committed
1771
  error= 2;
1772 1773
  if (db_stat)
  {
1774 1775
    int ha_err;
    if ((ha_err= (outparam->file->
unknown's avatar
unknown committed
1776
                  ha_open(outparam, share->normalized_path.str,
1777 1778 1779 1780 1781 1782 1783 1784
                          (db_stat & HA_READ_ONLY ? O_RDONLY : O_RDWR),
                          (db_stat & HA_OPEN_TEMPORARY ? HA_OPEN_TMP_TABLE :
                           ((db_stat & HA_WAIT_IF_LOCKED) ||
                            (specialflag & SPECIAL_WAIT_IF_LOCKED)) ?
                           HA_OPEN_WAIT_IF_LOCKED :
                           (db_stat & (HA_ABORT_IF_LOCKED | HA_GET_INFO)) ?
                          HA_OPEN_ABORT_IF_LOCKED :
                           HA_OPEN_IGNORE_IF_LOCKED) | ha_open_flags))))
1785 1786
    {
      /* Set a flag if the table is crashed and it can be auto. repaired */
1787
      share->crashed= ((ha_err == HA_ERR_CRASHED_ON_USAGE) &&
1788 1789
                       outparam->file->auto_repair() &&
                       !(ha_open_flags & HA_OPEN_FOR_REPAIR));
1790

1791
      switch (ha_err)
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
        case HA_ERR_NO_SUCH_TABLE:
	  /*
            The table did not exists in storage engine, use same error message
            as if the .frm file didn't exist
          */
	  error= 1;
	  my_errno= ENOENT;
          break;
        case EMFILE:
	  /*
            Too many files opened, use same error message as if the .frm
            file can't open
           */
          DBUG_PRINT("error", ("open file: %s failed, too many files opened (errno: %d)", 
		  share->normalized_path.str, ha_err));
	  error= 1;
	  my_errno= EMFILE;
          break;
        default:
          outparam->file->print_error(ha_err, MYF(0));
          error_reported= TRUE;
          if (ha_err == HA_ERR_TABLE_DEF_CHANGED)
            error= 7;
          break;
1817
      }
1818
      goto err;                                 /* purecov: inspected */
1819 1820 1821
    }
  }

1822 1823 1824 1825
#if defined(HAVE_purify) && !defined(DBUG_OFF)
  bzero((char*) bitmaps, bitmap_size*3);
#endif

1826
  thd->status_var.opened_tables++;
1827

unknown's avatar
unknown committed
1828 1829
  DBUG_RETURN (0);

1830
 err:
1831
  if (! error_reported)
unknown's avatar
unknown committed
1832
    open_table_error(share, error, my_errno, 0);
1833
  delete outparam->file;
1834
#ifdef WITH_PARTITION_STORAGE_ENGINE
unknown's avatar
unknown committed
1835 1836
  if (outparam->part_info)
    free_items(outparam->part_info->item_free_list);
1837
#endif
unknown's avatar
unknown committed
1838
  outparam->file= 0;				// For easier error checking
1839
  outparam->db_stat=0;
1840
  free_root(&outparam->mem_root, MYF(0));       // Safe to call on bzero'd root
1841
  my_free((char*) outparam->alias, MYF(MY_ALLOW_ZERO_PTR));
unknown's avatar
unknown committed
1842
  DBUG_RETURN (error);
unknown's avatar
unknown committed
1843
}
unknown's avatar
unknown committed
1844

1845 1846 1847 1848 1849 1850 1851 1852 1853

/*
  Free information allocated by openfrm

  SYNOPSIS
    closefrm()
    table		TABLE object to free
    free_share		Is 1 if we also want to free table_share
*/
unknown's avatar
unknown committed
1854

unknown's avatar
unknown committed
1855
int closefrm(register TABLE *table, bool free_share)
unknown's avatar
unknown committed
1856 1857
{
  int error=0;
1858 1859
  uint idx;
  KEY *key_info;
unknown's avatar
unknown committed
1860
  DBUG_ENTER("closefrm");
1861
  DBUG_PRINT("enter", ("table: 0x%lx", (long) table));
1862

unknown's avatar
unknown committed
1863 1864
  if (table->db_stat)
    error=table->file->close();
1865 1866 1867 1868
  key_info= table->key_info;
  for (idx= table->s->keys; idx; idx--, key_info++)
  {
    if (key_info->flags & HA_USES_PARSER)
1869
    {
unknown's avatar
unknown committed
1870
      plugin_unlock(NULL, key_info->parser);
1871 1872
      key_info->flags= 0;
    }
1873
  }
1874 1875 1876
  my_free((char*) table->alias, MYF(MY_ALLOW_ZERO_PTR));
  table->alias= 0;
  if (table->field)
unknown's avatar
unknown committed
1877 1878 1879
  {
    for (Field **ptr=table->field ; *ptr ; ptr++)
      delete *ptr;
1880
    table->field= 0;
unknown's avatar
unknown committed
1881 1882
  }
  delete table->file;
unknown's avatar
unknown committed
1883
  table->file= 0;				/* For easier errorchecking */
1884
#ifdef WITH_PARTITION_STORAGE_ENGINE
unknown's avatar
unknown committed
1885
  if (table->part_info)
1886
  {
unknown's avatar
unknown committed
1887
    free_items(table->part_info->item_free_list);
unknown's avatar
unknown committed
1888
    table->part_info->item_free_list= 0;
unknown's avatar
unknown committed
1889
    table->part_info= 0;
1890 1891
  }
#endif
unknown's avatar
unknown committed
1892 1893 1894 1895 1896 1897 1898
  if (free_share)
  {
    if (table->s->tmp_table == NO_TMP_TABLE)
      release_table_share(table->s, RELEASE_NORMAL);
    else
      free_table_share(table->s);
  }
1899
  free_root(&table->mem_root, MYF(0));
unknown's avatar
unknown committed
1900 1901 1902 1903 1904 1905 1906 1907
  DBUG_RETURN(error);
}


/* Deallocate temporary blob storage */

void free_blobs(register TABLE *table)
{
1908 1909 1910 1911 1912
  uint *ptr, *end;
  for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ;
       ptr != end ;
       ptr++)
    ((Field_blob*) table->field[*ptr])->free();
unknown's avatar
unknown committed
1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926
}


	/* Find where a form starts */
	/* if formname is NullS then only formnames is read */

ulong get_form_pos(File file, uchar *head, TYPELIB *save_names)
{
  uint a_length,names,length;
  uchar *pos,*buf;
  ulong ret_value=0;
  DBUG_ENTER("get_form_pos");

  names=uint2korr(head+8);
1927
  a_length=(names+2)*sizeof(char *);		/* Room for two extra */
unknown's avatar
unknown committed
1928 1929 1930 1931 1932 1933 1934 1935 1936 1937

  if (!save_names)
    a_length=0;
  else
    save_names->type_names=0;			/* Clear if error */

  if (names)
  {
    length=uint2korr(head+4);
    VOID(my_seek(file,64L,MY_SEEK_SET,MYF(0)));
1938
    if (!(buf= (uchar*) my_malloc((size_t) length+a_length+names*4,
unknown's avatar
unknown committed
1939
				  MYF(MY_WME))) ||
1940
	my_read(file, buf+a_length, (size_t) (length+names*4),
unknown's avatar
unknown committed
1941 1942
		MYF(MY_NABP)))
    {						/* purecov: inspected */
1943
      x_free((uchar*) buf);			/* purecov: inspected */
unknown's avatar
unknown committed
1944 1945 1946 1947 1948 1949
      DBUG_RETURN(0L);				/* purecov: inspected */
    }
    pos= buf+a_length+length;
    ret_value=uint4korr(pos);
  }
  if (! save_names)
1950 1951
  {
    if (names)
1952
      my_free((uchar*) buf,MYF(0));
1953
  }
unknown's avatar
unknown committed
1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
  else if (!names)
    bzero((char*) save_names,sizeof(save_names));
  else
  {
    char *str;
    str=(char *) (buf+a_length);
    fix_type_pointers((const char ***) &buf,save_names,1,&str);
  }
  DBUG_RETURN(ret_value);
}


1966 1967
/*
  Read string from a file with malloc
unknown's avatar
unknown committed
1968

1969 1970 1971 1972 1973
  NOTES:
    We add an \0 at end of the read string to make reading of C strings easier
*/

int read_string(File file, uchar**to, size_t length)
unknown's avatar
unknown committed
1974 1975 1976
{
  DBUG_ENTER("read_string");

1977 1978 1979
  x_free(*to);
  if (!(*to= (uchar*) my_malloc(length+1,MYF(MY_WME))) ||
      my_read(file, *to, length,MYF(MY_NABP)))
unknown's avatar
unknown committed
1980
  {
1981 1982 1983
    x_free(*to);                              /* purecov: inspected */
    *to= 0;                                   /* purecov: inspected */
    DBUG_RETURN(1);                           /* purecov: inspected */
unknown's avatar
unknown committed
1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996
  }
  *((char*) *to+length)= '\0';
  DBUG_RETURN (0);
} /* read_string */


	/* Add a new form to a form file */

ulong make_new_entry(File file, uchar *fileinfo, TYPELIB *formnames,
		     const char *newname)
{
  uint i,bufflength,maxlength,n_length,length,names;
  ulong endpos,newpos;
1997
  uchar buff[IO_SIZE];
unknown's avatar
unknown committed
1998 1999 2000
  uchar *pos;
  DBUG_ENTER("make_new_entry");

unknown's avatar
unknown committed
2001
  length=(uint) strlen(newname)+1;
unknown's avatar
unknown committed
2002 2003 2004 2005 2006 2007 2008 2009 2010
  n_length=uint2korr(fileinfo+4);
  maxlength=uint2korr(fileinfo+6);
  names=uint2korr(fileinfo+8);
  newpos=uint4korr(fileinfo+10);

  if (64+length+n_length+(names+1)*4 > maxlength)
  {						/* Expand file */
    newpos+=IO_SIZE;
    int4store(fileinfo+10,newpos);
unknown's avatar
unknown committed
2011
    endpos=(ulong) my_seek(file,0L,MY_SEEK_END,MYF(0));/* Copy from file-end */
unknown's avatar
unknown committed
2012 2013 2014 2015 2016
    bufflength= (uint) (endpos & (IO_SIZE-1));	/* IO_SIZE is a power of 2 */

    while (endpos > maxlength)
    {
      VOID(my_seek(file,(ulong) (endpos-bufflength),MY_SEEK_SET,MYF(0)));
2017
      if (my_read(file, buff, bufflength, MYF(MY_NABP+MY_WME)))
unknown's avatar
unknown committed
2018 2019 2020
	DBUG_RETURN(0L);
      VOID(my_seek(file,(ulong) (endpos-bufflength+IO_SIZE),MY_SEEK_SET,
		   MYF(0)));
2021
      if ((my_write(file, buff,bufflength,MYF(MY_NABP+MY_WME))))
unknown's avatar
unknown committed
2022 2023 2024 2025 2026
	DBUG_RETURN(0);
      endpos-=bufflength; bufflength=IO_SIZE;
    }
    bzero(buff,IO_SIZE);			/* Null new block */
    VOID(my_seek(file,(ulong) maxlength,MY_SEEK_SET,MYF(0)));
2027
    if (my_write(file,buff,bufflength,MYF(MY_NABP+MY_WME)))
unknown's avatar
unknown committed
2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041
	DBUG_RETURN(0L);
    maxlength+=IO_SIZE;				/* Fix old ref */
    int2store(fileinfo+6,maxlength);
    for (i=names, pos= (uchar*) *formnames->type_names+n_length-1; i-- ;
	 pos+=4)
    {
      endpos=uint4korr(pos)+IO_SIZE;
      int4store(pos,endpos);
    }
  }

  if (n_length == 1 )
  {						/* First name */
    length++;
2042
    VOID(strxmov((char*) buff,"/",newname,"/",NullS));
unknown's avatar
unknown committed
2043 2044
  }
  else
2045
    VOID(strxmov((char*) buff,newname,"/",NullS)); /* purecov: inspected */
unknown's avatar
unknown committed
2046
  VOID(my_seek(file,63L+(ulong) n_length,MY_SEEK_SET,MYF(0)));
2047 2048
  if (my_write(file, buff, (size_t) length+1,MYF(MY_NABP+MY_WME)) ||
      (names && my_write(file,(uchar*) (*formnames->type_names+n_length-1),
unknown's avatar
unknown committed
2049
			 names*4, MYF(MY_NABP+MY_WME))) ||
2050
      my_write(file, fileinfo+10, 4,MYF(MY_NABP+MY_WME)))
unknown's avatar
unknown committed
2051 2052 2053 2054
    DBUG_RETURN(0L); /* purecov: inspected */

  int2store(fileinfo+8,names+1);
  int2store(fileinfo+4,n_length+length);
2055
  VOID(my_chsize(file, newpos, 0, MYF(MY_WME)));/* Append file with '\0' */
unknown's avatar
unknown committed
2056 2057 2058 2059 2060 2061
  DBUG_RETURN(newpos);
} /* make_new_entry */


	/* error message when opening a form file */

unknown's avatar
unknown committed
2062
void open_table_error(TABLE_SHARE *share, int error, int db_errno, int errarg)
unknown's avatar
unknown committed
2063 2064 2065
{
  int err_no;
  char buff[FN_REFLEN];
unknown's avatar
unknown committed
2066 2067
  myf errortype= ME_ERROR+ME_WAITTANG;
  DBUG_ENTER("open_table_error");
unknown's avatar
unknown committed
2068 2069

  switch (error) {
unknown's avatar
unknown committed
2070
  case 7:
unknown's avatar
unknown committed
2071
  case 1:
unknown's avatar
unknown committed
2072 2073 2074
    if (db_errno == ENOENT)
      my_error(ER_NO_SUCH_TABLE, MYF(0), share->db.str, share->table_name.str);
    else
unknown's avatar
unknown committed
2075
    {
unknown's avatar
unknown committed
2076
      strxmov(buff, share->normalized_path.str, reg_ext, NullS);
2077 2078
      my_error((db_errno == EMFILE) ? ER_CANT_OPEN_FILE : ER_FILE_NOT_FOUND,
               errortype, buff, db_errno);
unknown's avatar
unknown committed
2079 2080 2081 2082
    }
    break;
  case 2:
  {
unknown's avatar
unknown committed
2083 2084 2085
    handler *file= 0;
    const char *datext= "";
    
unknown's avatar
unknown committed
2086
    if (share->db_type() != NULL)
unknown's avatar
unknown committed
2087 2088
    {
      if ((file= get_new_handler(share, current_thd->mem_root,
unknown's avatar
unknown committed
2089
                                 share->db_type())))
unknown's avatar
unknown committed
2090 2091 2092 2093 2094 2095
      {
        if (!(datext= *file->bas_ext()))
          datext= "";
      }
    }
    err_no= (db_errno == ENOENT) ? ER_FILE_NOT_FOUND : (db_errno == EAGAIN) ?
unknown's avatar
unknown committed
2096
      ER_FILE_USED : ER_CANT_OPEN_FILE;
unknown's avatar
unknown committed
2097 2098 2099
    strxmov(buff, share->normalized_path.str, datext, NullS);
    my_error(err_no,errortype, buff, db_errno);
    delete file;
unknown's avatar
unknown committed
2100 2101
    break;
  }
2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112
  case 5:
  {
    const char *csname= get_charset_name((uint) errarg);
    char tmp[10];
    if (!csname || csname[0] =='?')
    {
      my_snprintf(tmp, sizeof(tmp), "#%d", errarg);
      csname= tmp;
    }
    my_printf_error(ER_UNKNOWN_COLLATION,
                    "Unknown collation '%s' in table '%-.64s' definition", 
unknown's avatar
unknown committed
2113
                    MYF(0), csname, share->table_name.str);
unknown's avatar
unknown committed
2114 2115
    break;
  }
2116
  case 6:
unknown's avatar
unknown committed
2117
    strxmov(buff, share->normalized_path.str, reg_ext, NullS);
2118 2119
    my_printf_error(ER_NOT_FORM_FILE,
                    "Table '%-.64s' was created with a different version "
unknown's avatar
unknown committed
2120 2121
                    "of MySQL and cannot be read", 
                    MYF(0), buff);
2122
    break;
unknown's avatar
unknown committed
2123 2124
  default:				/* Better wrong error than none */
  case 4:
unknown's avatar
unknown committed
2125 2126
    strxmov(buff, share->normalized_path.str, reg_ext, NullS);
    my_error(ER_NOT_FORM_FILE, errortype, buff, 0);
unknown's avatar
unknown committed
2127 2128 2129
    break;
  }
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2130
} /* open_table_error */
unknown's avatar
unknown committed
2131 2132 2133 2134


	/*
	** fix a str_type to a array type
2135
	** typeparts separated with some char. differents types are separated
unknown's avatar
unknown committed
2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159
	** with a '\0'
	*/

static void
fix_type_pointers(const char ***array, TYPELIB *point_to_type, uint types,
		  char **names)
{
  char *type_name, *ptr;
  char chr;

  ptr= *names;
  while (types--)
  {
    point_to_type->name=0;
    point_to_type->type_names= *array;

    if ((chr= *ptr))			/* Test if empty type */
    {
      while ((type_name=strchr(ptr+1,chr)) != NullS)
      {
	*((*array)++) = ptr+1;
	*type_name= '\0';		/* End string */
	ptr=type_name;
      }
unknown's avatar
unknown committed
2160
      ptr+=2;				/* Skip end mark and last 0 */
unknown's avatar
unknown committed
2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172
    }
    else
      ptr++;
    point_to_type->count= (uint) (*array - point_to_type->type_names);
    point_to_type++;
    *((*array)++)= NullS;		/* End of type */
  }
  *names=ptr;				/* Update end */
  return;
} /* fix_type_pointers */


2173
TYPELIB *typelib(MEM_ROOT *mem_root, List<String> &strings)
unknown's avatar
unknown committed
2174
{
2175
  TYPELIB *result= (TYPELIB*) alloc_root(mem_root, sizeof(TYPELIB));
unknown's avatar
unknown committed
2176 2177 2178 2179
  if (!result)
    return 0;
  result->count=strings.elements;
  result->name="";
2180
  uint nbytes= (sizeof(char*) + sizeof(uint)) * (result->count + 1);
2181
  if (!(result->type_names= (const char**) alloc_root(mem_root, nbytes)))
unknown's avatar
unknown committed
2182
    return 0;
2183
  result->type_lengths= (uint*) (result->type_names + result->count + 1);
unknown's avatar
unknown committed
2184 2185 2186
  List_iterator<String> it(strings);
  String *tmp;
  for (uint i=0; (tmp=it++) ; i++)
2187 2188 2189 2190 2191 2192
  {
    result->type_names[i]= tmp->ptr();
    result->type_lengths[i]= tmp->length();
  }
  result->type_names[result->count]= 0;		// End marker
  result->type_lengths[result->count]= 0;
unknown's avatar
unknown committed
2193 2194 2195 2196
  return result;
}


2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
/*
 Search after a field with given start & length
 If an exact field isn't found, return longest field with starts
 at right position.
 
 NOTES
   This is needed because in some .frm fields 'fieldnr' was saved wrong

 RETURN
   0  error
   #  field number +1
*/
unknown's avatar
unknown committed
2209

2210
static uint find_field(Field **fields, uchar *record, uint start, uint length)
unknown's avatar
unknown committed
2211 2212
{
  Field **field;
unknown's avatar
unknown committed
2213
  uint i, pos;
unknown's avatar
unknown committed
2214

unknown's avatar
unknown committed
2215 2216
  pos= 0;
  for (field= fields, i=1 ; *field ; i++,field++)
unknown's avatar
unknown committed
2217
  {
2218
    if ((*field)->offset(record) == start)
unknown's avatar
unknown committed
2219 2220 2221
    {
      if ((*field)->key_length() == length)
	return (i);
unknown's avatar
unknown committed
2222
      if (!pos || fields[pos-1]->pack_length() <
unknown's avatar
unknown committed
2223
	  (*field)->pack_length())
unknown's avatar
unknown committed
2224
	pos= i;
unknown's avatar
unknown committed
2225 2226 2227 2228 2229 2230
    }
  }
  return (pos);
}


2231
	/* Check that the integer is in the internal */
unknown's avatar
unknown committed
2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252

int set_zone(register int nr, int min_zone, int max_zone)
{
  if (nr<=min_zone)
    return (min_zone);
  if (nr>=max_zone)
    return (max_zone);
  return (nr);
} /* set_zone */

	/* Adjust number to next larger disk buffer */

ulong next_io_size(register ulong pos)
{
  reg2 ulong offset;
  if ((offset= pos & (IO_SIZE-1)))
    return pos-offset+IO_SIZE;
  return pos;
} /* next_io_size */


2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265
/*
  Store an SQL quoted string.

  SYNOPSIS  
    append_unescaped()
    res		result String
    pos		string to be quoted
    length	it's length

  NOTE
    This function works correctly with utf8 or single-byte charset strings.
    May fail with some multibyte charsets though.
*/
2266

2267
void append_unescaped(String *res, const char *pos, uint length)
unknown's avatar
unknown committed
2268
{
2269 2270 2271 2272
  const char *end= pos+length;
  res->append('\'');

  for (; pos != end ; pos++)
unknown's avatar
unknown committed
2273
  {
unknown's avatar
unknown committed
2274
#if defined(USE_MB) && MYSQL_VERSION_ID < 40100
unknown's avatar
unknown committed
2275 2276 2277 2278 2279 2280 2281 2282 2283 2284
    uint mblen;
    if (use_mb(default_charset_info) &&
        (mblen= my_ismbchar(default_charset_info, pos, end)))
    {
      res->append(pos, mblen);
      pos+= mblen;
      continue;
    }
#endif

unknown's avatar
unknown committed
2285 2286 2287 2288 2289 2290 2291 2292 2293 2294
    switch (*pos) {
    case 0:				/* Must be escaped for 'mysql' */
      res->append('\\');
      res->append('0');
      break;
    case '\n':				/* Must be escaped for logs */
      res->append('\\');
      res->append('n');
      break;
    case '\r':
2295
      res->append('\\');		/* This gives better readability */
unknown's avatar
unknown committed
2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
      res->append('r');
      break;
    case '\\':
      res->append('\\');		/* Because of the sql syntax */
      res->append('\\');
      break;
    case '\'':
      res->append('\'');		/* Because of the sql syntax */
      res->append('\'');
      break;
    default:
      res->append(*pos);
      break;
    }
  }
2311
  res->append('\'');
unknown's avatar
unknown committed
2312 2313
}

2314

unknown's avatar
unknown committed
2315 2316
	/* Create a .frm file */

unknown's avatar
unknown committed
2317
File create_frm(THD *thd, const char *name, const char *db,
unknown's avatar
unknown committed
2318
                const char *table, uint reclength, uchar *fileinfo,
unknown's avatar
unknown committed
2319
  		HA_CREATE_INFO *create_info, uint keys)
unknown's avatar
unknown committed
2320 2321 2322
{
  register File file;
  ulong length;
2323
  uchar fill[IO_SIZE];
2324 2325 2326 2327
  int create_flags= O_RDWR | O_TRUNC;

  if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
    create_flags|= O_EXCL | O_NOFOLLOW;
unknown's avatar
unknown committed
2328

unknown's avatar
unknown committed
2329
  /* Fix this when we have new .frm files;  Current limit is 4G rows (QQ) */
2330 2331 2332 2333
  if (create_info->max_rows > UINT_MAX32)
    create_info->max_rows= UINT_MAX32;
  if (create_info->min_rows > UINT_MAX32)
    create_info->min_rows= UINT_MAX32;
2334

2335
  if ((file= my_create(name, CREATE_MODE, create_flags, MYF(0))) >= 0)
unknown's avatar
unknown committed
2336
  {
2337 2338
    uint key_length, tmp_key_length;
    uint tmp;
unknown's avatar
unknown committed
2339
    bzero((char*) fileinfo,64);
2340 2341 2342 2343 2344
    /* header */
    fileinfo[0]=(uchar) 254;
    fileinfo[1]= 1;
    fileinfo[2]= FRM_VER+3+ test(create_info->varchar);

unknown's avatar
unknown committed
2345 2346
    fileinfo[3]= (uchar) ha_legacy_type(
          ha_checktype(thd,ha_legacy_type(create_info->db_type),0,0));
unknown's avatar
unknown committed
2347 2348
    fileinfo[4]=1;
    int2store(fileinfo+6,IO_SIZE);		/* Next block starts here */
2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361
    /*
      Keep in sync with pack_keys() in unireg.cc
      For each key:
      8 bytes for the key header
      9 bytes for each key-part (MAX_REF_PARTS)
      NAME_LEN bytes for the name
      1 byte for the NAMES_SEP_CHAR (before the name)
      For all keys:
      6 bytes for the header
      1 byte for the NAMES_SEP_CHAR (after the last name)
      9 extra bytes (padding for safety? alignment?)
    */
    key_length= keys * (8 + MAX_REF_PARTS * 9 + NAME_LEN + 1) + 16;
2362 2363
    length= next_io_size((ulong) (IO_SIZE+key_length+reclength+
                                  create_info->extra_size));
unknown's avatar
unknown committed
2364
    int4store(fileinfo+10,length);
2365 2366
    tmp_key_length= (key_length < 0xffff) ? key_length : 0xffff;
    int2store(fileinfo+14,tmp_key_length);
unknown's avatar
unknown committed
2367 2368 2369 2370 2371 2372 2373
    int2store(fileinfo+16,reclength);
    int4store(fileinfo+18,create_info->max_rows);
    int4store(fileinfo+22,create_info->min_rows);
    fileinfo[27]=2;				// Use long pack-fields
    create_info->table_options|=HA_OPTION_LONG_BLOB_PTR; // Use portable blob pointers
    int2store(fileinfo+30,create_info->table_options);
    fileinfo[32]=0;				// No filename anymore
2374
    fileinfo[33]=5;                             // Mark for 5.0 frm file
unknown's avatar
unknown committed
2375
    int4store(fileinfo+34,create_info->avg_row_length);
2376 2377
    fileinfo[38]= (create_info->default_table_charset ?
		   create_info->default_table_charset->number : 0);
unknown's avatar
unknown committed
2378
    fileinfo[40]= (uchar) create_info->row_type;
2379 2380 2381 2382 2383 2384 2385
    /* Next few bytes were for RAID support */
    fileinfo[41]= 0;
    fileinfo[42]= 0;
    fileinfo[43]= 0;
    fileinfo[44]= 0;
    fileinfo[45]= 0;
    fileinfo[46]= 0;
2386 2387 2388
    int4store(fileinfo+47, key_length);
    tmp= MYSQL_VERSION_ID;          // Store to avoid warning from int4store
    int4store(fileinfo+51, tmp);
unknown's avatar
unknown committed
2389
    int4store(fileinfo+55, create_info->extra_size);
2390 2391 2392 2393 2394
    /*
      59-60 is reserved for extra_rec_buf_length,
      61 for default_part_db_type
    */
    int2store(fileinfo+62, create_info->key_block_size);
unknown's avatar
unknown committed
2395 2396 2397
    bzero(fill,IO_SIZE);
    for (; length > IO_SIZE ; length-= IO_SIZE)
    {
2398
      if (my_write(file,fill, IO_SIZE, MYF(MY_WME | MY_NABP)))
unknown's avatar
unknown committed
2399 2400 2401 2402 2403 2404 2405
      {
	VOID(my_close(file,MYF(0)));
	VOID(my_delete(name,MYF(0)));
	return(-1);
      }
    }
  }
2406 2407 2408 2409 2410 2411 2412
  else
  {
    if (my_errno == ENOENT)
      my_error(ER_BAD_DB_ERROR,MYF(0),db);
    else
      my_error(ER_CANT_CREATE_TABLE,MYF(0),table,my_errno);
  }
unknown's avatar
unknown committed
2413 2414 2415 2416 2417 2418
  return (file);
} /* create_frm */


void update_create_info_from_table(HA_CREATE_INFO *create_info, TABLE *table)
{
2419
  TABLE_SHARE *share= table->s;
2420
  DBUG_ENTER("update_create_info_from_table");
2421 2422 2423 2424 2425 2426 2427

  create_info->max_rows= share->max_rows;
  create_info->min_rows= share->min_rows;
  create_info->table_options= share->db_create_options;
  create_info->avg_row_length= share->avg_row_length;
  create_info->row_type= share->row_type;
  create_info->default_table_charset= share->table_charset;
2428
  create_info->table_charset= 0;
2429

2430
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2431
}
unknown's avatar
unknown committed
2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442

int
rename_file_ext(const char * from,const char * to,const char * ext)
{
  char from_b[FN_REFLEN],to_b[FN_REFLEN];
  VOID(strxmov(from_b,from,ext,NullS));
  VOID(strxmov(to_b,to,ext,NullS));
  return (my_rename(from_b,to_b,MYF(MY_WME)));
}


unknown's avatar
unknown committed
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452
/*
  Allocate string field in MEM_ROOT and return it as String

  SYNOPSIS
    get_field()
    mem   	MEM_ROOT for allocating
    field 	Field for retrieving of string
    res         result String

  RETURN VALUES
2453 2454
    1   string is empty
    0	all ok
unknown's avatar
unknown committed
2455 2456 2457 2458
*/

bool get_field(MEM_ROOT *mem, Field *field, String *res)
{
2459
  char buff[MAX_FIELD_WIDTH], *to;
unknown's avatar
unknown committed
2460
  String str(buff,sizeof(buff),&my_charset_bin);
2461 2462
  uint length;

2463
  field->val_str(&str);
2464
  if (!(length= str.length()))
2465 2466
  {
    res->length(0);
2467
    return 1;
2468 2469 2470
  }
  if (!(to= strmake_root(mem, str.ptr(), length)))
    length= 0;                                  // Safety fix
2471 2472
  res->set(to, length, ((Field_str*)field)->charset());
  return 0;
unknown's avatar
unknown committed
2473 2474
}

2475

unknown's avatar
unknown committed
2476
/*
2477 2478 2479 2480 2481 2482 2483 2484 2485 2486
  Allocate string field in MEM_ROOT and return it as NULL-terminated string

  SYNOPSIS
    get_field()
    mem   	MEM_ROOT for allocating
    field 	Field for retrieving of string

  RETURN VALUES
    NullS  string is empty
    #      pointer to NULL-terminated string value of field
unknown's avatar
unknown committed
2487 2488
*/

2489
char *get_field(MEM_ROOT *mem, Field *field)
unknown's avatar
unknown committed
2490
{
unknown's avatar
unknown committed
2491
  char buff[MAX_FIELD_WIDTH], *to;
2492
  String str(buff,sizeof(buff),&my_charset_bin);
2493 2494
  uint length;

2495
  field->val_str(&str);
unknown's avatar
unknown committed
2496
  length= str.length();
unknown's avatar
unknown committed
2497
  if (!length || !(to= (char*) alloc_root(mem,length+1)))
unknown's avatar
unknown committed
2498 2499 2500 2501 2502 2503
    return NullS;
  memcpy(to,str.ptr(),(uint) length);
  to[length]=0;
  return to;
}

2504 2505 2506 2507 2508
/*
  DESCRIPTION
    given a buffer with a key value, and a map of keyparts
    that are present in this value, returns the length of the value
*/
2509
uint calculate_key_len(TABLE *table, uint key, const uchar *buf,
unknown's avatar
unknown committed
2510
                       key_part_map keypart_map)
2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527
{
  /* works only with key prefixes */
  DBUG_ASSERT(((keypart_map + 1) & keypart_map) == 0);

  KEY *key_info= table->s->key_info+key;
  KEY_PART_INFO *key_part= key_info->key_part;
  KEY_PART_INFO *end_key_part= key_part + key_info->key_parts;
  uint length= 0;

  while (key_part < end_key_part && keypart_map)
  {
    length+= key_part->store_length;
    keypart_map >>= 1;
    key_part++;
  }
  return length;
}
2528 2529 2530 2531 2532 2533

/*
  Check if database name is valid

  SYNPOSIS
    check_db_name()
2534
    org_name		Name of database and length
2535 2536 2537 2538 2539 2540 2541 2542 2543

  NOTES
    If lower_case_table_names is set then database is converted to lower case

  RETURN
    0	ok
    1   error
*/

2544
bool check_db_name(LEX_STRING *org_name)
unknown's avatar
unknown committed
2545
{
2546
  char *name= org_name->str;
2547
  uint name_length= org_name->length;
2548

2549
  if (!name_length || name_length > NAME_LEN)
2550
    return 1;
2551

unknown's avatar
unknown committed
2552
  if (lower_case_table_names && name != any_db)
2553
    my_casedn_str(files_charset_info, name);
2554

unknown's avatar
unknown committed
2555
#if defined(USE_MB) && defined(USE_MB_IDENT)
2556 2557
  if (use_mb(system_charset_info))
  {
2558
    name_length= 0;
2559 2560 2561
    bool last_char_is_space= TRUE;
    char *end= name + org_name->length;
    while (name < end)
unknown's avatar
unknown committed
2562
    {
2563 2564 2565 2566 2567 2568
      int len;
      last_char_is_space= my_isspace(system_charset_info, *name);
      len= my_ismbchar(system_charset_info, name, end);
      if (!len)
        len= 1;
      name+= len;
2569
      name_length++;
unknown's avatar
unknown committed
2570
    }
2571
    return (last_char_is_space || name_length > NAME_CHAR_LEN);
unknown's avatar
unknown committed
2572
  }
2573 2574
  else
#endif
2575 2576
    return ((org_name->str[org_name->length - 1] != ' ') ||
            (name_length > NAME_CHAR_LEN)); /* purecov: inspected */
unknown's avatar
unknown committed
2577 2578 2579 2580 2581
}


/*
  Allow anything as a table name, as long as it doesn't contain an
2582
  ' ' at the end
unknown's avatar
unknown committed
2583 2584 2585 2586 2587 2588
  returns 1 on error
*/


bool check_table_name(const char *name, uint length)
{
2589
  uint name_length= 0;  // name length in symbols
unknown's avatar
unknown committed
2590
  const char *end= name+length;
unknown's avatar
unknown committed
2591 2592
  if (!length || length > NAME_LEN)
    return 1;
unknown's avatar
unknown committed
2593
#if defined(USE_MB) && defined(USE_MB_IDENT)
2594
  bool last_char_is_space= FALSE;
unknown's avatar
unknown committed
2595 2596 2597 2598
#else
  if (name[length-1]==' ')
    return 1;
#endif
unknown's avatar
unknown committed
2599 2600 2601 2602

  while (name != end)
  {
#if defined(USE_MB) && defined(USE_MB_IDENT)
2603
    last_char_is_space= my_isspace(system_charset_info, *name);
2604
    if (use_mb(system_charset_info))
unknown's avatar
unknown committed
2605
    {
2606
      int len=my_ismbchar(system_charset_info, name, end);
unknown's avatar
unknown committed
2607 2608 2609
      if (len)
      {
        name += len;
2610
        name_length++;
unknown's avatar
unknown committed
2611 2612 2613 2614 2615
        continue;
      }
    }
#endif
    name++;
2616
    name_length++;
unknown's avatar
unknown committed
2617
  }
unknown's avatar
unknown committed
2618
#if defined(USE_MB) && defined(USE_MB_IDENT)
2619
  return (last_char_is_space || name_length > NAME_CHAR_LEN) ;
2620
#else
unknown's avatar
unknown committed
2621
  return 0;
2622
#endif
unknown's avatar
unknown committed
2623 2624
}

unknown's avatar
unknown committed
2625

unknown's avatar
unknown committed
2626 2627
bool check_column_name(const char *name)
{
2628
  uint name_length= 0;  // name length in symbols
unknown's avatar
unknown committed
2629
  bool last_char_is_space= TRUE;
2630
  
unknown's avatar
unknown committed
2631 2632 2633
  while (*name)
  {
#if defined(USE_MB) && defined(USE_MB_IDENT)
2634
    last_char_is_space= my_isspace(system_charset_info, *name);
2635
    if (use_mb(system_charset_info))
unknown's avatar
unknown committed
2636
    {
2637
      int len=my_ismbchar(system_charset_info, name, 
2638
                          name+system_charset_info->mbmaxlen);
unknown's avatar
unknown committed
2639 2640 2641
      if (len)
      {
        name += len;
2642
        name_length++;
unknown's avatar
unknown committed
2643 2644 2645
        continue;
      }
    }
unknown's avatar
unknown committed
2646
#else
2647
    last_char_is_space= *name==' ';
unknown's avatar
unknown committed
2648 2649 2650 2651
#endif
    if (*name == NAMES_SEP_CHAR)
      return 1;
    name++;
2652
    name_length++;
unknown's avatar
unknown committed
2653
  }
unknown's avatar
unknown committed
2654
  /* Error if empty or too long column name */
2655
  return last_char_is_space || (uint) name_length > NAME_CHAR_LEN;
unknown's avatar
unknown committed
2656 2657
}

2658

2659
/**
2660 2661
  Checks whether a table is intact. Should be done *just* after the table has
  been opened.
2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673

  @param[in] table             The table to check
  @param[in] table_f_count     Expected number of columns in the table
  @param[in] table_def         Expected structure of the table (column name
                               and type)

  @retval  FALSE  OK
  @retval  TRUE   There was an error. An error message is output
                  to the error log.  We do not push an error
                  message into the error stack because this
                  function is currently only called at start up,
                  and such errors never reach the user.
2674 2675 2676
*/

my_bool
2677
table_check_intact(TABLE *table, const uint table_f_count,
2678
                   const TABLE_FIELD_W_TYPE *table_def)
2679 2680 2681 2682 2683
{
  uint i;
  my_bool error= FALSE;
  my_bool fields_diff_count;
  DBUG_ENTER("table_check_intact");
2684 2685 2686 2687 2688
  DBUG_PRINT("info",("table: %s  expected_count: %d",
                     table->alias, table_f_count));

  fields_diff_count= (table->s->fields != table_f_count);
  if (fields_diff_count)
2689
  {
2690 2691 2692 2693
    DBUG_PRINT("info", ("Column count has changed, checking the definition"));

    /* previous MySQL version */
    if (MYSQL_VERSION_ID > table->s->mysql_version)
2694
    {
2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721
      sql_print_error(ER(ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE),
                      table->alias, table_f_count, table->s->fields,
                      table->s->mysql_version, MYSQL_VERSION_ID);
      DBUG_RETURN(TRUE);
    }
    else if (MYSQL_VERSION_ID == table->s->mysql_version)
    {
      sql_print_error(ER(ER_COL_COUNT_DOESNT_MATCH_CORRUPTED), table->alias,
                      table_f_count, table->s->fields);
      DBUG_RETURN(TRUE);
    }
    /*
      Something has definitely changed, but we're running an older
      version of MySQL with new system tables.
      Let's check column definitions. If a column was added at
      the end of the table, then we don't care much since such change
      is backward compatible.
    */
  }
  char buffer[STRING_BUFFER_USUAL_SIZE];
  for (i=0 ; i < table_f_count; i++, table_def++)
  {
    String sql_type(buffer, sizeof(buffer), system_charset_info);
    sql_type.length(0);
    if (i < table->s->fields)
    {
      Field *field= table->field[i];
2722

2723 2724
      if (strncmp(field->field_name, table_def->name.str,
                  table_def->name.length))
2725
      {
2726
        /*
2727 2728 2729
          Name changes are not fatal, we use ordinal numbers to access columns.
          Still this can be a sign of a tampered table, output an error
          to the error log.
2730
        */
2731 2732 2733 2734
        sql_print_error("Incorrect definition of table %s.%s: "
                        "expected column '%s' at position %d, found '%s'.",
                        table->s->db.str, table->alias, table_def->name.str, i,
                        field->field_name);
2735
      }
2736
      field->sql_type(sql_type);
2737
      /*
2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755
        Generally, if column types don't match, then something is
        wrong.

        However, we only compare column definitions up to the
        length of the original definition, since we consider the
        following definitions compatible:

        1. DATETIME and DATETIM
        2. INT(11) and INT(11
        3. SET('one', 'two') and SET('one', 'two', 'more')

        For SETs or ENUMs, if the same prefix is there it's OK to
        add more elements - they will get higher ordinal numbers and
        the new table definition is backward compatible with the
        original one.
       */
      if (strncmp(sql_type.c_ptr_safe(), table_def->type.str,
                  table_def->type.length - 1))
2756
      {
2757 2758 2759 2760 2761 2762
        sql_print_error("Incorrect definition of table %s.%s: "
                        "expected column '%s' at position %d to have type "
                        "%s, found type %s.", table->s->db.str, table->alias,
                        table_def->name.str, i, table_def->type.str,
                        sql_type.c_ptr_safe());
        error= TRUE;
2763
      }
2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774
      else if (table_def->cset.str && !field->has_charset())
      {
        sql_print_error("Incorrect definition of table %s.%s: "
                        "expected the type of column '%s' at position %d "
                        "to have character set '%s' but the type has no "
                        "character set.", table->s->db.str, table->alias,
                        table_def->name.str, i, table_def->cset.str);
        error= TRUE;
      }
      else if (table_def->cset.str &&
               strcmp(field->charset()->csname, table_def->cset.str))
2775
      {
2776 2777 2778 2779 2780 2781 2782
        sql_print_error("Incorrect definition of table %s.%s: "
                        "expected the type of column '%s' at position %d "
                        "to have character set '%s' but found "
                        "character set '%s'.", table->s->db.str, table->alias,
                        table_def->name.str, i, table_def->cset.str,
                        field->charset()->csname);
        error= TRUE;
2783 2784
      }
    }
2785 2786 2787 2788 2789 2790 2791 2792 2793
    else
    {
      sql_print_error("Incorrect definition of table %s.%s: "
                      "expected column '%s' at position %d to have type %s "
                      " but the column is not found.",
                      table->s->db.str, table->alias,
                      table_def->name.str, i, table_def->type.str);
      error= TRUE;
    }
2794
  }
2795
  DBUG_RETURN(error);
2796 2797 2798
}


2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855
/*
  Create Item_field for each column in the table.

  SYNPOSIS
    st_table::fill_item_list()
      item_list          a pointer to an empty list used to store items

  DESCRIPTION
    Create Item_field object for each column in the table and
    initialize it with the corresponding Field. New items are
    created in the current THD memory root.

  RETURN VALUE
    0                    success
    1                    out of memory
*/

bool st_table::fill_item_list(List<Item> *item_list) const
{
  /*
    All Item_field's created using a direct pointer to a field
    are fixed in Item_field constructor.
  */
  for (Field **ptr= field; *ptr; ptr++)
  {
    Item_field *item= new Item_field(*ptr);
    if (!item || item_list->push_back(item))
      return TRUE;
  }
  return FALSE;
}

/*
  Reset an existing list of Item_field items to point to the
  Fields of this table.

  SYNPOSIS
    st_table::fill_item_list()
      item_list          a non-empty list with Item_fields

  DESCRIPTION
    This is a counterpart of fill_item_list used to redirect
    Item_fields to the fields of a newly created table.
    The caller must ensure that number of items in the item_list
    is the same as the number of columns in the table.
*/

void st_table::reset_item_list(List<Item> *item_list) const
{
  List_iterator_fast<Item> it(*item_list);
  for (Field **ptr= field; *ptr; ptr++)
  {
    Item_field *item_field= (Item_field*) it++;
    DBUG_ASSERT(item_field != 0);
    item_field->reset_field(*ptr);
  }
}
unknown's avatar
unknown committed
2856

2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985

/**
  Set the initial purpose of this TABLE_LIST object in the list of
  used tables. We need to track this information on table-by-
  table basis, since when this table becomes an element of the
  pre-locked list, it's impossible to identify which SQL
  sub-statement it has been originally used in.

  E.g.:

  User request:                 SELECT * FROM t1 WHERE f1();
  FUNCTION f1():                DELETE FROM t2; RETURN 1;
  BEFORE DELETE trigger on t2:  INSERT INTO t3 VALUES (old.a);

  For this user request, the pre-locked list will contain t1, t2, t3
  table elements, each needed for different DML.

  This method is called immediately after parsing for tables
  of the table list of the top-level select lex.

  The trigger event map is updated to reflect INSERT, UPDATE, DELETE,
  REPLACE, LOAD DATA, CREATE TABLE .. SELECT, CREATE TABLE ..
  REPLACE SELECT statements, and additionally ON DUPLICATE KEY UPDATE
  clause.
*/

void
TABLE_LIST::set_trg_event_type(const st_lex *lex)
{
  enum trg_event_type trg_event;

  /*
    Some auxiliary operations
    (e.g. GRANT processing) create TABLE_LIST instances outside
    the parser. Additionally, some commands (e.g. OPTIMIZE) change
    the lock type for a table only after parsing is done. Luckily,
    these do not fire triggers and do not need to pre-load them.
    For these TABLE_LISTs set_trg_event_type is never called, and
    trg_event_map is always empty. That means that the pre-locking
    algorithm will ignore triggers defined on these tables, if
    any, and the execution will either fail with an assert in
    sql_trigger.cc or with an error that a used table was not
    pre-locked, in case of a production build.

    TODO: this usage pattern creates unnecessary module dependencies
    and should be rewritten to go through the parser.
    Table list instances created outside the parser in most cases
    refer to mysql.* system tables. It is not allowed to have
    a trigger on a system table, but keeping track of
    initialization provides extra safety in case this limitation
    is circumvented.
  */

  /*
    This is a fast check to filter out statements that do
    not change data, or tables  on the right side, in case of
    INSERT .. SELECT, CREATE TABLE .. SELECT and so on.
    Here we also filter out OPTIMIZE statement and non-updateable
    views, for which lock_type is TL_UNLOCK or TL_READ after
    parsing.
  */
  if (static_cast<int>(lock_type) < static_cast<int>(TL_WRITE_ALLOW_WRITE))
    return;

  switch (lex->sql_command) {
  /*
    Basic INSERT. If there is an additional ON DUPLIATE KEY UPDATE
    clause, it will be handled later in this method.
  */
  case SQLCOM_INSERT:                           /* fall through */
  case SQLCOM_INSERT_SELECT:
  /*
    LOAD DATA ... INFILE is expected to fire BEFORE/AFTER INSERT
    triggers.
    If the statement also has REPLACE clause, it will be
    handled later in this method.
  */
  case SQLCOM_LOAD:                             /* fall through */
  /*
    REPLACE is semantically equivalent to INSERT. In case
    of a primary or unique key conflict, it deletes the old
    record and inserts a new one. So we also may need to
    fire ON DELETE triggers. This functionality is handled
    later in this method.
  */
  case SQLCOM_REPLACE:                          /* fall through */
  case SQLCOM_REPLACE_SELECT:
  /*
    CREATE TABLE ... SELECT defaults to INSERT if the table or
    view already exists. REPLACE option of CREATE TABLE ...
    REPLACE SELECT is handled later in this method.
  */
  case SQLCOM_CREATE_TABLE:
    trg_event= TRG_EVENT_INSERT;
    break;
  /* Basic update and multi-update */
  case SQLCOM_UPDATE:                           /* fall through */
  case SQLCOM_UPDATE_MULTI:
    trg_event= TRG_EVENT_UPDATE;
    break;
  /* Basic delete and multi-delete */
  case SQLCOM_DELETE:                           /* fall through */
  case SQLCOM_DELETE_MULTI:
    trg_event= TRG_EVENT_DELETE;
    break;
  default:
    /*
      OK to return, since value of 'duplicates' is irrelevant
      for non-updating commands.
    */
    return;
  }
  trg_event_map|= static_cast<uint8>(1 << static_cast<int>(trg_event));

  switch (lex->duplicates) {
  case DUP_UPDATE:
    trg_event= TRG_EVENT_UPDATE;
    break;
  case DUP_REPLACE:
    trg_event= TRG_EVENT_DELETE;
    break;
  case DUP_ERROR:
  default:
    return;
  }
  trg_event_map|= static_cast<uint8>(1 << static_cast<int>(trg_event));
}


unknown's avatar
VIEW  
unknown committed
2986 2987 2988 2989
/*
  calculate md5 of query

  SYNOPSIS
2990
    TABLE_LIST::calc_md5()
unknown's avatar
VIEW  
unknown committed
2991 2992
    buffer	buffer for md5 writing
*/
2993

2994
void  TABLE_LIST::calc_md5(char *buffer)
unknown's avatar
VIEW  
unknown committed
2995 2996
{
  my_MD5_CTX context;
2997 2998
  uchar digest[16];
  my_MD5Init(&context);
unknown's avatar
unknown committed
2999
  my_MD5Update(&context,(uchar *) select_stmt.str, select_stmt.length);
3000
  my_MD5Final(digest, &context);
unknown's avatar
VIEW  
unknown committed
3001 3002 3003 3004 3005 3006 3007 3008 3009 3010
  sprintf((char *) buffer,
	    "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
	    digest[0], digest[1], digest[2], digest[3],
	    digest[4], digest[5], digest[6], digest[7],
	    digest[8], digest[9], digest[10], digest[11],
	    digest[12], digest[13], digest[14], digest[15]);
}


/*
3011
  set underlying TABLE for table place holder of VIEW
unknown's avatar
VIEW  
unknown committed
3012

unknown's avatar
unknown committed
3013 3014 3015
  DESCRIPTION
    Replace all views that only uses one table with the table itself.
    This allows us to treat the view as a simple table and even update
3016
    it (it is a kind of optimisation)
unknown's avatar
unknown committed
3017

unknown's avatar
VIEW  
unknown committed
3018
  SYNOPSIS
3019
    TABLE_LIST::set_underlying_merge()
unknown's avatar
VIEW  
unknown committed
3020
*/
3021

3022
void TABLE_LIST::set_underlying_merge()
unknown's avatar
VIEW  
unknown committed
3023
{
unknown's avatar
unknown committed
3024 3025
  TABLE_LIST *tbl;

3026
  if ((tbl= merge_underlying_list))
unknown's avatar
merge  
unknown committed
3027
  {
unknown's avatar
unknown committed
3028
    /* This is a view. Process all tables of view */
3029
    DBUG_ASSERT(view && effective_algorithm == VIEW_ALGORITHM_MERGE);
unknown's avatar
unknown committed
3030 3031
    do
    {
3032
      if (tbl->merge_underlying_list)          // This is a view
unknown's avatar
unknown committed
3033
      {
3034 3035
        DBUG_ASSERT(tbl->view &&
                    tbl->effective_algorithm == VIEW_ALGORITHM_MERGE);
unknown's avatar
unknown committed
3036 3037 3038 3039
        /*
          This is the only case where set_ancestor is called on an object
          that may not be a view (in which case ancestor is 0)
        */
3040
        tbl->merge_underlying_list->set_underlying_merge();
unknown's avatar
unknown committed
3041 3042 3043
      }
    } while ((tbl= tbl->next_local));

unknown's avatar
unknown committed
3044
    if (!multitable_view)
unknown's avatar
unknown committed
3045
    {
3046 3047
      table= merge_underlying_list->table;
      schema_table= merge_underlying_list->schema_table;
unknown's avatar
unknown committed
3048
    }
unknown's avatar
merge  
unknown committed
3049
  }
3050 3051 3052
}


unknown's avatar
VIEW  
unknown committed
3053 3054 3055 3056
/*
  setup fields of placeholder of merged VIEW

  SYNOPSIS
3057
    TABLE_LIST::setup_underlying()
3058
    thd		    - thread handler
3059

3060 3061
  DESCRIPTION
    It is:
3062
    - preparing translation table for view columns
3063 3064
    If there are underlying view(s) procedure first will be called for them.

unknown's avatar
VIEW  
unknown committed
3065
  RETURN
unknown's avatar
unknown committed
3066 3067
    FALSE - OK
    TRUE  - error
unknown's avatar
VIEW  
unknown committed
3068
*/
3069

3070
bool TABLE_LIST::setup_underlying(THD *thd)
unknown's avatar
VIEW  
unknown committed
3071
{
3072
  DBUG_ENTER("TABLE_LIST::setup_underlying");
3073 3074

  if (!field_translation && merge_underlying_list)
3075
  {
3076 3077 3078 3079 3080 3081 3082
    Field_translator *transl;
    SELECT_LEX *select= &view->select_lex;
    Item *item;
    TABLE_LIST *tbl;
    List_iterator_fast<Item> it(select->item_list);
    uint field_count= 0;

3083
    if (check_stack_overrun(thd, STACK_MIN_SIZE, (uchar*) &field_count))
3084
    {
unknown's avatar
unknown committed
3085
      DBUG_RETURN(TRUE);
3086
    }
unknown's avatar
VIEW  
unknown committed
3087

3088
    for (tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3089
    {
3090 3091
      if (tbl->merge_underlying_list &&
          tbl->setup_underlying(thd))
3092 3093 3094 3095
      {
        DBUG_RETURN(TRUE);
      }
    }
unknown's avatar
unknown committed
3096

3097 3098 3099
    /* Create view fields translation table */

    if (!(transl=
unknown's avatar
unknown committed
3100
          (Field_translator*)(thd->stmt_arena->
3101 3102
                              alloc(select->item_list.elements *
                                    sizeof(Field_translator)))))
unknown's avatar
VIEW  
unknown committed
3103
    {
3104
      DBUG_RETURN(TRUE);
3105
    }
3106 3107

    while ((item= it++))
3108
    {
3109 3110
      transl[field_count].name= item->name;
      transl[field_count++].item= item;
3111
    }
3112 3113 3114
    field_translation= transl;
    field_translation_end= transl + field_count;
    /* TODO: use hash for big number of fields */
3115

3116 3117
    /* full text function moving to current select */
    if (view->select_lex.ftfunc_list->elements)
3118
    {
3119 3120 3121 3122 3123 3124
      Item_func_match *ifm;
      SELECT_LEX *current_select= thd->lex->current_select;
      List_iterator_fast<Item_func_match>
        li(*(view->select_lex.ftfunc_list));
      while ((ifm= li++))
        current_select->ftfunc_list->push_front(ifm);
unknown's avatar
VIEW  
unknown committed
3125 3126
    }
  }
3127 3128
  DBUG_RETURN(FALSE);
}
unknown's avatar
VIEW  
unknown committed
3129

unknown's avatar
unknown committed
3130

3131 3132
/*
  Prepare where expression of view
3133

3134
  SYNOPSIS
3135
    TABLE_LIST::prep_where()
3136 3137 3138 3139
    thd             - thread handler
    conds           - condition of this JOIN
    no_where_clause - do not build WHERE or ON outer qwery do not need it
                      (it is INSERT), we do not need conds if this flag is set
unknown's avatar
unknown committed
3140

3141 3142
  NOTE: have to be called befor CHECK OPTION preparation, because it makes
  fix_fields for view WHERE clause
unknown's avatar
VIEW  
unknown committed
3143

3144 3145 3146 3147
  RETURN
    FALSE - OK
    TRUE  - error
*/
unknown's avatar
VIEW  
unknown committed
3148

3149
bool TABLE_LIST::prep_where(THD *thd, Item **conds,
3150 3151
                               bool no_where_clause)
{
3152
  DBUG_ENTER("TABLE_LIST::prep_where");
3153

3154
  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3155
  {
3156 3157 3158 3159
    if (tbl->view && tbl->prep_where(thd, conds, no_where_clause))
    {
      DBUG_RETURN(TRUE);
    }
3160
  }
3161

3162 3163 3164
  if (where)
  {
    if (!where->fixed && where->fix_fields(thd, &where))
unknown's avatar
VIEW  
unknown committed
3165
    {
3166
      DBUG_RETURN(TRUE);
unknown's avatar
VIEW  
unknown committed
3167
    }
unknown's avatar
unknown committed
3168 3169 3170 3171 3172

    /*
      check that it is not VIEW in which we insert with INSERT SELECT
      (in this case we can't add view WHERE condition to main SELECT_LEX)
    */
3173
    if (!no_where_clause && !where_processed)
unknown's avatar
VIEW  
unknown committed
3174
    {
3175
      TABLE_LIST *tbl= this;
unknown's avatar
unknown committed
3176 3177
      Query_arena *arena= thd->stmt_arena, backup;
      arena= thd->activate_stmt_arena_if_needed(&backup);  // For easier test
3178

unknown's avatar
unknown committed
3179 3180
      /* Go up to join tree and try to find left join */
      for (; tbl; tbl= tbl->embedding)
unknown's avatar
unknown committed
3181
      {
unknown's avatar
unknown committed
3182 3183 3184 3185
        if (tbl->outer_join)
        {
          /*
            Store WHERE condition to ON expression for outer join, because
3186
            we can't use WHERE to correctly execute left joins on VIEWs and
unknown's avatar
unknown committed
3187 3188 3189
            this expression will not be moved to WHERE condition (i.e. will
            be clean correctly for PS/SP)
          */
3190 3191
          tbl->on_expr= and_conds(tbl->on_expr,
                                  where->copy_andor_structure(thd));
unknown's avatar
unknown committed
3192 3193
          break;
        }
unknown's avatar
unknown committed
3194
      }
unknown's avatar
unknown committed
3195
      if (tbl == 0)
3196
        *conds= and_conds(*conds, where->copy_andor_structure(thd));
3197
      if (arena)
unknown's avatar
unknown committed
3198
        thd->restore_active_arena(arena, &backup);
3199
      where_processed= TRUE;
unknown's avatar
VIEW  
unknown committed
3200 3201
    }
  }
3202

3203 3204 3205 3206
  DBUG_RETURN(FALSE);
}


unknown's avatar
unknown committed
3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247
/*
  Merge ON expressions for a view

  SYNOPSIS
    merge_on_conds()
    thd             thread handle
    table           table for the VIEW
    is_cascaded     TRUE <=> merge ON expressions from underlying views

  DESCRIPTION
    This function returns the result of ANDing the ON expressions
    of the given view and all underlying views. The ON expressions
    of the underlying views are added only if is_cascaded is TRUE.

  RETURN
    Pointer to the built expression if there is any.
    Otherwise and in the case of a failure NULL is returned.
*/

static Item *
merge_on_conds(THD *thd, TABLE_LIST *table, bool is_cascaded)
{
  DBUG_ENTER("merge_on_conds");

  Item *cond= NULL;
  DBUG_PRINT("info", ("alias: %s", table->alias));
  if (table->on_expr)
    cond= table->on_expr->copy_andor_structure(thd);
  if (!table->nested_join)
    DBUG_RETURN(cond);
  List_iterator<TABLE_LIST> li(table->nested_join->join_list);
  while (TABLE_LIST *tbl= li++)
  {
    if (tbl->view && !is_cascaded)
      continue;
    cond= and_conds(cond, merge_on_conds(thd, tbl, is_cascaded));
  }
  DBUG_RETURN(cond);
}


3248 3249 3250 3251
/*
  Prepare check option expression of table

  SYNOPSIS
3252
    TABLE_LIST::prep_check_option()
3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263
    thd             - thread handler
    check_opt_type  - WITH CHECK OPTION type (VIEW_CHECK_NONE,
                      VIEW_CHECK_LOCAL, VIEW_CHECK_CASCADED)
                      we use this parameter instead of direct check of
                      effective_with_check to change type of underlying
                      views to VIEW_CHECK_CASCADED if outer view have
                      such option and prevent processing of underlying
                      view check options if outer view have just
                      VIEW_CHECK_LOCAL option.

  NOTE
unknown's avatar
unknown committed
3264 3265
    This method builds check option condition to use it later on
    every call (usual execution or every SP/PS call).
3266
    This method have to be called after WHERE preparation
3267
    (TABLE_LIST::prep_where)
unknown's avatar
VIEW  
unknown committed
3268

3269 3270 3271 3272 3273
  RETURN
    FALSE - OK
    TRUE  - error
*/

3274
bool TABLE_LIST::prep_check_option(THD *thd, uint8 check_opt_type)
3275
{
3276
  DBUG_ENTER("TABLE_LIST::prep_check_option");
unknown's avatar
unknown committed
3277
  bool is_cascaded= check_opt_type == VIEW_CHECK_CASCADED;
3278

3279
  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3280
  {
3281
    /* see comment of check_opt_type parameter */
unknown's avatar
unknown committed
3282 3283 3284
    if (tbl->view && tbl->prep_check_option(thd, (is_cascaded ?
                                                  VIEW_CHECK_CASCADED :
                                                  VIEW_CHECK_NONE)))
3285
      DBUG_RETURN(TRUE);
3286
  }
unknown's avatar
VIEW  
unknown committed
3287

unknown's avatar
unknown committed
3288
  if (check_opt_type && !check_option_processed)
3289
  {
unknown's avatar
unknown committed
3290 3291 3292
    Query_arena *arena= thd->stmt_arena, backup;
    arena= thd->activate_stmt_arena_if_needed(&backup);  // For easier test

3293 3294 3295
    if (where)
    {
      DBUG_ASSERT(where->fixed);
unknown's avatar
unknown committed
3296
      check_option= where->copy_andor_structure(thd);
3297
    }
unknown's avatar
unknown committed
3298
    if (is_cascaded)
3299
    {
3300
      for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3301 3302
      {
        if (tbl->check_option)
unknown's avatar
unknown committed
3303
          check_option= and_conds(check_option, tbl->check_option);
3304 3305
      }
    }
unknown's avatar
unknown committed
3306 3307 3308 3309 3310 3311 3312
    check_option= and_conds(check_option,
                            merge_on_conds(thd, this, is_cascaded));

    if (arena)
      thd->restore_active_arena(arena, &backup);
    check_option_processed= TRUE;

3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325
  }

  if (check_option)
  {
    const char *save_where= thd->where;
    thd->where= "check option";
    if (!check_option->fixed &&
        check_option->fix_fields(thd, &check_option) ||
        check_option->check_cols(1))
    {
      DBUG_RETURN(TRUE);
    }
    thd->where= save_where;
3326
  }
3327 3328 3329
  DBUG_RETURN(FALSE);
}

3330

3331 3332 3333 3334
/*
  Hide errors which show view underlying table information

  SYNOPSIS
3335
    TABLE_LIST::hide_view_error()
3336
    thd     thread handler
unknown's avatar
VIEW  
unknown committed
3337

3338 3339
*/

3340
void TABLE_LIST::hide_view_error(THD *thd)
3341
{
3342 3343
  /* Hide "Unknown column" or "Unknown function" error */
  if (thd->net.last_errno == ER_BAD_FIELD_ERROR ||
3344 3345
      thd->net.last_errno == ER_SP_DOES_NOT_EXIST ||
      thd->net.last_errno == ER_PROCACCESS_DENIED_ERROR ||
3346
      thd->net.last_errno == ER_COLUMNACCESS_DENIED_ERROR ||
3347 3348 3349
      thd->net.last_errno == ER_TABLEACCESS_DENIED_ERROR ||
      thd->net.last_errno == ER_TABLE_NOT_LOCKED ||
      thd->net.last_errno == ER_NO_SUCH_TABLE)
3350
  {
3351
    TABLE_LIST *top= top_table();
3352
    thd->clear_error(); 
3353
    my_error(ER_VIEW_INVALID, MYF(0), top->view_db.str, top->view_name.str);
3354
  }
3355 3356
  else if (thd->net.last_errno == ER_NO_DEFAULT_FOR_FIELD)
  {
3357
    TABLE_LIST *top= top_table();
3358 3359
    thd->clear_error();
    // TODO: make correct error message
3360 3361
    my_error(ER_NO_DEFAULT_FOR_VIEW_FIELD, MYF(0),
             top->view_db.str, top->view_name.str);
3362
  }
unknown's avatar
VIEW  
unknown committed
3363 3364 3365
}


3366 3367 3368 3369 3370
/*
  Find underlying base tables (TABLE_LIST) which represent given
  table_to_find (TABLE)

  SYNOPSIS
3371
    TABLE_LIST::find_underlying_table()
3372 3373 3374 3375 3376 3377 3378
    table_to_find table to find

  RETURN
    0  table is not found
    found table reference
*/

3379
TABLE_LIST *TABLE_LIST::find_underlying_table(TABLE *table_to_find)
3380 3381
{
  /* is this real table and table which we are looking for? */
3382
  if (table == table_to_find && merge_underlying_list == 0)
3383 3384
    return this;

3385
  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3386 3387 3388 3389 3390 3391 3392 3393
  {
    TABLE_LIST *result;
    if ((result= tbl->find_underlying_table(table_to_find)))
      return result;
  }
  return 0;
}

unknown's avatar
unknown committed
3394 3395 3396 3397
/*
  cleunup items belonged to view fields translation table

  SYNOPSIS
3398
    TABLE_LIST::cleanup_items()
unknown's avatar
unknown committed
3399 3400
*/

3401
void TABLE_LIST::cleanup_items()
unknown's avatar
unknown committed
3402 3403 3404 3405
{
  if (!field_translation)
    return;

3406 3407 3408
  for (Field_translator *transl= field_translation;
       transl < field_translation_end;
       transl++)
3409
    transl->item->walk(&Item::cleanup_processor, 0, 0);
unknown's avatar
unknown committed
3410 3411 3412
}


unknown's avatar
unknown committed
3413 3414 3415 3416
/*
  check CHECK OPTION condition

  SYNOPSIS
3417
    TABLE_LIST::view_check_option()
unknown's avatar
unknown committed
3418 3419 3420 3421 3422 3423 3424 3425
    ignore_failure ignore check option fail

  RETURN
    VIEW_CHECK_OK     OK
    VIEW_CHECK_ERROR  FAILED
    VIEW_CHECK_SKIP   FAILED, but continue
*/

3426
int TABLE_LIST::view_check_option(THD *thd, bool ignore_failure)
unknown's avatar
unknown committed
3427 3428 3429
{
  if (check_option && check_option->val_int() == 0)
  {
3430
    TABLE_LIST *main_view= top_table();
unknown's avatar
unknown committed
3431 3432 3433 3434
    if (ignore_failure)
    {
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                          ER_VIEW_CHECK_FAILED, ER(ER_VIEW_CHECK_FAILED),
3435
                          main_view->view_db.str, main_view->view_name.str);
unknown's avatar
unknown committed
3436 3437
      return(VIEW_CHECK_SKIP);
    }
3438 3439 3440
    my_error(ER_VIEW_CHECK_FAILED, MYF(0), main_view->view_db.str,
             main_view->view_name.str);
    return(VIEW_CHECK_ERROR);
unknown's avatar
unknown committed
3441 3442 3443 3444 3445
  }
  return(VIEW_CHECK_OK);
}


3446
/*
3447
  Find table in underlying tables by mask and check that only this
unknown's avatar
unknown committed
3448
  table belong to given mask
3449 3450

  SYNOPSIS
3451
    TABLE_LIST::check_single_table()
3452
    table_arg	reference on variable where to store found table
3453 3454 3455
		(should be 0 on call, to find table, or point to table for
		unique test)
    map         bit mask of tables
3456
    view_arg    view for which we are looking table
3457 3458

  RETURN
unknown's avatar
unknown committed
3459 3460
    FALSE table not found or found only one
    TRUE  found several tables
3461 3462
*/

3463
bool TABLE_LIST::check_single_table(TABLE_LIST **table_arg,
3464
                                       table_map map,
3465
                                       TABLE_LIST *view_arg)
3466
{
3467
  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3468 3469 3470 3471 3472
  {
    if (tbl->table)
    {
      if (tbl->table->map & map)
      {
3473
	if (*table_arg)
unknown's avatar
unknown committed
3474
	  return TRUE;
3475 3476
        *table_arg= tbl;
        tbl->check_option= view_arg->check_option;
3477 3478
      }
    }
3479
    else if (tbl->check_single_table(table_arg, map, view_arg))
unknown's avatar
unknown committed
3480
      return TRUE;
3481
  }
unknown's avatar
unknown committed
3482
  return FALSE;
3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497
}


/*
  Set insert_values buffer

  SYNOPSIS
    set_insert_values()
    mem_root   memory pool for allocating

  RETURN
    FALSE - OK
    TRUE  - out of memory
*/

3498
bool TABLE_LIST::set_insert_values(MEM_ROOT *mem_root)
3499 3500 3501 3502
{
  if (table)
  {
    if (!table->insert_values &&
3503
        !(table->insert_values= (uchar *)alloc_root(mem_root,
3504
                                                   table->s->rec_buff_length)))
3505 3506 3507 3508
      return TRUE;
  }
  else
  {
3509 3510
    DBUG_ASSERT(view && merge_underlying_list);
    for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3511 3512 3513 3514 3515 3516 3517
      if (tbl->set_insert_values(mem_root))
        return TRUE;
  }
  return FALSE;
}


unknown's avatar
unknown committed
3518 3519 3520 3521
/*
  Test if this is a leaf with respect to name resolution.

  SYNOPSIS
3522
    TABLE_LIST::is_leaf_for_name_resolution()
unknown's avatar
unknown committed
3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533

  DESCRIPTION
    A table reference is a leaf with respect to name resolution if
    it is either a leaf node in a nested join tree (table, view,
    schema table, subquery), or an inner node that represents a
    NATURAL/USING join, or a nested join with materialized join
    columns.

  RETURN
    TRUE if a leaf, FALSE otherwise.
*/
3534
bool TABLE_LIST::is_leaf_for_name_resolution()
unknown's avatar
unknown committed
3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545
{
  return (view || is_natural_join || is_join_columns_complete ||
          !nested_join);
}


/*
  Retrieve the first (left-most) leaf in a nested join tree with
  respect to name resolution.

  SYNOPSIS
3546
    TABLE_LIST::first_leaf_for_name_resolution()
unknown's avatar
unknown committed
3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558

  DESCRIPTION
    Given that 'this' is a nested table reference, recursively walk
    down the left-most children of 'this' until we reach a leaf
    table reference with respect to name resolution.

  IMPLEMENTATION
    The left-most child of a nested table reference is the last element
    in the list of children because the children are inserted in
    reverse order.

  RETURN
3559
    If 'this' is a nested table reference - the left-most child of
unknown's avatar
unknown committed
3560
      the tree rooted in 'this',
3561
    else return 'this'
unknown's avatar
unknown committed
3562 3563
*/

3564
TABLE_LIST *TABLE_LIST::first_leaf_for_name_resolution()
unknown's avatar
unknown committed
3565
{
3566 3567 3568
  TABLE_LIST *cur_table_ref;
  NESTED_JOIN *cur_nested_join;
  LINT_INIT(cur_table_ref);
unknown's avatar
unknown committed
3569

3570
  if (is_leaf_for_name_resolution())
unknown's avatar
unknown committed
3571
    return this;
3572
  DBUG_ASSERT(nested_join);
unknown's avatar
unknown committed
3573

3574 3575 3576
  for (cur_nested_join= nested_join;
       cur_nested_join;
       cur_nested_join= cur_table_ref->nested_join)
unknown's avatar
unknown committed
3577 3578 3579 3580
  {
    List_iterator_fast<TABLE_LIST> it(cur_nested_join->join_list);
    cur_table_ref= it++;
    /*
3581 3582 3583 3584
      If the current nested join is a RIGHT JOIN, the operands in
      'join_list' are in reverse order, thus the first operand is
      already at the front of the list. Otherwise the first operand
      is in the end of the list of join operands.
unknown's avatar
unknown committed
3585 3586 3587
    */
    if (!(cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
    {
3588
      TABLE_LIST *next;
unknown's avatar
unknown committed
3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603
      while ((next= it++))
        cur_table_ref= next;
    }
    if (cur_table_ref->is_leaf_for_name_resolution())
      break;
  }
  return cur_table_ref;
}


/*
  Retrieve the last (right-most) leaf in a nested join tree with
  respect to name resolution.

  SYNOPSIS
3604
    TABLE_LIST::last_leaf_for_name_resolution()
unknown's avatar
unknown committed
3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621

  DESCRIPTION
    Given that 'this' is a nested table reference, recursively walk
    down the right-most children of 'this' until we reach a leaf
    table reference with respect to name resolution.

  IMPLEMENTATION
    The right-most child of a nested table reference is the first
    element in the list of children because the children are inserted
    in reverse order.

  RETURN
    - If 'this' is a nested table reference - the right-most child of
      the tree rooted in 'this',
    - else - 'this'
*/

3622
TABLE_LIST *TABLE_LIST::last_leaf_for_name_resolution()
unknown's avatar
unknown committed
3623 3624
{
  TABLE_LIST *cur_table_ref= this;
3625
  NESTED_JOIN *cur_nested_join;
unknown's avatar
unknown committed
3626

3627
  if (is_leaf_for_name_resolution())
unknown's avatar
unknown committed
3628
    return this;
3629
  DBUG_ASSERT(nested_join);
unknown's avatar
unknown committed
3630

3631 3632 3633
  for (cur_nested_join= nested_join;
       cur_nested_join;
       cur_nested_join= cur_table_ref->nested_join)
unknown's avatar
unknown committed
3634
  {
3635
    cur_table_ref= cur_nested_join->join_list.head();
unknown's avatar
unknown committed
3636
    /*
3637 3638 3639
      If the current nested is a RIGHT JOIN, the operands in
      'join_list' are in reverse order, thus the last operand is in the
      end of the list.
unknown's avatar
unknown committed
3640 3641 3642 3643
    */
    if ((cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
    {
      List_iterator_fast<TABLE_LIST> it(cur_nested_join->join_list);
3644
      TABLE_LIST *next;
unknown's avatar
unknown committed
3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655
      cur_table_ref= it++;
      while ((next= it++))
        cur_table_ref= next;
    }
    if (cur_table_ref->is_leaf_for_name_resolution())
      break;
  }
  return cur_table_ref;
}


3656 3657 3658 3659 3660 3661 3662 3663
/*
  Register access mode which we need for underlying tables

  SYNOPSIS
    register_want_access()
    want_access          Acess which we require
*/

3664
void TABLE_LIST::register_want_access(ulong want_access)
3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679
{
  /* Remove SHOW_VIEW_ACL, because it will be checked during making view */
  want_access&= ~SHOW_VIEW_ACL;
  if (belong_to_view)
  {
    grant.want_privilege= want_access;
    if (table)
      table->grant.want_privilege= want_access;
  }
  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
    tbl->register_want_access(want_access);
}


/*
unknown's avatar
unknown committed
3680
  Load security context information for this view
3681 3682

  SYNOPSIS
3683
    TABLE_LIST::prepare_view_securety_context()
3684 3685 3686 3687 3688 3689 3690 3691
    thd                  [in] thread handler

  RETURN
    FALSE  OK
    TRUE   Error
*/

#ifndef NO_EMBEDDED_ACCESS_CHECKS
3692
bool TABLE_LIST::prepare_view_securety_context(THD *thd)
3693
{
3694
  DBUG_ENTER("TABLE_LIST::prepare_view_securety_context");
3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707
  DBUG_PRINT("enter", ("table: %s", alias));

  DBUG_ASSERT(!prelocking_placeholder && view);
  if (view_suid)
  {
    DBUG_PRINT("info", ("This table is suid view => load contest"));
    DBUG_ASSERT(view && view_sctx);
    if (acl_getroot_no_password(view_sctx,
                                definer.user.str,
                                definer.host.str,
                                definer.host.str,
                                thd->db))
    {
3708 3709
      if ((thd->lex->sql_command == SQLCOM_SHOW_CREATE) ||
          (thd->lex->sql_command == SQLCOM_SHOW_FIELDS))
3710 3711 3712 3713 3714 3715 3716 3717
      {
        push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, 
                            ER_NO_SUCH_USER, 
                            ER(ER_NO_SUCH_USER),
                            definer.user.str, definer.host.str);
      }
      else
      {
3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729
        if (thd->security_ctx->master_access & SUPER_ACL)
        {
          my_error(ER_NO_SUCH_USER, MYF(0), definer.user.str, definer.host.str);

        }
        else
        {
           my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
                    thd->security_ctx->priv_user,
                    thd->security_ctx->priv_host,
                    (thd->password ?  ER(ER_YES) : ER(ER_NO)));
        }
3730 3731
        DBUG_RETURN(TRUE);
      }
3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742
    }
  }
  DBUG_RETURN(FALSE);
}
#endif


/*
  Find security context of current view

  SYNOPSIS
3743
    TABLE_LIST::find_view_security_context()
3744 3745 3746 3747 3748
    thd                  [in] thread handler

*/

#ifndef NO_EMBEDDED_ACCESS_CHECKS
3749
Security_context *TABLE_LIST::find_view_security_context(THD *thd)
3750 3751 3752
{
  Security_context *sctx;
  TABLE_LIST *upper_view= this;
3753
  DBUG_ENTER("TABLE_LIST::find_view_security_context");
3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781

  DBUG_ASSERT(view);
  while (upper_view && !upper_view->view_suid)
  {
    DBUG_ASSERT(!upper_view->prelocking_placeholder);
    upper_view= upper_view->referencing_view;
  }
  if (upper_view)
  {
    DBUG_PRINT("info", ("Securety context of view %s will be used",
                        upper_view->alias));
    sctx= upper_view->view_sctx;
    DBUG_ASSERT(sctx);
  }
  else
  {
    DBUG_PRINT("info", ("Current global context will be used"));
    sctx= thd->security_ctx;
  }
  DBUG_RETURN(sctx);
}
#endif


/*
  Prepare security context and load underlying tables priveleges for view

  SYNOPSIS
3782
    TABLE_LIST::prepare_security()
3783 3784 3785 3786 3787 3788 3789
    thd                  [in] thread handler

  RETURN
    FALSE  OK
    TRUE   Error
*/

3790
bool TABLE_LIST::prepare_security(THD *thd)
3791 3792 3793
{
  List_iterator_fast<TABLE_LIST> tb(*view_tables);
  TABLE_LIST *tbl;
3794
  DBUG_ENTER("TABLE_LIST::prepare_security");
3795 3796 3797 3798 3799 3800 3801 3802 3803 3804
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  Security_context *save_security_ctx= thd->security_ctx;

  DBUG_ASSERT(!prelocking_placeholder);
  if (prepare_view_securety_context(thd))
    DBUG_RETURN(TRUE);
  thd->security_ctx= find_view_security_context(thd);
  while ((tbl= tb++))
  {
    DBUG_ASSERT(tbl->referencing_view);
3805
    char *local_db, *local_table_name;
3806 3807
    if (tbl->view)
    {
3808 3809
      local_db= tbl->view_db.str;
      local_table_name= tbl->view_name.str;
3810 3811 3812
    }
    else
    {
3813 3814
      local_db= tbl->db;
      local_table_name= tbl->table_name;
3815
    }
3816 3817
    fill_effective_table_privileges(thd, &tbl->grant, local_db,
                                    local_table_name);
3818 3819 3820 3821 3822 3823 3824 3825
    if (tbl->table)
      tbl->table->grant= grant;
  }
  thd->security_ctx= save_security_ctx;
#else
  while ((tbl= tb++))
    tbl->grant.privilege= ~NO_ACCESS;
#endif
unknown's avatar
unknown committed
3826
  DBUG_RETURN(FALSE);
3827 3828 3829
}


unknown's avatar
unknown committed
3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842 3843
Natural_join_column::Natural_join_column(Field_translator *field_param,
                                         TABLE_LIST *tab)
{
  DBUG_ASSERT(tab->field_translation);
  view_field= field_param;
  table_field= NULL;
  table_ref= tab;
  is_common= FALSE;
}


Natural_join_column::Natural_join_column(Field *field_param,
                                         TABLE_LIST *tab)
{
3844
  DBUG_ASSERT(tab->table == field_param->table);
unknown's avatar
unknown committed
3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858
  table_field= field_param;
  view_field= NULL;
  table_ref= tab;
  is_common= FALSE;
}


const char *Natural_join_column::name()
{
  if (view_field)
  {
    DBUG_ASSERT(table_field == NULL);
    return view_field->name;
  }
3859 3860

  return table_field->field_name;
unknown's avatar
unknown committed
3861 3862 3863 3864 3865 3866 3867 3868
}


Item *Natural_join_column::create_item(THD *thd)
{
  if (view_field)
  {
    DBUG_ASSERT(table_field == NULL);
3869 3870
    return create_view_field(thd, table_ref, &view_field->item,
                             view_field->name);
unknown's avatar
unknown committed
3871
  }
3872
  return new Item_field(thd, &thd->lex->current_select->context, table_field);
unknown's avatar
unknown committed
3873 3874 3875 3876 3877 3878 3879 3880 3881 3882
}


Field *Natural_join_column::field()
{
  if (view_field)
  {
    DBUG_ASSERT(table_field == NULL);
    return NULL;
  }
3883
  return table_field;
unknown's avatar
unknown committed
3884 3885 3886 3887 3888
}


const char *Natural_join_column::table_name()
{
3889
  DBUG_ASSERT(table_ref);
unknown's avatar
unknown committed
3890 3891 3892 3893 3894 3895 3896 3897
  return table_ref->alias;
}


const char *Natural_join_column::db_name()
{
  if (view_field)
    return table_ref->view_db.str;
3898

3899 3900 3901 3902 3903
  /*
    Test that TABLE_LIST::db is the same as st_table_share::db to
    ensure consistency. An exception are I_S schema tables, which
    are inconsistent in this respect.
  */
3904
  DBUG_ASSERT(!strcmp(table_ref->db,
3905
                      table_ref->table->s->db.str) ||
3906
              (table_ref->schema_table &&
3907
               table_ref->table->s->db.str[0] == 0));
3908
  return table_ref->db;
unknown's avatar
unknown committed
3909 3910 3911 3912 3913 3914 3915
}


GRANT_INFO *Natural_join_column::grant()
{
  if (view_field)
    return &(table_ref->grant);
3916
  return &(table_ref->table->grant);
unknown's avatar
unknown committed
3917 3918 3919
}


unknown's avatar
VIEW  
unknown committed
3920 3921
void Field_iterator_view::set(TABLE_LIST *table)
{
unknown's avatar
unknown committed
3922
  DBUG_ASSERT(table->field_translation);
3923
  view= table;
unknown's avatar
VIEW  
unknown committed
3924
  ptr= table->field_translation;
3925
  array_end= table->field_translation_end;
unknown's avatar
VIEW  
unknown committed
3926 3927 3928 3929 3930 3931 3932 3933 3934
}


const char *Field_iterator_table::name()
{
  return (*ptr)->field_name;
}


3935
Item *Field_iterator_table::create_item(THD *thd)
unknown's avatar
VIEW  
unknown committed
3936
{
3937 3938 3939 3940 3941 3942 3943 3944 3945 3946
  SELECT_LEX *select= thd->lex->current_select;

  Item_field *item= new Item_field(thd, &select->context, *ptr);
  if (item && thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
      !thd->lex->in_sum_func && select->cur_pos_in_select_list != UNDEF_POS)
  {
    select->non_agg_fields.push_back(item);
    item->marker= select->cur_pos_in_select_list;
  }
  return item;
unknown's avatar
VIEW  
unknown committed
3947 3948 3949 3950 3951
}


const char *Field_iterator_view::name()
{
3952
  return ptr->name;
unknown's avatar
VIEW  
unknown committed
3953 3954 3955
}


3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970
Item *Field_iterator_view::create_item(THD *thd)
{
  return create_view_field(thd, view, &ptr->item, ptr->name);
}

Item *create_view_field(THD *thd, TABLE_LIST *view, Item **field_ref,
                        const char *name)
{
  bool save_wrapper= thd->lex->select_lex.no_wrap_view_item;
  Item *field= *field_ref;
  DBUG_ENTER("create_view_field");

  if (view->schema_table_reformed)
  {
    /*
3971 3972 3973
      Translation table items are always Item_fields and already fixed
      ('mysql_schema_table' function). So we can return directly the
      field. This case happens only for 'show & where' commands.
3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990
    */
    DBUG_ASSERT(field && field->fixed);
    DBUG_RETURN(field);
  }

  DBUG_ASSERT(field);
  thd->lex->current_select->no_wrap_view_item= TRUE;
  if (!field->fixed)
  {
    if (field->fix_fields(thd, field_ref))
    {
      thd->lex->current_select->no_wrap_view_item= save_wrapper;
      DBUG_RETURN(0);
    }
    field= *field_ref;
  }
  thd->lex->current_select->no_wrap_view_item= save_wrapper;
3991
  if (save_wrapper)
3992 3993 3994 3995
  {
    DBUG_RETURN(field);
  }
  Item *item= new Item_direct_view_ref(&view->view->select_lex.context,
3996
                                       field_ref, view->alias,
3997 3998 3999 4000 4001
                                       name);
  DBUG_RETURN(item);
}


unknown's avatar
unknown committed
4002 4003 4004
void Field_iterator_natural_join::set(TABLE_LIST *table_ref)
{
  DBUG_ASSERT(table_ref->join_columns);
4005 4006
  column_ref_it.init(*(table_ref->join_columns));
  cur_column_ref= column_ref_it++;
unknown's avatar
unknown committed
4007 4008 4009
}


4010 4011
void Field_iterator_natural_join::next()
{
4012
  cur_column_ref= column_ref_it++;
4013 4014 4015
  DBUG_ASSERT(!cur_column_ref || ! cur_column_ref->table_field ||
              cur_column_ref->table_ref->table ==
              cur_column_ref->table_field->table);
4016 4017 4018
}


unknown's avatar
unknown committed
4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045
void Field_iterator_table_ref::set_field_iterator()
{
  DBUG_ENTER("Field_iterator_table_ref::set_field_iterator");
  /*
    If the table reference we are iterating over is a natural join, or it is
    an operand of a natural join, and TABLE_LIST::join_columns contains all
    the columns of the join operand, then we pick the columns from
    TABLE_LIST::join_columns, instead of the  orginial container of the
    columns of the join operator.
  */
  if (table_ref->is_join_columns_complete)
  {
    /* Necesary, but insufficient conditions. */
    DBUG_ASSERT(table_ref->is_natural_join ||
                table_ref->nested_join ||
                table_ref->join_columns &&
                /* This is a merge view. */
                ((table_ref->field_translation &&
                  table_ref->join_columns->elements ==
                  (ulong)(table_ref->field_translation_end -
                          table_ref->field_translation)) ||
                 /* This is stored table or a tmptable view. */
                 (!table_ref->field_translation &&
                  table_ref->join_columns->elements ==
                  table_ref->table->s->fields)));
    field_it= &natural_join_it;
    DBUG_PRINT("info",("field_it for '%s' is Field_iterator_natural_join",
unknown's avatar
unknown committed
4046
                       table_ref->alias));
unknown's avatar
unknown committed
4047 4048 4049 4050 4051 4052 4053 4054
  }
  /* This is a merge view, so use field_translation. */
  else if (table_ref->field_translation)
  {
    DBUG_ASSERT(table_ref->view &&
                table_ref->effective_algorithm == VIEW_ALGORITHM_MERGE);
    field_it= &view_field_it;
    DBUG_PRINT("info", ("field_it for '%s' is Field_iterator_view",
unknown's avatar
unknown committed
4055
                        table_ref->alias));
unknown's avatar
unknown committed
4056 4057 4058 4059 4060 4061 4062
  }
  /* This is a base table or stored view. */
  else
  {
    DBUG_ASSERT(table_ref->table || table_ref->view);
    field_it= &table_field_it;
    DBUG_PRINT("info", ("field_it for '%s' is Field_iterator_table",
unknown's avatar
unknown committed
4063
                        table_ref->alias));
unknown's avatar
unknown committed
4064
  }
4065
  field_it->set(table_ref);
unknown's avatar
unknown committed
4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103
  DBUG_VOID_RETURN;
}


void Field_iterator_table_ref::set(TABLE_LIST *table)
{
  DBUG_ASSERT(table);
  first_leaf= table->first_leaf_for_name_resolution();
  last_leaf=  table->last_leaf_for_name_resolution();
  DBUG_ASSERT(first_leaf && last_leaf);
  table_ref= first_leaf;
  set_field_iterator();
}


void Field_iterator_table_ref::next()
{
  /* Move to the next field in the current table reference. */
  field_it->next();
  /*
    If all fields of the current table reference are exhausted, move to
    the next leaf table reference.
  */
  if (field_it->end_of_fields() && table_ref != last_leaf)
  {
    table_ref= table_ref->next_name_resolution_table;
    DBUG_ASSERT(table_ref);
    set_field_iterator();
  }
}


const char *Field_iterator_table_ref::table_name()
{
  if (table_ref->view)
    return table_ref->view_name.str;
  else if (table_ref->is_natural_join)
    return natural_join_it.column_ref()->table_name();
4104 4105

  DBUG_ASSERT(!strcmp(table_ref->table_name,
unknown's avatar
unknown committed
4106
                      table_ref->table->s->table_name.str));
4107
  return table_ref->table_name;
unknown's avatar
unknown committed
4108 4109 4110 4111 4112 4113 4114 4115 4116
}


const char *Field_iterator_table_ref::db_name()
{
  if (table_ref->view)
    return table_ref->view_db.str;
  else if (table_ref->is_natural_join)
    return natural_join_it.column_ref()->db_name();
4117

4118 4119 4120 4121 4122
  /*
    Test that TABLE_LIST::db is the same as st_table_share::db to
    ensure consistency. An exception are I_S schema tables, which
    are inconsistent in this respect.
  */
4123
  DBUG_ASSERT(!strcmp(table_ref->db, table_ref->table->s->db.str) ||
4124
              (table_ref->schema_table &&
4125
               table_ref->table->s->db.str[0] == 0));
4126

4127
  return table_ref->db;
unknown's avatar
unknown committed
4128 4129 4130 4131 4132 4133 4134 4135 4136
}


GRANT_INFO *Field_iterator_table_ref::grant()
{
  if (table_ref->view)
    return &(table_ref->grant);
  else if (table_ref->is_natural_join)
    return natural_join_it.column_ref()->grant();
4137
  return &(table_ref->table->grant);
unknown's avatar
unknown committed
4138 4139 4140 4141 4142 4143 4144 4145 4146
}


/*
  Create new or return existing column reference to a column of a
  natural/using join.

  SYNOPSIS
    Field_iterator_table_ref::get_or_create_column_ref()
unknown's avatar
unknown committed
4147 4148
    parent_table_ref  the parent table reference over which the
                      iterator is iterating
unknown's avatar
unknown committed
4149 4150

  DESCRIPTION
unknown's avatar
unknown committed
4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171
    Create a new natural join column for the current field of the
    iterator if no such column was created, or return an already
    created natural join column. The former happens for base tables or
    views, and the latter for natural/using joins. If a new field is
    created, then the field is added to 'parent_table_ref' if it is
    given, or to the original table referene of the field if
    parent_table_ref == NULL.

  NOTES
    This method is designed so that when a Field_iterator_table_ref
    walks through the fields of a table reference, all its fields
    are created and stored as follows:
    - If the table reference being iterated is a stored table, view or
      natural/using join, store all natural join columns in a list
      attached to that table reference.
    - If the table reference being iterated is a nested join that is
      not natural/using join, then do not materialize its result
      fields. This is OK because for such table references
      Field_iterator_table_ref iterates over the fields of the nested
      table references (recursively). In this way we avoid the storage
      of unnecessay copies of result columns of nested joins.
unknown's avatar
unknown committed
4172 4173

  RETURN
4174 4175
    #     Pointer to a column of a natural join (or its operand)
    NULL  No memory to allocate the column
unknown's avatar
unknown committed
4176 4177 4178
*/

Natural_join_column *
unknown's avatar
unknown committed
4179
Field_iterator_table_ref::get_or_create_column_ref(TABLE_LIST *parent_table_ref)
unknown's avatar
unknown committed
4180
{
4181
  Natural_join_column *nj_col;
unknown's avatar
unknown committed
4182 4183 4184 4185
  bool is_created= TRUE;
  uint field_count;
  TABLE_LIST *add_table_ref= parent_table_ref ?
                             parent_table_ref : table_ref;
4186
  LINT_INIT(field_count);
unknown's avatar
unknown committed
4187

unknown's avatar
unknown committed
4188
  if (field_it == &table_field_it)
4189 4190
  {
    /* The field belongs to a stored table. */
4191 4192
    Field *tmp_field= table_field_it.field();
    nj_col= new Natural_join_column(tmp_field, table_ref);
unknown's avatar
unknown committed
4193
    field_count= table_ref->table->s->fields;
4194 4195 4196 4197 4198 4199
  }
  else if (field_it == &view_field_it)
  {
    /* The field belongs to a merge view or information schema table. */
    Field_translator *translated_field= view_field_it.field_translator();
    nj_col= new Natural_join_column(translated_field, table_ref);
unknown's avatar
unknown committed
4200 4201
    field_count= table_ref->field_translation_end -
                 table_ref->field_translation;
4202 4203 4204 4205 4206 4207 4208 4209
  }
  else
  {
    /*
      The field belongs to a NATURAL join, therefore the column reference was
      already created via one of the two constructor calls above. In this case
      we just return the already created column reference.
    */
unknown's avatar
unknown committed
4210 4211
    DBUG_ASSERT(table_ref->is_join_columns_complete);
    is_created= FALSE;
4212 4213 4214
    nj_col= natural_join_it.column_ref();
    DBUG_ASSERT(nj_col);
  }
4215 4216
  DBUG_ASSERT(!nj_col->table_field ||
              nj_col->table_ref->table == nj_col->table_field->table);
unknown's avatar
unknown committed
4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246

  /*
    If the natural join column was just created add it to the list of
    natural join columns of either 'parent_table_ref' or to the table
    reference that directly contains the original field.
  */
  if (is_created)
  {
    /* Make sure not all columns were materialized. */
    DBUG_ASSERT(!add_table_ref->is_join_columns_complete);
    if (!add_table_ref->join_columns)
    {
      /* Create a list of natural join columns on demand. */
      if (!(add_table_ref->join_columns= new List<Natural_join_column>))
        return NULL;
      add_table_ref->is_join_columns_complete= FALSE;
    }
    add_table_ref->join_columns->push_back(nj_col);
    /*
      If new fields are added to their original table reference, mark if
      all fields were added. We do it here as the caller has no easy way
      of knowing when to do it.
      If the fields are being added to parent_table_ref, then the caller
      must take care to mark when all fields are created/added.
    */
    if (!parent_table_ref &&
        add_table_ref->join_columns->elements == field_count)
      add_table_ref->is_join_columns_complete= TRUE;
  }

4247
  return nj_col;
unknown's avatar
unknown committed
4248 4249 4250
}


4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284
/*
  Return an existing reference to a column of a natural/using join.

  SYNOPSIS
    Field_iterator_table_ref::get_natural_column_ref()

  DESCRIPTION
    The method should be called in contexts where it is expected that
    all natural join columns are already created, and that the column
    being retrieved is a Natural_join_column.

  RETURN
    #     Pointer to a column of a natural join (or its operand)
    NULL  No memory to allocate the column
*/

Natural_join_column *
Field_iterator_table_ref::get_natural_column_ref()
{
  Natural_join_column *nj_col;

  DBUG_ASSERT(field_it == &natural_join_it);
  /*
    The field belongs to a NATURAL join, therefore the column reference was
    already created via one of the two constructor calls above. In this case
    we just return the already created column reference.
  */
  nj_col= natural_join_it.column_ref();
  DBUG_ASSERT(nj_col &&
              (!nj_col->table_field ||
               nj_col->table_ref->table == nj_col->table_field->table));
  return nj_col;
}

4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404
/*****************************************************************************
  Functions to handle column usage bitmaps (read_set, write_set etc...)
*****************************************************************************/

/* Reset all columns bitmaps */

void st_table::clear_column_bitmaps()
{
  /*
    Reset column read/write usage. It's identical to:
    bitmap_clear_all(&table->def_read_set);
    bitmap_clear_all(&table->def_write_set);
  */
  bzero((char*) def_read_set.bitmap, s->column_bitmap_size*2);
  column_bitmaps_set(&def_read_set, &def_write_set);
}


/*
  Tell handler we are going to call position() and rnd_pos() later.
  
  NOTES:
  This is needed for handlers that uses the primary key to find the
  row. In this case we have to extend the read bitmap with the primary
  key fields.
*/

void st_table::prepare_for_position()
{
  DBUG_ENTER("st_table::prepare_for_position");

  if ((file->ha_table_flags() & HA_PRIMARY_KEY_IN_READ_INDEX) &&
      s->primary_key < MAX_KEY)
  {
    mark_columns_used_by_index_no_reset(s->primary_key, read_set);
    /* signal change */
    file->column_bitmaps_signal();
  }
  DBUG_VOID_RETURN;
}


/*
  Mark that only fields from one key is used

  NOTE:
    This changes the bitmap to use the tmp bitmap
    After this, you can't access any other columns in the table until
    bitmaps are reset, for example with st_table::clear_column_bitmaps()
    or st_table::restore_column_maps_after_mark_index()
*/

void st_table::mark_columns_used_by_index(uint index)
{
  MY_BITMAP *bitmap= &tmp_set;
  DBUG_ENTER("st_table::mark_columns_used_by_index");

  (void) file->extra(HA_EXTRA_KEYREAD);
  bitmap_clear_all(bitmap);
  mark_columns_used_by_index_no_reset(index, bitmap);
  column_bitmaps_set(bitmap, bitmap);
  DBUG_VOID_RETURN;
}


/*
  Restore to use normal column maps after key read

  NOTES
    This reverse the change done by mark_columns_used_by_index

  WARNING
    For this to work, one must have the normal table maps in place
    when calling mark_columns_used_by_index
*/

void st_table::restore_column_maps_after_mark_index()
{
  DBUG_ENTER("st_table::restore_column_maps_after_mark_index");

  key_read= 0;
  (void) file->extra(HA_EXTRA_NO_KEYREAD);
  default_column_bitmaps();
  file->column_bitmaps_signal();
  DBUG_VOID_RETURN;
}


/*
  mark columns used by key, but don't reset other fields
*/

void st_table::mark_columns_used_by_index_no_reset(uint index,
                                                   MY_BITMAP *bitmap)
{
  KEY_PART_INFO *key_part= key_info[index].key_part;
  KEY_PART_INFO *key_part_end= (key_part +
                                key_info[index].key_parts);
  for (;key_part != key_part_end; key_part++)
    bitmap_set_bit(bitmap, key_part->fieldnr-1);
}


/*
  Mark auto-increment fields as used fields in both read and write maps

  NOTES
    This is needed in insert & update as the auto-increment field is
    always set and sometimes read.
*/

void st_table::mark_auto_increment_column()
{
  DBUG_ASSERT(found_next_number_field);
  /*
    We must set bit in read set as update_auto_increment() is using the
    store() to check overflow of auto_increment values
  */
  bitmap_set_bit(read_set, found_next_number_field->field_index);
  bitmap_set_bit(write_set, found_next_number_field->field_index);
4405
  if (s->next_number_keypart)
4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431
    mark_columns_used_by_index_no_reset(s->next_number_index, read_set);
  file->column_bitmaps_signal();
}


/*
  Mark columns needed for doing an delete of a row

  DESCRIPTON
    Some table engines don't have a cursor on the retrieve rows
    so they need either to use the primary key or all columns to
    be able to delete a row.

    If the engine needs this, the function works as follows:
    - If primary key exits, mark the primary key columns to be read.
    - If not, mark all columns to be read

    If the engine has HA_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
    mark all key columns as 'to-be-read'. This allows the engine to
    loop over the given record to find all keys and doesn't have to
    retrieve the row again.
*/

void st_table::mark_columns_needed_for_delete()
{
  if (triggers)
4432
    triggers->mark_fields_used(TRG_EVENT_DELETE);
4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482
  if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
  {
    Field **reg_field;
    for (reg_field= field ; *reg_field ; reg_field++)
    {
      if ((*reg_field)->flags & PART_KEY_FLAG)
        bitmap_set_bit(read_set, (*reg_field)->field_index);
    }
    file->column_bitmaps_signal();
  }
  if (file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_DELETE)
  {
    /*
      If the handler has no cursor capabilites, we have to read either
      the primary key, the hidden primary key or all columns to be
      able to do an delete
    */
    if (s->primary_key == MAX_KEY)
      file->use_hidden_primary_key();
    else
    {
      mark_columns_used_by_index_no_reset(s->primary_key, read_set);
      file->column_bitmaps_signal();
    }
  }
}


/*
  Mark columns needed for doing an update of a row

  DESCRIPTON
    Some engines needs to have all columns in an update (to be able to
    build a complete row). If this is the case, we mark all not
    updated columns to be read.

    If this is no the case, we do like in the delete case and mark
    if neeed, either the primary key column or all columns to be read.
    (see mark_columns_needed_for_delete() for details)

    If the engine has HA_REQUIRES_KEY_COLUMNS_FOR_DELETE, we will
    mark all USED key columns as 'to-be-read'. This allows the engine to
    loop over the given record to find all changed keys and doesn't have to
    retrieve the row again.
*/

void st_table::mark_columns_needed_for_update()
{
  DBUG_ENTER("mark_columns_needed_for_update");
  if (triggers)
4483
    triggers->mark_fields_used(TRG_EVENT_UPDATE);
4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525
  if (file->ha_table_flags() & HA_REQUIRES_KEY_COLUMNS_FOR_DELETE)
  {
    /* Mark all used key columns for read */
    Field **reg_field;
    for (reg_field= field ; *reg_field ; reg_field++)
    {
      /* Merge keys is all keys that had a column refered to in the query */
      if (merge_keys.is_overlapping((*reg_field)->part_of_key))
        bitmap_set_bit(read_set, (*reg_field)->field_index);
    }
    file->column_bitmaps_signal();
  }
  if (file->ha_table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_DELETE)
  {
    /*
      If the handler has no cursor capabilites, we have to read either
      the primary key, the hidden primary key or all columns to be
      able to do an update
    */
    if (s->primary_key == MAX_KEY)
      file->use_hidden_primary_key();
    else
    {
      mark_columns_used_by_index_no_reset(s->primary_key, read_set);
      file->column_bitmaps_signal();
    }
  }
  DBUG_VOID_RETURN;
}


/*
  Mark columns the handler needs for doing an insert

  For now, this is used to mark fields used by the trigger
  as changed.
*/

void st_table::mark_columns_needed_for_insert()
{
  if (triggers)
  {
4526 4527 4528 4529 4530 4531 4532 4533
    /*
      We don't need to mark columns which are used by ON DELETE and
      ON UPDATE triggers, which may be invoked in case of REPLACE or
      INSERT ... ON DUPLICATE KEY UPDATE, since before doing actual
      row replacement or update write_record() will mark all table
      fields as used.
    */
    triggers->mark_fields_used(TRG_EVENT_INSERT);
4534 4535 4536 4537 4538
  }
  if (found_next_number_field)
    mark_auto_increment_column();
}

4539 4540 4541 4542
/*
  Cleanup this table for re-execution.

  SYNOPSIS
4543
    TABLE_LIST::reinit_before_use()
4544 4545
*/

4546
void TABLE_LIST::reinit_before_use(THD *thd)
4547 4548 4549 4550 4551 4552
{
  /*
    Reset old pointers to TABLEs: they are not valid since the tables
    were closed in the end of previous prepare or execute call.
  */
  table= 0;
4553
  /* Reset is_schema_table_processed value(needed for I_S tables */
4554
  schema_table_state= NOT_PROCESSED;
4555 4556

  TABLE_LIST *embedded; /* The table at the current level of nesting. */
4557
  TABLE_LIST *parent_embedding= this; /* The parent nested table reference. */
4558 4559
  do
  {
4560
    embedded= parent_embedding;
4561 4562
    if (embedded->prep_on_expr)
      embedded->on_expr= embedded->prep_on_expr->copy_andor_structure(thd);
4563
    parent_embedding= embedded->embedding;
4564
  }
4565 4566
  while (parent_embedding &&
         parent_embedding->nested_join->join_list.head() == embedded);
4567 4568
}

unknown's avatar
unknown committed
4569 4570 4571 4572
/*
  Return subselect that contains the FROM list this table is taken from

  SYNOPSIS
4573
    TABLE_LIST::containing_subselect()
unknown's avatar
unknown committed
4574 4575 4576 4577 4578 4579 4580 4581
 
  RETURN
    Subselect item for the subquery that contains the FROM list
    this table is taken from if there is any
    0 - otherwise

*/

4582
Item_subselect *TABLE_LIST::containing_subselect()
unknown's avatar
unknown committed
4583 4584 4585
{    
  return (select_lex ? select_lex->master_unit()->item : 0);
}
4586

4587 4588 4589 4590 4591 4592 4593 4594 4595
/*
  Compiles the tagged hints list and fills up the bitmasks.

  SYNOPSIS
    process_index_hints()
      table         the TABLE to operate on.

  DESCRIPTION
    The parser collects the index hints for each table in a "tagged list" 
4596
    (TABLE_LIST::index_hints). Using the information in this tagged list
4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637
    this function sets the members st_table::keys_in_use_for_query, 
    st_table::keys_in_use_for_group_by, st_table::keys_in_use_for_order_by,
    st_table::force_index and st_table::covering_keys.

    Current implementation of the runtime does not allow mixing FORCE INDEX
    and USE INDEX, so this is checked here. Then the FORCE INDEX list 
    (if non-empty) is appended to the USE INDEX list and a flag is set.

    Multiple hints of the same kind are processed so that each clause 
    is applied to what is computed in the previous clause.
    For example:
        USE INDEX (i1) USE INDEX (i2)
    is equivalent to
        USE INDEX (i1,i2)
    and means "consider only i1 and i2".
        
    Similarly
        USE INDEX () USE INDEX (i1)
    is equivalent to
        USE INDEX (i1)
    and means "consider only the index i1"

    It is OK to have the same index several times, e.g. "USE INDEX (i1,i1)" is
    not an error.
        
    Different kind of hints (USE/FORCE/IGNORE) are processed in the following
    order:
      1. All indexes in USE (or FORCE) INDEX are added to the mask.
      2. All IGNORE INDEX

    e.g. "USE INDEX i1, IGNORE INDEX i1, USE INDEX i1" will not use i1 at all
    as if we had "USE INDEX i1, USE INDEX i1, IGNORE INDEX i1".

    As an optimization if there is a covering index, and we have 
    IGNORE INDEX FOR GROUP/ORDER, and this index is used for the JOIN part, 
    then we have to ignore the IGNORE INDEX FROM GROUP/ORDER.

  RETURN VALUE
    FALSE                no errors found
    TRUE                 found and reported an error.
*/
4638
bool TABLE_LIST::process_index_hints(TABLE *table)
4639 4640 4641 4642 4643 4644 4645 4646 4647 4648 4649
{
  /* initialize the result variables */
  table->keys_in_use_for_query= table->keys_in_use_for_group_by= 
    table->keys_in_use_for_order_by= table->s->keys_in_use;

  /* index hint list processing */
  if (index_hints)
  {
    key_map index_join[INDEX_HINT_FORCE + 1];
    key_map index_order[INDEX_HINT_FORCE + 1];
    key_map index_group[INDEX_HINT_FORCE + 1];
unknown's avatar
unknown committed
4650
    Index_hint *hint;
4651 4652 4653
    int type;
    bool have_empty_use_join= FALSE, have_empty_use_order= FALSE, 
         have_empty_use_group= FALSE;
unknown's avatar
unknown committed
4654
    List_iterator <Index_hint> iter(*index_hints);
4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738

    /* initialize temporary variables used to collect hints of each kind */
    for (type= INDEX_HINT_IGNORE; type <= INDEX_HINT_FORCE; type++)
    {
      index_join[type].clear_all();
      index_order[type].clear_all();
      index_group[type].clear_all();
    }

    /* iterate over the hints list */
    while ((hint= iter++))
    {
      uint pos;

      /* process empty USE INDEX () */
      if (hint->type == INDEX_HINT_USE && !hint->key_name.str)
      {
        if (hint->clause & INDEX_HINT_MASK_JOIN)
        {
          index_join[hint->type].clear_all();
          have_empty_use_join= TRUE;
        }
        if (hint->clause & INDEX_HINT_MASK_ORDER)
        {
          index_order[hint->type].clear_all();
          have_empty_use_order= TRUE;
        }
        if (hint->clause & INDEX_HINT_MASK_GROUP)
        {
          index_group[hint->type].clear_all();
          have_empty_use_group= TRUE;
        }
        continue;
      }

      /* 
        Check if an index with the given name exists and get his offset in 
        the keys bitmask for the table 
      */
      if (table->s->keynames.type_names == 0 ||
          (pos= find_type(&table->s->keynames, hint->key_name.str,
                          hint->key_name.length, 1)) <= 0)
      {
        my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), hint->key_name.str, alias);
        return 1;
      }

      pos--;

      /* add to the appropriate clause mask */
      if (hint->clause & INDEX_HINT_MASK_JOIN)
        index_join[hint->type].set_bit (pos);
      if (hint->clause & INDEX_HINT_MASK_ORDER)
        index_order[hint->type].set_bit (pos);
      if (hint->clause & INDEX_HINT_MASK_GROUP)
        index_group[hint->type].set_bit (pos);
    }

    /* cannot mix USE INDEX and FORCE INDEX */
    if ((!index_join[INDEX_HINT_FORCE].is_clear_all() ||
         !index_order[INDEX_HINT_FORCE].is_clear_all() ||
         !index_group[INDEX_HINT_FORCE].is_clear_all()) &&
        (!index_join[INDEX_HINT_USE].is_clear_all() ||  have_empty_use_join ||
         !index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order ||
         !index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group))
    {
      my_error(ER_WRONG_USAGE, MYF(0), index_hint_type_name[INDEX_HINT_USE],
               index_hint_type_name[INDEX_HINT_FORCE]);
      return 1;
    }

    /* process FORCE INDEX as USE INDEX with a flag */
    if (!index_join[INDEX_HINT_FORCE].is_clear_all() ||
        !index_order[INDEX_HINT_FORCE].is_clear_all() ||
        !index_group[INDEX_HINT_FORCE].is_clear_all())
    {
      table->force_index= TRUE;
      index_join[INDEX_HINT_USE].merge(index_join[INDEX_HINT_FORCE]);
      index_order[INDEX_HINT_USE].merge(index_order[INDEX_HINT_FORCE]);
      index_group[INDEX_HINT_USE].merge(index_group[INDEX_HINT_FORCE]);
    }

    /* apply USE INDEX */
    if (!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join)
unknown's avatar
unknown committed
4739
      table->keys_in_use_for_query.intersect(index_join[INDEX_HINT_USE]);
4740
    if (!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order)
unknown's avatar
unknown committed
4741
      table->keys_in_use_for_order_by.intersect (index_order[INDEX_HINT_USE]);
4742
    if (!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group)
unknown's avatar
unknown committed
4743
      table->keys_in_use_for_group_by.intersect (index_group[INDEX_HINT_USE]);
4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755

    /* apply IGNORE INDEX */
    table->keys_in_use_for_query.subtract (index_join[INDEX_HINT_IGNORE]);
    table->keys_in_use_for_order_by.subtract (index_order[INDEX_HINT_IGNORE]);
    table->keys_in_use_for_group_by.subtract (index_group[INDEX_HINT_IGNORE]);
  }

  /* make sure covering_keys don't include indexes disabled with a hint */
  table->covering_keys.intersect(table->keys_in_use_for_query);
  return 0;
}

4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773

size_t max_row_length(TABLE *table, const uchar *data)
{
  TABLE_SHARE *table_s= table->s;
  size_t length= table_s->reclength + 2 * table_s->fields;
  uint *const beg= table_s->blob_field;
  uint *const end= beg + table_s->blob_fields;

  for (uint *ptr= beg ; ptr != end ; ++ptr)
  {
    Field_blob* const blob= (Field_blob*) table->field[*ptr];
    length+= blob->get_length((const uchar*)
                              (data + blob->offset(table->record[0]))) +
      HA_KEY_BLOB_LENGTH;
  }
  return length;
}

unknown's avatar
unknown committed
4774 4775 4776 4777
/*****************************************************************************
** Instansiate templates
*****************************************************************************/

4778
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
unknown's avatar
unknown committed
4779 4780 4781
template class List<String>;
template class List_iterator<String>;
#endif