table.cc 143 KB
Newer Older
1
/* Copyright 2000-2008 MySQL AB, 2008 Sun Microsystems, Inc.
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 26 27 28 29 30 31 32 33 34 35
/* INFORMATION_SCHEMA name */
LEX_STRING INFORMATION_SCHEMA_NAME= {C_STRING_WITH_LEN("information_schema")};

/* MYSQL_SCHEMA name */
LEX_STRING MYSQL_SCHEMA_NAME= {C_STRING_WITH_LEN("mysql")};

/* GENERAL_LOG name */
LEX_STRING GENERAL_LOG_NAME= {C_STRING_WITH_LEN("general_log")};

/* SLOW_LOG name */
LEX_STRING SLOW_LOG_NAME= {C_STRING_WITH_LEN("slow_log")};

unknown's avatar
unknown committed
36 37
	/* Functions defined in this file */

unknown's avatar
unknown committed
38 39
void open_table_error(TABLE_SHARE *share, int error, int db_errno,
                      myf errortype, int errarg);
40 41
static int open_binary_frm(THD *thd, TABLE_SHARE *share,
                           uchar *head, File file);
unknown's avatar
unknown committed
42 43
static void fix_type_pointers(const char ***array, TYPELIB *point_to_type,
			      uint types, char **names);
44
static uint find_field(Field **fields, uchar *record, uint start, uint length);
unknown's avatar
unknown committed
45

46
inline bool is_system_table_name(const char *name, uint length);
unknown's avatar
unknown committed
47

48 49
static ulong get_form_pos(File file, uchar *head);

unknown's avatar
unknown committed
50 51 52 53 54 55
/**************************************************************************
  Object_creation_ctx implementation.
**************************************************************************/

Object_creation_ctx *Object_creation_ctx::set_n_backup(THD *thd)
{
56 57
  Object_creation_ctx *backup_ctx;
  DBUG_ENTER("Object_creation_ctx::set_n_backup");
unknown's avatar
unknown committed
58

59
  backup_ctx= create_backup_ctx(thd);
unknown's avatar
unknown committed
60 61
  change_env(thd);

62
  DBUG_RETURN(backup_ctx);
unknown's avatar
unknown committed
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
}

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 *
91
Default_object_creation_ctx::create_backup_ctx(THD *thd) const
unknown's avatar
unknown committed
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
{
  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,
118
                                              TABLE_LIST *view)
unknown's avatar
unknown committed
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 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
{
  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
173 174
/* Get column name from column hash */

175 176
static uchar *get_field_name(Field **buff, size_t *length,
                             my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
177
{
178
  *length= (uint) strlen((*buff)->field_name);
179
  return (uchar*) (*buff)->field_name;
unknown's avatar
unknown committed
180 181
}

unknown's avatar
unknown committed
182

183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
/*
  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, '.');
207
  if (res && !strcmp(res, reg_ext))
208 209 210 211
    return res;
  return name + strlen(name);
}

212 213 214 215 216
TABLE_CATEGORY get_table_category(const LEX_STRING *db, const LEX_STRING *name)
{
  DBUG_ASSERT(db != NULL);
  DBUG_ASSERT(name != NULL);

217
  if (is_schema_db(db->str, db->length))
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
  {
    return TABLE_CATEGORY_INFORMATION;
  }

  if ((db->length == MYSQL_SCHEMA_NAME.length) &&
      (my_strcasecmp(system_charset_info,
                    MYSQL_SCHEMA_NAME.str,
                    db->str) == 0))
  {
    if (is_system_table_name(name->str, name->length))
    {
      return TABLE_CATEGORY_SYSTEM;
    }

    if ((name->length == GENERAL_LOG_NAME.length) &&
        (my_strcasecmp(system_charset_info,
                      GENERAL_LOG_NAME.str,
                      name->str) == 0))
    {
      return TABLE_CATEGORY_PERFORMANCE;
    }

    if ((name->length == SLOW_LOG_NAME.length) &&
        (my_strcasecmp(system_charset_info,
                      SLOW_LOG_NAME.str,
                      name->str) == 0))
    {
      return TABLE_CATEGORY_PERFORMANCE;
    }
  }

  return TABLE_CATEGORY_USER;
}

252

unknown's avatar
unknown committed
253 254 255 256 257 258 259 260 261 262 263 264 265 266
/*
  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
*/

267
TABLE_SHARE *alloc_table_share(TABLE_LIST *table_list, char *key,
unknown's avatar
unknown committed
268 269 270 271
                               uint key_length)
{
  MEM_ROOT mem_root;
  TABLE_SHARE *share;
272
  char *key_buff, *path_buff;
273 274
  char path[FN_REFLEN];
  uint path_length;
275 276 277
  DBUG_ENTER("alloc_table_share");
  DBUG_PRINT("enter", ("table: '%s'.'%s'",
                       table_list->db, table_list->table_name));
unknown's avatar
unknown committed
278

279 280
  path_length= build_table_filename(path, sizeof(path) - 1,
                                    table_list->db,
281
                                    table_list->table_name, "", 0);
unknown's avatar
unknown committed
282
  init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
283 284 285 286 287
  if (multi_alloc_root(&mem_root,
                       &share, sizeof(*share),
                       &key_buff, key_length,
                       &path_buff, path_length + 1,
                       NULL))
unknown's avatar
unknown committed
288 289 290
  {
    bzero((char*) share, sizeof(*share));

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

293
    share->path.str= path_buff;
unknown's avatar
unknown committed
294 295
    share->path.length= path_length;
    strmov(share->path.str, path);
296 297
    share->normalized_path.str=    share->path.str;
    share->normalized_path.length= path_length;
unknown's avatar
unknown committed
298 299 300

    share->version=       refresh_version;

301 302 303 304 305 306 307
    /*
      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.
    */
308
    share->table_map_id= ~0UL;
309 310
    share->cached_row_logging_check= -1;

unknown's avatar
unknown committed
311 312 313 314
    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);
  }
315
  DBUG_RETURN(share);
unknown's avatar
unknown committed
316 317 318 319 320 321 322 323
}


/*
  Initialize share for temporary tables

  SYNOPSIS
    init_tmp_table_share()
324
    thd         thread handle
unknown's avatar
unknown committed
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
    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).
*/

342
void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key,
unknown's avatar
unknown committed
343 344 345 346
                          uint key_length, const char *table_name,
                          const char *path)
{
  DBUG_ENTER("init_tmp_table_share");
347
  DBUG_PRINT("enter", ("table: '%s'.'%s'", key, table_name));
unknown's avatar
unknown committed
348 349 350

  bzero((char*) share, sizeof(*share));
  init_sql_alloc(&share->mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
351 352
  share->table_category=         TABLE_CATEGORY_TEMPORARY;
  share->tmp_table=              INTERNAL_TMP_TABLE;
unknown's avatar
unknown committed
353 354 355 356 357 358 359 360 361 362 363
  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;

364
  share->cached_row_logging_check= -1;
365

366 367 368 369 370 371
  /*
    table_map_id is also used for MERGE tables to suppress repeated
    compatibility checks.
  */
  share->table_map_id= (ulong) thd->query_id;

unknown's avatar
unknown committed
372 373 374 375
  DBUG_VOID_RETURN;
}


376
/*
unknown's avatar
unknown committed
377 378 379 380 381 382 383 384 385 386 387 388 389
  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;
390 391
  uint idx;
  KEY *key_info;
unknown's avatar
unknown committed
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413
  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
414 415 416
  
  plugin_unlock(NULL, share->db_plugin);
  share->db_plugin= NULL;
unknown's avatar
unknown committed
417

418 419 420 421 422 423 424 425 426 427
  /* Release fulltext parsers */
  key_info= share->key_info;
  for (idx= share->keys; idx; idx--, key_info++)
  {
    if (key_info->flags & HA_USES_PARSER)
    {
      plugin_unlock(NULL, key_info->parser);
      key_info->flags= 0;
    }
  }
428 429 430 431 432
  if (share->ha_data_destroy)
  {
    share->ha_data_destroy(share->ha_data);
    share->ha_data_destroy= NULL;
  }
unknown's avatar
unknown committed
433 434 435 436 437
  /* 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;
}
438

unknown's avatar
unknown committed
439

440 441 442 443 444
/**
  Return TRUE if a table name matches one of the system table names.
  Currently these are:

  help_category, help_keyword, help_relation, help_topic,
445
  proc, event
446 447 448 449 450 451 452 453 454 455 456 457 458
  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 (
Staale Smedseng's avatar
Staale Smedseng committed
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
           /* 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' &&
                 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')
             )
           )
488 489 490 491
         );
}


492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
/**
  Check if a string contains path elements
*/  

static inline bool has_disabled_path_chars(const char *str)
{
  for (; *str; str++)
    switch (*str)
    {
      case FN_EXTCHAR:
      case '/':
      case '\\':
      case '~':
      case '@':
        return TRUE;
    }
  return FALSE;
}


unknown's avatar
unknown committed
512 513 514
/*
  Read table definition from a binary / text based .frm file
  
515
  SYNOPSIS
unknown's avatar
unknown committed
516 517 518 519
  open_table_def()
  thd		Thread handler
  share		Fill this with table definition
  db_flags	Bit mask of the following flags: OPEN_VIEW
520

unknown's avatar
unknown committed
521 522 523 524 525
  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.
526 527 528

  RETURN VALUES
   0	ok
unknown's avatar
unknown committed
529 530
   1	Error (see open_table_error)
   2    Error (see open_table_error)
531
   3    Wrong data in .frm file
unknown's avatar
unknown committed
532 533
   4    Error (see open_table_error)
   5    Error (see open_table_error: charset unavailable)
534
   6    Unknown .frm version
535
*/
unknown's avatar
unknown committed
536

unknown's avatar
unknown committed
537 538 539 540 541
int open_table_def(THD *thd, TABLE_SHARE *share, uint db_flags)
{
  int error, table_type;
  bool error_given;
  File file;
542
  uchar head[288];
unknown's avatar
unknown committed
543
  char	path[FN_REFLEN];
unknown's avatar
unknown committed
544
  MEM_ROOT **root_ptr, *old_root;
unknown's avatar
unknown committed
545
  DBUG_ENTER("open_table_def");
546 547
  DBUG_PRINT("enter", ("table: '%s'.'%s'  path: '%s'", share->db.str,
                       share->table_name.str, share->normalized_path.str));
unknown's avatar
unknown committed
548

549
  error= 1;
unknown's avatar
unknown committed
550
  error_given= 0;
unknown's avatar
VIEW  
unknown committed
551

unknown's avatar
unknown committed
552 553
  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
554
  {
555 556 557 558 559 560 561 562 563 564 565
    /*
      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.
    */
566 567
    if (has_disabled_path_chars(share->table_name.str) ||
        has_disabled_path_chars(share->db.str) ||
568 569 570 571
        !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))
572 573
      goto err_not_open;

574
    /* Try unencoded 5.0 name */
unknown's avatar
unknown committed
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598
    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
599

600
  error= 4;
601
  if (my_read(file, head, 64, MYF(MY_NABP)))
602
    goto err;
unknown's avatar
VIEW  
unknown committed
603

unknown's avatar
unknown committed
604
  if (head[0] == (uchar) 254 && head[1] == 1)
unknown's avatar
VIEW  
unknown committed
605
  {
unknown's avatar
unknown committed
606 607
    if (head[2] == FRM_VER || head[2] == FRM_VER+1 ||
        (head[2] >= FRM_VER+3 && head[2] <= FRM_VER+4))
608 609 610 611 612 613 614
    {
      /* Open view only */
      if (db_flags & OPEN_VIEW_ONLY)
      {
        error_given= 1;
        goto err;
      }
unknown's avatar
unknown committed
615
      table_type= 1;
616
    }
unknown's avatar
unknown committed
617 618 619 620 621 622
    else
    {
      error= 6;                                 // Unkown .frm version
      goto err;
    }
  }
unknown's avatar
unknown committed
623
  else if (memcmp(head, STRING_WITH_LEN("TYPE=")) == 0)
unknown's avatar
unknown committed
624 625 626 627 628 629 630 631 632 633 634
  {
    error= 5;
    if (memcmp(head+5,"VIEW",4) == 0)
    {
      share->is_view= 1;
      if (db_flags & OPEN_VIEW)
        error= 0;
    }
    goto err;
  }
  else
635
    goto err;
unknown's avatar
VIEW  
unknown committed
636

unknown's avatar
unknown committed
637 638 639 640 641 642 643 644 645
  /* 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;
    error_given= 1;
unknown's avatar
VIEW  
unknown committed
646 647
  }

648 649
  share->table_category= get_table_category(& share->db, & share->table_name);

unknown's avatar
unknown committed
650 651
  if (!error)
    thd->status_var.opened_shares++;
unknown's avatar
unknown committed
652

unknown's avatar
unknown committed
653 654
err:
  my_close(file, MYF(MY_WME));
unknown's avatar
unknown committed
655

unknown's avatar
unknown committed
656 657
err_not_open:
  if (error && !error_given)
658
  {
unknown's avatar
unknown committed
659 660
    share->error= error;
    open_table_error(share, error, (share->open_errno= my_errno), 0);
661
  }
662

unknown's avatar
unknown committed
663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
  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;
682 683
  char *keynames, *names, *comment_pos;
  uchar *record;
unknown's avatar
unknown committed
684 685 686 687 688 689 690 691
  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
692
  enum legacy_db_type legacy_db_type;
693
  my_bitmap_map *bitmaps;
unknown's avatar
unknown committed
694 695 696
  DBUG_ENTER("open_binary_frm");

  new_field_pack_flag= head[27];
697
  new_frm_ver= (head[2] - FRM_VER);
698
  field_pack_length= new_frm_ver < 2 ? 11 : 17;
unknown's avatar
unknown committed
699
  disk_buff= 0;
unknown's avatar
unknown committed
700

unknown's avatar
unknown committed
701
  error= 3;
702 703
  /* Position of the form in the form file. */
  if (!(pos= get_form_pos(file, head)))
704
    goto err;                                   /* purecov: inspected */
unknown's avatar
unknown committed
705

706
  share->frm_version= head[2];
707 708 709 710 711 712 713 714 715
  /*
    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
716
#ifdef WITH_PARTITION_STORAGE_ENGINE
717 718 719 720
  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
721
  DBUG_PRINT("info", ("default_part_db_type = %u", head[61]));
unknown's avatar
unknown committed
722
#endif
unknown's avatar
unknown committed
723
  legacy_db_type= (enum legacy_db_type) (uint) *(head+3);
unknown's avatar
unknown committed
724 725 726 727 728 729 730 731 732
  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
733
  share->db_create_options= db_create_options= uint2korr(head+30);
734
  share->db_options_in_use= share->db_create_options;
735
  share->mysql_version= uint4korr(head+51);
unknown's avatar
unknown committed
736
  share->null_field_first= 0;
unknown's avatar
unknown committed
737 738
  if (!head[32])				// New frm file in 3.23
  {
739
    share->avg_row_length= uint4korr(head+34);
740
    share->row_type= (row_type) head[40];
741
    share->table_charset= get_charset((uint) head[38],MYF(0));
unknown's avatar
unknown committed
742
    share->null_field_first= 1;
743 744 745 746
  }
  if (!share->table_charset)
  {
    /* unknown charset in head[38] or pre-3.23 frm */
747 748 749 750 751 752
    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",
753
                        share->path.str);
754
    }
755
    share->table_charset= default_charset_info;
unknown's avatar
unknown committed
756
  }
757
  share->db_record_offset= 1;
unknown's avatar
unknown committed
758
  if (db_create_options & HA_OPTION_LONG_BLOB_PTR)
759
    share->blob_ptr_size= portable_sizeof_char_ptr;
760
  /* Set temporarily a good value for db_low_byte_first */
unknown's avatar
unknown committed
761
  share->db_low_byte_first= test(legacy_db_type != DB_TYPE_ISAM);
unknown's avatar
unknown committed
762
  error=4;
763 764
  share->max_rows= uint4korr(head+18);
  share->min_rows= uint4korr(head+22);
unknown's avatar
unknown committed
765 766

  /* Read keyinformation */
767
  key_info_length= (uint) uint2korr(head+28);
unknown's avatar
unknown committed
768
  VOID(my_seek(file,(ulong) uint2korr(head+6),MY_SEEK_SET,MYF(0)));
769
  if (read_string(file,(uchar**) &disk_buff,key_info_length))
770
    goto err;                                   /* purecov: inspected */
unknown's avatar
unknown committed
771
  if (disk_buff[0] & 0x80)
unknown's avatar
unknown committed
772
  {
773 774
    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
775 776 777
  }
  else
  {
778 779
    share->keys=      keys=      disk_buff[0];
    share->key_parts= key_parts= disk_buff[1];
unknown's avatar
unknown committed
780
  }
781 782
  share->keys_for_keyread.init(0);
  share->keys_in_use.init(keys);
unknown's avatar
unknown committed
783 784

  n_length=keys*sizeof(KEY)+key_parts*sizeof(KEY_PART_INFO);
unknown's avatar
unknown committed
785 786
  if (!(keyinfo = (KEY*) alloc_root(&share->mem_root,
				    n_length + uint2korr(disk_buff+4))))
787
    goto err;                                   /* purecov: inspected */
unknown's avatar
unknown committed
788
  bzero((char*) keyinfo,n_length);
unknown's avatar
unknown committed
789
  share->key_info= keyinfo;
unknown's avatar
unknown committed
790
  key_part= my_reinterpret_cast(KEY_PART_INFO*) (keyinfo+keys);
unknown's avatar
unknown committed
791 792
  strpos=disk_buff+6;

unknown's avatar
unknown committed
793
  if (!(rec_per_key= (ulong*) alloc_root(&share->mem_root,
794
                                         sizeof(ulong)*key_parts)))
795
    goto err;
unknown's avatar
unknown committed
796 797 798

  for (i=0 ; i < keys ; i++, keyinfo++)
  {
unknown's avatar
unknown committed
799
    keyinfo->table= 0;                           // Updated in open_frm
800
    if (new_frm_ver >= 3)
801 802 803 804 805
    {
      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];
806
      keyinfo->block_size= uint2korr(strpos+6);
807 808 809 810 811 812 813 814 815 816
      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
817

unknown's avatar
unknown committed
818 819 820 821 822 823 824 825 826
    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
827
      if (new_frm_ver >= 1)
unknown's avatar
unknown committed
828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
      {
	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;
    }
  }
847 848
  keynames=(char*) key_part;
  strpos+= (strmov(keynames, (char *) strpos) - keynames)+1;
849

850
  share->reclength = uint2korr((head+16));
unknown's avatar
unknown committed
851
  if (*(head+26) == 1)
852
    share->system= 1;				/* one-record-database */
unknown's avatar
unknown committed
853 854 855
#ifdef HAVE_CRYPTED_FRM
  else if (*(head+26) == 2)
  {
unknown's avatar
unknown committed
856 857
    crypted= get_crypt_for_frm();
    share->crypted= 1;
unknown's avatar
unknown committed
858 859 860
  }
#endif

861 862 863 864
  record_offset= (ulong) (uint2korr(head+6)+
                          ((uint2korr(head+14) == 0xffff ?
                            uint4korr(head+47) : uint2korr(head+14))));
 
unknown's avatar
unknown committed
865
  if ((n_length= uint4korr(head+55)))
866 867
  {
    /* Read extra data segment */
868
    uchar *buff, *next_chunk, *buff_end;
869
    DBUG_PRINT("info", ("extra segment size is %u bytes", n_length));
870
    if (!(next_chunk= buff= (uchar*) my_malloc(n_length, MYF(MY_WME))))
871
      goto err;
872
    if (my_pread(file, buff, n_length, record_offset + share->reclength,
873 874 875 876 877
                 MYF(MY_NABP)))
    {
      my_free(buff, MYF(0));
      goto err;
    }
878
    share->connect_string.length= uint2korr(buff);
879 880 881 882
    if (!(share->connect_string.str= strmake_root(&share->mem_root,
                                                  (char*) next_chunk + 2,
                                                  share->connect_string.
                                                  length)))
883
    {
884 885
      my_free(buff, MYF(0));
      goto err;
886
    }
887
    next_chunk+= share->connect_string.length + 2;
888
    buff_end= buff + n_length;
889 890 891
    if (next_chunk + 2 < buff_end)
    {
      uint str_db_type_length= uint2korr(next_chunk);
892 893 894 895
      LEX_STRING name;
      name.str= (char*) next_chunk + 2;
      name.length= str_db_type_length;

unknown's avatar
unknown committed
896
      plugin_ref tmp_plugin= ha_resolve_by_name(thd, &name);
unknown's avatar
unknown committed
897
      if (tmp_plugin != NULL && !plugin_equals(tmp_plugin, share->db_plugin))
898
      {
unknown's avatar
unknown committed
899 900 901 902 903 904 905 906 907
        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
908 909 910 911 912 913 914
        /*
          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);
915 916
        DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",
                            str_db_type_length, next_chunk + 2,
unknown's avatar
unknown committed
917
                            ha_legacy_type(share->db_type())));
918
      }
919
#ifdef WITH_PARTITION_STORAGE_ENGINE
920 921
      else if (str_db_type_length == 9 &&
               !strncmp((char *) next_chunk + 2, "partition", 9))
922
      {
923 924 925 926 927 928
        /*
          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
        */
929 930 931 932 933 934 935 936 937
        /* Check if the partitioning engine is ready */
        if (!plugin_is_ready(&name, MYSQL_STORAGE_ENGINE_PLUGIN))
        {
          error= 8;
          my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0),
                   "--skip-partition");
          my_free(buff, MYF(0));
          goto err;
        }
938 939 940 941 942
        plugin_unlock(NULL, share->db_plugin);
        share->db_plugin= ha_lock_engine(NULL, partition_hton);
        DBUG_PRINT("info", ("setting dbtype to '%.*s' (%d)",
                            str_db_type_length, next_chunk + 2,
                            ha_legacy_type(share->db_type())));
943 944
      }
#endif
945 946 947 948 949 950 951 952 953
      else if (!tmp_plugin)
      {
        /* purecov: begin inspected */
        error= 8;
        my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), name.str);
        my_free(buff, MYF(0));
        goto err;
        /* purecov: end */
      }
954 955
      next_chunk+= str_db_type_length + 2;
    }
unknown's avatar
unknown committed
956
    if (next_chunk + 5 < buff_end)
957
    {
958 959
      uint32 partition_info_len = uint4korr(next_chunk);
#ifdef WITH_PARTITION_STORAGE_ENGINE
960 961
      if ((share->partition_info_buffer_size=
             share->partition_info_len= partition_info_len))
962
      {
963
        if (!(share->partition_info= (char*)
964 965
              memdup_root(&share->mem_root, next_chunk + 4,
                          partition_info_len + 1)))
966 967 968 969
        {
          my_free(buff, MYF(0));
          goto err;
        }
970 971 972 973 974 975 976
      }
#else
      if (partition_info_len)
      {
        DBUG_PRINT("info", ("WITH_PARTITION_STORAGE_ENGINE is not defined"));
        my_free(buff, MYF(0));
        goto err;
977
      }
978
#endif
unknown's avatar
unknown committed
979
      next_chunk+= 5 + partition_info_len;
980
    }
981 982
#if MYSQL_VERSION_ID < 50200
    if (share->mysql_version >= 50106 && share->mysql_version <= 50109)
unknown's avatar
unknown committed
983 984
    {
      /*
985 986 987 988 989
         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
990
      */
unknown's avatar
unknown committed
991
      next_chunk+= 4;
unknown's avatar
unknown committed
992
    }
993
    else if (share->mysql_version >= 50110)
unknown's avatar
unknown committed
994
#endif
995 996 997 998 999 1000 1001
    {
      /* 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
1002
    keyinfo= share->key_info;
1003 1004 1005 1006 1007 1008 1009
    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
1010 1011
          DBUG_PRINT("error",
                     ("fulltext key uses parser that is not defined in .frm"));
1012 1013 1014
          my_free(buff, MYF(0));
          goto err;
        }
1015 1016
        parser_name.str= (char*) next_chunk;
        parser_name.length= strlen((char*) next_chunk);
1017
        next_chunk+= parser_name.length + 1;
unknown's avatar
unknown committed
1018 1019
        keyinfo->parser= my_plugin_lock_by_name(NULL, &parser_name,
                                                MYSQL_FTPARSER_PLUGIN);
1020 1021 1022
        if (! keyinfo->parser)
        {
          my_error(ER_PLUGIN_IS_NOT_LOADED, MYF(0), parser_name.str);
1023
          my_free(buff, MYF(0));
1024 1025 1026 1027
          goto err;
        }
      }
    }
1028 1029
    my_free(buff, MYF(0));
  }
1030
  share->key_block_size= uint2korr(head+62);
unknown's avatar
unknown committed
1031 1032

  error=4;
1033
  extra_rec_buf_length= uint2korr(head+59);
unknown's avatar
unknown committed
1034
  rec_buff_length= ALIGN_SIZE(share->reclength + 1 + extra_rec_buf_length);
1035
  share->rec_buff_length= rec_buff_length;
1036 1037
  if (!(record= (uchar *) alloc_root(&share->mem_root,
                                     rec_buff_length)))
1038
    goto err;                                   /* purecov: inspected */
1039 1040
  share->default_values= record;
  if (my_pread(file, record, (size_t) share->reclength,
1041
               record_offset, MYF(MY_NABP)))
unknown's avatar
unknown committed
1042
    goto err;                                   /* purecov: inspected */
unknown's avatar
unknown committed
1043 1044

  VOID(my_seek(file,pos,MY_SEEK_SET,MYF(0)));
1045
  if (my_read(file, head,288,MYF(MY_NABP)))
1046
    goto err;
1047
#ifdef HAVE_CRYPTED_FRM
unknown's avatar
unknown committed
1048 1049 1050 1051
  if (crypted)
  {
    crypted->decode((char*) head+256,288-256);
    if (sint2korr(head+284) != 0)		// Should be 0
1052
      goto err;                                 // Wrong password
unknown's avatar
unknown committed
1053
  }
1054
#endif
unknown's avatar
unknown committed
1055

1056 1057 1058 1059 1060 1061 1062 1063
  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);
1064
  share->comment.length=  (int) (head[46]);
1065
  share->comment.str= strmake_root(&share->mem_root, (char*) head+47,
1066
                                   share->comment.length);
unknown's avatar
unknown committed
1067

1068
  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
1069 1070

  if (!(field_ptr = (Field **)
unknown's avatar
unknown committed
1071
	alloc_root(&share->mem_root,
1072
		   (uint) ((share->fields+1)*sizeof(Field*)+
unknown's avatar
unknown committed
1073
			   interval_count*sizeof(TYPELIB)+
1074
			   (share->fields+interval_parts+
1075
			    keys+3)*sizeof(char *)+
1076
			   (n_length+int_length+com_length)))))
1077
    goto err;                                   /* purecov: inspected */
unknown's avatar
unknown committed
1078

unknown's avatar
unknown committed
1079
  share->field= field_ptr;
1080
  read_length=(uint) (share->fields * field_pack_length +
unknown's avatar
unknown committed
1081
		      pos+ (uint) (n_length+int_length+com_length));
1082
  if (read_string(file,(uchar**) &disk_buff,read_length))
1083
    goto err;                                   /* purecov: inspected */
1084
#ifdef HAVE_CRYPTED_FRM
unknown's avatar
unknown committed
1085 1086 1087 1088 1089 1090
  if (crypted)
  {
    crypted->decode((char*) disk_buff,read_length);
    delete crypted;
    crypted=0;
  }
1091
#endif
unknown's avatar
unknown committed
1092 1093
  strpos= disk_buff+pos;

1094
  share->intervals= (TYPELIB*) (field_ptr+share->fields+1);
unknown's avatar
unknown committed
1095 1096
  interval_array= (const char **) (share->intervals+interval_count);
  names= (char*) (interval_array+share->fields+interval_parts+keys+3);
unknown's avatar
unknown committed
1097
  if (!interval_count)
1098 1099
    share->intervals= 0;			// For better debugging
  memcpy((char*) names, strpos+(share->fields*field_pack_length),
unknown's avatar
unknown committed
1100
	 (uint) (n_length+int_length));
1101
  comment_pos= names+(n_length+int_length);
unknown's avatar
unknown committed
1102
  memcpy(comment_pos, disk_buff+read_length-com_length, com_length);
unknown's avatar
unknown committed
1103

unknown's avatar
unknown committed
1104
  fix_type_pointers(&interval_array, &share->fieldnames, 1, &names);
1105 1106
  if (share->fieldnames.count != share->fields)
    goto err;
unknown's avatar
unknown committed
1107
  fix_type_pointers(&interval_array, share->intervals, interval_count,
unknown's avatar
unknown committed
1108
		    &names);
1109 1110 1111 1112

  {
    /* Set ENUM and SET lengths */
    TYPELIB *interval;
1113 1114
    for (interval= share->intervals;
         interval < share->intervals + interval_count;
1115 1116 1117
         interval++)
    {
      uint count= (uint) (interval->count + 1) * sizeof(uint);
unknown's avatar
unknown committed
1118
      if (!(interval->type_lengths= (uint *) alloc_root(&share->mem_root,
1119
                                                        count)))
1120
        goto err;
1121
      for (count= 0; count < interval->count; count++)
1122 1123 1124 1125
      {
        char *val= (char*) interval->type_names[count];
        interval->type_lengths[count]= strlen(val);
      }
1126 1127 1128 1129
      interval->type_lengths[count]= 0;
    }
  }

unknown's avatar
unknown committed
1130
  if (keynames)
unknown's avatar
unknown committed
1131
    fix_type_pointers(&interval_array, &share->keynames, 1, &keynames);
unknown's avatar
unknown committed
1132

unknown's avatar
unknown committed
1133 1134
 /* Allocate handler */
  if (!(handler_file= get_new_handler(share, thd->mem_root,
unknown's avatar
unknown committed
1135
                                      share->db_type())))
1136 1137
    goto err;

1138
  record= share->default_values-1;              /* Fieldstart = 1 */
unknown's avatar
unknown committed
1139
  if (share->null_field_first)
unknown's avatar
unknown committed
1140
  {
unknown's avatar
unknown committed
1141
    null_flags= null_pos= (uchar*) record+1;
unknown's avatar
unknown committed
1142
    null_bit_pos= (db_create_options & HA_OPTION_PACK_RECORD) ? 0 : 1;
1143 1144 1145 1146 1147
    /*
      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
    */
1148
    share->null_bytes= (share->null_fields + null_bit_pos + 7) / 8;
unknown's avatar
unknown committed
1149
  }
unknown's avatar
unknown committed
1150
#ifndef WE_WANT_TO_SUPPORT_VERY_OLD_FRM_FILES
unknown's avatar
unknown committed
1151 1152
  else
  {
1153
    share->null_bytes= (share->null_fields+7)/8;
unknown's avatar
unknown committed
1154 1155
    null_flags= null_pos= (uchar*) (record + 1 +share->reclength -
                                    share->null_bytes);
unknown's avatar
unknown committed
1156
    null_bit_pos= 0;
unknown's avatar
unknown committed
1157
  }
unknown's avatar
unknown committed
1158
#endif
unknown's avatar
unknown committed
1159

1160
  use_hash= share->fields >= MAX_FIELDS_BEFORE_HASH;
unknown's avatar
unknown committed
1161
  if (use_hash)
1162
    use_hash= !hash_init(&share->name_hash,
unknown's avatar
unknown committed
1163
			 system_charset_info,
1164
			 share->fields,0,0,
unknown's avatar
unknown committed
1165
			 (hash_get_key) get_field_name,0,0);
unknown's avatar
unknown committed
1166

1167
  for (i=0 ; i < share->fields; i++, strpos+=field_pack_length, field_ptr++)
unknown's avatar
unknown committed
1168
  {
1169
    uint pack_flag, interval_nr, unireg_type, recpos, field_length;
1170
    enum_field_types field_type;
1171
    CHARSET_INFO *charset=NULL;
unknown's avatar
unknown committed
1172
    Field::geometry_type geom_type= Field::GEOM_GEOMETRY;
1173
    LEX_STRING comment;
unknown's avatar
unknown committed
1174

1175
    if (new_frm_ver >= 3)
1176 1177
    {
      /* new frm file in 4.1 */
1178 1179 1180 1181 1182 1183 1184
      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
1185

1186
      /* charset and geometry_type share the same byte in frm */
1187
      if (field_type == MYSQL_TYPE_GEOMETRY)
unknown's avatar
unknown committed
1188
      {
unknown's avatar
unknown committed
1189
#ifdef HAVE_SPATIAL
unknown's avatar
unknown committed
1190 1191
	geom_type= (Field::geometry_type) strpos[14];
	charset= &my_charset_bin;
unknown's avatar
unknown committed
1192 1193
#else
	error= 4;  // unsupported field type
1194
	goto err;
unknown's avatar
unknown committed
1195
#endif
unknown's avatar
unknown committed
1196 1197 1198
      }
      else
      {
1199 1200 1201 1202 1203 1204
        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];
1205
          goto err;
1206
        }
unknown's avatar
unknown committed
1207
      }
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
      if (!comment_length)
      {
	comment.str= (char*) "";
	comment.length=0;
      }
      else
      {
	comment.str=    (char*) comment_pos;
	comment.length= comment_length;
	comment_pos+=   comment_length;
      }
    }
    else
    {
1222 1223 1224
      field_length= (uint) strpos[3];
      recpos=	    uint2korr(strpos+4),
      pack_flag=    uint2korr(strpos+6);
unknown's avatar
unknown committed
1225
      pack_flag&=   ~FIELDFLAG_NO_DEFAULT;     // Safety for old files
1226 1227 1228
      unireg_type=  (uint) strpos[8];
      interval_nr=  (uint) strpos[10];

1229 1230
      /* old frm file */
      field_type= (enum_field_types) f_packtype(pack_flag);
unknown's avatar
unknown committed
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241
      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
1242
          if (!(charset= get_charset_by_csname(share->table_charset->csname,
unknown's avatar
unknown committed
1243 1244 1245 1246 1247 1248 1249
                                               MY_CS_BINSORT, MYF(0))))
            charset= &my_charset_bin;
        }
        else
          charset= &my_charset_bin;
      }
      else
1250
        charset= share->table_charset;
1251 1252
      bzero((char*) &comment, sizeof(comment));
    }
1253 1254 1255 1256

    if (interval_nr && charset->mbminlen > 1)
    {
      /* Unescape UCS2 intervals from HEX notation */
1257
      TYPELIB *interval= share->intervals + interval_nr - 1;
1258
      unhex_type2(interval);
1259 1260
    }
    
1261
#ifndef TO_BE_DELETED_ON_PRODUCTION
1262
    if (field_type == MYSQL_TYPE_NEWDECIMAL && !share->mysql_version)
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272
    {
      /*
        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
1273 1274 1275 1276
      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);
1277 1278
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                          ER_CRASHED_ON_USAGE,
unknown's avatar
unknown committed
1279 1280 1281 1282 1283
                          "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);
1284 1285 1286 1287
      share->crashed= 1;                        // Marker for CHECK TABLE
    }
#endif

unknown's avatar
unknown committed
1288 1289
    *field_ptr= reg_field=
      make_field(share, record+recpos,
1290
		 (uint32) field_length,
unknown's avatar
unknown committed
1291
		 null_pos, null_bit_pos,
unknown's avatar
unknown committed
1292
		 pack_flag,
1293
		 field_type,
1294
		 charset,
unknown's avatar
unknown committed
1295
		 geom_type,
1296
		 (Field::utype) MTYP_TYPENR(unireg_type),
unknown's avatar
unknown committed
1297
		 (interval_nr ?
1298
		  share->intervals+interval_nr-1 :
unknown's avatar
unknown committed
1299
		  (TYPELIB*) 0),
unknown's avatar
unknown committed
1300
		 share->fieldnames.type_names[i]);
unknown's avatar
unknown committed
1301
    if (!reg_field)				// Not supported field type
1302 1303
    {
      error= 4;
1304
      goto err;			/* purecov: inspected */
1305
    }
1306

1307
    reg_field->field_index= i;
1308
    reg_field->comment=comment;
1309
    if (field_type == MYSQL_TYPE_BIT && !f_bit_as_char(pack_flag))
unknown's avatar
unknown committed
1310
    {
unknown's avatar
unknown committed
1311
      if ((null_bit_pos+= field_length & 7) > 7)
unknown's avatar
unknown committed
1312
      {
unknown's avatar
unknown committed
1313 1314
        null_pos++;
        null_bit_pos-= 8;
unknown's avatar
unknown committed
1315 1316
      }
    }
unknown's avatar
unknown committed
1317 1318 1319 1320 1321
    if (!(reg_field->flags & NOT_NULL_FLAG))
    {
      if (!(null_bit_pos= (null_bit_pos + 1) & 7))
        null_pos++;
    }
unknown's avatar
unknown committed
1322 1323
    if (f_no_default(pack_flag))
      reg_field->flags|= NO_DEFAULT_VALUE_FLAG;
unknown's avatar
unknown committed
1324

unknown's avatar
unknown committed
1325
    if (reg_field->unireg_check == Field::NEXT_NUMBER)
unknown's avatar
unknown committed
1326 1327
      share->found_next_number_field= field_ptr;
    if (share->timestamp_field == reg_field)
1328
      share->timestamp_field_offset= i;
unknown's avatar
unknown committed
1329

unknown's avatar
unknown committed
1330
    if (use_hash)
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340
      if (my_hash_insert(&share->name_hash, (uchar*) field_ptr) )
      {
        /*
          Set return code 8 here to indicate that an error has
          occurred but that the error message already has been
          sent (OOM).
        */
        error= 8; 
        goto err;
      }
unknown's avatar
unknown committed
1341 1342 1343 1344 1345 1346
  }
  *field_ptr=0;					// End marker

  /* Fix key->name and key_part->field */
  if (key_parts)
  {
1347
    uint primary_key=(uint) (find_type((char*) primary_key_name,
1348
				       &share->keynames, 3) - 1);
1349
    longlong ha_option= handler_file->ha_table_flags();
unknown's avatar
unknown committed
1350 1351
    keyinfo= share->key_info;
    key_part= keyinfo->key_part;
unknown's avatar
unknown committed
1352

1353
    for (uint key=0 ; key < share->keys ; key++,keyinfo++)
unknown's avatar
unknown committed
1354
    {
unknown's avatar
unknown committed
1355
      uint usable_parts= 0;
1356
      keyinfo->name=(char*) share->keynames.type_names[key];
1357
      /* Fix fulltext keys for old .frm files */
unknown's avatar
unknown committed
1358 1359
      if (share->key_info[key].flags & HA_FULLTEXT)
	share->key_info[key].algorithm= HA_KEY_ALG_FULLTEXT;
1360

unknown's avatar
unknown committed
1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
      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
1382 1383
      for (i=0 ; i < keyinfo->key_parts ; key_part++,i++)
      {
unknown's avatar
unknown committed
1384
        Field *field;
unknown's avatar
unknown committed
1385
	if (new_field_pack_flag <= 1)
unknown's avatar
unknown committed
1386
	  key_part->fieldnr= (uint16) find_field(share->field,
1387
                                                 share->default_values,
unknown's avatar
unknown committed
1388 1389 1390 1391 1392 1393 1394 1395
                                                 (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
1396
        key_part->type= field->key_type();
unknown's avatar
unknown committed
1397 1398
        if (field->null_ptr)
        {
1399
          key_part->null_offset=(uint) ((uchar*) field->null_ptr -
unknown's avatar
unknown committed
1400 1401 1402 1403 1404 1405 1406
                                        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;
        }
1407
        if (field->type() == MYSQL_TYPE_BLOB ||
1408 1409
            field->real_type() == MYSQL_TYPE_VARCHAR ||
            field->type() == MYSQL_TYPE_GEOMETRY)
unknown's avatar
unknown committed
1410
        {
1411 1412
          if (field->type() == MYSQL_TYPE_BLOB ||
              field->type() == MYSQL_TYPE_GEOMETRY)
unknown's avatar
unknown committed
1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441
            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);
1442
            field->part_of_key_not_clustered.set_bit(key);
unknown's avatar
unknown committed
1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458
          }
          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)
1459
          {
1460 1461 1462
            if (field->key_length() == key_part->length &&
                !(field->flags & BLOB_FLAG))
              field->part_of_key= share->keys_in_use;
1463
            if (field->part_of_sortkey.is_set(key))
1464 1465
              field->part_of_sortkey= share->keys_in_use;
          }
unknown's avatar
unknown committed
1466 1467 1468
        }
        if (field->key_length() != key_part->length)
        {
1469
#ifndef TO_BE_DELETED_ON_PRODUCTION
1470
          if (field->type() == MYSQL_TYPE_NEWDECIMAL)
unknown's avatar
unknown committed
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
          {
            /*
              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;
          }
1497
#endif
unknown's avatar
unknown committed
1498 1499
          key_part->key_part_flag|= HA_PART_KEY_SEG;
        }
1500 1501 1502

	to_be_deleted:

unknown's avatar
unknown committed
1503 1504 1505 1506 1507 1508
        /*
          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())
1509
          key_part->key_part_flag|= HA_NULL_PART;
unknown's avatar
unknown committed
1510
      }
unknown's avatar
unknown committed
1511
      keyinfo->usable_key_parts= usable_parts; // Filesort
1512

1513
      set_if_bigger(share->max_key_length,keyinfo->key_length+
1514
                    keyinfo->key_parts);
1515
      share->total_key_length+= keyinfo->key_length;
1516 1517 1518 1519 1520 1521
      /*
        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
1522
        set_if_bigger(share->max_unique_length,keyinfo->key_length);
unknown's avatar
unknown committed
1523
    }
1524
    if (primary_key < MAX_KEY &&
1525
	(share->keys_in_use.is_set(primary_key)))
unknown's avatar
unknown committed
1526
    {
1527
      share->primary_key= primary_key;
1528 1529 1530 1531
      /*
	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
1532
      if (share->key_info[primary_key].key_parts == 1)
unknown's avatar
unknown committed
1533
      {
unknown's avatar
unknown committed
1534
	Field *field= share->key_info[primary_key].key_part[0].field;
unknown's avatar
unknown committed
1535
	if (field && field->result_type() == INT_RESULT)
unknown's avatar
unknown committed
1536 1537 1538 1539 1540
        {
          /* 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
1541 1542 1543
      }
    }
    else
1544
      share->primary_key = MAX_KEY; // we do not have a primary key
unknown's avatar
unknown committed
1545
  }
1546
  else
1547
    share->primary_key= MAX_KEY;
1548
  x_free((uchar*) disk_buff);
1549
  disk_buff=0;
unknown's avatar
unknown committed
1550
  if (new_field_pack_flag <= 1)
1551 1552 1553
  {
    /* Old file format with default as not null */
    uint null_length= (share->null_fields+7)/8;
unknown's avatar
unknown committed
1554
    bfill(share->default_values + (null_flags - (uchar*) record),
1555
          null_length, 255);
unknown's avatar
unknown committed
1556 1557
  }

unknown's avatar
unknown committed
1558
  if (share->found_next_number_field)
unknown's avatar
unknown committed
1559
  {
unknown's avatar
unknown committed
1560
    reg_field= *share->found_next_number_field;
1561
    if ((int) (share->next_number_index= (uint)
1562 1563
	       find_ref_key(share->key_info, share->keys,
                            share->default_values, reg_field,
1564 1565
			    &share->next_number_key_offset,
                            &share->next_number_keypart)) < 0)
unknown's avatar
unknown committed
1566
    {
1567
      /* Wrong field definition */
1568 1569
      error= 4;
      goto err;
unknown's avatar
unknown committed
1570 1571
    }
    else
unknown's avatar
unknown committed
1572
      reg_field->flags |= AUTO_INCREMENT_FLAG;
unknown's avatar
unknown committed
1573 1574
  }

1575
  if (share->blob_fields)
unknown's avatar
unknown committed
1576 1577
  {
    Field **ptr;
1578
    uint k, *save;
unknown's avatar
unknown committed
1579

1580 1581
    /* Store offsets to blob fields to find them fast */
    if (!(share->blob_field= save=
unknown's avatar
unknown committed
1582
	  (uint*) alloc_root(&share->mem_root,
1583
                             (uint) (share->blob_fields* sizeof(uint)))))
1584
      goto err;
unknown's avatar
unknown committed
1585
    for (k=0, ptr= share->field ; *ptr ; ptr++, k++)
unknown's avatar
unknown committed
1586 1587
    {
      if ((*ptr)->flags & BLOB_FLAG)
1588
	(*save++)= k;
unknown's avatar
unknown committed
1589 1590 1591
    }
  }

1592 1593 1594 1595
  /*
    the correct null_bytes can now be set, since bitfields have been taken
    into account
  */
unknown's avatar
unknown committed
1596
  share->null_bytes= (null_pos - (uchar*) null_flags +
1597
                      (null_bit_pos + 7) / 8);
unknown's avatar
unknown committed
1598
  share->last_null_bit_pos= null_bit_pos;
unknown's avatar
unknown committed
1599

unknown's avatar
unknown committed
1600
  share->db_low_byte_first= handler_file->low_byte_first();
1601 1602 1603
  share->column_bitmap_size= bitmap_buffer_size(share->fields);

  if (!(bitmaps= (my_bitmap_map*) alloc_root(&share->mem_root,
unknown's avatar
unknown committed
1604
                                             share->column_bitmap_size)))
1605 1606 1607 1608
    goto err;
  bitmap_init(&share->all_set, bitmaps, share->fields, FALSE);
  bitmap_set_all(&share->all_set);

unknown's avatar
unknown committed
1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
  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;
1620
  x_free((uchar*) disk_buff);
unknown's avatar
unknown committed
1621 1622 1623
  delete crypted;
  delete handler_file;
  hash_free(&share->name_hash);
1624 1625 1626 1627 1628
  if (share->ha_data_destroy)
  {
    share->ha_data_destroy(share->ha_data);
    share->ha_data_destroy= NULL;
  }
unknown's avatar
unknown committed
1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661

  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
1662
                          TABLE *outparam, bool is_create_table)
unknown's avatar
unknown committed
1663 1664
{
  int error;
1665
  uint records, i, bitmap_size;
unknown's avatar
unknown committed
1666
  bool error_reported= FALSE;
1667
  uchar *record, *bitmaps;
unknown's avatar
unknown committed
1668 1669 1670
  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
1671
                      share->table_name.str, (long) outparam));
unknown's avatar
unknown committed
1672

1673 1674 1675
  /* Parsing of partitioning information from .frm needs thd->lex set up. */
  DBUG_ASSERT(thd->lex->is_lex_started);

unknown's avatar
unknown committed
1676 1677 1678 1679 1680
  error= 1;
  bzero((char*) outparam, sizeof(*outparam));
  outparam->in_use= thd;
  outparam->s= share;
  outparam->db_stat= db_stat;
1681
  outparam->write_row_record= NULL;
unknown's avatar
unknown committed
1682 1683 1684 1685 1686 1687

  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();
1688
  outparam->covering_keys.init();
1689
  outparam->merge_keys.init();
unknown's avatar
unknown committed
1690 1691 1692
  outparam->keys_in_use_for_query.init();

  /* Allocate handler */
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
  outparam->file= 0;
  if (!(prgflag & OPEN_FRM_FILE_ONLY))
  {
    if (!(outparam->file= get_new_handler(share, &outparam->mem_root,
                                          share->db_type())))
      goto err;
  }
  else
  {
    DBUG_ASSERT(!db_stat);
  }
unknown's avatar
unknown committed
1704 1705 1706 1707 1708 1709 1710 1711 1712 1713

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

1714
  if (!(record= (uchar*) alloc_root(&outparam->mem_root,
unknown's avatar
unknown committed
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739
                                   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);
1740
    memcpy(outparam->record[1], share->default_values, share->null_bytes);
unknown's avatar
unknown committed
1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753
    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;

1754
  record= (uchar*) outparam->record[0]-1;	/* Fieldstart = 1 */
unknown's avatar
unknown committed
1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814
  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
1815
                                                  outparam, 0);
unknown's avatar
unknown committed
1816 1817 1818 1819 1820 1821 1822
          field->field_length= key_part->length;
        }
      }
    }
  }

#ifdef WITH_PARTITION_STORAGE_ENGINE
1823
  if (share->partition_info_len && outparam->file)
unknown's avatar
unknown committed
1824
  {
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
  /*
    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;
1841
    bool tmp;
1842
    bool work_part_info_used;
1843

1844 1845
    tmp= mysql_unpack_partition(thd, share->partition_info,
                                share->partition_info_len,
1846
                                share->part_state,
1847 1848
                                share->part_state_len,
                                outparam, is_create_table,
1849 1850
                                share->default_part_db_type,
                                &work_part_info_used);
1851 1852 1853 1854 1855 1856 1857
    if (tmp)
    {
      thd->stmt_arena= backup_stmt_arena_ptr;
      thd->restore_active_arena(&part_func_arena, &backup_arena);
      goto partititon_err;
    }
    outparam->part_info->is_auto_partitioned= share->auto_partitioned;
1858
    DBUG_PRINT("info", ("autopartitioned: %u", share->auto_partitioned));
1859 1860 1861
    /* we should perform the fix_partition_func in either local or
       caller's arena depending on work_part_info_used value
    */
1862
    if (!work_part_info_used)
1863
      tmp= fix_partition_func(thd, outparam, is_create_table);
1864 1865
    thd->stmt_arena= backup_stmt_arena_ptr;
    thd->restore_active_arena(&part_func_arena, &backup_arena);
1866
    if (!tmp)
1867 1868 1869
    {
      if (work_part_info_used)
        tmp= fix_partition_func(thd, outparam, is_create_table);
1870
      outparam->part_info->item_free_list= part_func_arena.free_list;
1871
    }
1872
partititon_err:
1873
    if (tmp)
1874 1875 1876 1877 1878 1879 1880 1881 1882 1883
    {
      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
1884
      goto err;
1885
    }
unknown's avatar
unknown committed
1886 1887 1888
  }
#endif

1889 1890 1891
  /* Allocate bitmaps */

  bitmap_size= share->column_bitmap_size;
1892
  if (!(bitmaps= (uchar*) alloc_root(&outparam->mem_root, bitmap_size*3)))
1893 1894 1895 1896 1897 1898 1899 1900 1901
    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();

1902
  /* The table struct is now initialized;  Open the table */
unknown's avatar
unknown committed
1903
  error= 2;
1904 1905
  if (db_stat)
  {
1906 1907
    int ha_err;
    if ((ha_err= (outparam->file->
unknown's avatar
unknown committed
1908
                  ha_open(outparam, share->normalized_path.str,
1909 1910 1911 1912 1913 1914 1915 1916
                          (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))))
1917 1918
    {
      /* Set a flag if the table is crashed and it can be auto. repaired */
1919
      share->crashed= ((ha_err == HA_ERR_CRASHED_ON_USAGE) &&
1920 1921
                       outparam->file->auto_repair() &&
                       !(ha_open_flags & HA_OPEN_FOR_REPAIR));
1922

1923
      switch (ha_err)
1924
      {
1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948
        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;
1949
      }
1950
      goto err;                                 /* purecov: inspected */
1951 1952 1953
    }
  }

1954 1955 1956 1957
#if defined(HAVE_purify) && !defined(DBUG_OFF)
  bzero((char*) bitmaps, bitmap_size*3);
#endif

unknown's avatar
unknown committed
1958 1959
  outparam->no_replicate= outparam->file &&
                          test(outparam->file->ha_table_flags() &
1960
                               HA_HAS_OWN_BINLOGGING);
1961
  thd->status_var.opened_tables++;
1962

unknown's avatar
unknown committed
1963 1964
  DBUG_RETURN (0);

1965
 err:
1966
  if (! error_reported)
unknown's avatar
unknown committed
1967
    open_table_error(share, error, my_errno, 0);
1968
  delete outparam->file;
1969
#ifdef WITH_PARTITION_STORAGE_ENGINE
unknown's avatar
unknown committed
1970 1971
  if (outparam->part_info)
    free_items(outparam->part_info->item_free_list);
1972
#endif
unknown's avatar
unknown committed
1973
  outparam->file= 0;				// For easier error checking
1974
  outparam->db_stat=0;
1975
  free_root(&outparam->mem_root, MYF(0));       // Safe to call on bzero'd root
1976
  my_free((char*) outparam->alias, MYF(MY_ALLOW_ZERO_PTR));
unknown's avatar
unknown committed
1977
  DBUG_RETURN (error);
unknown's avatar
unknown committed
1978
}
unknown's avatar
unknown committed
1979

1980 1981 1982 1983 1984 1985 1986 1987 1988

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

unknown's avatar
unknown committed
1990
int closefrm(register TABLE *table, bool free_share)
unknown's avatar
unknown committed
1991 1992 1993
{
  int error=0;
  DBUG_ENTER("closefrm");
1994
  DBUG_PRINT("enter", ("table: 0x%lx", (long) table));
1995

unknown's avatar
unknown committed
1996 1997
  if (table->db_stat)
    error=table->file->close();
1998 1999 2000
  my_free((char*) table->alias, MYF(MY_ALLOW_ZERO_PTR));
  table->alias= 0;
  if (table->field)
unknown's avatar
unknown committed
2001 2002 2003
  {
    for (Field **ptr=table->field ; *ptr ; ptr++)
      delete *ptr;
2004
    table->field= 0;
unknown's avatar
unknown committed
2005 2006
  }
  delete table->file;
unknown's avatar
unknown committed
2007
  table->file= 0;				/* For easier errorchecking */
2008
#ifdef WITH_PARTITION_STORAGE_ENGINE
unknown's avatar
unknown committed
2009
  if (table->part_info)
2010
  {
unknown's avatar
unknown committed
2011
    free_items(table->part_info->item_free_list);
unknown's avatar
unknown committed
2012
    table->part_info->item_free_list= 0;
unknown's avatar
unknown committed
2013
    table->part_info= 0;
2014 2015
  }
#endif
unknown's avatar
unknown committed
2016 2017 2018 2019 2020 2021 2022
  if (free_share)
  {
    if (table->s->tmp_table == NO_TMP_TABLE)
      release_table_share(table->s, RELEASE_NORMAL);
    else
      free_table_share(table->s);
  }
2023
  free_root(&table->mem_root, MYF(0));
unknown's avatar
unknown committed
2024 2025 2026 2027 2028 2029 2030 2031
  DBUG_RETURN(error);
}


/* Deallocate temporary blob storage */

void free_blobs(register TABLE *table)
{
2032 2033 2034 2035 2036
  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
2037 2038 2039
}


2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061
/**
  Reclaim temporary blob storage which is bigger than 
  a threshold.
 
  @param table A handle to the TABLE object containing blob fields
  @param size The threshold value.
 
*/

void free_field_buffers_larger_than(TABLE *table, uint32 size)
{
  uint *ptr, *end;
  for (ptr= table->s->blob_field, end=ptr + table->s->blob_fields ;
       ptr != end ;
       ptr++)
  {
    Field_blob *blob= (Field_blob*) table->field[*ptr];
    if (blob->get_field_buffer_size() > size)
        blob->free();
  }
}

2062 2063 2064 2065 2066 2067 2068 2069 2070
/**
  Find where a form starts.

  @param head The start of the form file.

  @remark If formname is NULL then only formnames is read.

  @retval The form position.
*/
unknown's avatar
unknown committed
2071

2072
static ulong get_form_pos(File file, uchar *head)
unknown's avatar
unknown committed
2073
{
2074 2075
  uchar *pos, *buf;
  uint names, length;
unknown's avatar
unknown committed
2076 2077 2078
  ulong ret_value=0;
  DBUG_ENTER("get_form_pos");

2079
  names= uint2korr(head+8);
unknown's avatar
unknown committed
2080

2081 2082
  if (!(names= uint2korr(head+8)))
    DBUG_RETURN(0);
unknown's avatar
unknown committed
2083

2084 2085 2086 2087 2088 2089 2090 2091
  length= uint2korr(head+4);

  my_seek(file, 64L, MY_SEEK_SET, MYF(0));

  if (!(buf= (uchar*) my_malloc(length+names*4, MYF(MY_WME))))
    DBUG_RETURN(0);

  if (my_read(file, buf, length+names*4, MYF(MY_NABP)))
unknown's avatar
unknown committed
2092
  {
2093 2094
    x_free(buf);
    DBUG_RETURN(0);
unknown's avatar
unknown committed
2095
  }
2096 2097 2098 2099 2100 2101

  pos= buf+length;
  ret_value= uint4korr(pos);

  my_free(buf, MYF(0));

unknown's avatar
unknown committed
2102 2103 2104 2105
  DBUG_RETURN(ret_value);
}


2106 2107
/*
  Read string from a file with malloc
unknown's avatar
unknown committed
2108

2109 2110 2111 2112 2113
  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
2114 2115 2116
{
  DBUG_ENTER("read_string");

2117 2118 2119
  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
2120
  {
2121 2122 2123
    x_free(*to);                              /* purecov: inspected */
    *to= 0;                                   /* purecov: inspected */
    DBUG_RETURN(1);                           /* purecov: inspected */
unknown's avatar
unknown committed
2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136
  }
  *((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;
2137
  uchar buff[IO_SIZE];
unknown's avatar
unknown committed
2138 2139 2140
  uchar *pos;
  DBUG_ENTER("make_new_entry");

unknown's avatar
unknown committed
2141
  length=(uint) strlen(newname)+1;
unknown's avatar
unknown committed
2142 2143 2144 2145 2146 2147 2148 2149 2150
  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
2151
    endpos=(ulong) my_seek(file,0L,MY_SEEK_END,MYF(0));/* Copy from file-end */
unknown's avatar
unknown committed
2152 2153 2154 2155 2156
    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)));
2157
      if (my_read(file, buff, bufflength, MYF(MY_NABP+MY_WME)))
unknown's avatar
unknown committed
2158 2159 2160
	DBUG_RETURN(0L);
      VOID(my_seek(file,(ulong) (endpos-bufflength+IO_SIZE),MY_SEEK_SET,
		   MYF(0)));
2161
      if ((my_write(file, buff,bufflength,MYF(MY_NABP+MY_WME))))
unknown's avatar
unknown committed
2162 2163 2164 2165 2166
	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)));
2167
    if (my_write(file,buff,bufflength,MYF(MY_NABP+MY_WME)))
unknown's avatar
unknown committed
2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181
	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++;
2182
    VOID(strxmov((char*) buff,"/",newname,"/",NullS));
unknown's avatar
unknown committed
2183 2184
  }
  else
2185
    VOID(strxmov((char*) buff,newname,"/",NullS)); /* purecov: inspected */
unknown's avatar
unknown committed
2186
  VOID(my_seek(file,63L+(ulong) n_length,MY_SEEK_SET,MYF(0)));
2187 2188
  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
2189
			 names*4, MYF(MY_NABP+MY_WME))) ||
2190
      my_write(file, fileinfo+10, 4,MYF(MY_NABP+MY_WME)))
unknown's avatar
unknown committed
2191 2192 2193 2194
    DBUG_RETURN(0L); /* purecov: inspected */

  int2store(fileinfo+8,names+1);
  int2store(fileinfo+4,n_length+length);
2195
  VOID(my_chsize(file, newpos, 0, MYF(MY_WME)));/* Append file with '\0' */
unknown's avatar
unknown committed
2196 2197 2198 2199 2200 2201
  DBUG_RETURN(newpos);
} /* make_new_entry */


	/* error message when opening a form file */

unknown's avatar
unknown committed
2202
void open_table_error(TABLE_SHARE *share, int error, int db_errno, int errarg)
unknown's avatar
unknown committed
2203 2204 2205
{
  int err_no;
  char buff[FN_REFLEN];
unknown's avatar
unknown committed
2206 2207
  myf errortype= ME_ERROR+ME_WAITTANG;
  DBUG_ENTER("open_table_error");
unknown's avatar
unknown committed
2208 2209

  switch (error) {
unknown's avatar
unknown committed
2210
  case 7:
unknown's avatar
unknown committed
2211
  case 1:
unknown's avatar
unknown committed
2212 2213 2214
    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
2215
    {
unknown's avatar
unknown committed
2216
      strxmov(buff, share->normalized_path.str, reg_ext, NullS);
2217 2218
      my_error((db_errno == EMFILE) ? ER_CANT_OPEN_FILE : ER_FILE_NOT_FOUND,
               errortype, buff, db_errno);
unknown's avatar
unknown committed
2219 2220 2221 2222
    }
    break;
  case 2:
  {
unknown's avatar
unknown committed
2223 2224 2225
    handler *file= 0;
    const char *datext= "";
    
unknown's avatar
unknown committed
2226
    if (share->db_type() != NULL)
unknown's avatar
unknown committed
2227 2228
    {
      if ((file= get_new_handler(share, current_thd->mem_root,
unknown's avatar
unknown committed
2229
                                 share->db_type())))
unknown's avatar
unknown committed
2230 2231 2232 2233 2234 2235
      {
        if (!(datext= *file->bas_ext()))
          datext= "";
      }
    }
    err_no= (db_errno == ENOENT) ? ER_FILE_NOT_FOUND : (db_errno == EAGAIN) ?
unknown's avatar
unknown committed
2236
      ER_FILE_USED : ER_CANT_OPEN_FILE;
unknown's avatar
unknown committed
2237 2238 2239
    strxmov(buff, share->normalized_path.str, datext, NullS);
    my_error(err_no,errortype, buff, db_errno);
    delete file;
unknown's avatar
unknown committed
2240 2241
    break;
  }
2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252
  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
2253
                    MYF(0), csname, share->table_name.str);
unknown's avatar
unknown committed
2254 2255
    break;
  }
2256
  case 6:
unknown's avatar
unknown committed
2257
    strxmov(buff, share->normalized_path.str, reg_ext, NullS);
2258 2259
    my_printf_error(ER_NOT_FORM_FILE,
                    "Table '%-.64s' was created with a different version "
unknown's avatar
unknown committed
2260 2261
                    "of MySQL and cannot be read", 
                    MYF(0), buff);
2262
    break;
2263 2264
  case 8:
    break;
unknown's avatar
unknown committed
2265 2266
  default:				/* Better wrong error than none */
  case 4:
unknown's avatar
unknown committed
2267 2268
    strxmov(buff, share->normalized_path.str, reg_ext, NullS);
    my_error(ER_NOT_FORM_FILE, errortype, buff, 0);
unknown's avatar
unknown committed
2269 2270 2271
    break;
  }
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2272
} /* open_table_error */
unknown's avatar
unknown committed
2273 2274 2275 2276


	/*
	** fix a str_type to a array type
2277
	** typeparts separated with some char. differents types are separated
unknown's avatar
unknown committed
2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301
	** 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
2302
      ptr+=2;				/* Skip end mark and last 0 */
unknown's avatar
unknown committed
2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314
    }
    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 */


2315
TYPELIB *typelib(MEM_ROOT *mem_root, List<String> &strings)
unknown's avatar
unknown committed
2316
{
2317
  TYPELIB *result= (TYPELIB*) alloc_root(mem_root, sizeof(TYPELIB));
unknown's avatar
unknown committed
2318 2319 2320 2321
  if (!result)
    return 0;
  result->count=strings.elements;
  result->name="";
2322
  uint nbytes= (sizeof(char*) + sizeof(uint)) * (result->count + 1);
2323
  if (!(result->type_names= (const char**) alloc_root(mem_root, nbytes)))
unknown's avatar
unknown committed
2324
    return 0;
2325
  result->type_lengths= (uint*) (result->type_names + result->count + 1);
unknown's avatar
unknown committed
2326 2327 2328
  List_iterator<String> it(strings);
  String *tmp;
  for (uint i=0; (tmp=it++) ; i++)
2329 2330 2331 2332 2333 2334
  {
    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
2335 2336 2337 2338
  return result;
}


2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350
/*
 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
2351

2352
static uint find_field(Field **fields, uchar *record, uint start, uint length)
unknown's avatar
unknown committed
2353 2354
{
  Field **field;
unknown's avatar
unknown committed
2355
  uint i, pos;
unknown's avatar
unknown committed
2356

unknown's avatar
unknown committed
2357 2358
  pos= 0;
  for (field= fields, i=1 ; *field ; i++,field++)
unknown's avatar
unknown committed
2359
  {
2360
    if ((*field)->offset(record) == start)
unknown's avatar
unknown committed
2361 2362 2363
    {
      if ((*field)->key_length() == length)
	return (i);
unknown's avatar
unknown committed
2364
      if (!pos || fields[pos-1]->pack_length() <
unknown's avatar
unknown committed
2365
	  (*field)->pack_length())
unknown's avatar
unknown committed
2366
	pos= i;
unknown's avatar
unknown committed
2367 2368 2369 2370 2371 2372
    }
  }
  return (pos);
}


2373
	/* Check that the integer is in the internal */
unknown's avatar
unknown committed
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394

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


2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407
/*
  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.
*/
2408

2409
void append_unescaped(String *res, const char *pos, uint length)
unknown's avatar
unknown committed
2410
{
2411 2412 2413 2414
  const char *end= pos+length;
  res->append('\'');

  for (; pos != end ; pos++)
unknown's avatar
unknown committed
2415
  {
unknown's avatar
unknown committed
2416
#if defined(USE_MB) && MYSQL_VERSION_ID < 40100
unknown's avatar
unknown committed
2417 2418 2419 2420 2421 2422 2423 2424 2425 2426
    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
2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
    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':
2437
      res->append('\\');		/* This gives better readability */
unknown's avatar
unknown committed
2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452
      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;
    }
  }
2453
  res->append('\'');
unknown's avatar
unknown committed
2454 2455
}

2456

unknown's avatar
unknown committed
2457 2458
	/* Create a .frm file */

unknown's avatar
unknown committed
2459
File create_frm(THD *thd, const char *name, const char *db,
unknown's avatar
unknown committed
2460
                const char *table, uint reclength, uchar *fileinfo,
unknown's avatar
unknown committed
2461
  		HA_CREATE_INFO *create_info, uint keys)
unknown's avatar
unknown committed
2462 2463 2464
{
  register File file;
  ulong length;
2465
  uchar fill[IO_SIZE];
2466 2467 2468 2469
  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
2470

unknown's avatar
unknown committed
2471
  /* Fix this when we have new .frm files;  Current limit is 4G rows (QQ) */
2472 2473 2474 2475
  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;
2476

2477
  if ((file= my_create(name, CREATE_MODE, create_flags, MYF(0))) >= 0)
unknown's avatar
unknown committed
2478
  {
2479 2480
    uint key_length, tmp_key_length;
    uint tmp;
unknown's avatar
unknown committed
2481
    bzero((char*) fileinfo,64);
2482 2483 2484 2485 2486
    /* header */
    fileinfo[0]=(uchar) 254;
    fileinfo[1]= 1;
    fileinfo[2]= FRM_VER+3+ test(create_info->varchar);

unknown's avatar
unknown committed
2487 2488
    fileinfo[3]= (uchar) ha_legacy_type(
          ha_checktype(thd,ha_legacy_type(create_info->db_type),0,0));
unknown's avatar
unknown committed
2489 2490
    fileinfo[4]=1;
    int2store(fileinfo+6,IO_SIZE);		/* Next block starts here */
2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503
    /*
      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;
2504 2505
    length= next_io_size((ulong) (IO_SIZE+key_length+reclength+
                                  create_info->extra_size));
unknown's avatar
unknown committed
2506
    int4store(fileinfo+10,length);
2507 2508
    tmp_key_length= (key_length < 0xffff) ? key_length : 0xffff;
    int2store(fileinfo+14,tmp_key_length);
unknown's avatar
unknown committed
2509 2510 2511
    int2store(fileinfo+16,reclength);
    int4store(fileinfo+18,create_info->max_rows);
    int4store(fileinfo+22,create_info->min_rows);
2512
    /* fileinfo[26] is set in mysql_create_frm() */
unknown's avatar
unknown committed
2513
    fileinfo[27]=2;				// Use long pack-fields
2514
    /* fileinfo[28 & 29] is set to key_info_length in mysql_create_frm() */
unknown's avatar
unknown committed
2515 2516 2517
    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
2518
    fileinfo[33]=5;                             // Mark for 5.0 frm file
unknown's avatar
unknown committed
2519
    int4store(fileinfo+34,create_info->avg_row_length);
2520 2521
    fileinfo[38]= (create_info->default_table_charset ?
		   create_info->default_table_charset->number : 0);
2522 2523 2524 2525 2526
    /*
      In future versions, we will store in fileinfo[39] the values of the
      TRANSACTIONAL and PAGE_CHECKSUM clauses of CREATE TABLE.
    */
    fileinfo[39]= 0;
unknown's avatar
unknown committed
2527
    fileinfo[40]= (uchar) create_info->row_type;
2528
    /* Next few bytes where for RAID support */
2529 2530 2531 2532 2533 2534
    fileinfo[41]= 0;
    fileinfo[42]= 0;
    fileinfo[43]= 0;
    fileinfo[44]= 0;
    fileinfo[45]= 0;
    fileinfo[46]= 0;
2535 2536 2537
    int4store(fileinfo+47, key_length);
    tmp= MYSQL_VERSION_ID;          // Store to avoid warning from int4store
    int4store(fileinfo+51, tmp);
unknown's avatar
unknown committed
2538
    int4store(fileinfo+55, create_info->extra_size);
2539 2540 2541 2542 2543
    /*
      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
2544 2545 2546
    bzero(fill,IO_SIZE);
    for (; length > IO_SIZE ; length-= IO_SIZE)
    {
2547
      if (my_write(file,fill, IO_SIZE, MYF(MY_WME | MY_NABP)))
unknown's avatar
unknown committed
2548 2549 2550 2551 2552 2553 2554
      {
	VOID(my_close(file,MYF(0)));
	VOID(my_delete(name,MYF(0)));
	return(-1);
      }
    }
  }
2555 2556 2557 2558 2559 2560 2561
  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
2562 2563 2564 2565 2566 2567
  return (file);
} /* create_frm */


void update_create_info_from_table(HA_CREATE_INFO *create_info, TABLE *table)
{
2568
  TABLE_SHARE *share= table->s;
2569
  DBUG_ENTER("update_create_info_from_table");
2570 2571 2572 2573 2574 2575 2576

  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;
2577
  create_info->table_charset= 0;
2578
  create_info->comment= share->comment;
2579

2580
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
2581
}
unknown's avatar
unknown committed
2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592

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
2593 2594 2595 2596 2597 2598 2599 2600 2601 2602
/*
  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
2603 2604
    1   string is empty
    0	all ok
unknown's avatar
unknown committed
2605 2606 2607 2608
*/

bool get_field(MEM_ROOT *mem, Field *field, String *res)
{
2609
  char buff[MAX_FIELD_WIDTH], *to;
unknown's avatar
unknown committed
2610
  String str(buff,sizeof(buff),&my_charset_bin);
2611 2612
  uint length;

2613
  field->val_str(&str);
2614
  if (!(length= str.length()))
2615 2616
  {
    res->length(0);
2617
    return 1;
2618 2619 2620
  }
  if (!(to= strmake_root(mem, str.ptr(), length)))
    length= 0;                                  // Safety fix
2621 2622
  res->set(to, length, ((Field_str*)field)->charset());
  return 0;
unknown's avatar
unknown committed
2623 2624
}

2625

unknown's avatar
unknown committed
2626
/*
2627 2628 2629 2630 2631 2632 2633 2634 2635 2636
  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
2637 2638
*/

2639
char *get_field(MEM_ROOT *mem, Field *field)
unknown's avatar
unknown committed
2640
{
unknown's avatar
unknown committed
2641
  char buff[MAX_FIELD_WIDTH], *to;
2642
  String str(buff,sizeof(buff),&my_charset_bin);
2643 2644
  uint length;

2645
  field->val_str(&str);
unknown's avatar
unknown committed
2646
  length= str.length();
unknown's avatar
unknown committed
2647
  if (!length || !(to= (char*) alloc_root(mem,length+1)))
unknown's avatar
unknown committed
2648 2649 2650 2651 2652 2653
    return NullS;
  memcpy(to,str.ptr(),(uint) length);
  to[length]=0;
  return to;
}

2654 2655 2656 2657 2658
/*
  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
*/
2659
uint calculate_key_len(TABLE *table, uint key, const uchar *buf,
unknown's avatar
unknown committed
2660
                       key_part_map keypart_map)
2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677
{
  /* 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;
}
2678 2679 2680 2681 2682 2683

/*
  Check if database name is valid

  SYNPOSIS
    check_db_name()
2684
    org_name		Name of database and length
2685 2686 2687 2688 2689 2690 2691 2692 2693

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

  RETURN
    0	ok
    1   error
*/

2694
bool check_db_name(LEX_STRING *org_name)
unknown's avatar
unknown committed
2695
{
2696
  char *name= org_name->str;
2697
  uint name_length= org_name->length;
2698
  bool check_for_path_chars;
2699

2700
  if (!name_length || name_length > NAME_LEN)
2701
    return 1;
2702

2703 2704 2705 2706 2707 2708
  if ((check_for_path_chars= check_mysql50_prefix(name)))
  {
    name+= MYSQL50_TABLE_NAME_PREFIX_LENGTH;
    name_length-= MYSQL50_TABLE_NAME_PREFIX_LENGTH;
  }

unknown's avatar
unknown committed
2709
  if (lower_case_table_names && name != any_db)
2710
    my_casedn_str(files_charset_info, name);
2711

2712
  return check_table_name(name, name_length, check_for_path_chars);
unknown's avatar
unknown committed
2713 2714
}

2715

unknown's avatar
unknown committed
2716 2717
/*
  Allow anything as a table name, as long as it doesn't contain an
2718
  ' ' at the end
unknown's avatar
unknown committed
2719 2720 2721
  returns 1 on error
*/

2722
bool check_table_name(const char *name, uint length, bool check_for_path_chars)
unknown's avatar
unknown committed
2723
{
2724
  uint name_length= 0;  // name length in symbols
unknown's avatar
unknown committed
2725
  const char *end= name+length;
unknown's avatar
unknown committed
2726 2727
  if (!length || length > NAME_LEN)
    return 1;
unknown's avatar
unknown committed
2728
#if defined(USE_MB) && defined(USE_MB_IDENT)
2729
  bool last_char_is_space= FALSE;
unknown's avatar
unknown committed
2730 2731 2732 2733
#else
  if (name[length-1]==' ')
    return 1;
#endif
unknown's avatar
unknown committed
2734 2735 2736 2737

  while (name != end)
  {
#if defined(USE_MB) && defined(USE_MB_IDENT)
2738
    last_char_is_space= my_isspace(system_charset_info, *name);
2739
    if (use_mb(system_charset_info))
unknown's avatar
unknown committed
2740
    {
2741
      int len=my_ismbchar(system_charset_info, name, end);
unknown's avatar
unknown committed
2742 2743 2744
      if (len)
      {
        name += len;
2745
        name_length++;
unknown's avatar
unknown committed
2746 2747 2748
        continue;
      }
    }
2749
#endif
2750 2751
    if (check_for_path_chars &&
        (*name == '/' || *name == '\\' || *name == '~' || *name == FN_EXTCHAR))
unknown's avatar
unknown committed
2752 2753
      return 1;
    name++;
2754
    name_length++;
unknown's avatar
unknown committed
2755
  }
unknown's avatar
unknown committed
2756
#if defined(USE_MB) && defined(USE_MB_IDENT)
2757
  return (last_char_is_space || name_length > NAME_CHAR_LEN) ;
2758
#else
unknown's avatar
unknown committed
2759
  return 0;
2760
#endif
unknown's avatar
unknown committed
2761 2762
}

unknown's avatar
unknown committed
2763

unknown's avatar
unknown committed
2764 2765
bool check_column_name(const char *name)
{
2766
  uint name_length= 0;  // name length in symbols
unknown's avatar
unknown committed
2767
  bool last_char_is_space= TRUE;
2768
  
unknown's avatar
unknown committed
2769 2770 2771
  while (*name)
  {
#if defined(USE_MB) && defined(USE_MB_IDENT)
2772
    last_char_is_space= my_isspace(system_charset_info, *name);
2773
    if (use_mb(system_charset_info))
unknown's avatar
unknown committed
2774
    {
2775
      int len=my_ismbchar(system_charset_info, name, 
2776
                          name+system_charset_info->mbmaxlen);
unknown's avatar
unknown committed
2777 2778 2779
      if (len)
      {
        name += len;
2780
        name_length++;
unknown's avatar
unknown committed
2781 2782 2783
        continue;
      }
    }
unknown's avatar
unknown committed
2784
#else
2785
    last_char_is_space= *name==' ';
unknown's avatar
unknown committed
2786 2787 2788 2789
#endif
    if (*name == NAMES_SEP_CHAR)
      return 1;
    name++;
2790
    name_length++;
unknown's avatar
unknown committed
2791
  }
unknown's avatar
unknown committed
2792
  /* Error if empty or too long column name */
2793
  return last_char_is_space || (uint) name_length > NAME_CHAR_LEN;
unknown's avatar
unknown committed
2794 2795
}

2796

2797
/**
2798 2799
  Checks whether a table is intact. Should be done *just* after the table has
  been opened.
2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811

  @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.
2812 2813
*/

2814 2815
bool
Table_check_intact::check(TABLE *table, const TABLE_FIELD_DEF *table_def)
2816 2817 2818
{
  uint i;
  my_bool error= FALSE;
2819
  const TABLE_FIELD_TYPE *field_def= table_def->field;
2820
  DBUG_ENTER("table_check_intact");
2821
  DBUG_PRINT("info",("table: %s  expected_count: %d",
2822
                     table->alias, table_def->count));
2823

2824 2825 2826 2827 2828
  /* Whether the table definition has already been validated. */
  if (table->s->table_field_def_cache == table_def)
    DBUG_RETURN(FALSE);

  if (table->s->fields != table_def->count)
2829
  {
2830 2831 2832 2833
    DBUG_PRINT("info", ("Column count has changed, checking the definition"));

    /* previous MySQL version */
    if (MYSQL_VERSION_ID > table->s->mysql_version)
2834
    {
2835 2836 2837 2838
      report_error(ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE,
                   ER(ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE),
                   table->alias, table_def->count, table->s->fields,
                   table->s->mysql_version, MYSQL_VERSION_ID);
2839 2840 2841 2842
      DBUG_RETURN(TRUE);
    }
    else if (MYSQL_VERSION_ID == table->s->mysql_version)
    {
2843 2844 2845
      report_error(ER_COL_COUNT_DOESNT_MATCH_CORRUPTED,
                   ER(ER_COL_COUNT_DOESNT_MATCH_CORRUPTED), table->alias,
                   table_def->count, table->s->fields);
2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856
      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];
2857
  for (i=0 ; i < table_def->count; i++, field_def++)
2858 2859 2860 2861 2862 2863
  {
    String sql_type(buffer, sizeof(buffer), system_charset_info);
    sql_type.length(0);
    if (i < table->s->fields)
    {
      Field *field= table->field[i];
2864

2865 2866
      if (strncmp(field->field_name, field_def->name.str,
                  field_def->name.length))
2867
      {
2868
        /*
2869 2870 2871
          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.
2872
        */
2873 2874 2875 2876
        report_error(0, "Incorrect definition of table %s.%s: "
                     "expected column '%s' at position %d, found '%s'.",
                     table->s->db.str, table->alias, field_def->name.str, i,
                     field->field_name);
2877
      }
2878
      field->sql_type(sql_type);
2879
      /*
2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895
        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.
       */
2896 2897
      if (strncmp(sql_type.c_ptr_safe(), field_def->type.str,
                  field_def->type.length - 1))
2898
      {
2899 2900 2901 2902 2903
        report_error(0, "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,
                     field_def->name.str, i, field_def->type.str,
                     sql_type.c_ptr_safe());
2904
        error= TRUE;
2905
      }
2906
      else if (field_def->cset.str && !field->has_charset())
2907
      {
2908 2909 2910 2911 2912
        report_error(0, "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,
                     field_def->name.str, i, field_def->cset.str);
2913 2914
        error= TRUE;
      }
2915 2916
      else if (field_def->cset.str &&
               strcmp(field->charset()->csname, field_def->cset.str))
2917
      {
2918 2919 2920 2921 2922 2923
        report_error(0, "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,
                     field_def->name.str, i, field_def->cset.str,
                     field->charset()->csname);
2924
        error= TRUE;
2925 2926
      }
    }
2927 2928
    else
    {
2929 2930 2931 2932 2933
      report_error(0, "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,
                   field_def->name.str, i, field_def->type.str);
2934 2935
      error= TRUE;
    }
2936
  }
2937 2938 2939 2940

  if (! error)
    table->s->table_field_def_cache= table_def;

2941
  DBUG_RETURN(error);
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 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001
/*
  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
3002

unknown's avatar
VIEW  
unknown committed
3003 3004 3005 3006
/*
  calculate md5 of query

  SYNOPSIS
3007
    TABLE_LIST::calc_md5()
unknown's avatar
VIEW  
unknown committed
3008 3009
    buffer	buffer for md5 writing
*/
3010

3011
void  TABLE_LIST::calc_md5(char *buffer)
unknown's avatar
VIEW  
unknown committed
3012
{
3013
  uchar digest[16];
3014
  MY_MD5_HASH(digest, (uchar *) select_stmt.str, select_stmt.length);
unknown's avatar
VIEW  
unknown committed
3015 3016 3017 3018 3019 3020 3021 3022 3023
  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]);
}


3024 3025
/**
   @brief Set underlying table for table place holder of view.
unknown's avatar
VIEW  
unknown committed
3026

3027
   @details
unknown's avatar
unknown committed
3028

3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044
   Replace all views that only use one table with the table itself.  This
   allows us to treat the view as a simple table and even update it (it is a
   kind of optimization).

   @note 

   This optimization is potentially dangerous as it makes views
   masquerade as base tables: Views don't have the pointer TABLE_LIST::table
   set to non-@c NULL.

   We may have the case where a view accesses tables not normally accessible
   in the current Security_context (only in the definer's
   Security_context). According to the table's GRANT_INFO (TABLE::grant),
   access is fulfilled, but this is implicitly meant in the definer's security
   context. Hence we must never look at only a TABLE's GRANT_INFO without
   looking at the one of the referring TABLE_LIST.
unknown's avatar
VIEW  
unknown committed
3045
*/
3046

3047
void TABLE_LIST::set_underlying_merge()
unknown's avatar
VIEW  
unknown committed
3048
{
unknown's avatar
unknown committed
3049 3050
  TABLE_LIST *tbl;

3051
  if ((tbl= merge_underlying_list))
unknown's avatar
merge  
unknown committed
3052
  {
unknown's avatar
unknown committed
3053
    /* This is a view. Process all tables of view */
3054
    DBUG_ASSERT(view && effective_algorithm == VIEW_ALGORITHM_MERGE);
unknown's avatar
unknown committed
3055 3056
    do
    {
3057
      if (tbl->merge_underlying_list)          // This is a view
unknown's avatar
unknown committed
3058
      {
3059 3060
        DBUG_ASSERT(tbl->view &&
                    tbl->effective_algorithm == VIEW_ALGORITHM_MERGE);
unknown's avatar
unknown committed
3061 3062 3063 3064
        /*
          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)
        */
3065
        tbl->merge_underlying_list->set_underlying_merge();
unknown's avatar
unknown committed
3066 3067 3068
      }
    } while ((tbl= tbl->next_local));

unknown's avatar
unknown committed
3069
    if (!multitable_view)
unknown's avatar
unknown committed
3070
    {
3071 3072
      table= merge_underlying_list->table;
      schema_table= merge_underlying_list->schema_table;
unknown's avatar
unknown committed
3073
    }
unknown's avatar
merge  
unknown committed
3074
  }
3075 3076 3077
}


unknown's avatar
VIEW  
unknown committed
3078 3079 3080 3081
/*
  setup fields of placeholder of merged VIEW

  SYNOPSIS
3082
    TABLE_LIST::setup_underlying()
3083
    thd		    - thread handler
3084

3085 3086
  DESCRIPTION
    It is:
3087
    - preparing translation table for view columns
3088 3089
    If there are underlying view(s) procedure first will be called for them.

unknown's avatar
VIEW  
unknown committed
3090
  RETURN
unknown's avatar
unknown committed
3091 3092
    FALSE - OK
    TRUE  - error
unknown's avatar
VIEW  
unknown committed
3093
*/
3094

3095
bool TABLE_LIST::setup_underlying(THD *thd)
unknown's avatar
VIEW  
unknown committed
3096
{
3097
  DBUG_ENTER("TABLE_LIST::setup_underlying");
3098 3099

  if (!field_translation && merge_underlying_list)
3100
  {
3101 3102 3103 3104 3105 3106 3107
    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;

3108
    if (check_stack_overrun(thd, STACK_MIN_SIZE, (uchar*) &field_count))
3109
    {
unknown's avatar
unknown committed
3110
      DBUG_RETURN(TRUE);
3111
    }
unknown's avatar
VIEW  
unknown committed
3112

3113
    for (tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3114
    {
3115 3116
      if (tbl->merge_underlying_list &&
          tbl->setup_underlying(thd))
3117 3118 3119 3120
      {
        DBUG_RETURN(TRUE);
      }
    }
unknown's avatar
unknown committed
3121

3122 3123 3124
    /* Create view fields translation table */

    if (!(transl=
unknown's avatar
unknown committed
3125
          (Field_translator*)(thd->stmt_arena->
3126 3127
                              alloc(select->item_list.elements *
                                    sizeof(Field_translator)))))
unknown's avatar
VIEW  
unknown committed
3128
    {
3129
      DBUG_RETURN(TRUE);
3130
    }
3131 3132

    while ((item= it++))
3133
    {
3134 3135
      transl[field_count].name= item->name;
      transl[field_count++].item= item;
3136
    }
3137 3138 3139
    field_translation= transl;
    field_translation_end= transl + field_count;
    /* TODO: use hash for big number of fields */
3140

3141 3142
    /* full text function moving to current select */
    if (view->select_lex.ftfunc_list->elements)
3143
    {
3144 3145 3146 3147 3148 3149
      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
3150 3151
    }
  }
3152 3153
  DBUG_RETURN(FALSE);
}
unknown's avatar
VIEW  
unknown committed
3154

unknown's avatar
unknown committed
3155

3156 3157
/*
  Prepare where expression of view
3158

3159
  SYNOPSIS
3160
    TABLE_LIST::prep_where()
3161 3162 3163 3164
    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
3165

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

3169 3170 3171 3172
  RETURN
    FALSE - OK
    TRUE  - error
*/
unknown's avatar
VIEW  
unknown committed
3173

3174
bool TABLE_LIST::prep_where(THD *thd, Item **conds,
3175 3176
                               bool no_where_clause)
{
3177
  DBUG_ENTER("TABLE_LIST::prep_where");
3178

3179
  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3180
  {
3181 3182 3183 3184
    if (tbl->view && tbl->prep_where(thd, conds, no_where_clause))
    {
      DBUG_RETURN(TRUE);
    }
3185
  }
3186

3187 3188 3189
  if (where)
  {
    if (!where->fixed && where->fix_fields(thd, &where))
unknown's avatar
VIEW  
unknown committed
3190
    {
3191
      DBUG_RETURN(TRUE);
unknown's avatar
VIEW  
unknown committed
3192
    }
unknown's avatar
unknown committed
3193 3194 3195 3196 3197

    /*
      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)
    */
3198
    if (!no_where_clause && !where_processed)
unknown's avatar
VIEW  
unknown committed
3199
    {
3200
      TABLE_LIST *tbl= this;
unknown's avatar
unknown committed
3201 3202
      Query_arena *arena= thd->stmt_arena, backup;
      arena= thd->activate_stmt_arena_if_needed(&backup);  // For easier test
3203

unknown's avatar
unknown committed
3204 3205
      /* Go up to join tree and try to find left join */
      for (; tbl; tbl= tbl->embedding)
unknown's avatar
unknown committed
3206
      {
unknown's avatar
unknown committed
3207 3208 3209 3210
        if (tbl->outer_join)
        {
          /*
            Store WHERE condition to ON expression for outer join, because
3211
            we can't use WHERE to correctly execute left joins on VIEWs and
unknown's avatar
unknown committed
3212 3213 3214
            this expression will not be moved to WHERE condition (i.e. will
            be clean correctly for PS/SP)
          */
3215 3216
          tbl->on_expr= and_conds(tbl->on_expr,
                                  where->copy_andor_structure(thd));
unknown's avatar
unknown committed
3217 3218
          break;
        }
unknown's avatar
unknown committed
3219
      }
unknown's avatar
unknown committed
3220
      if (tbl == 0)
3221
        *conds= and_conds(*conds, where->copy_andor_structure(thd));
3222
      if (arena)
unknown's avatar
unknown committed
3223
        thd->restore_active_arena(arena, &backup);
3224
      where_processed= TRUE;
unknown's avatar
VIEW  
unknown committed
3225 3226
    }
  }
3227

3228 3229 3230 3231
  DBUG_RETURN(FALSE);
}


unknown's avatar
unknown committed
3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272
/*
  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);
}


3273 3274 3275 3276
/*
  Prepare check option expression of table

  SYNOPSIS
3277
    TABLE_LIST::prep_check_option()
3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288
    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
3289 3290
    This method builds check option condition to use it later on
    every call (usual execution or every SP/PS call).
3291
    This method have to be called after WHERE preparation
3292
    (TABLE_LIST::prep_where)
unknown's avatar
VIEW  
unknown committed
3293

3294 3295 3296 3297 3298
  RETURN
    FALSE - OK
    TRUE  - error
*/

3299
bool TABLE_LIST::prep_check_option(THD *thd, uint8 check_opt_type)
3300
{
3301
  DBUG_ENTER("TABLE_LIST::prep_check_option");
unknown's avatar
unknown committed
3302
  bool is_cascaded= check_opt_type == VIEW_CHECK_CASCADED;
3303

3304
  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3305
  {
3306
    /* see comment of check_opt_type parameter */
unknown's avatar
unknown committed
3307 3308 3309
    if (tbl->view && tbl->prep_check_option(thd, (is_cascaded ?
                                                  VIEW_CHECK_CASCADED :
                                                  VIEW_CHECK_NONE)))
3310
      DBUG_RETURN(TRUE);
3311
  }
unknown's avatar
VIEW  
unknown committed
3312

unknown's avatar
unknown committed
3313
  if (check_opt_type && !check_option_processed)
3314
  {
unknown's avatar
unknown committed
3315 3316 3317
    Query_arena *arena= thd->stmt_arena, backup;
    arena= thd->activate_stmt_arena_if_needed(&backup);  // For easier test

3318 3319 3320
    if (where)
    {
      DBUG_ASSERT(where->fixed);
unknown's avatar
unknown committed
3321
      check_option= where->copy_andor_structure(thd);
3322
    }
unknown's avatar
unknown committed
3323
    if (is_cascaded)
3324
    {
3325
      for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3326 3327
      {
        if (tbl->check_option)
unknown's avatar
unknown committed
3328
          check_option= and_conds(check_option, tbl->check_option);
3329 3330
      }
    }
unknown's avatar
unknown committed
3331 3332 3333 3334 3335 3336 3337
    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;

3338 3339 3340 3341 3342 3343
  }

  if (check_option)
  {
    const char *save_where= thd->where;
    thd->where= "check option";
3344 3345
    if ((!check_option->fixed &&
        check_option->fix_fields(thd, &check_option)) ||
3346 3347 3348 3349 3350
        check_option->check_cols(1))
    {
      DBUG_RETURN(TRUE);
    }
    thd->where= save_where;
3351
  }
3352 3353 3354
  DBUG_RETURN(FALSE);
}

3355

3356
/**
3357 3358 3359 3360 3361 3362
  Hide errors which show view underlying table information. 
  There are currently two mechanisms at work that handle errors for views,
  this one and a more general mechanism based on an Internal_error_handler,
  see Show_create_error_handler. The latter handles errors encountered during
  execution of SHOW CREATE VIEW, while the machanism using this method is
  handles SELECT from views. The two methods should not clash.
3363

3364
  @param[in,out]  thd     thread handler
unknown's avatar
VIEW  
unknown committed
3365

3366
  @pre This method can be called only if there is an error.
3367 3368
*/

3369
void TABLE_LIST::hide_view_error(THD *thd)
3370
{
3371
  if (thd->killed || thd->get_internal_handler())
3372
    return;
3373
  /* Hide "Unknown column" or "Unknown function" error */
3374 3375 3376 3377
  DBUG_ASSERT(thd->is_error());

  if (thd->main_da.sql_errno() == ER_BAD_FIELD_ERROR ||
      thd->main_da.sql_errno() == ER_SP_DOES_NOT_EXIST ||
3378
      thd->main_da.sql_errno() == ER_FUNC_INEXISTENT_NAME_COLLISION ||
3379 3380 3381 3382 3383
      thd->main_da.sql_errno() == ER_PROCACCESS_DENIED_ERROR ||
      thd->main_da.sql_errno() == ER_COLUMNACCESS_DENIED_ERROR ||
      thd->main_da.sql_errno() == ER_TABLEACCESS_DENIED_ERROR ||
      thd->main_da.sql_errno() == ER_TABLE_NOT_LOCKED ||
      thd->main_da.sql_errno() == ER_NO_SUCH_TABLE)
3384
  {
3385
    TABLE_LIST *top= top_table();
3386
    thd->clear_error();
3387
    my_error(ER_VIEW_INVALID, MYF(0), top->view_db.str, top->view_name.str);
3388
  }
3389
  else if (thd->main_da.sql_errno() == ER_NO_DEFAULT_FOR_FIELD)
3390
  {
3391
    TABLE_LIST *top= top_table();
3392 3393
    thd->clear_error();
    // TODO: make correct error message
3394 3395
    my_error(ER_NO_DEFAULT_FOR_VIEW_FIELD, MYF(0),
             top->view_db.str, top->view_name.str);
3396
  }
unknown's avatar
VIEW  
unknown committed
3397 3398 3399
}


3400 3401 3402 3403 3404
/*
  Find underlying base tables (TABLE_LIST) which represent given
  table_to_find (TABLE)

  SYNOPSIS
3405
    TABLE_LIST::find_underlying_table()
3406 3407 3408 3409 3410 3411 3412
    table_to_find table to find

  RETURN
    0  table is not found
    found table reference
*/

3413
TABLE_LIST *TABLE_LIST::find_underlying_table(TABLE *table_to_find)
3414 3415
{
  /* is this real table and table which we are looking for? */
3416
  if (table == table_to_find && merge_underlying_list == 0)
3417 3418
    return this;

3419
  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3420 3421 3422 3423 3424 3425 3426 3427
  {
    TABLE_LIST *result;
    if ((result= tbl->find_underlying_table(table_to_find)))
      return result;
  }
  return 0;
}

unknown's avatar
unknown committed
3428
/*
3429
  cleanup items belonged to view fields translation table
unknown's avatar
unknown committed
3430 3431

  SYNOPSIS
3432
    TABLE_LIST::cleanup_items()
unknown's avatar
unknown committed
3433 3434
*/

3435
void TABLE_LIST::cleanup_items()
unknown's avatar
unknown committed
3436 3437 3438 3439
{
  if (!field_translation)
    return;

3440 3441 3442
  for (Field_translator *transl= field_translation;
       transl < field_translation_end;
       transl++)
3443
    transl->item->walk(&Item::cleanup_processor, 0, 0);
unknown's avatar
unknown committed
3444 3445 3446
}


unknown's avatar
unknown committed
3447 3448 3449 3450
/*
  check CHECK OPTION condition

  SYNOPSIS
3451
    TABLE_LIST::view_check_option()
unknown's avatar
unknown committed
3452 3453 3454 3455 3456 3457 3458 3459
    ignore_failure ignore check option fail

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

3460
int TABLE_LIST::view_check_option(THD *thd, bool ignore_failure)
unknown's avatar
unknown committed
3461 3462 3463
{
  if (check_option && check_option->val_int() == 0)
  {
3464
    TABLE_LIST *main_view= top_table();
unknown's avatar
unknown committed
3465 3466 3467 3468
    if (ignore_failure)
    {
      push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
                          ER_VIEW_CHECK_FAILED, ER(ER_VIEW_CHECK_FAILED),
3469
                          main_view->view_db.str, main_view->view_name.str);
unknown's avatar
unknown committed
3470 3471
      return(VIEW_CHECK_SKIP);
    }
3472 3473 3474
    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
3475 3476 3477 3478 3479
  }
  return(VIEW_CHECK_OK);
}


3480
/*
3481
  Find table in underlying tables by mask and check that only this
unknown's avatar
unknown committed
3482
  table belong to given mask
3483 3484

  SYNOPSIS
3485
    TABLE_LIST::check_single_table()
3486
    table_arg	reference on variable where to store found table
3487 3488 3489
		(should be 0 on call, to find table, or point to table for
		unique test)
    map         bit mask of tables
3490
    view_arg    view for which we are looking table
3491 3492

  RETURN
unknown's avatar
unknown committed
3493 3494
    FALSE table not found or found only one
    TRUE  found several tables
3495 3496
*/

3497
bool TABLE_LIST::check_single_table(TABLE_LIST **table_arg,
3498
                                       table_map map,
3499
                                       TABLE_LIST *view_arg)
3500
{
3501
  for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3502 3503 3504 3505 3506
  {
    if (tbl->table)
    {
      if (tbl->table->map & map)
      {
3507
	if (*table_arg)
unknown's avatar
unknown committed
3508
	  return TRUE;
3509 3510
        *table_arg= tbl;
        tbl->check_option= view_arg->check_option;
3511 3512
      }
    }
3513
    else if (tbl->check_single_table(table_arg, map, view_arg))
unknown's avatar
unknown committed
3514
      return TRUE;
3515
  }
unknown's avatar
unknown committed
3516
  return FALSE;
3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531
}


/*
  Set insert_values buffer

  SYNOPSIS
    set_insert_values()
    mem_root   memory pool for allocating

  RETURN
    FALSE - OK
    TRUE  - out of memory
*/

3532
bool TABLE_LIST::set_insert_values(MEM_ROOT *mem_root)
3533 3534 3535 3536
{
  if (table)
  {
    if (!table->insert_values &&
3537
        !(table->insert_values= (uchar *)alloc_root(mem_root,
3538
                                                   table->s->rec_buff_length)))
3539 3540 3541 3542
      return TRUE;
  }
  else
  {
3543 3544
    DBUG_ASSERT(view && merge_underlying_list);
    for (TABLE_LIST *tbl= merge_underlying_list; tbl; tbl= tbl->next_local)
3545 3546 3547 3548 3549 3550 3551
      if (tbl->set_insert_values(mem_root))
        return TRUE;
  }
  return FALSE;
}


unknown's avatar
unknown committed
3552 3553 3554 3555
/*
  Test if this is a leaf with respect to name resolution.

  SYNOPSIS
3556
    TABLE_LIST::is_leaf_for_name_resolution()
unknown's avatar
unknown committed
3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567

  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.
*/
3568
bool TABLE_LIST::is_leaf_for_name_resolution()
unknown's avatar
unknown committed
3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579
{
  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
3580
    TABLE_LIST::first_leaf_for_name_resolution()
unknown's avatar
unknown committed
3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592

  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
3593
    If 'this' is a nested table reference - the left-most child of
unknown's avatar
unknown committed
3594
      the tree rooted in 'this',
3595
    else return 'this'
unknown's avatar
unknown committed
3596 3597
*/

3598
TABLE_LIST *TABLE_LIST::first_leaf_for_name_resolution()
unknown's avatar
unknown committed
3599
{
3600 3601 3602
  TABLE_LIST *cur_table_ref;
  NESTED_JOIN *cur_nested_join;
  LINT_INIT(cur_table_ref);
unknown's avatar
unknown committed
3603

3604
  if (is_leaf_for_name_resolution())
unknown's avatar
unknown committed
3605
    return this;
3606
  DBUG_ASSERT(nested_join);
unknown's avatar
unknown committed
3607

3608 3609 3610
  for (cur_nested_join= nested_join;
       cur_nested_join;
       cur_nested_join= cur_table_ref->nested_join)
unknown's avatar
unknown committed
3611 3612 3613 3614
  {
    List_iterator_fast<TABLE_LIST> it(cur_nested_join->join_list);
    cur_table_ref= it++;
    /*
3615 3616 3617 3618
      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
3619 3620 3621
    */
    if (!(cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
    {
3622
      TABLE_LIST *next;
unknown's avatar
unknown committed
3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637
      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
3638
    TABLE_LIST::last_leaf_for_name_resolution()
unknown's avatar
unknown committed
3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655

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

3656
TABLE_LIST *TABLE_LIST::last_leaf_for_name_resolution()
unknown's avatar
unknown committed
3657 3658
{
  TABLE_LIST *cur_table_ref= this;
3659
  NESTED_JOIN *cur_nested_join;
unknown's avatar
unknown committed
3660

3661
  if (is_leaf_for_name_resolution())
unknown's avatar
unknown committed
3662
    return this;
3663
  DBUG_ASSERT(nested_join);
unknown's avatar
unknown committed
3664

3665 3666 3667
  for (cur_nested_join= nested_join;
       cur_nested_join;
       cur_nested_join= cur_table_ref->nested_join)
unknown's avatar
unknown committed
3668
  {
3669
    cur_table_ref= cur_nested_join->join_list.head();
unknown's avatar
unknown committed
3670
    /*
3671 3672 3673
      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
3674 3675 3676 3677
    */
    if ((cur_table_ref->outer_join & JOIN_TYPE_RIGHT))
    {
      List_iterator_fast<TABLE_LIST> it(cur_nested_join->join_list);
3678
      TABLE_LIST *next;
unknown's avatar
unknown committed
3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689
      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;
}


3690 3691 3692 3693 3694 3695 3696 3697
/*
  Register access mode which we need for underlying tables

  SYNOPSIS
    register_want_access()
    want_access          Acess which we require
*/

3698
void TABLE_LIST::register_want_access(ulong want_access)
3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713
{
  /* 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
3714
  Load security context information for this view
3715 3716

  SYNOPSIS
3717
    TABLE_LIST::prepare_view_securety_context()
3718 3719 3720 3721 3722 3723 3724 3725
    thd                  [in] thread handler

  RETURN
    FALSE  OK
    TRUE   Error
*/

#ifndef NO_EMBEDDED_ACCESS_CHECKS
3726
bool TABLE_LIST::prepare_view_securety_context(THD *thd)
3727
{
3728
  DBUG_ENTER("TABLE_LIST::prepare_view_securety_context");
3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741
  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))
    {
3742 3743
      if ((thd->lex->sql_command == SQLCOM_SHOW_CREATE) ||
          (thd->lex->sql_command == SQLCOM_SHOW_FIELDS))
3744 3745 3746 3747 3748 3749 3750 3751
      {
        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
      {
3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763
        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)));
        }
3764 3765
        DBUG_RETURN(TRUE);
      }
3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776
    }
  }
  DBUG_RETURN(FALSE);
}
#endif


/*
  Find security context of current view

  SYNOPSIS
3777
    TABLE_LIST::find_view_security_context()
3778 3779 3780 3781 3782
    thd                  [in] thread handler

*/

#ifndef NO_EMBEDDED_ACCESS_CHECKS
3783
Security_context *TABLE_LIST::find_view_security_context(THD *thd)
3784 3785 3786
{
  Security_context *sctx;
  TABLE_LIST *upper_view= this;
3787
  DBUG_ENTER("TABLE_LIST::find_view_security_context");
3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815

  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
3816
    TABLE_LIST::prepare_security()
3817 3818 3819 3820 3821 3822 3823
    thd                  [in] thread handler

  RETURN
    FALSE  OK
    TRUE   Error
*/

3824
bool TABLE_LIST::prepare_security(THD *thd)
3825 3826 3827
{
  List_iterator_fast<TABLE_LIST> tb(*view_tables);
  TABLE_LIST *tbl;
3828
  DBUG_ENTER("TABLE_LIST::prepare_security");
3829 3830 3831 3832 3833 3834 3835 3836 3837 3838
#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);
3839
    char *local_db, *local_table_name;
3840 3841
    if (tbl->view)
    {
3842 3843
      local_db= tbl->view_db.str;
      local_table_name= tbl->view_name.str;
3844 3845 3846
    }
    else
    {
3847 3848
      local_db= tbl->db;
      local_table_name= tbl->table_name;
3849
    }
3850 3851
    fill_effective_table_privileges(thd, &tbl->grant, local_db,
                                    local_table_name);
3852 3853 3854 3855 3856 3857 3858 3859
    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
3860
  DBUG_RETURN(FALSE);
3861 3862 3863
}


unknown's avatar
unknown committed
3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874
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;
}


3875
Natural_join_column::Natural_join_column(Item_field *field_param,
unknown's avatar
unknown committed
3876 3877
                                         TABLE_LIST *tab)
{
3878
  DBUG_ASSERT(tab->table == field_param->field->table);
unknown's avatar
unknown committed
3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892
  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;
  }
3893 3894

  return table_field->field_name;
unknown's avatar
unknown committed
3895 3896 3897 3898 3899 3900 3901 3902
}


Item *Natural_join_column::create_item(THD *thd)
{
  if (view_field)
  {
    DBUG_ASSERT(table_field == NULL);
3903 3904
    return create_view_field(thd, table_ref, &view_field->item,
                             view_field->name);
unknown's avatar
unknown committed
3905
  }
3906
  return table_field;
unknown's avatar
unknown committed
3907 3908 3909 3910 3911 3912 3913 3914 3915 3916
}


Field *Natural_join_column::field()
{
  if (view_field)
  {
    DBUG_ASSERT(table_field == NULL);
    return NULL;
  }
3917
  return table_field->field;
unknown's avatar
unknown committed
3918 3919 3920 3921 3922
}


const char *Natural_join_column::table_name()
{
3923
  DBUG_ASSERT(table_ref);
unknown's avatar
unknown committed
3924 3925 3926 3927 3928 3929 3930 3931
  return table_ref->alias;
}


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

3933 3934 3935 3936 3937
  /*
    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.
  */
3938
  DBUG_ASSERT(!strcmp(table_ref->db,
3939
                      table_ref->table->s->db.str) ||
3940
              (table_ref->schema_table &&
3941
               table_ref->table->s->db.str[0] == 0));
3942
  return table_ref->db;
unknown's avatar
unknown committed
3943 3944 3945 3946 3947 3948 3949
}


GRANT_INFO *Natural_join_column::grant()
{
  if (view_field)
    return &(table_ref->grant);
3950
  return &(table_ref->table->grant);
unknown's avatar
unknown committed
3951 3952 3953
}


unknown's avatar
VIEW  
unknown committed
3954 3955
void Field_iterator_view::set(TABLE_LIST *table)
{
unknown's avatar
unknown committed
3956
  DBUG_ASSERT(table->field_translation);
3957
  view= table;
unknown's avatar
VIEW  
unknown committed
3958
  ptr= table->field_translation;
3959
  array_end= table->field_translation_end;
unknown's avatar
VIEW  
unknown committed
3960 3961 3962 3963 3964 3965 3966 3967 3968
}


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


3969
Item *Field_iterator_table::create_item(THD *thd)
unknown's avatar
VIEW  
unknown committed
3970
{
3971 3972 3973 3974 3975 3976 3977 3978 3979 3980
  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
3981 3982 3983 3984 3985
}


const char *Field_iterator_view::name()
{
3986
  return ptr->name;
unknown's avatar
VIEW  
unknown committed
3987 3988 3989
}


3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004
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)
  {
    /*
4005 4006 4007
      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.
4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024
    */
    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;
4025
  if (save_wrapper)
4026 4027 4028
  {
    DBUG_RETURN(field);
  }
4029
  Item *item= new Item_direct_view_ref(view, field_ref, name);
4030 4031 4032 4033
  DBUG_RETURN(item);
}


unknown's avatar
unknown committed
4034 4035 4036
void Field_iterator_natural_join::set(TABLE_LIST *table_ref)
{
  DBUG_ASSERT(table_ref->join_columns);
4037 4038
  column_ref_it.init(*(table_ref->join_columns));
  cur_column_ref= column_ref_it++;
unknown's avatar
unknown committed
4039 4040 4041
}


4042 4043
void Field_iterator_natural_join::next()
{
4044
  cur_column_ref= column_ref_it++;
4045 4046
  DBUG_ASSERT(!cur_column_ref || ! cur_column_ref->table_field ||
              cur_column_ref->table_ref->table ==
4047
              cur_column_ref->table_field->field->table);
4048 4049 4050
}


unknown's avatar
unknown committed
4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065
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 ||
4066
                (table_ref->join_columns &&
unknown's avatar
unknown committed
4067 4068 4069 4070 4071 4072 4073 4074
                /* 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 ==
4075
                  table_ref->table->s->fields))));
unknown's avatar
unknown committed
4076 4077
    field_it= &natural_join_it;
    DBUG_PRINT("info",("field_it for '%s' is Field_iterator_natural_join",
unknown's avatar
unknown committed
4078
                       table_ref->alias));
unknown's avatar
unknown committed
4079 4080 4081 4082 4083 4084 4085 4086
  }
  /* 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
4087
                        table_ref->alias));
unknown's avatar
unknown committed
4088 4089 4090 4091 4092 4093 4094
  }
  /* 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
4095
                        table_ref->alias));
unknown's avatar
unknown committed
4096
  }
4097
  field_it->set(table_ref);
unknown's avatar
unknown committed
4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129
  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();
  }
}


4130
const char *Field_iterator_table_ref::get_table_name()
unknown's avatar
unknown committed
4131 4132 4133 4134 4135
{
  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();
4136 4137

  DBUG_ASSERT(!strcmp(table_ref->table_name,
unknown's avatar
unknown committed
4138
                      table_ref->table->s->table_name.str));
4139
  return table_ref->table_name;
unknown's avatar
unknown committed
4140 4141 4142
}


4143
const char *Field_iterator_table_ref::get_db_name()
unknown's avatar
unknown committed
4144 4145 4146 4147 4148
{
  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();
4149

4150 4151 4152 4153 4154
  /*
    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.
  */
4155
  DBUG_ASSERT(!strcmp(table_ref->db, table_ref->table->s->db.str) ||
4156
              (table_ref->schema_table &&
4157
               table_ref->table->s->db.str[0] == 0));
4158

4159
  return table_ref->db;
unknown's avatar
unknown committed
4160 4161 4162 4163 4164 4165 4166 4167 4168
}


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();
4169
  return &(table_ref->table->grant);
unknown's avatar
unknown committed
4170 4171 4172 4173 4174 4175 4176 4177 4178
}


/*
  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
4179 4180
    parent_table_ref  the parent table reference over which the
                      iterator is iterating
unknown's avatar
unknown committed
4181 4182

  DESCRIPTION
unknown's avatar
unknown committed
4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203
    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
4204 4205

  RETURN
4206 4207
    #     Pointer to a column of a natural join (or its operand)
    NULL  No memory to allocate the column
unknown's avatar
unknown committed
4208 4209 4210
*/

Natural_join_column *
4211
Field_iterator_table_ref::get_or_create_column_ref(THD *thd, TABLE_LIST *parent_table_ref)
unknown's avatar
unknown committed
4212
{
4213
  Natural_join_column *nj_col;
unknown's avatar
unknown committed
4214 4215 4216 4217
  bool is_created= TRUE;
  uint field_count;
  TABLE_LIST *add_table_ref= parent_table_ref ?
                             parent_table_ref : table_ref;
4218
  LINT_INIT(field_count);
unknown's avatar
unknown committed
4219

unknown's avatar
unknown committed
4220
  if (field_it == &table_field_it)
4221 4222
  {
    /* The field belongs to a stored table. */
4223
    Field *tmp_field= table_field_it.field();
4224 4225 4226 4227 4228
    Item_field *tmp_item=
      new Item_field(thd, &thd->lex->current_select->context, tmp_field);
    if (!tmp_item)
      return NULL;
    nj_col= new Natural_join_column(tmp_item, table_ref);
unknown's avatar
unknown committed
4229
    field_count= table_ref->table->s->fields;
4230 4231 4232 4233 4234 4235
  }
  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
4236 4237
    field_count= table_ref->field_translation_end -
                 table_ref->field_translation;
4238 4239 4240 4241 4242 4243 4244 4245
  }
  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
4246 4247
    DBUG_ASSERT(table_ref->is_join_columns_complete);
    is_created= FALSE;
4248 4249 4250
    nj_col= natural_join_it.column_ref();
    DBUG_ASSERT(nj_col);
  }
4251
  DBUG_ASSERT(!nj_col->table_field ||
4252
              nj_col->table_ref->table == nj_col->table_field->field->table);
unknown's avatar
unknown committed
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

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

4283
  return nj_col;
unknown's avatar
unknown committed
4284 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
/*
  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 ||
4317
               nj_col->table_ref->table == nj_col->table_field->field->table));
4318 4319 4320
  return nj_col;
}

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

4378
  set_keyread(TRUE);
4379 4380 4381 4382 4383 4384 4385
  bitmap_clear_all(bitmap);
  mark_columns_used_by_index_no_reset(index, bitmap);
  column_bitmaps_set(bitmap, bitmap);
  DBUG_VOID_RETURN;
}


4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406
/*
  Add fields used by a specified index to the table's read_set.

  NOTE:
    The original state can be restored with
    restore_column_maps_after_mark_index().
*/

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

  set_keyread(TRUE);
  bitmap_copy(bitmap, read_set);
  mark_columns_used_by_index_no_reset(index, bitmap);
  column_bitmaps_set(bitmap, write_set);
  DBUG_VOID_RETURN;
}


4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421
/*
  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");

4422
  set_keyread(FALSE);
4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 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
  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);
4461
  if (s->next_number_keypart)
4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487
    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)
4488
    triggers->mark_fields_used(TRG_EVENT_DELETE);
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 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538
  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)
4539
    triggers->mark_fields_used(TRG_EVENT_UPDATE);
4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581
  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)
  {
4582 4583 4584 4585 4586 4587 4588 4589
    /*
      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);
4590 4591 4592 4593 4594
  }
  if (found_next_number_field)
    mark_auto_increment_column();
}

4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613

/**
  @brief Check if this is part of a MERGE table with attached children.

  @return       status
    @retval     TRUE            children are attached
    @retval     FALSE           no MERGE part or children not attached

  @detail
    A MERGE table consists of a parent TABLE and zero or more child
    TABLEs. Each of these TABLEs is called a part of a MERGE table.
*/

bool st_table::is_children_attached(void)
{
  return((child_l && children_attached) ||
         (parent && parent->children_attached));
}

4614 4615 4616 4617
/*
  Cleanup this table for re-execution.

  SYNOPSIS
4618
    TABLE_LIST::reinit_before_use()
4619 4620
*/

4621
void TABLE_LIST::reinit_before_use(THD *thd)
4622 4623 4624 4625 4626 4627
{
  /*
    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;
4628
  /* Reset is_schema_table_processed value(needed for I_S tables */
4629
  schema_table_state= NOT_PROCESSED;
4630 4631

  TABLE_LIST *embedded; /* The table at the current level of nesting. */
4632
  TABLE_LIST *parent_embedding= this; /* The parent nested table reference. */
4633 4634
  do
  {
4635
    embedded= parent_embedding;
4636 4637
    if (embedded->prep_on_expr)
      embedded->on_expr= embedded->prep_on_expr->copy_andor_structure(thd);
4638
    parent_embedding= embedded->embedding;
4639
  }
4640 4641
  while (parent_embedding &&
         parent_embedding->nested_join->join_list.head() == embedded);
4642 4643
}

unknown's avatar
unknown committed
4644 4645 4646 4647
/*
  Return subselect that contains the FROM list this table is taken from

  SYNOPSIS
4648
    TABLE_LIST::containing_subselect()
unknown's avatar
unknown committed
4649 4650 4651 4652 4653 4654 4655 4656
 
  RETURN
    Subselect item for the subquery that contains the FROM list
    this table is taken from if there is any
    0 - otherwise

*/

4657
Item_subselect *TABLE_LIST::containing_subselect()
unknown's avatar
unknown committed
4658 4659 4660
{    
  return (select_lex ? select_lex->master_unit()->item : 0);
}
4661

4662 4663 4664 4665 4666 4667 4668 4669 4670
/*
  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" 
4671
    (TABLE_LIST::index_hints). Using the information in this tagged list
4672 4673
    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,
4674 4675
    st_table::force_index, st_table::force_index_order, 
    st_table::force_index_group and st_table::covering_keys.
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

    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.
*/
4714
bool TABLE_LIST::process_index_hints(TABLE *tbl)
4715 4716
{
  /* initialize the result variables */
4717 4718
  tbl->keys_in_use_for_query= tbl->keys_in_use_for_group_by= 
    tbl->keys_in_use_for_order_by= tbl->s->keys_in_use;
4719 4720 4721 4722 4723 4724 4725

  /* 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
4726
    Index_hint *hint;
4727 4728 4729
    int type;
    bool have_empty_use_join= FALSE, have_empty_use_order= FALSE, 
         have_empty_use_group= FALSE;
unknown's avatar
unknown committed
4730
    List_iterator <Index_hint> iter(*index_hints);
4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769

    /* 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 
      */
4770 4771
      if (tbl->s->keynames.type_names == 0 ||
          (pos= find_type(&tbl->s->keynames, hint->key_name.str,
4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802
                          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 */
4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819
    if (!index_order[INDEX_HINT_FORCE].is_clear_all())
    {
      tbl->force_index_order= TRUE;
      index_order[INDEX_HINT_USE].merge(index_order[INDEX_HINT_FORCE]);
    }

    if (!index_group[INDEX_HINT_FORCE].is_clear_all())
    {
      tbl->force_index_group= TRUE;
      index_group[INDEX_HINT_USE].merge(index_group[INDEX_HINT_FORCE]);
    }

    /*
      TODO: get rid of tbl->force_index (on if any FORCE INDEX is specified) and
      create tbl->force_index_join instead.
      Then use the correct force_index_XX instead of the global one.
    */
4820
    if (!index_join[INDEX_HINT_FORCE].is_clear_all() ||
4821
        tbl->force_index_group || tbl->force_index_order)
4822
    {
4823
      tbl->force_index= TRUE;
4824 4825 4826 4827 4828
      index_join[INDEX_HINT_USE].merge(index_join[INDEX_HINT_FORCE]);
    }

    /* apply USE INDEX */
    if (!index_join[INDEX_HINT_USE].is_clear_all() || have_empty_use_join)
4829
      tbl->keys_in_use_for_query.intersect(index_join[INDEX_HINT_USE]);
4830
    if (!index_order[INDEX_HINT_USE].is_clear_all() || have_empty_use_order)
4831
      tbl->keys_in_use_for_order_by.intersect (index_order[INDEX_HINT_USE]);
4832
    if (!index_group[INDEX_HINT_USE].is_clear_all() || have_empty_use_group)
4833
      tbl->keys_in_use_for_group_by.intersect (index_group[INDEX_HINT_USE]);
4834 4835

    /* apply IGNORE INDEX */
4836 4837 4838
    tbl->keys_in_use_for_query.subtract (index_join[INDEX_HINT_IGNORE]);
    tbl->keys_in_use_for_order_by.subtract (index_order[INDEX_HINT_IGNORE]);
    tbl->keys_in_use_for_group_by.subtract (index_group[INDEX_HINT_IGNORE]);
4839 4840 4841
  }

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

4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863

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
4864 4865 4866 4867
/*****************************************************************************
** Instansiate templates
*****************************************************************************/

4868
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
unknown's avatar
unknown committed
4869 4870 4871
template class List<String>;
template class List_iterator<String>;
#endif