← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/sql_base.cc

  • Committer: Brian Aker
  • Date: 2008-07-13 22:45:08 UTC
  • Revision ID: brian@tangent.org-20080713224508-hb20z4okblotb39a
longlong replacement

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/sql_base.cc
15
15
 
16
16
 
17
17
/* Basic functions needed by many modules */
18
 
#include <drizzled/server_includes.h>
19
 
#include <drizzled/sql_select.h>
20
 
#include <mysys/my_dir.h>
21
 
#include <drizzled/drizzled_error_messages.h>
22
 
#include <libdrizzle/gettext.h>
 
18
 
 
19
#include "mysql_priv.h"
 
20
#include "sql_select.h"
 
21
#include <m_ctype.h>
 
22
#include <my_dir.h>
 
23
#include <hash.h>
23
24
 
24
25
#define FLAGSTR(S,F) ((S) & (F) ? #F " " : "")
25
26
 
27
28
  @defgroup Data_Dictionary Data Dictionary
28
29
  @{
29
30
*/
30
 
Table *unused_tables;                           /* Used by mysql_test */
 
31
TABLE *unused_tables;                           /* Used by mysql_test */
31
32
HASH open_cache;                                /* Used by mysql_test */
32
33
static HASH table_def_cache;
33
34
static TABLE_SHARE *oldest_unused_share, end_of_unused_share;
34
35
static pthread_mutex_t LOCK_table_share;
35
36
static bool table_def_inited= 0;
36
37
 
37
 
static int open_unireg_entry(THD *thd, Table *entry, TableList *table_list,
38
 
                             const char *alias,
39
 
                             char *cache_key, uint32_t cache_key_length);
40
 
static void free_cache_entry(Table *entry);
41
 
static void close_old_data_files(THD *thd, Table *table, bool morph_locks,
 
38
static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
 
39
                             const char *alias,
 
40
                             char *cache_key, uint cache_key_length,
 
41
                             MEM_ROOT *mem_root, uint flags);
 
42
static void free_cache_entry(TABLE *entry);
 
43
static void close_old_data_files(THD *thd, TABLE *table, bool morph_locks,
42
44
                                 bool send_refresh);
43
45
 
44
46
 
45
 
extern "C" unsigned char *table_cache_key(const unsigned char *record, size_t *length,
 
47
extern "C" uchar *table_cache_key(const uchar *record, size_t *length,
46
48
                                  bool not_used __attribute__((unused)))
47
49
{
48
 
  Table *entry=(Table*) record;
 
50
  TABLE *entry=(TABLE*) record;
49
51
  *length= entry->s->table_cache_key.length;
50
 
  return (unsigned char*) entry->s->table_cache_key.str;
 
52
  return (uchar*) entry->s->table_cache_key.str;
51
53
}
52
54
 
53
55
 
55
57
{
56
58
  return hash_init(&open_cache, &my_charset_bin, table_cache_size+16,
57
59
                   0, 0, table_cache_key,
58
 
                   (hash_free_key) free_cache_entry, 0);
 
60
                   (hash_free_key) free_cache_entry, 0) != 0;
59
61
}
60
62
 
61
63
void table_cache_free(void)
69
71
  return;
70
72
}
71
73
 
72
 
uint32_t cached_open_tables(void)
 
74
uint cached_open_tables(void)
73
75
{
74
76
  return open_cache.records;
75
77
}
99
101
    Length of key
100
102
*/
101
103
 
102
 
uint32_t create_table_def_key(THD *thd, char *key, TableList *table_list,
 
104
uint create_table_def_key(THD *thd, char *key, TABLE_LIST *table_list,
103
105
                          bool tmp_table)
104
106
{
105
 
  uint32_t key_length= (uint) (my_stpcpy(my_stpcpy(key, table_list->db)+1,
 
107
  uint key_length= (uint) (strmov(strmov(key, table_list->db)+1,
106
108
                                  table_list->table_name)-key)+1;
107
109
  if (tmp_table)
108
110
  {
119
121
  Functions to handle table definition cach (TABLE_SHARE)
120
122
*****************************************************************************/
121
123
 
122
 
extern "C" unsigned char *table_def_key(const unsigned char *record, size_t *length,
 
124
extern "C" uchar *table_def_key(const uchar *record, size_t *length,
123
125
                                bool not_used __attribute__((unused)))
124
126
{
125
127
  TABLE_SHARE *entry=(TABLE_SHARE*) record;
126
128
  *length= entry->table_cache_key.length;
127
 
  return (unsigned char*) entry->table_cache_key.str;
 
129
  return (uchar*) entry->table_cache_key.str;
128
130
}
129
131
 
130
132
 
152
154
 
153
155
  return hash_init(&table_def_cache, &my_charset_bin, table_def_size,
154
156
                   0, 0, table_def_key,
155
 
                   (hash_free_key) table_def_free_entry, 0);
 
157
                   (hash_free_key) table_def_free_entry, 0) != 0;
156
158
}
157
159
 
158
160
 
168
170
}
169
171
 
170
172
 
171
 
uint32_t cached_table_definitions(void)
 
173
uint cached_table_definitions(void)
172
174
{
173
175
  return table_def_cache.records;
174
176
}
199
201
   #  Share for table
200
202
*/
201
203
 
202
 
TABLE_SHARE *get_table_share(THD *thd, TableList *table_list, char *key,
203
 
                             uint32_t key_length, uint32_t db_flags, int *error)
 
204
TABLE_SHARE *get_table_share(THD *thd, TABLE_LIST *table_list, char *key,
 
205
                             uint key_length, uint db_flags, int *error)
204
206
{
205
207
  TABLE_SHARE *share;
206
208
 
207
209
  *error= 0;
208
210
 
209
211
  /* Read table definition from cache */
210
 
  if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(unsigned char*) key,
 
212
  if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key,
211
213
                                         key_length)))
212
214
    goto found;
213
215
 
237
239
   */
238
240
  assign_new_table_id(share);
239
241
 
240
 
  if (my_hash_insert(&table_def_cache, (unsigned char*) share))
 
242
  if (my_hash_insert(&table_def_cache, (uchar*) share))
241
243
  {
242
244
    free_table_share(share);
243
245
    return(0);                          // return error
245
247
  if (open_table_def(thd, share, db_flags))
246
248
  {
247
249
    *error= share->error;
248
 
    (void) hash_delete(&table_def_cache, (unsigned char*) share);
 
250
    (void) hash_delete(&table_def_cache, (uchar*) share);
249
251
    return(0);
250
252
  }
251
253
  share->ref_count++;                           // Mark in use
288
290
         oldest_unused_share->next)
289
291
  {
290
292
    pthread_mutex_lock(&oldest_unused_share->mutex);
291
 
    hash_delete(&table_def_cache, (unsigned char*) oldest_unused_share);
 
293
    VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
292
294
  }
293
295
 
294
296
  return(share);
302
304
*/
303
305
 
304
306
static TABLE_SHARE
305
 
*get_table_share_with_create(THD *thd, TableList *table_list,
306
 
                             char *key, uint32_t key_length,
307
 
                             uint32_t db_flags, int *error)
 
307
*get_table_share_with_create(THD *thd, TABLE_LIST *table_list,
 
308
                             char *key, uint key_length,
 
309
                             uint db_flags, int *error)
308
310
{
309
311
  TABLE_SHARE *share;
310
312
  int tmp;
327
329
    Finally, if share is still NULL, it's a real error and we need
328
330
    to abort.
329
331
 
330
 
    @todo Rework alternative ways to deal with ER_NO_SUCH Table.
 
332
    @todo Rework alternative ways to deal with ER_NO_SUCH TABLE.
331
333
  */
332
334
  if (share || (thd->is_error() && (thd->main_da.sql_errno() != ER_NO_SUCH_TABLE)))
333
335
 
336
338
  /* Table didn't exist. Check if some engine can provide it */
337
339
  if ((tmp= ha_create_table_from_engine(thd, table_list->db,
338
340
                                        table_list->table_name)) < 0)
 
341
  {
 
342
    /*
 
343
      No such table in any engine.
 
344
      Hide "Table doesn't exist" errors if the table belongs to a view.
 
345
      The check for thd->is_error() is necessary to not push an
 
346
      unwanted error in case of pre-locking, which silences
 
347
      "no such table" errors.
 
348
      @todo Rework the alternative ways to deal with ER_NO_SUCH TABLE.
 
349
    */
 
350
    if (thd->is_error() && table_list->belong_to_view)
 
351
    {
 
352
      thd->clear_error();
 
353
      my_error(ER_VIEW_INVALID, MYF(0), "", "");
 
354
    }
339
355
    return(0);
340
 
 
 
356
  }
341
357
  if (tmp)
342
358
  {
343
359
    /* Give right error message */
349
365
    return(0);
350
366
  }
351
367
  /* Table existed in engine. Let's open it */
352
 
  drizzle_reset_errors(thd, 1);                   // Clear warnings
 
368
  mysql_reset_errors(thd, 1);                   // Clear warnings
353
369
  thd->clear_error();                           // Clear error message
354
370
  return(get_table_share(thd, table_list, key, key_length,
355
371
                              db_flags, error));
378
394
*/
379
395
 
380
396
void release_table_share(TABLE_SHARE *share,
381
 
                         enum release_type type __attribute__((unused)))
 
397
                         enum release_type type __attribute__((__unused__)))
382
398
{
383
399
  bool to_be_deleted= 0;
384
400
 
406
422
 
407
423
  if (to_be_deleted)
408
424
  {
409
 
    hash_delete(&table_def_cache, (unsigned char*) share);
 
425
    hash_delete(&table_def_cache, (uchar*) share);
410
426
    return;
411
427
  }
412
428
  pthread_mutex_unlock(&share->mutex);
430
446
TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name)
431
447
{
432
448
  char key[NAME_LEN*2+2];
433
 
  TableList table_list;
434
 
  uint32_t key_length;
 
449
  TABLE_LIST table_list;
 
450
  uint key_length;
435
451
  safe_mutex_assert_owner(&LOCK_open);
436
452
 
437
453
  table_list.db= (char*) db;
438
454
  table_list.table_name= (char*) table_name;
439
455
  key_length= create_table_def_key((THD*) 0, key, &table_list, 0);
440
 
  return (TABLE_SHARE*) hash_search(&table_def_cache,(unsigned char*) key, key_length);
 
456
  return (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key, key_length);
441
457
}  
442
458
 
443
459
 
459
475
*/
460
476
 
461
477
 
462
 
void close_handle_and_leave_table_as_lock(Table *table)
 
478
void close_handle_and_leave_table_as_lock(TABLE *table)
463
479
{
464
480
  TABLE_SHARE *share, *old_share= table->s;
465
481
  char *key_buff;
477
493
                       &key_buff, old_share->table_cache_key.length,
478
494
                       NULL))
479
495
  {
480
 
    memset(share, 0, sizeof(*share));
 
496
    bzero((char*) share, sizeof(*share));
481
497
    share->set_table_cache_key(key_buff, old_share->table_cache_key.str,
482
498
                               old_share->table_cache_key.length);
483
499
    share->tmp_table= INTERNAL_TMP_TABLE;       // for intern_close_table()
512
528
    #           Pointer to list of names of open tables.
513
529
*/
514
530
 
515
 
OPEN_TableList *list_open_tables(THD *thd __attribute__((unused)),
 
531
OPEN_TABLE_LIST *list_open_tables(THD *thd __attribute__((__unused__)),
516
532
                                  const char *db, const char *wild)
517
533
{
518
534
  int result = 0;
519
 
  OPEN_TableList **start_list, *open_list;
520
 
  TableList table_list;
 
535
  OPEN_TABLE_LIST **start_list, *open_list;
 
536
  TABLE_LIST table_list;
521
537
 
522
 
  pthread_mutex_lock(&LOCK_open);
523
 
  memset(&table_list, 0, sizeof(table_list));
 
538
  VOID(pthread_mutex_lock(&LOCK_open));
 
539
  bzero((char*) &table_list,sizeof(table_list));
524
540
  start_list= &open_list;
525
541
  open_list=0;
526
542
 
527
 
  for (uint32_t idx=0 ; result == 0 && idx < open_cache.records; idx++)
 
543
  for (uint idx=0 ; result == 0 && idx < open_cache.records; idx++)
528
544
  {
529
 
    OPEN_TableList *table;
530
 
    Table *entry=(Table*) hash_element(&open_cache,idx);
 
545
    OPEN_TABLE_LIST *table;
 
546
    TABLE *entry=(TABLE*) hash_element(&open_cache,idx);
531
547
    TABLE_SHARE *share= entry->s;
532
548
 
533
549
    if (db && my_strcasecmp(system_charset_info, db, share->db.str))
554
570
    }
555
571
    if (table)
556
572
      continue;
557
 
    if (!(*start_list = (OPEN_TableList *)
 
573
    if (!(*start_list = (OPEN_TABLE_LIST *)
558
574
          sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
559
575
    {
560
576
      open_list=0;                              // Out of memory
561
577
      break;
562
578
    }
563
 
    my_stpcpy((*start_list)->table=
564
 
           my_stpcpy(((*start_list)->db= (char*) ((*start_list)+1)),
 
579
    strmov((*start_list)->table=
 
580
           strmov(((*start_list)->db= (char*) ((*start_list)+1)),
565
581
                  share->db.str)+1,
566
582
           share->table_name.str);
567
583
    (*start_list)->in_use= entry->in_use ? 1 : 0;
569
585
    start_list= &(*start_list)->next;
570
586
    *start_list=0;
571
587
  }
572
 
  pthread_mutex_unlock(&LOCK_open);
 
588
  VOID(pthread_mutex_unlock(&LOCK_open));
573
589
  return(open_list);
574
590
}
575
591
 
578
594
 ****************************************************************************/
579
595
 
580
596
 
581
 
void intern_close_table(Table *table)
 
597
void intern_close_table(TABLE *table)
582
598
{                                               // Free all structures
583
599
  free_io_cache(table);
584
600
  if (table->file)                              // Not true if name lock
585
 
    closefrm(table, 1);                 // close file
 
601
    VOID(closefrm(table, 1));                   // close file
586
602
  return;
587
603
}
588
604
 
597
613
    We need to have a lock on LOCK_open when calling this
598
614
*/
599
615
 
600
 
static void free_cache_entry(Table *table)
 
616
static void free_cache_entry(TABLE *table)
601
617
{
602
618
  intern_close_table(table);
603
619
  if (!table->in_use)
611
627
        unused_tables=0;
612
628
    }
613
629
  }
614
 
  free((unsigned char*) table);
 
630
  my_free((uchar*) table,MYF(0));
615
631
  return;
616
632
}
617
633
 
618
634
/* Free resources allocated by filesort() and read_record() */
619
635
 
620
 
void free_io_cache(Table *table)
 
636
void free_io_cache(TABLE *table)
621
637
{
622
638
  if (table->sort.io_cache)
623
639
  {
624
640
    close_cached_file(table->sort.io_cache);
625
 
    free((unsigned char*) table->sort.io_cache);
 
641
    my_free((uchar*) table->sort.io_cache,MYF(0));
626
642
    table->sort.io_cache=0;
627
643
  }
628
644
  return;
644
660
          and tables must be NULL.
645
661
*/
646
662
 
647
 
bool close_cached_tables(THD *thd, TableList *tables, bool have_lock,
 
663
bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool have_lock,
648
664
                         bool wait_for_refresh, bool wait_for_placeholders)
649
665
{
650
666
  bool result=0;
651
667
  assert(thd || (!wait_for_refresh && !tables));
652
668
 
653
669
  if (!have_lock)
654
 
    pthread_mutex_lock(&LOCK_open);
 
670
    VOID(pthread_mutex_lock(&LOCK_open));
655
671
  if (!tables)
656
672
  {
657
673
    refresh_version++;                          // Force close of open tables
658
674
    while (unused_tables)
659
675
    {
660
676
#ifdef EXTRA_DEBUG
661
 
      if (hash_delete(&open_cache,(unsigned char*) unused_tables))
 
677
      if (hash_delete(&open_cache,(uchar*) unused_tables))
662
678
        printf("Warning: Couldn't delete open table from hash\n");
663
679
#else
664
 
      hash_delete(&open_cache,(unsigned char*) unused_tables);
 
680
      VOID(hash_delete(&open_cache,(uchar*) unused_tables));
665
681
#endif
666
682
    }
667
683
    /* Free table shares */
668
684
    while (oldest_unused_share->next)
669
685
    {
670
686
      pthread_mutex_lock(&oldest_unused_share->mutex);
671
 
      hash_delete(&table_def_cache, (unsigned char*) oldest_unused_share);
 
687
      VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
672
688
    }
673
689
    if (wait_for_refresh)
674
690
    {
709
725
        after the call to close_old_data_files() i.e. after removal of
710
726
        current thread locks.
711
727
      */
712
 
      for (uint32_t idx=0 ; idx < open_cache.records ; idx++)
 
728
      for (uint idx=0 ; idx < open_cache.records ; idx++)
713
729
      {
714
 
        Table *table=(Table*) hash_element(&open_cache,idx);
 
730
        TABLE *table=(TABLE*) hash_element(&open_cache,idx);
715
731
        if (table->in_use)
716
732
          table->in_use->some_tables_deleted= 1;
717
733
      }
720
736
  else
721
737
  {
722
738
    bool found=0;
723
 
    for (TableList *table= tables; table; table= table->next_local)
 
739
    for (TABLE_LIST *table= tables; table; table= table->next_local)
724
740
    {
725
741
      if (remove_table_from_cache(thd, table->db, table->table_name,
726
742
                                  RTFC_OWNED_BY_THD_FLAG))
748
764
    while (found && ! thd->killed)
749
765
    {
750
766
      found=0;
751
 
      for (uint32_t idx=0 ; idx < open_cache.records ; idx++)
 
767
      for (uint idx=0 ; idx < open_cache.records ; idx++)
752
768
      {
753
 
        Table *table=(Table*) hash_element(&open_cache,idx);
 
769
        TABLE *table=(TABLE*) hash_element(&open_cache,idx);
754
770
        /* Avoid a self-deadlock. */
755
771
        if (table->in_use == thd)
756
772
          continue;
757
773
        /*
758
774
          Note that we wait here only for tables which are actually open, and
759
 
          not for placeholders with Table::open_placeholder set. Waiting for
 
775
          not for placeholders with TABLE::open_placeholder set. Waiting for
760
776
          latter will cause deadlock in the following scenario, for example:
761
777
 
762
778
          conn1: lock table t1 write;
786
802
    result=reopen_tables(thd,1,1);
787
803
    thd->in_lock_tables=0;
788
804
    /* Set version for table */
789
 
    for (Table *table=thd->open_tables; table ; table= table->next)
 
805
    for (TABLE *table=thd->open_tables; table ; table= table->next)
790
806
    {
791
807
      /*
792
808
        Preserve the version (0) of write locked tables so that a impending
797
813
    }
798
814
  }
799
815
  if (!have_lock)
800
 
    pthread_mutex_unlock(&LOCK_open);
 
816
    VOID(pthread_mutex_unlock(&LOCK_open));
801
817
  if (wait_for_refresh)
802
818
  {
803
819
    pthread_mutex_lock(&thd->mysys_var->mutex);
818
834
bool close_cached_connection_tables(THD *thd, bool if_wait_for_refresh,
819
835
                                    LEX_STRING *connection, bool have_lock)
820
836
{
821
 
  uint32_t idx;
822
 
  TableList tmp, *tables= NULL;
 
837
  uint idx;
 
838
  TABLE_LIST tmp, *tables= NULL;
823
839
  bool result= false;
824
840
  assert(thd);
825
841
 
826
 
  memset(&tmp, 0, sizeof(TableList));
 
842
  bzero(&tmp, sizeof(TABLE_LIST));
827
843
 
828
844
  if (!have_lock)
829
 
    pthread_mutex_lock(&LOCK_open);
 
845
    VOID(pthread_mutex_lock(&LOCK_open));
830
846
 
831
847
  for (idx= 0; idx < table_def_cache.records; idx++)
832
848
  {
851
867
    tmp.table_name= share->table_name.str;
852
868
    tmp.next_local= tables;
853
869
 
854
 
    tables= (TableList *) memdup_root(thd->mem_root, (char*)&tmp, 
855
 
                                       sizeof(TableList));
 
870
    tables= (TABLE_LIST *) memdup_root(thd->mem_root, (char*)&tmp, 
 
871
                                       sizeof(TABLE_LIST));
856
872
  }
857
873
 
858
874
  if (tables)
859
875
    result= close_cached_tables(thd, tables, true, false, false);
860
876
 
861
877
  if (!have_lock)
862
 
    pthread_mutex_unlock(&LOCK_open);
 
878
    VOID(pthread_mutex_unlock(&LOCK_open));
863
879
 
864
880
  if (if_wait_for_refresh)
865
881
  {
866
882
    pthread_mutex_lock(&thd->mysys_var->mutex);
867
883
    thd->mysys_var->current_mutex= 0;
868
884
    thd->mysys_var->current_cond= 0;
869
 
    thd->set_proc_info(0);
 
885
    thd->proc_info=0;
870
886
    pthread_mutex_unlock(&thd->mysys_var->mutex);
871
887
  }
872
888
 
886
902
 
887
903
static void mark_temp_tables_as_free_for_reuse(THD *thd)
888
904
{
889
 
  for (Table *table= thd->temporary_tables ; table ; table= table->next)
 
905
  for (TABLE *table= thd->temporary_tables ; table ; table= table->next)
890
906
  {
891
907
    if ((table->query_id == thd->query_id) && ! table->open_by_handler)
892
908
    {
920
936
    set to query_id of original query.
921
937
*/
922
938
 
923
 
static void mark_used_tables_as_free_for_reuse(THD *thd, Table *table)
 
939
static void mark_used_tables_as_free_for_reuse(THD *thd, TABLE *table)
924
940
{
925
941
  for (; table ; table= table->next)
926
942
  {
947
963
 
948
964
  safe_mutex_assert_not_owner(&LOCK_open);
949
965
 
950
 
  pthread_mutex_lock(&LOCK_open);
 
966
  VOID(pthread_mutex_lock(&LOCK_open));
951
967
 
952
968
  while (thd->open_tables)
953
969
    found_old_table|= close_thread_table(thd, &thd->open_tables);
955
971
 
956
972
  /* Free tables to hold down open files */
957
973
  while (open_cache.records > table_cache_size && unused_tables)
958
 
    hash_delete(&open_cache,(unsigned char*) unused_tables); /* purecov: tested */
 
974
    VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
959
975
  if (found_old_table)
960
976
  {
961
977
    /* Tell threads waiting for refresh that something has happened */
962
978
    broadcast_refresh();
963
979
  }
964
980
 
965
 
  pthread_mutex_unlock(&LOCK_open);
 
981
  VOID(pthread_mutex_unlock(&LOCK_open));
966
982
}
967
983
 
968
984
 
986
1002
 
987
1003
void close_thread_tables(THD *thd)
988
1004
{
989
 
  Table *table;
 
1005
  TABLE *table;
990
1006
 
991
1007
  /*
992
1008
    We are assuming here that thd->derived_tables contains ONLY derived
1001
1017
  */
1002
1018
  if (thd->derived_tables)
1003
1019
  {
1004
 
    Table *next;
 
1020
    TABLE *next;
1005
1021
    /*
1006
1022
      Close all derived tables generated in queries like
1007
1023
      SELECT * FROM (SELECT * FROM t1)
1009
1025
    for (table= thd->derived_tables ; table ; table= next)
1010
1026
    {
1011
1027
      next= table->next;
1012
 
      table->free_tmp_table(thd);
 
1028
      free_tmp_table(thd, table);
1013
1029
    }
1014
1030
    thd->derived_tables= 0;
1015
1031
  }
1077
1093
 
1078
1094
/* move one table to free list */
1079
1095
 
1080
 
bool close_thread_table(THD *thd, Table **table_ptr)
 
1096
bool close_thread_table(THD *thd, TABLE **table_ptr)
1081
1097
{
1082
1098
  bool found_old_table= 0;
1083
 
  Table *table= *table_ptr;
 
1099
  TABLE *table= *table_ptr;
1084
1100
 
1085
1101
  assert(table->key_read == 0);
1086
1102
  assert(!table->file || table->file->inited == handler::NONE);
1090
1106
  if (table->needs_reopen_or_name_lock() ||
1091
1107
      thd->version != refresh_version || !table->db_stat)
1092
1108
  {
1093
 
    hash_delete(&open_cache,(unsigned char*) table);
 
1109
    VOID(hash_delete(&open_cache,(uchar*) table));
1094
1110
    found_old_table=1;
1095
1111
  }
1096
1112
  else
1097
1113
  {
1098
1114
    /*
1099
 
      Open placeholders have Table::db_stat set to 0, so they should be
 
1115
      Open placeholders have TABLE::db_stat set to 0, so they should be
1100
1116
      handled by the first alternative.
1101
1117
    */
1102
1118
    assert(!table->open_placeholder);
1119
1135
 
1120
1136
 
1121
1137
/* close_temporary_tables' internal, 4 is due to uint4korr definition */
1122
 
static inline uint32_t  tmpkeyval(THD *thd __attribute__((unused)),
1123
 
                              Table *table)
 
1138
static inline uint  tmpkeyval(THD *thd __attribute__((__unused__)),
 
1139
                              TABLE *table)
1124
1140
{
1125
1141
  return uint4korr(table->s->table_cache_key.str + table->s->table_cache_key.length - 4);
1126
1142
}
1128
1144
 
1129
1145
/*
1130
1146
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
1131
 
  creates one DROP TEMPORARY Table binlog event for each pseudo-thread 
 
1147
  creates one DROP TEMPORARY TABLE binlog event for each pseudo-thread 
1132
1148
*/
1133
1149
 
1134
1150
void close_temporary_tables(THD *thd)
1135
1151
{
1136
 
  Table *table;
1137
 
  Table *next= NULL;
1138
 
  Table *prev_table;
 
1152
  TABLE *table;
 
1153
  TABLE *next= NULL;
 
1154
  TABLE *prev_table;
1139
1155
  /* Assume thd->options has OPTION_QUOTE_SHOW_CREATE */
1140
1156
  bool was_quote_show= true;
1141
1157
 
1144
1160
 
1145
1161
  if (!mysql_bin_log.is_open() || thd->current_stmt_binlog_row_based)
1146
1162
  {
1147
 
    Table *tmp_next;
 
1163
    TABLE *tmp_next;
1148
1164
    for (table= thd->temporary_tables; table; table= tmp_next)
1149
1165
    {
1150
1166
      tmp_next= table->next;
1155
1171
  }
1156
1172
 
1157
1173
  /* Better add "if exists", in case a RESET MASTER has been done */
1158
 
  const char stub[]= "DROP /*!40005 TEMPORARY */ Table IF EXISTS ";
1159
 
  uint32_t stub_len= sizeof(stub) - 1;
 
1174
  const char stub[]= "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ";
 
1175
  uint stub_len= sizeof(stub) - 1;
1160
1176
  char buf[256];
1161
1177
  String s_query= String(buf, sizeof(buf), system_charset_info);
1162
1178
  bool found_user_tables= false;
1172
1188
       table;
1173
1189
       prev_table= table, table= table->next)
1174
1190
  {
1175
 
    Table *prev_sorted /* same as for prev_table */, *sorted;
 
1191
    TABLE *prev_sorted /* same as for prev_table */, *sorted;
1176
1192
    if (is_user_table(table))
1177
1193
    {
1178
1194
      if (!found_user_tables)
1238
1254
        close_temporary(table, 1, 1);
1239
1255
      }
1240
1256
      thd->clear_error();
1241
 
      const CHARSET_INFO * const cs_save= thd->variables.character_set_client;
 
1257
      CHARSET_INFO *cs_save= thd->variables.character_set_client;
1242
1258
      thd->variables.character_set_client= system_charset_info;
1243
1259
      Query_log_event qinfo(thd, s_query.ptr(),
1244
1260
                            s_query.length() - 1 /* to remove trailing ',' */,
1288
1304
    #           Pointer to found table.
1289
1305
*/
1290
1306
 
1291
 
TableList *find_table_in_list(TableList *table,
1292
 
                               TableList *TableList::*link,
 
1307
TABLE_LIST *find_table_in_list(TABLE_LIST *table,
 
1308
                               TABLE_LIST *TABLE_LIST::*link,
1293
1309
                               const char *db_name,
1294
1310
                               const char *table_name)
1295
1311
{
1328
1344
    Also SELECT::exclude_from_table_unique_test used to exclude from check
1329
1345
    tables of main SELECT of multi-delete and multi-update
1330
1346
 
1331
 
    We also skip tables with TableList::prelocking_placeholder set,
 
1347
    We also skip tables with TABLE_LIST::prelocking_placeholder set,
1332
1348
    because we want to allow SELECTs from them, and their modification
1333
1349
    will rise the error anyway.
1334
1350
 
1340
1356
    0 if table is unique
1341
1357
*/
1342
1358
 
1343
 
TableList* unique_table(THD *thd, TableList *table, TableList *table_list,
 
1359
TABLE_LIST* unique_table(THD *thd, TABLE_LIST *table, TABLE_LIST *table_list,
1344
1360
                         bool check_alias)
1345
1361
{
1346
 
  TableList *res;
 
1362
  TABLE_LIST *res;
1347
1363
  const char *d_name, *t_name, *t_alias;
1348
1364
 
1349
1365
  /*
1350
1366
    If this function called for query which update table (INSERT/UPDATE/...)
1351
 
    then we have in table->table pointer to Table object which we are
1352
 
    updating even if it is VIEW so we need TableList of this Table object
 
1367
    then we have in table->table pointer to TABLE object which we are
 
1368
    updating even if it is VIEW so we need TABLE_LIST of this TABLE object
1353
1369
    to get right names (even if lower_case_table_names used).
1354
1370
 
1355
1371
    If this function called for CREATE command that we have not opened table
1356
 
    (table->table equal to 0) and right names is in current TableList
 
1372
    (table->table equal to 0) and right names is in current TABLE_LIST
1357
1373
    object.
1358
1374
  */
1359
1375
  if (table->table)
1363
1379
      return(0);
1364
1380
    table= table->find_underlying_table(table->table);
1365
1381
    /*
1366
 
      as far as we have table->table we have to find real TableList of
 
1382
      as far as we have table->table we have to find real TABLE_LIST of
1367
1383
      it in underlying tables
1368
1384
    */
1369
1385
    assert(table);
1407
1423
    here we hide view underlying tables if we have them
1408
1424
*/
1409
1425
 
1410
 
void update_non_unique_table_error(TableList *update,
1411
 
                                   const char *operation __attribute__((unused)),
1412
 
                                   TableList *duplicate __attribute__((unused)))
 
1426
void update_non_unique_table_error(TABLE_LIST *update,
 
1427
                                   const char *operation __attribute__((__unused__)),
 
1428
                                   TABLE_LIST *duplicate __attribute__((__unused__)))
1413
1429
{
1414
1430
  my_error(ER_UPDATE_TABLE_USED, MYF(0), update->alias);
1415
1431
}
1416
1432
 
1417
1433
 
1418
 
Table *find_temporary_table(THD *thd, const char *db, const char *table_name)
 
1434
TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name)
1419
1435
{
1420
 
  TableList table_list;
 
1436
  TABLE_LIST table_list;
1421
1437
 
1422
1438
  table_list.db= (char*) db;
1423
1439
  table_list.table_name= (char*) table_name;
1425
1441
}
1426
1442
 
1427
1443
 
1428
 
Table *find_temporary_table(THD *thd, TableList *table_list)
 
1444
TABLE *find_temporary_table(THD *thd, TABLE_LIST *table_list)
1429
1445
{
1430
1446
  char  key[MAX_DBKEY_LENGTH];
1431
1447
  uint  key_length;
1432
 
  Table *table;
 
1448
  TABLE *table;
1433
1449
 
1434
1450
  key_length= create_table_def_key(thd, key, table_list, 1);
1435
1451
  for (table=thd->temporary_tables ; table ; table= table->next)
1456
1472
 
1457
1473
  This function is used to drop user temporary tables, as well as
1458
1474
  internal tables created in CREATE TEMPORARY TABLE ... SELECT
1459
 
  or ALTER Table. Even though part of the work done by this function
 
1475
  or ALTER TABLE. Even though part of the work done by this function
1460
1476
  is redundant when the table is internal, as long as we
1461
1477
  link both internal and user temporary tables into the same
1462
1478
  thd->temporary_tables list, it's impossible to tell here whether
1468
1484
  @retval -1  the table is in use by a outer query
1469
1485
*/
1470
1486
 
1471
 
int drop_temporary_table(THD *thd, TableList *table_list)
 
1487
int drop_temporary_table(THD *thd, TABLE_LIST *table_list)
1472
1488
{
1473
 
  Table *table;
 
1489
  TABLE *table;
1474
1490
 
1475
1491
  if (!(table= find_temporary_table(thd, table_list)))
1476
1492
    return(1);
1495
1511
  unlink from thd->temporary tables and close temporary table
1496
1512
*/
1497
1513
 
1498
 
void close_temporary_table(THD *thd, Table *table,
 
1514
void close_temporary_table(THD *thd, TABLE *table,
1499
1515
                           bool free_share, bool delete_table)
1500
1516
{
1501
1517
  if (table->prev)
1536
1552
    If this is needed, use close_temporary_table()
1537
1553
*/
1538
1554
 
1539
 
void close_temporary(Table *table, bool free_share, bool delete_table)
 
1555
void close_temporary(TABLE *table, bool free_share, bool delete_table)
1540
1556
{
1541
1557
  handlerton *table_type= table->s->db_type();
1542
1558
 
1552
1568
  if (free_share)
1553
1569
  {
1554
1570
    free_table_share(table->s);
1555
 
    free((char*) table);
 
1571
    my_free((char*) table,MYF(0));
1556
1572
  }
1557
1573
  return;
1558
1574
}
1559
1575
 
1560
1576
 
1561
1577
/*
1562
 
  Used by ALTER Table when the table is a temporary one. It changes something
 
1578
  Used by ALTER TABLE when the table is a temporary one. It changes something
1563
1579
  only if the ALTER contained a RENAME clause (otherwise, table_name is the old
1564
1580
  name).
1565
1581
  Prepares a table cache key, which is the concatenation of db, table_name and
1566
1582
  thd->slave_proxy_id, separated by '\0'.
1567
1583
*/
1568
1584
 
1569
 
bool rename_temporary_table(THD* thd, Table *table, const char *db,
 
1585
bool rename_temporary_table(THD* thd, TABLE *table, const char *db,
1570
1586
                            const char *table_name)
1571
1587
{
1572
1588
  char *key;
1573
 
  uint32_t key_length;
 
1589
  uint key_length;
1574
1590
  TABLE_SHARE *share= table->s;
1575
 
  TableList table_list;
 
1591
  TABLE_LIST table_list;
1576
1592
 
1577
1593
  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
1578
1594
    return(1);                          /* purecov: inspected */
1587
1603
 
1588
1604
        /* move table first in unused links */
1589
1605
 
1590
 
static void relink_unused(Table *table)
 
1606
static void relink_unused(TABLE *table)
1591
1607
{
1592
1608
  if (table != unused_tables)
1593
1609
  {
1617
1633
          not locked (for example already unlocked).
1618
1634
*/
1619
1635
 
1620
 
void unlink_open_table(THD *thd, Table *find, bool unlock)
 
1636
void unlink_open_table(THD *thd, TABLE *find, bool unlock)
1621
1637
{
1622
1638
  char key[MAX_DBKEY_LENGTH];
1623
 
  uint32_t key_length= find->s->table_cache_key.length;
1624
 
  Table *list, **prev;
 
1639
  uint key_length= find->s->table_cache_key.length;
 
1640
  TABLE *list, **prev;
1625
1641
 
1626
1642
  safe_mutex_assert_owner(&LOCK_open);
1627
1643
 
1646
1662
      /* Remove table from open_tables list. */
1647
1663
      *prev= list->next;
1648
1664
      /* Close table. */
1649
 
      hash_delete(&open_cache,(unsigned char*) list); // Close table
 
1665
      VOID(hash_delete(&open_cache,(uchar*) list)); // Close table
1650
1666
    }
1651
1667
    else
1652
1668
    {
1665
1681
    Auxiliary routine which closes and drops open table.
1666
1682
 
1667
1683
    @param  thd         Thread handle
1668
 
    @param  table       Table object for table to be dropped
 
1684
    @param  table       TABLE object for table to be dropped
1669
1685
    @param  db_name     Name of database for this table
1670
1686
    @param  table_name  Name of this table
1671
1687
 
1680
1696
          table that was locked with LOCK TABLES.
1681
1697
*/
1682
1698
 
1683
 
void drop_open_table(THD *thd, Table *table, const char *db_name,
 
1699
void drop_open_table(THD *thd, TABLE *table, const char *db_name,
1684
1700
                     const char *table_name)
1685
1701
{
1686
1702
  if (table->s->tmp_table)
1688
1704
  else
1689
1705
  {
1690
1706
    handlerton *table_type= table->s->db_type();
1691
 
    pthread_mutex_lock(&LOCK_open);
 
1707
    VOID(pthread_mutex_lock(&LOCK_open));
1692
1708
    /*
1693
1709
      unlink_open_table() also tells threads waiting for refresh or close
1694
1710
      that something has happened.
1695
1711
    */
1696
1712
    unlink_open_table(thd, table, false);
1697
1713
    quick_rm_table(table_type, db_name, table_name, 0);
1698
 
    pthread_mutex_unlock(&LOCK_open);
 
1714
    VOID(pthread_mutex_unlock(&LOCK_open));
1699
1715
  }
1700
1716
}
1701
1717
 
1717
1733
  const char *proc_info;
1718
1734
  thd->mysys_var->current_mutex= mutex;
1719
1735
  thd->mysys_var->current_cond= cond;
1720
 
  proc_info=thd->get_proc_info();
 
1736
  proc_info=thd->proc_info;
1721
1737
  thd_proc_info(thd, "Waiting for table");
1722
1738
  if (!thd->killed)
1723
1739
    (void) pthread_cond_wait(cond, mutex);
1753
1769
  @return false on success, true otherwise.
1754
1770
*/
1755
1771
 
1756
 
bool name_lock_locked_table(THD *thd, TableList *tables)
 
1772
bool name_lock_locked_table(THD *thd, TABLE_LIST *tables)
1757
1773
{
1758
1774
  /* Under LOCK TABLES we must only accept write locked tables. */
1759
1775
  tables->table= find_locked_table(thd, tables->db, tables->table_name);
1782
1798
  SYNOPSIS
1783
1799
    reopen_name_locked_table()
1784
1800
      thd         Thread handle
1785
 
      table_list  TableList object for table to be open, TableList::table
1786
 
                  member should point to Table object which was used for
 
1801
      table_list  TABLE_LIST object for table to be open, TABLE_LIST::table
 
1802
                  member should point to TABLE object which was used for
1787
1803
                  name-locking.
1788
 
      link_in     true  - if Table object for table to be opened should be
 
1804
      link_in     true  - if TABLE object for table to be opened should be
1789
1805
                          linked into THD::open_tables list.
1790
1806
                  false - placeholder used for name-locking is already in
1791
 
                          this list so we only need to preserve Table::next
 
1807
                          this list so we only need to preserve TABLE::next
1792
1808
                          pointer.
1793
1809
 
1794
1810
  NOTE
1799
1815
    true  - Error
1800
1816
*/
1801
1817
 
1802
 
bool reopen_name_locked_table(THD* thd, TableList* table_list, bool link_in)
 
1818
bool reopen_name_locked_table(THD* thd, TABLE_LIST* table_list, bool link_in)
1803
1819
{
1804
 
  Table *table= table_list->table;
 
1820
  TABLE *table= table_list->table;
1805
1821
  TABLE_SHARE *share;
1806
1822
  char *table_name= table_list->table_name;
1807
 
  Table orig_table;
 
1823
  TABLE orig_table;
1808
1824
 
1809
1825
  safe_mutex_assert_owner(&LOCK_open);
1810
1826
 
1815
1831
 
1816
1832
  if (open_unireg_entry(thd, table, table_list, table_name,
1817
1833
                        table->s->table_cache_key.str,
1818
 
                        table->s->table_cache_key.length))
 
1834
                        table->s->table_cache_key.length, thd->mem_root, 0))
1819
1835
  {
1820
1836
    intern_close_table(table);
1821
1837
    /*
1848
1864
  else
1849
1865
  {
1850
1866
    /*
1851
 
      Table object should be already in THD::open_tables list so we just
1852
 
      need to set Table::next correctly.
 
1867
      TABLE object should be already in THD::open_tables list so we just
 
1868
      need to set TABLE::next correctly.
1853
1869
    */
1854
1870
    table->next= orig_table.next;
1855
1871
  }
1857
1873
  table->tablenr=thd->current_tablenr++;
1858
1874
  table->used_fields=0;
1859
1875
  table->const_table=0;
1860
 
  table->null_row= false;
1861
 
  table->maybe_null= false;
1862
 
  table->force_index= false;
 
1876
  table->null_row= table->maybe_null= table->force_index= 0;
1863
1877
  table->status=STATUS_NO_RECORD;
1864
 
  return false;
 
1878
  return(false);
1865
1879
}
1866
1880
 
1867
1881
 
1874
1888
    @param key         Table cache key for name to be locked
1875
1889
    @param key_length  Table cache key length
1876
1890
 
1877
 
    @return Pointer to Table object used for name locking or 0 in
 
1891
    @return Pointer to TABLE object used for name locking or 0 in
1878
1892
            case of failure.
1879
1893
*/
1880
1894
 
1881
 
Table *table_cache_insert_placeholder(THD *thd, const char *key,
1882
 
                                      uint32_t key_length)
 
1895
TABLE *table_cache_insert_placeholder(THD *thd, const char *key,
 
1896
                                      uint key_length)
1883
1897
{
1884
 
  Table *table;
 
1898
  TABLE *table;
1885
1899
  TABLE_SHARE *share;
1886
1900
  char *key_buff;
1887
1901
 
1905
1919
  table->in_use= thd;
1906
1920
  table->locked_by_name=1;
1907
1921
 
1908
 
  if (my_hash_insert(&open_cache, (unsigned char*)table))
 
1922
  if (my_hash_insert(&open_cache, (uchar*)table))
1909
1923
  {
1910
 
    free((unsigned char*) table);
 
1924
    my_free((uchar*) table, MYF(0));
1911
1925
    return(NULL);
1912
1926
  }
1913
1927
 
1925
1939
    @param[out] table       Out parameter which is either:
1926
1940
                            - set to NULL if table cache contains record for
1927
1941
                              the table or
1928
 
                            - set to point to the Table instance used for
 
1942
                            - set to point to the TABLE instance used for
1929
1943
                              name-locking.
1930
1944
 
1931
1945
    @note This function takes into account all records for table in table
1938
1952
*/
1939
1953
 
1940
1954
bool lock_table_name_if_not_cached(THD *thd, const char *db,
1941
 
                                   const char *table_name, Table **table)
 
1955
                                   const char *table_name, TABLE **table)
1942
1956
{
1943
1957
  char key[MAX_DBKEY_LENGTH];
1944
 
  uint32_t key_length;
1945
 
 
1946
 
  key_length= (uint)(my_stpcpy(my_stpcpy(key, db) + 1, table_name) - key) + 1;
1947
 
  pthread_mutex_lock(&LOCK_open);
1948
 
 
1949
 
  if (hash_search(&open_cache, (unsigned char *)key, key_length))
 
1958
  uint key_length;
 
1959
 
 
1960
  key_length= (uint)(strmov(strmov(key, db) + 1, table_name) - key) + 1;
 
1961
  VOID(pthread_mutex_lock(&LOCK_open));
 
1962
 
 
1963
  if (hash_search(&open_cache, (uchar *)key, key_length))
1950
1964
  {
1951
 
    pthread_mutex_unlock(&LOCK_open);
 
1965
    VOID(pthread_mutex_unlock(&LOCK_open));
1952
1966
    *table= 0;
1953
1967
    return(false);
1954
1968
  }
1955
1969
  if (!(*table= table_cache_insert_placeholder(thd, key, key_length)))
1956
1970
  {
1957
 
    pthread_mutex_unlock(&LOCK_open);
 
1971
    VOID(pthread_mutex_unlock(&LOCK_open));
1958
1972
    return(true);
1959
1973
  }
1960
1974
  (*table)->open_placeholder= 1;
1961
1975
  (*table)->next= thd->open_tables;
1962
1976
  thd->open_tables= *table;
1963
 
  pthread_mutex_unlock(&LOCK_open);
 
1977
  VOID(pthread_mutex_unlock(&LOCK_open));
1964
1978
  return(false);
1965
1979
}
1966
1980
 
1986
2000
    @retval  false  No error. 'exists' out parameter set accordingly.
1987
2001
*/
1988
2002
 
1989
 
bool check_if_table_exists(THD *thd, TableList *table, bool *exists)
 
2003
bool check_if_table_exists(THD *thd, TABLE_LIST *table, bool *exists)
1990
2004
{
1991
2005
  char path[FN_REFLEN];
1992
2006
  int rc;
2040
2054
                        If this is a NULL pointer, then the table is not
2041
2055
                        put in the thread-open-list.
2042
2056
    flags               Bitmap of flags to modify how open works:
2043
 
                          DRIZZLE_LOCK_IGNORE_FLUSH - Open table even if
 
2057
                          MYSQL_LOCK_IGNORE_FLUSH - Open table even if
2044
2058
                          someone has done a flush or namelock on it.
2045
2059
                          No version number checking is done.
2046
 
                          DRIZZLE_OPEN_TEMPORARY_ONLY - Open only temporary
 
2060
                          MYSQL_OPEN_TEMPORARY_ONLY - Open only temporary
2047
2061
                          table not the base table or view.
2048
2062
 
2049
2063
  IMPLEMENTATION
2052
2066
    If table list element for the table to be opened has "create" flag
2053
2067
    set and table does not exist, this function will automatically insert
2054
2068
    a placeholder for exclusive name lock into the open tables cache and
2055
 
    will return the Table instance that corresponds to this placeholder.
 
2069
    will return the TABLE instance that corresponds to this placeholder.
2056
2070
 
2057
2071
  RETURN
2058
2072
    NULL  Open failed.  If refresh is set then one should close
2059
2073
          all other tables and retry the open.
2060
 
    #     Success. Pointer to Table object for open table.
 
2074
    #     Success. Pointer to TABLE object for open table.
2061
2075
*/
2062
2076
 
2063
2077
 
2064
 
Table *open_table(THD *thd, TableList *table_list, bool *refresh, uint32_t flags)
 
2078
TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
 
2079
                  bool *refresh, uint flags)
2065
2080
{
2066
 
  register Table *table;
 
2081
  register TABLE *table;
2067
2082
  char key[MAX_DBKEY_LENGTH];
2068
2083
  unsigned int key_length;
2069
2084
  char *alias= table_list->alias;
2077
2092
    *refresh=0;
2078
2093
 
2079
2094
  /* an open table operation needs a lot of the stack space */
2080
 
  if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (unsigned char *)&alias))
 
2095
  if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (uchar *)&alias))
2081
2096
    return(0);
2082
2097
 
2083
2098
  if (thd->killed)
2104
2119
        /*
2105
2120
          We're trying to use the same temporary table twice in a query.
2106
2121
          Right now we don't support this because a temporary table
2107
 
          is always represented by only one Table object in THD, and
 
2122
          is always represented by only one TABLE object in THD, and
2108
2123
          it can not be cloned. Emit an error for an unsupported behaviour.
2109
2124
        */
2110
2125
        if (table->query_id)
2119
2134
    }
2120
2135
  }
2121
2136
 
2122
 
  if (flags & DRIZZLE_OPEN_TEMPORARY_ONLY)
 
2137
  if (flags & MYSQL_OPEN_TEMPORARY_ONLY)
2123
2138
  {
2124
2139
    my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);
2125
2140
    return(0);
2134
2149
  */
2135
2150
  if (thd->locked_tables)
2136
2151
  {                                             // Using table locks
2137
 
    Table *best_table= 0;
 
2152
    TABLE *best_table= 0;
2138
2153
    int best_distance= INT_MIN;
2139
2154
    bool check_if_used= false;
2140
2155
    for (table=thd->open_tables; table ; table=table->next)
2156
2171
          return(0);
2157
2172
        }
2158
2173
        /*
2159
 
          When looking for a usable Table, ignore MERGE children, as they
 
2174
          When looking for a usable TABLE, ignore MERGE children, as they
2160
2175
          belong to their parent and cannot be used explicitly.
2161
2176
        */
2162
2177
        if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
2216
2231
    this is the normal use case.
2217
2232
    Now we should:
2218
2233
    - try to find the table in the table cache.
2219
 
    - if one of the discovered Table instances is name-locked
 
2234
    - if one of the discovered TABLE instances is name-locked
2220
2235
      (table->s->version == 0) or some thread has started FLUSH TABLES
2221
2236
      (refresh_version > table->s->version), back off -- we have to wait
2222
2237
      until no one holds a name lock on the table.
2223
 
    - if there is no such Table in the name cache, read the table definition
 
2238
    - if there is no such TABLE in the name cache, read the table definition
2224
2239
    and insert it into the cache.
2225
2240
    We perform all of the above under LOCK_open which currently protects
2226
2241
    the open cache (also known as table cache) and table definitions stored
2227
2242
    on disk.
2228
2243
  */
2229
2244
 
2230
 
  pthread_mutex_lock(&LOCK_open);
 
2245
  VOID(pthread_mutex_lock(&LOCK_open));
2231
2246
 
2232
2247
  /*
2233
2248
    If it's the first table from a list of tables used in a query,
2240
2255
  if (!thd->open_tables)
2241
2256
    thd->version=refresh_version;
2242
2257
  else if ((thd->version != refresh_version) &&
2243
 
           ! (flags & DRIZZLE_LOCK_IGNORE_FLUSH))
 
2258
           ! (flags & MYSQL_LOCK_IGNORE_FLUSH))
2244
2259
  {
2245
2260
    /* Someone did a refresh while thread was opening tables */
2246
2261
    if (refresh)
2247
2262
      *refresh=1;
2248
 
    pthread_mutex_unlock(&LOCK_open);
 
2263
    VOID(pthread_mutex_unlock(&LOCK_open));
2249
2264
    return(0);
2250
2265
  }
2251
2266
 
2261
2276
 
2262
2277
  /*
2263
2278
    Actually try to find the table in the open_cache.
2264
 
    The cache may contain several "Table" instances for the same
 
2279
    The cache may contain several "TABLE" instances for the same
2265
2280
    physical table. The instances that are currently "in use" by
2266
2281
    some thread have their "in_use" member != NULL.
2267
2282
    There is no good reason for having more than one entry in the
2269
2284
    an implicit "pending locks queue" - see
2270
2285
    wait_for_locked_table_names for details.
2271
2286
  */
2272
 
  for (table= (Table*) hash_first(&open_cache, (unsigned char*) key, key_length,
 
2287
  for (table= (TABLE*) hash_first(&open_cache, (uchar*) key, key_length,
2273
2288
                                  &state);
2274
2289
       table && table->in_use ;
2275
 
       table= (Table*) hash_next(&open_cache, (unsigned char*) key, key_length,
 
2290
       table= (TABLE*) hash_next(&open_cache, (uchar*) key, key_length,
2276
2291
                                 &state))
2277
2292
  {
2278
2293
    /*
2282
2297
      (re-)opened and added to the cache.
2283
2298
      If since then we did (or just started) FLUSH TABLES
2284
2299
      statement, refresh_version has been increased.
2285
 
      For "name-locked" Table instances, table->s->version is set
 
2300
      For "name-locked" TABLE instances, table->s->version is set
2286
2301
      to 0 (see lock_table_name for details).
2287
2302
      In case there is a pending FLUSH TABLES or a name lock, we
2288
2303
      need to back off and re-start opening tables.
2295
2310
    */
2296
2311
    if (table->needs_reopen_or_name_lock())
2297
2312
    {
2298
 
      if (flags & DRIZZLE_LOCK_IGNORE_FLUSH)
 
2313
      if (flags & MYSQL_LOCK_IGNORE_FLUSH)
2299
2314
      {
2300
2315
        /* Force close at once after usage */
2301
2316
        thd->version= table->s->version;
2305
2320
      /* Avoid self-deadlocks by detecting self-dependencies. */
2306
2321
      if (table->open_placeholder && table->in_use == thd)
2307
2322
      {
2308
 
        pthread_mutex_unlock(&LOCK_open);
 
2323
        VOID(pthread_mutex_unlock(&LOCK_open));
2309
2324
        my_error(ER_UPDATE_TABLE_USED, MYF(0), table->s->table_name.str);
2310
2325
        return(0);
2311
2326
      }
2346
2361
      }
2347
2362
      else
2348
2363
      {
2349
 
        pthread_mutex_unlock(&LOCK_open);
 
2364
        VOID(pthread_mutex_unlock(&LOCK_open));
2350
2365
      }
2351
2366
      /*
2352
2367
        There is a refresh in progress for this table.
2372
2387
  }
2373
2388
  else
2374
2389
  {
2375
 
    /* Insert a new Table instance into the open cache */
 
2390
    /* Insert a new TABLE instance into the open cache */
2376
2391
    int error;
2377
2392
    /* Free cache if too big */
2378
2393
    while (open_cache.records > table_cache_size && unused_tables)
2379
 
      hash_delete(&open_cache,(unsigned char*) unused_tables); /* purecov: tested */
 
2394
      VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
2380
2395
 
2381
2396
    if (table_list->create)
2382
2397
    {
2384
2399
 
2385
2400
      if (check_if_table_exists(thd, table_list, &exists))
2386
2401
      {
2387
 
        pthread_mutex_unlock(&LOCK_open);
 
2402
        VOID(pthread_mutex_unlock(&LOCK_open));
2388
2403
        return(NULL);
2389
2404
      }
2390
2405
 
2395
2410
        */
2396
2411
        if (!(table= table_cache_insert_placeholder(thd, key, key_length)))
2397
2412
        {
2398
 
          pthread_mutex_unlock(&LOCK_open);
 
2413
          VOID(pthread_mutex_unlock(&LOCK_open));
2399
2414
          return(NULL);
2400
2415
        }
2401
2416
        /*
2406
2421
        table->open_placeholder= 1;
2407
2422
        table->next= thd->open_tables;
2408
2423
        thd->open_tables= table;
2409
 
        pthread_mutex_unlock(&LOCK_open);
 
2424
        VOID(pthread_mutex_unlock(&LOCK_open));
2410
2425
        return(table);
2411
2426
      }
2412
2427
      /* Table exists. Let us try to open it. */
2413
2428
    }
2414
2429
 
2415
2430
    /* make a new table */
2416
 
    if (!(table=(Table*) my_malloc(sizeof(*table),MYF(MY_WME))))
 
2431
    if (!(table=(TABLE*) my_malloc(sizeof(*table),MYF(MY_WME))))
2417
2432
    {
2418
 
      pthread_mutex_unlock(&LOCK_open);
 
2433
      VOID(pthread_mutex_unlock(&LOCK_open));
2419
2434
      return(NULL);
2420
2435
    }
2421
2436
 
2422
 
    error= open_unireg_entry(thd, table, table_list, alias, key, key_length);
 
2437
    error= open_unireg_entry(thd, table, table_list, alias, key, key_length,
 
2438
                             mem_root, (flags & OPEN_VIEW_NO_PARSE));
2423
2439
    /* Combine the follow two */
2424
2440
    if (error > 0)
2425
2441
    {
2426
 
      free((unsigned char*)table);
2427
 
      pthread_mutex_unlock(&LOCK_open);
 
2442
      my_free((uchar*)table, MYF(0));
 
2443
      VOID(pthread_mutex_unlock(&LOCK_open));
2428
2444
      return(NULL);
2429
2445
    }
2430
2446
    if (error < 0)
2431
2447
    {
2432
 
      free((unsigned char*)table);
2433
 
      pthread_mutex_unlock(&LOCK_open);
 
2448
      my_free((uchar*)table, MYF(0));
 
2449
      VOID(pthread_mutex_unlock(&LOCK_open));
2434
2450
      return(0); // VIEW
2435
2451
    }
2436
 
    my_hash_insert(&open_cache,(unsigned char*) table);
 
2452
    VOID(my_hash_insert(&open_cache,(uchar*) table));
2437
2453
  }
2438
2454
 
2439
 
  pthread_mutex_unlock(&LOCK_open);
 
2455
  VOID(pthread_mutex_unlock(&LOCK_open));
2440
2456
  if (refresh)
2441
2457
  {
2442
2458
    table->next=thd->open_tables;               /* Link into simple list */
2453
2469
  /* Fix alias if table name changes */
2454
2470
  if (strcmp(table->alias, alias))
2455
2471
  {
2456
 
    uint32_t length=(uint) strlen(alias)+1;
 
2472
    uint length=(uint) strlen(alias)+1;
2457
2473
    table->alias= (char*) my_realloc((char*) table->alias, length,
2458
2474
                                     MYF(MY_WME));
2459
 
    memcpy((void*) table->alias, alias, length);
 
2475
    memcpy((char*) table->alias, alias, length);
2460
2476
  }
2461
2477
  /* These variables are also set in reopen_table() */
2462
2478
  table->tablenr=thd->current_tablenr++;
2463
2479
  table->used_fields=0;
2464
2480
  table->const_table=0;
2465
 
  table->null_row= false;
2466
 
  table->maybe_null= false;
2467
 
  table->force_index= false;
 
2481
  table->null_row= table->maybe_null= table->force_index= 0;
2468
2482
  table->status=STATUS_NO_RECORD;
2469
2483
  table->insert_values= 0;
2470
2484
  /* Catch wrong handling of the auto_increment_field_not_null. */
2479
2493
}
2480
2494
 
2481
2495
 
2482
 
Table *find_locked_table(THD *thd, const char *db,const char *table_name)
 
2496
TABLE *find_locked_table(THD *thd, const char *db,const char *table_name)
2483
2497
{
2484
2498
  char  key[MAX_DBKEY_LENGTH];
2485
 
  uint32_t key_length=(uint) (my_stpcpy(my_stpcpy(key,db)+1,table_name)-key)+1;
 
2499
  uint key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
2486
2500
 
2487
 
  for (Table *table=thd->open_tables; table ; table=table->next)
 
2501
  for (TABLE *table=thd->open_tables; table ; table=table->next)
2488
2502
  {
2489
2503
    if (table->s->table_cache_key.length == key_length &&
2490
2504
        !memcmp(table->s->table_cache_key.str, key, key_length))
2510
2524
   1  error. The old table object is not changed.
2511
2525
*/
2512
2526
 
2513
 
bool reopen_table(Table *table)
 
2527
bool reopen_table(TABLE *table)
2514
2528
{
2515
 
  Table tmp;
 
2529
  TABLE tmp;
2516
2530
  bool error= 1;
2517
2531
  Field **field;
2518
 
  uint32_t key,part;
2519
 
  TableList table_list;
 
2532
  uint key,part;
 
2533
  TABLE_LIST table_list;
2520
2534
  THD *thd= table->in_use;
2521
2535
 
2522
2536
  assert(table->s->ref_count == 0);
2524
2538
 
2525
2539
#ifdef EXTRA_DEBUG
2526
2540
  if (table->db_stat)
2527
 
    sql_print_error(_("Table %s had a open data handler in reopen_table"),
 
2541
    sql_print_error("Table %s had a open data handler in reopen_table",
2528
2542
                    table->alias);
2529
2543
#endif
2530
 
  memset(&table_list, 0, sizeof(TableList));
 
2544
  bzero((char*) &table_list, sizeof(TABLE_LIST));
2531
2545
  table_list.db=         table->s->db.str;
2532
2546
  table_list.table_name= table->s->table_name.str;
2533
2547
  table_list.table=      table;
2538
2552
  if (open_unireg_entry(thd, &tmp, &table_list,
2539
2553
                        table->alias,
2540
2554
                        table->s->table_cache_key.str,
2541
 
                        table->s->table_cache_key.length))
 
2555
                        table->s->table_cache_key.length,
 
2556
                        thd->mem_root, 0))
2542
2557
    goto end;
2543
2558
 
2544
2559
  /* This list copies variables set by open_table */
2560
2575
  tmp.prev=             table->prev;
2561
2576
 
2562
2577
  if (table->file)
2563
 
    closefrm(table, 1);         // close file, free everything
 
2578
    VOID(closefrm(table, 1));           // close file, free everything
2564
2579
 
2565
2580
  *table= tmp;
2566
2581
  table->default_column_bitmaps();
2602
2617
    @note This function assumes that if we are not under LOCK TABLES,
2603
2618
          then there is only one table open and locked. This means that
2604
2619
          the function probably has to be adjusted before it can be used
2605
 
          anywhere outside ALTER Table.
 
2620
          anywhere outside ALTER TABLE.
2606
2621
 
2607
2622
    @note Must not use TABLE_SHARE::table_name/db of the table being closed,
2608
2623
          the strings are used in a loop even after the share may be freed.
2611
2626
void close_data_files_and_morph_locks(THD *thd, const char *db,
2612
2627
                                      const char *table_name)
2613
2628
{
2614
 
  Table *table;
 
2629
  TABLE *table;
2615
2630
 
2616
2631
  safe_mutex_assert_owner(&LOCK_open);
2617
2632
 
2627
2642
 
2628
2643
  /*
2629
2644
    Note that open table list may contain a name-lock placeholder
2630
 
    for target table name if we process ALTER Table ... RENAME.
 
2645
    for target table name if we process ALTER TABLE ... RENAME.
2631
2646
    So loop below makes sense even if we are not under LOCK TABLES.
2632
2647
  */
2633
2648
  for (table=thd->open_tables; table ; table=table->next)
2657
2672
 
2658
2673
    @note Since this function can't properly handle prelocking and
2659
2674
          create placeholders it should be used in very special
2660
 
          situations like FLUSH TABLES or ALTER Table. In general
 
2675
          situations like FLUSH TABLES or ALTER TABLE. In general
2661
2676
          case one should just repeat open_tables()/lock_tables()
2662
2677
          combination when one needs tables to be reopened (for
2663
2678
          example see open_and_lock_tables()).
2669
2684
 
2670
2685
bool reopen_tables(THD *thd, bool get_locks, bool mark_share_as_old)
2671
2686
{
2672
 
  Table *table,*next,**prev;
2673
 
  Table **tables,**tables_ptr;                  // For locks
 
2687
  TABLE *table,*next,**prev;
 
2688
  TABLE **tables,**tables_ptr;                  // For locks
2674
2689
  bool error=0, not_used;
2675
 
  const uint32_t flags= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN |
2676
 
                    DRIZZLE_LOCK_IGNORE_GLOBAL_READ_LOCK |
2677
 
                    DRIZZLE_LOCK_IGNORE_FLUSH;
 
2690
  const uint flags= MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN |
 
2691
                    MYSQL_LOCK_IGNORE_GLOBAL_READ_LOCK |
 
2692
                    MYSQL_LOCK_IGNORE_FLUSH;
2678
2693
 
2679
2694
  if (!thd->open_tables)
2680
2695
    return(0);
2686
2701
      The ptr is checked later
2687
2702
      Do not handle locks of MERGE children.
2688
2703
    */
2689
 
    uint32_t opens=0;
 
2704
    uint opens=0;
2690
2705
    for (table= thd->open_tables; table ; table=table->next)
2691
2706
      opens++;
2692
 
    tables= (Table**) my_alloca(sizeof(Table*)*opens);
 
2707
    tables= (TABLE**) my_alloca(sizeof(TABLE*)*opens);
2693
2708
  }
2694
2709
  else
2695
2710
    tables= &thd->open_tables;
2698
2713
  prev= &thd->open_tables;
2699
2714
  for (table=thd->open_tables; table ; table=next)
2700
2715
  {
2701
 
    uint32_t db_stat=table->db_stat;
 
2716
    uint db_stat=table->db_stat;
2702
2717
    next=table->next;
2703
2718
    if (!tables || (!db_stat && reopen_table(table)))
2704
2719
    {
2705
2720
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
2706
 
      hash_delete(&open_cache,(unsigned char*) table);
 
2721
      VOID(hash_delete(&open_cache,(uchar*) table));
2707
2722
      error=1;
2708
2723
    }
2709
2724
    else
2723
2738
  *prev=0;
2724
2739
  if (tables != tables_ptr)                     // Should we get back old locks
2725
2740
  {
2726
 
    DRIZZLE_LOCK *lock;
 
2741
    MYSQL_LOCK *lock;
2727
2742
    /*
2728
2743
      We should always get these locks. Anyway, we must not go into
2729
2744
      wait_for_tables() as it tries to acquire LOCK_open, which is
2748
2763
  }
2749
2764
  if (get_locks && tables)
2750
2765
  {
2751
 
    my_afree((unsigned char*) tables);
 
2766
    my_afree((uchar*) tables);
2752
2767
  }
2753
2768
  broadcast_refresh();
2754
2769
  return(error);
2756
2771
 
2757
2772
 
2758
2773
/**
2759
 
    Close handlers for tables in list, but leave the Table structure
 
2774
    Close handlers for tables in list, but leave the TABLE structure
2760
2775
    intact so that we can re-open these quickly.
2761
2776
 
2762
2777
    @param thd           Thread context
2763
 
    @param table         Head of the list of Table objects
 
2778
    @param table         Head of the list of TABLE objects
2764
2779
    @param morph_locks   true  - remove locks which we have on tables being closed
2765
2780
                                 but ensure that no DML or DDL will sneak in before
2766
2781
                                 we will re-open the table (i.e. temporarily morph
2769
2784
    @param send_refresh  Should we awake waiters even if we didn't close any tables?
2770
2785
*/
2771
2786
 
2772
 
static void close_old_data_files(THD *thd, Table *table, bool morph_locks,
 
2787
static void close_old_data_files(THD *thd, TABLE *table, bool morph_locks,
2773
2788
                                 bool send_refresh)
2774
2789
{
2775
2790
  bool found= send_refresh;
2786
2801
      {
2787
2802
        if (morph_locks)
2788
2803
        {
2789
 
          Table *ulcktbl= table;
 
2804
          TABLE *ulcktbl= table;
2790
2805
          if (ulcktbl->lock_count)
2791
2806
          {
2792
2807
            /*
2812
2827
          }
2813
2828
          /*
2814
2829
            We want to protect the table from concurrent DDL operations
2815
 
            (like RENAME Table) until we will re-open and re-lock it.
 
2830
            (like RENAME TABLE) until we will re-open and re-lock it.
2816
2831
          */
2817
2832
          table->open_placeholder= 1;
2818
2833
        }
2824
2839
          We come here only in close-for-back-off scenario. So we have to
2825
2840
          "close" create placeholder here to avoid deadlocks (for example,
2826
2841
          in case of concurrent execution of CREATE TABLE t1 SELECT * FROM t2
2827
 
          and RENAME Table t2 TO t1). In close-for-re-open scenario we will
 
2842
          and RENAME TABLE t2 TO t1). In close-for-re-open scenario we will
2828
2843
          probably want to let it stay.
2829
2844
 
2830
2845
          Note "***": We must not enter this branch if the placeholder
2847
2862
  if the table is closed
2848
2863
*/
2849
2864
 
2850
 
bool table_is_used(Table *table, bool wait_for_name_lock)
 
2865
bool table_is_used(TABLE *table, bool wait_for_name_lock)
2851
2866
{
2852
2867
  do
2853
2868
  {
2854
2869
    char *key= table->s->table_cache_key.str;
2855
 
    uint32_t key_length= table->s->table_cache_key.length;
 
2870
    uint key_length= table->s->table_cache_key.length;
2856
2871
 
2857
2872
    HASH_SEARCH_STATE state;
2858
 
    for (Table *search= (Table*) hash_first(&open_cache, (unsigned char*) key,
 
2873
    for (TABLE *search= (TABLE*) hash_first(&open_cache, (uchar*) key,
2859
2874
                                             key_length, &state);
2860
2875
         search ;
2861
 
         search= (Table*) hash_next(&open_cache, (unsigned char*) key,
 
2876
         search= (TABLE*) hash_next(&open_cache, (uchar*) key,
2862
2877
                                    key_length, &state))
2863
2878
    {
2864
2879
      if (search->in_use == table->in_use)
2923
2938
  INFORMATION
2924
2939
    This is only called on drop tables
2925
2940
 
2926
 
    The Table object for the dropped table is unlocked but still kept around
 
2941
    The TABLE object for the dropped table is unlocked but still kept around
2927
2942
    as a name lock, which means that the table will be available for other
2928
2943
    thread as soon as we call unlock_table_names().
2929
2944
    If there is multiple copies of the table locked, all copies except
2935
2950
*/
2936
2951
 
2937
2952
 
2938
 
Table *drop_locked_tables(THD *thd,const char *db, const char *table_name)
 
2953
TABLE *drop_locked_tables(THD *thd,const char *db, const char *table_name)
2939
2954
{
2940
 
  Table *table,*next,**prev, *found= 0;
 
2955
  TABLE *table,*next,**prev, *found= 0;
2941
2956
  prev= &thd->open_tables;
2942
2957
 
2943
2958
  /*
2968
2983
      else
2969
2984
      {
2970
2985
        /* We already have a name lock, remove copy */
2971
 
        hash_delete(&open_cache,(unsigned char*) table);
 
2986
        VOID(hash_delete(&open_cache,(uchar*) table));
2972
2987
      }
2973
2988
    }
2974
2989
    else
2982
2997
    broadcast_refresh();
2983
2998
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
2984
2999
  {
2985
 
    free((unsigned char*) thd->locked_tables);
 
3000
    my_free((uchar*) thd->locked_tables,MYF(0));
2986
3001
    thd->locked_tables=0;
2987
3002
  }
2988
3003
  return(found);
2990
3005
 
2991
3006
 
2992
3007
/*
2993
 
  If we have the table open, which only happens when a LOCK Table has been
 
3008
  If we have the table open, which only happens when a LOCK TABLE has been
2994
3009
  done on the table, change the lock type to a lock that will abort all
2995
3010
  other threads trying to get the lock.
2996
3011
*/
2997
3012
 
2998
3013
void abort_locked_tables(THD *thd,const char *db, const char *table_name)
2999
3014
{
3000
 
  Table *table;
 
3015
  TABLE *table;
3001
3016
  for (table= thd->open_tables; table ; table= table->next)
3002
3017
  {
3003
3018
    if (!strcmp(table->s->table_name.str, table_name) &&
3038
3053
    share opens have been executed while one table was open all the
3039
3054
    time).
3040
3055
 
3041
 
    share->table_map_id is not UINT32_MAX.
 
3056
    share->table_map_id is not ~0UL.
3042
3057
 */
3043
3058
void assign_new_table_id(TABLE_SHARE *share)
3044
3059
{
3045
 
  static uint32_t last_table_id= UINT32_MAX;
 
3060
  static ulong last_table_id= ~0UL;
3046
3061
 
3047
3062
  /* Preconditions */
3048
3063
  assert(share != NULL);
3053
3068
    There is one reserved number that cannot be used.  Remember to
3054
3069
    change this when 6-byte global table id's are introduced.
3055
3070
  */
3056
 
  if (unlikely(tid == UINT32_MAX))
 
3071
  if (unlikely(tid == ~0UL))
3057
3072
    tid= ++last_table_id;
3058
3073
  share->table_map_id= tid;
3059
3074
 
3060
3075
  /* Post conditions */
3061
 
  assert(share->table_map_id != UINT32_MAX);
 
3076
  assert(share->table_map_id != ~0UL);
3062
3077
 
3063
3078
  return;
3064
3079
}
3070
3085
    open_unireg_entry()
3071
3086
    thd                 Thread handle
3072
3087
    entry               Store open table definition here
3073
 
    table_list          TableList with db, table_name
 
3088
    table_list          TABLE_LIST with db, table_name & belong_to_view
3074
3089
    alias               Alias name
3075
3090
    cache_key           Key for share_cache
3076
3091
    cache_key_length    length of cache_key
 
3092
    mem_root            temporary mem_root for parsing
 
3093
    flags               the OPEN_VIEW_NO_PARSE flag to be passed to
 
3094
                        openfrm()/open_new_frm()
3077
3095
 
3078
3096
  NOTES
3079
3097
   Extra argument for open is taken from thd->open_options
3084
3102
    #   Error
3085
3103
*/
3086
3104
 
3087
 
static int open_unireg_entry(THD *thd, Table *entry, TableList *table_list,
 
3105
static int open_unireg_entry(THD *thd, TABLE *entry, TABLE_LIST *table_list,
3088
3106
                             const char *alias,
3089
 
                             char *cache_key, uint32_t cache_key_length)
 
3107
                             char *cache_key, uint cache_key_length,
 
3108
                             MEM_ROOT *mem_root __attribute__((__unused__)),
 
3109
                             uint flags __attribute__((__unused__)))
3090
3110
{
3091
3111
  int error;
3092
3112
  TABLE_SHARE *share;
3093
 
  uint32_t discover_retry_count= 0;
 
3113
  uint discover_retry_count= 0;
3094
3114
 
3095
3115
  safe_mutex_assert_owner(&LOCK_open);
3096
3116
retry:
3097
3117
  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
3098
3118
                                           cache_key_length, 
 
3119
                                           OPEN_VIEW |
3099
3120
                                           table_list->i_s_requested_object,
3100
3121
                                           &error)))
3101
3122
    return(1);
3105
3126
                                               HA_OPEN_RNDFILE |
3106
3127
                                               HA_GET_INDEX |
3107
3128
                                               HA_TRY_READ_ONLY),
3108
 
                                       (EXTRA_RECORD),
 
3129
                                       (READ_KEYINFO | COMPUTE_TYPES |
 
3130
                                        EXTRA_RECORD),
3109
3131
                                       thd->open_options, entry, OTM_OPEN)))
3110
3132
  {
3111
3133
    if (error == 7)                             // Table def changed
3141
3163
      release_table_share(share, RELEASE_WAIT_FOR_DROP);
3142
3164
      if (!thd->killed)
3143
3165
      {
3144
 
        drizzle_reset_errors(thd, 1);         // Clear warnings
 
3166
        mysql_reset_errors(thd, 1);         // Clear warnings
3145
3167
        thd->clear_error();                 // Clear error message
3146
3168
        goto retry;
3147
3169
      }
3167
3189
                               (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
3168
3190
                                       HA_GET_INDEX |
3169
3191
                                       HA_TRY_READ_ONLY),
3170
 
                               EXTRA_RECORD,
 
3192
                               READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD,
3171
3193
                               ha_open_options | HA_OPEN_FOR_REPAIR,
3172
3194
                               entry, OTM_OPEN) || ! entry->file ||
3173
3195
        (entry->file->is_crashed() && entry->file->ha_check_and_repair(thd)))
3175
3197
       /* Give right error message */
3176
3198
       thd->clear_error();
3177
3199
       my_error(ER_NOT_KEYFILE, MYF(0), share->table_name.str, my_errno);
3178
 
       sql_print_error(_("Couldn't repair table: %s.%s"), share->db.str,
 
3200
       sql_print_error("Couldn't repair table: %s.%s", share->db.str,
3179
3201
                       share->table_name.str);
3180
3202
       if (entry->file)
3181
3203
        closefrm(entry, 0);
3201
3223
    if (mysql_bin_log.is_open())
3202
3224
    {
3203
3225
      char *query, *end;
3204
 
      uint32_t query_buf_size= 20 + share->db.length + share->table_name.length +1;
 
3226
      uint query_buf_size= 20 + share->db.length + share->table_name.length +1;
3205
3227
      if ((query= (char*) my_malloc(query_buf_size,MYF(MY_WME))))
3206
3228
      {
3207
3229
        /* this DELETE FROM is needed even with row-based binlogging */
3208
 
        end = strxmov(my_stpcpy(query, "DELETE FROM `"),
3209
 
                      share->db.str,"`.`",share->table_name.str,"`", NULL);
 
3230
        end = strxmov(strmov(query, "DELETE FROM `"),
 
3231
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
3210
3232
        thd->binlog_query(THD::STMT_QUERY_TYPE,
3211
3233
                          query, (ulong)(end-query), false, false);
3212
 
        free(query);
 
3234
        my_free(query, MYF(0));
3213
3235
      }
3214
3236
      else
3215
3237
      {
3218
3240
          DBA on top of warning the client (which will automatically be done
3219
3241
          because of MYF(MY_WME) in my_malloc() above).
3220
3242
        */
3221
 
        sql_print_error(_("When opening HEAP table, could not allocate memory "
3222
 
                          "to write 'DELETE FROM `%s`.`%s`' to the binary log"),
 
3243
        sql_print_error("When opening HEAP table, could not allocate memory "
 
3244
                        "to write 'DELETE FROM `%s`.`%s`' to the binary log",
3223
3245
                        table_list->db, table_list->table_name);
3224
3246
        closefrm(entry, 0);
3225
3247
        goto err;
3243
3265
    start - list of tables in/out
3244
3266
    counter - number of opened tables will be return using this parameter
3245
3267
    flags   - bitmap of flags to modify how the tables will be open:
3246
 
              DRIZZLE_LOCK_IGNORE_FLUSH - open table even if someone has
 
3268
              MYSQL_LOCK_IGNORE_FLUSH - open table even if someone has
3247
3269
              done a flush or namelock on it.
3248
3270
 
3249
3271
  NOTE
3262
3284
    -1 - error
3263
3285
*/
3264
3286
 
3265
 
int open_tables(THD *thd, TableList **start, uint32_t *counter, uint32_t flags)
 
3287
int open_tables(THD *thd, TABLE_LIST **start, uint *counter, uint flags)
3266
3288
{
3267
 
  TableList *tables= NULL;
 
3289
  TABLE_LIST *tables= NULL;
3268
3290
  bool refresh;
3269
3291
  int result=0;
3270
3292
  MEM_ROOT new_frm_mem;
3301
3323
      continue;
3302
3324
    }
3303
3325
    /*
3304
 
      If this TableList object is a placeholder for an information_schema
 
3326
      If this TABLE_LIST object is a placeholder for an information_schema
3305
3327
      table, create a temporary table to represent the information_schema
3306
3328
      table in the query. Do not fill it yet - will be filled during
3307
3329
      execution.
3319
3341
      not opened yet. Try to open the table.
3320
3342
    */
3321
3343
    if (!tables->table)
3322
 
      tables->table= open_table(thd, tables, &refresh, flags);
 
3344
      tables->table= open_table(thd, tables, &new_frm_mem, &refresh, flags);
3323
3345
 
3324
3346
    if (!tables->table)
3325
3347
    {
3367
3389
  {
3368
3390
    /*
3369
3391
      Some functions determine success as (tables->table != NULL).
3370
 
      tables->table is in thd->open_tables.
 
3392
      tables->table is in thd->open_tables. It won't go lost. If the
 
3393
      error happens on a MERGE child, clear the parents TABLE reference.
3371
3394
    */
 
3395
    if (tables->parent_l)
 
3396
      tables->parent_l->table= NULL;
3372
3397
    tables->table= NULL;
3373
3398
  }
3374
3399
  return(result);
3389
3414
  1     error
3390
3415
*/
3391
3416
 
3392
 
static bool check_lock_and_start_stmt(THD *thd, Table *table,
 
3417
static bool check_lock_and_start_stmt(THD *thd, TABLE *table,
3393
3418
                                      thr_lock_type lock_type)
3394
3419
{
3395
3420
  int error;
3439
3464
    and locking issues because it does not call lock_tables().
3440
3465
*/
3441
3466
 
3442
 
Table *open_n_lock_single_table(THD *thd, TableList *table_l,
 
3467
TABLE *open_n_lock_single_table(THD *thd, TABLE_LIST *table_l,
3443
3468
                                thr_lock_type lock_type)
3444
3469
{
3445
 
  TableList *save_next_global;
 
3470
  TABLE_LIST *save_next_global;
3446
3471
 
3447
3472
  /* Remember old 'next' pointer. */
3448
3473
  save_next_global= table_l->next_global;
3451
3476
 
3452
3477
  /* Set requested lock type. */
3453
3478
  table_l->lock_type= lock_type;
 
3479
  /* Allow to open real tables only. */
 
3480
  table_l->required_type= FRMTYPE_TABLE;
3454
3481
 
3455
3482
  /* Open the table. */
3456
3483
  if (simple_open_n_lock_tables(thd, table_l))
3487
3514
      table_list->table         table
3488
3515
*/
3489
3516
 
3490
 
Table *open_ltable(THD *thd, TableList *table_list, thr_lock_type lock_type,
3491
 
                   uint32_t lock_flags)
 
3517
TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type lock_type,
 
3518
                   uint lock_flags)
3492
3519
{
3493
 
  Table *table;
 
3520
  TABLE *table;
3494
3521
  bool refresh;
3495
3522
 
3496
3523
  thd_proc_info(thd, "Opening table");
3497
3524
  thd->current_tablenr= 0;
3498
 
  while (!(table= open_table(thd, table_list, &refresh, 0)) &&
 
3525
  /* open_ltable can be used only for BASIC TABLEs */
 
3526
  table_list->required_type= FRMTYPE_TABLE;
 
3527
  while (!(table= open_table(thd, table_list, thd->mem_root, &refresh, 0)) &&
3499
3528
         refresh)
3500
3529
    ;
3501
3530
 
3547
3576
    the third argument set appropriately.
3548
3577
*/
3549
3578
 
3550
 
int open_and_lock_tables_derived(THD *thd, TableList *tables, bool derived)
 
3579
int open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables, bool derived)
3551
3580
{
3552
 
  uint32_t counter;
 
3581
  uint counter;
3553
3582
  bool need_reopen;
3554
3583
 
3555
3584
  for ( ; ; ) 
3580
3609
    thd         - thread handler
3581
3610
    tables      - list of tables for open
3582
3611
    flags       - bitmap of flags to modify how the tables will be open:
3583
 
                  DRIZZLE_LOCK_IGNORE_FLUSH - open table even if someone has
 
3612
                  MYSQL_LOCK_IGNORE_FLUSH - open table even if someone has
3584
3613
                  done a flush or namelock on it.
3585
3614
 
3586
3615
  RETURN
3592
3621
    data from the tables.
3593
3622
*/
3594
3623
 
3595
 
bool open_normal_and_derived_tables(THD *thd, TableList *tables, uint32_t flags)
 
3624
bool open_normal_and_derived_tables(THD *thd, TABLE_LIST *tables, uint flags)
3596
3625
{
3597
 
  uint32_t counter;
 
3626
  uint counter;
3598
3627
  assert(!thd->fill_derived_tables());
3599
3628
  if (open_tables(thd, &tables, &counter, flags) ||
3600
3629
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
3640
3669
   @param tables Tables involved in the query
3641
3670
 */
3642
3671
 
3643
 
int decide_logging_format(THD *thd, TableList *tables)
 
3672
int decide_logging_format(THD *thd, TABLE_LIST *tables)
3644
3673
{
3645
3674
  if (mysql_bin_log.is_open() && (thd->options & OPTION_BIN_LOG))
3646
3675
  {
3647
3676
    handler::Table_flags flags_some_set= handler::Table_flags();
3648
3677
    handler::Table_flags flags_all_set= ~handler::Table_flags();
3649
 
    bool multi_engine= false;
 
3678
    my_bool multi_engine= false;
3650
3679
    void* prev_ht= NULL;
3651
 
    for (TableList *table= tables; table; table= table->next_global)
 
3680
    for (TABLE_LIST *table= tables; table; table= table->next_global)
3652
3681
    {
3653
3682
      if (!table->placeholder() && table->lock_type >= TL_WRITE_ALLOW_WRITE)
3654
3683
      {
3684
3713
                " but not allowed by this combination of engines");
3685
3714
    }
3686
3715
 
 
3716
    /*
 
3717
      If more than one engine is involved in the statement and at
 
3718
      least one is doing it's own logging (is *self-logging*), the
 
3719
      statement cannot be logged atomically, so we generate an error
 
3720
      rather than allowing the binlog to become corrupt.
 
3721
     */
 
3722
    if (multi_engine &&
 
3723
        (flags_some_set & HA_HAS_OWN_BINLOGGING))
 
3724
    {
 
3725
      error= ER_BINLOG_LOGGING_IMPOSSIBLE;
 
3726
      my_error(error, MYF(0),
 
3727
               "Statement cannot be written atomically since more"
 
3728
               " than one engine involved and at least one engine"
 
3729
               " is self-logging");
 
3730
    }
 
3731
 
3687
3732
    if (error)
3688
3733
      return -1;
3689
3734
 
3737
3782
   -1   Error
3738
3783
*/
3739
3784
 
3740
 
int lock_tables(THD *thd, TableList *tables, uint32_t count, bool *need_reopen)
 
3785
int lock_tables(THD *thd, TABLE_LIST *tables, uint count, bool *need_reopen)
3741
3786
{
3742
 
  TableList *table;
 
3787
  TABLE_LIST *table;
3743
3788
 
3744
3789
  /*
3745
3790
    We can't meet statement requiring prelocking if we already
3753
3798
  if (!thd->locked_tables)
3754
3799
  {
3755
3800
    assert(thd->lock == 0);     // You must lock everything at once
3756
 
    Table **start,**ptr;
3757
 
    uint32_t lock_flag= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN;
 
3801
    TABLE **start,**ptr;
 
3802
    uint lock_flag= MYSQL_LOCK_NOTIFY_IF_NEED_REOPEN;
3758
3803
 
3759
 
    if (!(ptr=start=(Table**) thd->alloc(sizeof(Table*)*count)))
 
3804
    if (!(ptr=start=(TABLE**) thd->alloc(sizeof(TABLE*)*count)))
3760
3805
      return(-1);
3761
3806
    for (table= tables; table; table= table->next_global)
3762
3807
    {
3772
3817
  }
3773
3818
  else
3774
3819
  {
3775
 
    TableList *first_not_own= thd->lex->first_not_own_table();
 
3820
    TABLE_LIST *first_not_own= thd->lex->first_not_own_table();
3776
3821
    /*
3777
3822
      When open_and_lock_tables() is called for a single table out of
3778
3823
      a table list, the 'next_global' chain is temporarily broken. We
3808
3853
 
3809
3854
*/
3810
3855
 
3811
 
void close_tables_for_reopen(THD *thd, TableList **tables)
 
3856
void close_tables_for_reopen(THD *thd, TABLE_LIST **tables)
3812
3857
{
3813
3858
  /*
3814
3859
    If table list consists only from tables from prelocking set, table list
3817
3862
  if (thd->lex->first_not_own_table() == *tables)
3818
3863
    *tables= 0;
3819
3864
  thd->lex->chop_off_not_own_tables();
3820
 
  for (TableList *tmp= *tables; tmp; tmp= tmp->next_global)
 
3865
  for (TABLE_LIST *tmp= *tables; tmp; tmp= tmp->next_global)
3821
3866
    tmp->table= 0;
3822
3867
  close_thread_tables(thd);
3823
3868
}
3840
3885
 
3841
3886
 RETURN
3842
3887
   0  Error
3843
 
   #  Table object
 
3888
   #  TABLE object
3844
3889
*/
3845
3890
 
3846
 
Table *open_temporary_table(THD *thd, const char *path, const char *db,
 
3891
TABLE *open_temporary_table(THD *thd, const char *path, const char *db,
3847
3892
                            const char *table_name, bool link_in_list,
3848
3893
                            open_table_mode open_mode)
3849
3894
{
3850
 
  Table *tmp_table;
 
3895
  TABLE *tmp_table;
3851
3896
  TABLE_SHARE *share;
3852
3897
  char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
3853
 
  uint32_t key_length;
3854
 
  TableList table_list;
 
3898
  uint key_length;
 
3899
  TABLE_LIST table_list;
3855
3900
 
3856
3901
  table_list.db=         (char*) db;
3857
3902
  table_list.table_name= (char*) table_name;
3858
3903
  /* Create the cache_key for temporary tables */
3859
3904
  key_length= create_table_def_key(thd, cache_key, &table_list, 1);
3860
3905
 
3861
 
  if (!(tmp_table= (Table*) my_malloc(sizeof(*tmp_table) + sizeof(*share) +
 
3906
  if (!(tmp_table= (TABLE*) my_malloc(sizeof(*tmp_table) + sizeof(*share) +
3862
3907
                                      strlen(path)+1 + key_length,
3863
3908
                                      MYF(MY_WME))))
3864
3909
    return(0);                          /* purecov: inspected */
3865
3910
 
3866
3911
  share= (TABLE_SHARE*) (tmp_table+1);
3867
3912
  tmp_path= (char*) (share+1);
3868
 
  saved_cache_key= my_stpcpy(tmp_path, path)+1;
 
3913
  saved_cache_key= strmov(tmp_path, path)+1;
3869
3914
  memcpy(saved_cache_key, cache_key, key_length);
3870
3915
 
3871
3916
  init_tmp_table_share(thd, share, saved_cache_key, key_length,
3872
 
                       strchr(saved_cache_key, '\0')+1, tmp_path);
 
3917
                       strend(saved_cache_key)+1, tmp_path);
3873
3918
 
3874
3919
  if (open_table_def(thd, share, 0) ||
3875
3920
      open_table_from_share(thd, share, table_name,
3877
3922
                            (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
3878
3923
                                    HA_GET_INDEX),
3879
3924
                            (open_mode == OTM_ALTER) ?
3880
 
                              (EXTRA_RECORD | OPEN_FRM_FILE_ONLY)
3881
 
                            : (EXTRA_RECORD),
 
3925
                              (READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD |
 
3926
                               OPEN_FRM_FILE_ONLY)
 
3927
                            : (READ_KEYINFO | COMPUTE_TYPES | EXTRA_RECORD),
3882
3928
                            ha_open_options,
3883
3929
                            tmp_table, open_mode))
3884
3930
  {
3885
3931
    /* No need to lock share->mutex as this is not needed for tmp tables */
3886
3932
    free_table_share(share);
3887
 
    free((char*) tmp_table);
 
3933
    my_free((char*) tmp_table,MYF(0));
3888
3934
    return(0);
3889
3935
  }
3890
3936
 
3923
3969
  handler *file;
3924
3970
  char *ext;
3925
3971
 
3926
 
  my_stpcpy(ext= strchr(path, '\0'), reg_ext);
 
3972
  strmov(ext= strend(path), reg_ext);
3927
3973
  if (my_delete(path,MYF(0)))
3928
3974
    error=1; /* purecov: inspected */
3929
3975
  *ext= 0;                              // remove extension
3931
3977
  if (!frm_only && file && file->ha_delete_table(path))
3932
3978
  {
3933
3979
    error=1;
3934
 
    sql_print_warning(_("Could not remove temporary table: '%s', error: %d"),
 
3980
    sql_print_warning("Could not remove temporary table: '%s', error: %d",
3935
3981
                      path, my_errno);
3936
3982
  }
3937
3983
  delete file;
3954
4000
 
3955
4001
#define WRONG_GRANT (Field*) -1
3956
4002
 
3957
 
static void update_field_dependencies(THD *thd, Field *field, Table *table)
 
4003
static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
3958
4004
{
3959
4005
  if (thd->mark_used_columns != MARK_COLUMNS_NONE)
3960
4006
  {
3996
4042
 
3997
4043
 
3998
4044
/*
 
4045
  Find a field by name in a view that uses merge algorithm.
 
4046
 
 
4047
  SYNOPSIS
 
4048
    find_field_in_view()
 
4049
    thd                         thread handler
 
4050
    table_list                  view to search for 'name'
 
4051
    name                        name of field
 
4052
    length                      length of name
 
4053
    item_name                   name of item if it will be created (VIEW)
 
4054
    ref                         expression substituted in VIEW should be passed
 
4055
                                using this reference (return view_ref_found)
 
4056
    register_tree_change        true if ref is not stack variable and we
 
4057
                                need register changes in item tree
 
4058
 
 
4059
  RETURN
 
4060
    0                   field is not found
 
4061
    view_ref_found      found value in VIEW (real result is in *ref)
 
4062
    #                   pointer to field - only for schema table fields
 
4063
*/
 
4064
 
 
4065
static Field *
 
4066
find_field_in_view(THD *thd, TABLE_LIST *table_list,
 
4067
                   const char *name, uint length __attribute__((__unused__)),
 
4068
                   const char *item_name __attribute__((__unused__)),
 
4069
                   Item **ref,
 
4070
                   bool register_tree_change __attribute__((__unused__)))
 
4071
{
 
4072
  Field_iterator_view field_it;
 
4073
  field_it.set(table_list);
 
4074
  
 
4075
  assert(table_list->schema_table_reformed ||
 
4076
              (ref != 0 && (0) != 0));
 
4077
  for (; !field_it.end_of_fields(); field_it.next())
 
4078
  {
 
4079
    if (!my_strcasecmp(system_charset_info, field_it.name(), name))
 
4080
    {
 
4081
      /*
 
4082
        create_item() may, or may not create a new Item, depending on
 
4083
        the column reference. See create_view_field() for details.
 
4084
      */
 
4085
      Item *item= field_it.create_item(thd);
 
4086
      
 
4087
      if (!item)
 
4088
        return(0);
 
4089
      /*
 
4090
       *ref != NULL means that *ref contains the item that we need to
 
4091
       replace. If the item was aliased by the user, set the alias to
 
4092
       the replacing item.
 
4093
       We need to set alias on both ref itself and on ref real item.
 
4094
      */
 
4095
      if (*ref && !(*ref)->is_autogenerated_name)
 
4096
      {
 
4097
        item->set_name((*ref)->name, (*ref)->name_length,
 
4098
                       system_charset_info);
 
4099
        item->real_item()->set_name((*ref)->name, (*ref)->name_length,
 
4100
                       system_charset_info);
 
4101
      }
 
4102
      if (register_tree_change)
 
4103
        thd->change_item_tree(ref, item);
 
4104
      else
 
4105
        *ref= item;
 
4106
      return((Field*) view_ref_found);
 
4107
    }
 
4108
  }
 
4109
  return(0);
 
4110
}
 
4111
 
 
4112
 
 
4113
/*
3999
4114
  Find field by name in a NATURAL/USING join table reference.
4000
4115
 
4001
4116
  SYNOPSIS
4025
4140
*/
4026
4141
 
4027
4142
static Field *
4028
 
find_field_in_natural_join(THD *thd, TableList *table_ref, const char *name,
4029
 
                           uint32_t length __attribute__((unused)),
4030
 
                           Item **ref __attribute__((unused)), bool register_tree_change __attribute__((unused)),
4031
 
                           TableList **actual_table)
 
4143
find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
 
4144
                           uint length __attribute__((__unused__)),
 
4145
                           Item **ref, bool register_tree_change,
 
4146
                           TABLE_LIST **actual_table)
4032
4147
{
4033
4148
  List_iterator_fast<Natural_join_column>
4034
4149
    field_it(*(table_ref->join_columns));
4053
4168
  }
4054
4169
  if (!nj_col)
4055
4170
    return(NULL);
 
4171
 
 
4172
  if (nj_col->view_field)
 
4173
  {
 
4174
    Item *item;
 
4175
    /*
 
4176
      create_item() may, or may not create a new Item, depending on the
 
4177
      column reference. See create_view_field() for details.
 
4178
    */
 
4179
    item= nj_col->create_item(thd);
 
4180
    /*
 
4181
     *ref != NULL means that *ref contains the item that we need to
 
4182
     replace. If the item was aliased by the user, set the alias to
 
4183
     the replacing item.
 
4184
     We need to set alias on both ref itself and on ref real item.
 
4185
     */
 
4186
    if (*ref && !(*ref)->is_autogenerated_name)
 
4187
    {
 
4188
      item->set_name((*ref)->name, (*ref)->name_length,
 
4189
                     system_charset_info);
 
4190
      item->real_item()->set_name((*ref)->name, (*ref)->name_length,
 
4191
                                  system_charset_info);
 
4192
    }
 
4193
 
 
4194
    if (!item)
 
4195
      return(NULL);
 
4196
    assert(nj_col->table_field == NULL);
 
4197
    if (nj_col->table_ref->schema_table_reformed)
 
4198
    {
 
4199
      /*
 
4200
        Translation table items are always Item_fields and fixed
 
4201
        already('mysql_schema_table' function). So we can return
 
4202
        ->field. It is used only for 'show & where' commands.
 
4203
      */
 
4204
      return(((Item_field*) (nj_col->view_field->item))->field);
 
4205
    }
 
4206
    if (register_tree_change)
 
4207
      thd->change_item_tree(ref, item);
 
4208
    else
 
4209
      *ref= item;
 
4210
    found_field= (Field*) view_ref_found;
 
4211
  }
 
4212
  else
4056
4213
  {
4057
4214
    /* This is a base table. */
 
4215
    assert(nj_col->view_field == NULL);
4058
4216
    assert(nj_col->table_ref->table == nj_col->table_field->table);
4059
4217
    found_field= nj_col->table_field;
4060
4218
    update_field_dependencies(thd, found_field, nj_col->table_ref->table);
4085
4243
*/
4086
4244
 
4087
4245
Field *
4088
 
find_field_in_table(THD *thd, Table *table, const char *name, uint32_t length,
4089
 
                    bool allow_rowid, uint32_t *cached_field_index_ptr)
 
4246
find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
 
4247
                    bool allow_rowid, uint *cached_field_index_ptr)
4090
4248
{
4091
4249
  Field **field_ptr, *field;
4092
 
  uint32_t cached_field_index= *cached_field_index_ptr;
 
4250
  uint cached_field_index= *cached_field_index_ptr;
4093
4251
 
4094
4252
  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
4095
4253
  if (cached_field_index < table->s->fields &&
4098
4256
    field_ptr= table->field + cached_field_index;
4099
4257
  else if (table->s->name_hash.records)
4100
4258
  {
4101
 
    field_ptr= (Field**) hash_search(&table->s->name_hash, (unsigned char*) name,
 
4259
    field_ptr= (Field**) hash_search(&table->s->name_hash, (uchar*) name,
4102
4260
                                     length);
4103
4261
    if (field_ptr)
4104
4262
    {
4181
4339
*/
4182
4340
 
4183
4341
Field *
4184
 
find_field_in_table_ref(THD *thd, TableList *table_list,
4185
 
                        const char *name, uint32_t length,
 
4342
find_field_in_table_ref(THD *thd, TABLE_LIST *table_list,
 
4343
                        const char *name, uint length,
4186
4344
                        const char *item_name, const char *db_name,
4187
4345
                        const char *table_name, Item **ref,
4188
4346
                        bool check_privileges, bool allow_rowid,
4189
 
                        uint32_t *cached_field_index_ptr,
4190
 
                        bool register_tree_change, TableList **actual_table)
 
4347
                        uint *cached_field_index_ptr,
 
4348
                        bool register_tree_change, TABLE_LIST **actual_table)
4191
4349
{
4192
 
  Field *fld= NULL;
 
4350
  Field *fld;
4193
4351
 
4194
4352
  assert(table_list->alias);
4195
4353
  assert(name);
4230
4388
 
4231
4389
  if (table_list->field_translation)
4232
4390
  {
 
4391
    /* 'table_list' is a view or an information schema table. */
 
4392
    if ((fld= find_field_in_view(thd, table_list, name, length, item_name, ref,
 
4393
                                 register_tree_change)))
 
4394
      *actual_table= table_list;
4233
4395
  }
4234
4396
  else if (!table_list->nested_join)
4235
4397
  {
4251
4413
    */
4252
4414
    if (table_name && table_name[0])
4253
4415
    {
4254
 
      List_iterator<TableList> it(table_list->nested_join->join_list);
4255
 
      TableList *table;
 
4416
      List_iterator<TABLE_LIST> it(table_list->nested_join->join_list);
 
4417
      TABLE_LIST *table;
4256
4418
      while ((table= it++))
4257
4419
      {
4258
4420
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
4292
4454
          else
4293
4455
          {
4294
4456
            if (thd->mark_used_columns == MARK_COLUMNS_READ)
4295
 
              it->walk(&Item::register_field_in_read_map, 1, (unsigned char *) 0);
 
4457
              it->walk(&Item::register_field_in_read_map, 1, (uchar *) 0);
4296
4458
          }
4297
4459
        }
4298
4460
        else
4299
4461
          field_to_set= fld;
4300
4462
        if (field_to_set)
4301
4463
        {
4302
 
          Table *table= field_to_set->table;
 
4464
          TABLE *table= field_to_set->table;
4303
4465
          if (thd->mark_used_columns == MARK_COLUMNS_READ)
4304
4466
            bitmap_set_bit(table->read_set, field_to_set->field_index);
4305
4467
          else
4326
4488
    #                   pointer to field
4327
4489
*/
4328
4490
 
4329
 
Field *find_field_in_table_sef(Table *table, const char *name)
 
4491
Field *find_field_in_table_sef(TABLE *table, const char *name)
4330
4492
{
4331
4493
  Field **field_ptr;
4332
4494
  if (table->s->name_hash.records)
4333
4495
  {
4334
 
    field_ptr= (Field**)hash_search(&table->s->name_hash,(unsigned char*) name,
 
4496
    field_ptr= (Field**)hash_search(&table->s->name_hash,(uchar*) name,
4335
4497
                                    strlen(name));
4336
4498
    if (field_ptr)
4337
4499
    {
4393
4555
 
4394
4556
Field *
4395
4557
find_field_in_tables(THD *thd, Item_ident *item,
4396
 
                     TableList *first_table, TableList *last_table,
 
4558
                     TABLE_LIST *first_table, TABLE_LIST *last_table,
4397
4559
                     Item **ref, find_item_error_report_type report_error,
4398
4560
                     bool check_privileges, bool register_tree_change)
4399
4561
{
4401
4563
  const char *db= item->db_name;
4402
4564
  const char *table_name= item->table_name;
4403
4565
  const char *name= item->field_name;
4404
 
  uint32_t length=(uint) strlen(name);
 
4566
  uint length=(uint) strlen(name);
4405
4567
  char name_buff[NAME_LEN+1];
4406
 
  TableList *cur_table= first_table;
4407
 
  TableList *actual_table;
 
4568
  TABLE_LIST *cur_table= first_table;
 
4569
  TABLE_LIST *actual_table;
4408
4570
  bool allow_rowid;
4409
4571
 
4410
4572
  if (!table_name || !table_name[0])
4419
4581
  {
4420
4582
    /*
4421
4583
      This shortcut is used by prepared statements. We assume that
4422
 
      TableList *first_table is not changed during query execution (which
 
4584
      TABLE_LIST *first_table is not changed during query execution (which
4423
4585
      is true for all queries except RENAME but luckily RENAME doesn't
4424
4586
      use fields...) so we can rely on reusing pointer to its member.
4425
4587
      With this optimization we also miss case when addition of one more
4426
4588
      field makes some prepared query ambiguous and so erroneous, but we
4427
4589
      accept this trade off.
4428
4590
    */
4429
 
    TableList *table_ref= item->cached_table;
 
4591
    TABLE_LIST *table_ref= item->cached_table;
4430
4592
    /*
4431
4593
      The condition (table_ref->view == NULL) ensures that we will call
4432
4594
      find_field_in_table even in the case of information schema tables
4450
4612
        Only views fields should be marked as dependent, not an underlying
4451
4613
        fields.
4452
4614
      */
 
4615
      if (!table_ref->belong_to_view)
4453
4616
      {
4454
4617
        SELECT_LEX *current_sel= thd->lex->current_select;
4455
4618
        SELECT_LEX *last_select= table_ref->select_lex;
4561
4724
    char buff[NAME_LEN*2+1];
4562
4725
    if (db && db[0])
4563
4726
    {
4564
 
      strxnmov(buff,sizeof(buff)-1,db,".",table_name,NULL);
 
4727
      strxnmov(buff,sizeof(buff)-1,db,".",table_name,NullS);
4565
4728
      table_name=buff;
4566
4729
    }
4567
4730
    my_error(ER_UNKNOWN_TABLE, MYF(0), table_name, thd->where);
4616
4779
 
4617
4780
 
4618
4781
Item **
4619
 
find_item_in_list(Item *find, List<Item> &items, uint32_t *counter,
 
4782
find_item_in_list(Item *find, List<Item> &items, uint *counter,
4620
4783
                  find_item_error_report_type report_error,
4621
4784
                  enum_resolution_type *resolution)
4622
4785
{
4631
4794
    (and not an item that happens to have a name).
4632
4795
  */
4633
4796
  bool is_ref_by_name= 0;
4634
 
  uint32_t unaliased_counter= 0;
 
4797
  uint unaliased_counter= 0;
4635
4798
 
4636
4799
  *resolution= NOT_RESOLVED;
4637
4800
 
4644
4807
    db_name=    ((Item_ident*) find)->db_name;
4645
4808
  }
4646
4809
 
4647
 
  for (uint32_t i= 0; (item=li++); i++)
 
4810
  for (uint i= 0; (item=li++); i++)
4648
4811
  {
4649
4812
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
4650
4813
    {
4886
5049
*/
4887
5050
 
4888
5051
static bool
4889
 
set_new_item_local_context(THD *thd, Item_ident *item, TableList *table_ref)
 
5052
set_new_item_local_context(THD *thd, Item_ident *item, TABLE_LIST *table_ref)
4890
5053
{
4891
5054
  Name_resolution_context *context;
4892
5055
  if (!(context= new (thd->mem_root) Name_resolution_context))
4931
5094
*/
4932
5095
 
4933
5096
static bool
4934
 
mark_common_columns(THD *thd, TableList *table_ref_1, TableList *table_ref_2,
4935
 
                    List<String> *using_fields, uint32_t *found_using_fields)
 
5097
mark_common_columns(THD *thd, TABLE_LIST *table_ref_1, TABLE_LIST *table_ref_2,
 
5098
                    List<String> *using_fields, uint *found_using_fields)
4936
5099
{
4937
5100
  Field_iterator_table_ref it_1, it_2;
4938
5101
  Natural_join_column *nj_col_1, *nj_col_2;
4942
5105
    Leaf table references to which new natural join columns are added
4943
5106
    if the leaves are != NULL.
4944
5107
  */
4945
 
  TableList *leaf_1= (table_ref_1->nested_join &&
 
5108
  TABLE_LIST *leaf_1= (table_ref_1->nested_join &&
4946
5109
                       !table_ref_1->is_natural_join) ?
4947
5110
                      NULL : table_ref_1;
4948
 
  TableList *leaf_2= (table_ref_2->nested_join &&
 
5111
  TABLE_LIST *leaf_2= (table_ref_2->nested_join &&
4949
5112
                       !table_ref_2->is_natural_join) ?
4950
5113
                      NULL : table_ref_2;
4951
5114
 
5032
5195
        goto err;                               // out of memory
5033
5196
 
5034
5197
      /*
 
5198
        The following assert checks that the two created items are of
 
5199
        type Item_ident.
 
5200
      */
 
5201
      assert(!thd->lex->current_select->no_wrap_view_item);
 
5202
      /*
5035
5203
        In the case of no_wrap_view_item == 0, the created items must be
5036
5204
        of sub-classes of Item_ident.
5037
5205
      */
5072
5240
 
5073
5241
      if (field_1)
5074
5242
      {
5075
 
        Table *table_1= nj_col_1->table_ref->table;
 
5243
        TABLE *table_1= nj_col_1->table_ref->table;
5076
5244
        /* Mark field_1 used for table cache. */
5077
5245
        bitmap_set_bit(table_1->read_set, field_1->field_index);
5078
5246
        table_1->covering_keys.intersect(field_1->part_of_key);
5080
5248
      }
5081
5249
      if (field_2)
5082
5250
      {
5083
 
        Table *table_2= nj_col_2->table_ref->table;
 
5251
        TABLE *table_2= nj_col_2->table_ref->table;
5084
5252
        /* Mark field_2 used for table cache. */
5085
5253
        bitmap_set_bit(table_2->read_set, field_2->field_index);
5086
5254
        table_2->covering_keys.intersect(field_2->part_of_key);
5145
5313
*/
5146
5314
 
5147
5315
static bool
5148
 
store_natural_using_join_columns(THD *thd __attribute__((unused)),
5149
 
                                 TableList *natural_using_join,
5150
 
                                 TableList *table_ref_1,
5151
 
                                 TableList *table_ref_2,
 
5316
store_natural_using_join_columns(THD *thd __attribute__((__unused__)),
 
5317
                                 TABLE_LIST *natural_using_join,
 
5318
                                 TABLE_LIST *table_ref_1,
 
5319
                                 TABLE_LIST *table_ref_2,
5152
5320
                                 List<String> *using_fields,
5153
 
                                 uint32_t found_using_fields)
 
5321
                                 uint found_using_fields)
5154
5322
{
5155
5323
  Field_iterator_table_ref it_1, it_2;
5156
5324
  Natural_join_column *nj_col_1, *nj_col_2;
5248
5416
  DESCRIPTION
5249
5417
    The procedure performs a post-order traversal of a nested join tree
5250
5418
    and materializes the row types of NATURAL/USING joins in a
5251
 
    bottom-up manner until it reaches the TableList elements that
 
5419
    bottom-up manner until it reaches the TABLE_LIST elements that
5252
5420
    represent the top-most NATURAL/USING joins. The procedure should be
5253
5421
    applied to each element of SELECT_LEX::top_join_list (i.e. to each
5254
5422
    top-level element of the FROM clause).
5264
5432
*/
5265
5433
 
5266
5434
static bool
5267
 
store_top_level_join_columns(THD *thd, TableList *table_ref,
5268
 
                             TableList *left_neighbor,
5269
 
                             TableList *right_neighbor)
 
5435
store_top_level_join_columns(THD *thd, TABLE_LIST *table_ref,
 
5436
                             TABLE_LIST *left_neighbor,
 
5437
                             TABLE_LIST *right_neighbor)
5270
5438
{
5271
5439
  bool result= true;
5272
5440
 
5273
5441
  /* Call the procedure recursively for each nested table reference. */
5274
5442
  if (table_ref->nested_join)
5275
5443
  {
5276
 
    List_iterator_fast<TableList> nested_it(table_ref->nested_join->join_list);
5277
 
    TableList *same_level_left_neighbor= nested_it++;
5278
 
    TableList *same_level_right_neighbor= NULL;
 
5444
    List_iterator_fast<TABLE_LIST> nested_it(table_ref->nested_join->join_list);
 
5445
    TABLE_LIST *same_level_left_neighbor= nested_it++;
 
5446
    TABLE_LIST *same_level_right_neighbor= NULL;
5279
5447
    /* Left/right-most neighbors, possibly at higher levels in the join tree. */
5280
 
    TableList *real_left_neighbor, *real_right_neighbor;
 
5448
    TABLE_LIST *real_left_neighbor, *real_right_neighbor;
5281
5449
 
5282
5450
    while (same_level_left_neighbor)
5283
5451
    {
5284
 
      TableList *cur_table_ref= same_level_left_neighbor;
 
5452
      TABLE_LIST *cur_table_ref= same_level_left_neighbor;
5285
5453
      same_level_left_neighbor= nested_it++;
5286
5454
      /*
5287
5455
        The order of RIGHT JOIN operands is reversed in 'join list' to
5299
5467
      {
5300
5468
        /* This can happen only for JOIN ... ON. */
5301
5469
        assert(table_ref->nested_join->join_list.elements == 2);
5302
 
        std::swap(same_level_left_neighbor, cur_table_ref);
 
5470
        swap_variables(TABLE_LIST*, same_level_left_neighbor, cur_table_ref);
5303
5471
      }
5304
5472
 
5305
5473
      /*
5327
5495
  {
5328
5496
    assert(table_ref->nested_join &&
5329
5497
                table_ref->nested_join->join_list.elements == 2);
5330
 
    List_iterator_fast<TableList> operand_it(table_ref->nested_join->join_list);
 
5498
    List_iterator_fast<TABLE_LIST> operand_it(table_ref->nested_join->join_list);
5331
5499
    /*
5332
5500
      Notice that the order of join operands depends on whether table_ref
5333
5501
      represents a LEFT or a RIGHT join. In a RIGHT join, the operands are
5334
5502
      in inverted order.
5335
5503
     */
5336
 
    TableList *table_ref_2= operand_it++; /* Second NATURAL join operand.*/
5337
 
    TableList *table_ref_1= operand_it++; /* First NATURAL join operand. */
 
5504
    TABLE_LIST *table_ref_2= operand_it++; /* Second NATURAL join operand.*/
 
5505
    TABLE_LIST *table_ref_1= operand_it++; /* First NATURAL join operand. */
5338
5506
    List<String> *using_fields= table_ref->join_using_fields;
5339
 
    uint32_t found_using_fields;
 
5507
    uint found_using_fields;
5340
5508
 
5341
5509
    /*
5342
5510
      The two join operands were interchanged in the parser, change the order
5343
5511
      back for 'mark_common_columns'.
5344
5512
    */
5345
5513
    if (table_ref_2->outer_join & JOIN_TYPE_RIGHT)
5346
 
      std::swap(table_ref_1, table_ref_2);
 
5514
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
5347
5515
    if (mark_common_columns(thd, table_ref_1, table_ref_2,
5348
5516
                            using_fields, &found_using_fields))
5349
5517
      goto err;
5354
5522
      same as of an equivalent LEFT JOIN.
5355
5523
    */
5356
5524
    if (table_ref_1->outer_join & JOIN_TYPE_RIGHT)
5357
 
      std::swap(table_ref_1, table_ref_2);
 
5525
      swap_variables(TABLE_LIST*, table_ref_1, table_ref_2);
5358
5526
    if (store_natural_using_join_columns(thd, table_ref, table_ref_1,
5359
5527
                                         table_ref_2, using_fields,
5360
5528
                                         found_using_fields))
5376
5544
    /* Change this table reference to become a leaf for name resolution. */
5377
5545
    if (left_neighbor)
5378
5546
    {
5379
 
      TableList *last_leaf_on_the_left;
 
5547
      TABLE_LIST *last_leaf_on_the_left;
5380
5548
      last_leaf_on_the_left= left_neighbor->last_leaf_for_name_resolution();
5381
5549
      last_leaf_on_the_left->next_name_resolution_table= table_ref;
5382
5550
    }
5383
5551
    if (right_neighbor)
5384
5552
    {
5385
 
      TableList *first_leaf_on_the_right;
 
5553
      TABLE_LIST *first_leaf_on_the_right;
5386
5554
      first_leaf_on_the_right= right_neighbor->first_leaf_for_name_resolution();
5387
5555
      table_ref->next_name_resolution_table= first_leaf_on_the_right;
5388
5556
    }
5421
5589
    false  OK
5422
5590
*/
5423
5591
static bool setup_natural_join_row_types(THD *thd,
5424
 
                                         List<TableList> *from_clause,
 
5592
                                         List<TABLE_LIST> *from_clause,
5425
5593
                                         Name_resolution_context *context)
5426
5594
{
5427
5595
  thd->where= "from clause";
5428
5596
  if (from_clause->elements == 0)
5429
5597
    return false; /* We come here in the case of UNIONs. */
5430
5598
 
5431
 
  List_iterator_fast<TableList> table_ref_it(*from_clause);
5432
 
  TableList *table_ref; /* Current table reference. */
 
5599
  List_iterator_fast<TABLE_LIST> table_ref_it(*from_clause);
 
5600
  TABLE_LIST *table_ref; /* Current table reference. */
5433
5601
  /* Table reference to the left of the current. */
5434
 
  TableList *left_neighbor;
 
5602
  TABLE_LIST *left_neighbor;
5435
5603
  /* Table reference to the right of the current. */
5436
 
  TableList *right_neighbor= NULL;
 
5604
  TABLE_LIST *right_neighbor= NULL;
5437
5605
 
5438
5606
  /* Note that tables in the list are in reversed order */
5439
5607
  for (left_neighbor= table_ref_it++; left_neighbor ; )
5440
5608
  {
5441
5609
    table_ref= left_neighbor;
5442
5610
    left_neighbor= table_ref_it++;
5443
 
    if (store_top_level_join_columns(thd, table_ref,
5444
 
                                     left_neighbor, right_neighbor))
5445
 
      return true;
5446
 
    if (left_neighbor)
 
5611
    /* For stored procedures do not redo work if already done. */
 
5612
    if (context->select_lex->first_execution)
5447
5613
    {
5448
 
      TableList *first_leaf_on_the_right;
5449
 
      first_leaf_on_the_right= table_ref->first_leaf_for_name_resolution();
5450
 
      left_neighbor->next_name_resolution_table= first_leaf_on_the_right;
 
5614
      if (store_top_level_join_columns(thd, table_ref,
 
5615
                                       left_neighbor, right_neighbor))
 
5616
        return true;
 
5617
      if (left_neighbor)
 
5618
      {
 
5619
        TABLE_LIST *first_leaf_on_the_right;
 
5620
        first_leaf_on_the_right= table_ref->first_leaf_for_name_resolution();
 
5621
        left_neighbor->next_name_resolution_table= first_leaf_on_the_right;
 
5622
      }
5451
5623
    }
5452
5624
    right_neighbor= table_ref;
5453
5625
  }
5471
5643
****************************************************************************/
5472
5644
 
5473
5645
int setup_wild(THD *thd,
5474
 
               TableList *tables __attribute__((unused)),
 
5646
               TABLE_LIST *tables __attribute__((__unused__)),
5475
5647
               List<Item> &fields,
5476
5648
               List<Item> *sum_func_list,
5477
 
               uint32_t wild_num)
 
5649
               uint wild_num)
5478
5650
{
5479
5651
  if (!wild_num)
5480
5652
    return(0);
5490
5662
        ((Item_field*) item)->field_name[0] == '*' &&
5491
5663
        !((Item_field*) item)->field)
5492
5664
    {
5493
 
      uint32_t elem= fields.elements;
 
5665
      uint elem= fields.elements;
5494
5666
      bool any_privileges= ((Item_field *) item)->any_privileges;
5495
5667
      Item_subselect *subsel= thd->lex->current_select->master_unit()->item;
5496
5668
      if (subsel &&
5562
5734
    ref_pointer_array
5563
5735
  */
5564
5736
  if (ref_pointer_array)
5565
 
    memset(ref_pointer_array, 0, sizeof(Item *) * fields.elements);
 
5737
    bzero(ref_pointer_array, sizeof(Item *) * fields.elements);
5566
5738
 
5567
5739
  Item **ref= ref_pointer_array;
5568
5740
  thd->lex->current_select->cur_pos_in_select_list= 0;
5603
5775
  RETURN pointer on pointer to next_leaf of last element
5604
5776
*/
5605
5777
 
5606
 
TableList **make_leaves_list(TableList **list, TableList *tables)
 
5778
TABLE_LIST **make_leaves_list(TABLE_LIST **list, TABLE_LIST *tables)
5607
5779
{
5608
 
  for (TableList *table= tables; table; table= table->next_local)
 
5780
  for (TABLE_LIST *table= tables; table; table= table->next_local)
5609
5781
  {
5610
5782
    {
5611
5783
      *list= table;
5644
5816
*/
5645
5817
 
5646
5818
bool setup_tables(THD *thd, Name_resolution_context *context,
5647
 
                  List<TableList> *from_clause, TableList *tables,
5648
 
                  TableList **leaves, bool select_insert)
 
5819
                  List<TABLE_LIST> *from_clause, TABLE_LIST *tables,
 
5820
                  TABLE_LIST **leaves, bool select_insert)
5649
5821
{
5650
 
  uint32_t tablenr= 0;
 
5822
  uint tablenr= 0;
5651
5823
 
5652
5824
  assert ((select_insert && !tables->next_name_resolution_table) || !tables || 
5653
5825
               (context->table_list && context->first_name_resolution_table));
5655
5827
    this is used for INSERT ... SELECT.
5656
5828
    For select we setup tables except first (and its underlying tables)
5657
5829
  */
5658
 
  TableList *first_select_table= (select_insert ?
 
5830
  TABLE_LIST *first_select_table= (select_insert ?
5659
5831
                                   tables->next_local:
5660
5832
                                   0);
5661
5833
  if (!(*leaves))
5662
5834
    make_leaves_list(leaves, tables);
5663
5835
 
5664
 
  TableList *table_list;
 
5836
  TABLE_LIST *table_list;
5665
5837
  for (table_list= *leaves;
5666
5838
       table_list;
5667
5839
       table_list= table_list->next_leaf, tablenr++)
5668
5840
  {
5669
 
    Table *table= table_list->table;
 
5841
    TABLE *table= table_list->table;
5670
5842
    table->pos_in_table_list= table_list;
5671
5843
    if (first_select_table &&
5672
5844
        table_list->top_table() == first_select_table)
5718
5890
*/
5719
5891
bool setup_tables_and_check_access(THD *thd, 
5720
5892
                                   Name_resolution_context *context,
5721
 
                                   List<TableList> *from_clause,
5722
 
                                   TableList *tables,
5723
 
                                   TableList **leaves,
 
5893
                                   List<TABLE_LIST> *from_clause,
 
5894
                                   TABLE_LIST *tables,
 
5895
                                   TABLE_LIST **leaves,
5724
5896
                                   bool select_insert)
5725
5897
{
5726
 
  TableList *leaves_tmp= NULL;
 
5898
  TABLE_LIST *leaves_tmp= NULL;
5727
5899
  bool first_table= true;
5728
5900
 
5729
5901
  if (setup_tables(thd, context, from_clause, tables,
5735
5907
 
5736
5908
  for (; leaves_tmp; leaves_tmp= leaves_tmp->next_leaf)
5737
5909
  {
 
5910
    if (leaves_tmp->belong_to_view)
 
5911
    {
 
5912
      return true;
 
5913
    }
5738
5914
    first_table= 0;
5739
5915
  }
5740
5916
  return false;
5755
5931
     1  error
5756
5932
*/
5757
5933
 
5758
 
bool get_key_map_from_key_list(key_map *map, Table *table,
 
5934
bool get_key_map_from_key_list(key_map *map, TABLE *table,
5759
5935
                               List<String> *index_list)
5760
5936
{
5761
5937
  List_iterator_fast<String> it(*index_list);
5762
5938
  String *name;
5763
 
  uint32_t pos;
 
5939
  uint pos;
5764
5940
 
5765
5941
  map->clear_all();
5766
5942
  while ((name=it++))
5802
5978
bool
5803
5979
insert_fields(THD *thd, Name_resolution_context *context, const char *db_name,
5804
5980
              const char *table_name, List_iterator<Item> *it,
5805
 
              bool any_privileges __attribute__((unused)))
 
5981
              bool any_privileges __attribute__((__unused__)))
5806
5982
{
5807
5983
  Field_iterator_table_ref field_iterator;
5808
5984
  bool found;
5827
6003
    else treat natural joins as leaves and do not iterate over their underlying
5828
6004
    tables.
5829
6005
  */
5830
 
  for (TableList *tables= (table_name ? context->table_list :
 
6006
  for (TABLE_LIST *tables= (table_name ? context->table_list :
5831
6007
                            context->first_name_resolution_table);
5832
6008
       tables;
5833
6009
       tables= (table_name ? tables->next_local :
5835
6011
       )
5836
6012
  {
5837
6013
    Field *field;
5838
 
    Table *table= tables->table;
 
6014
    TABLE *table= tables->table;
5839
6015
 
5840
6016
    assert(tables->is_leaf_for_name_resolution());
5841
6017
 
5884
6060
        }
5885
6061
        if (tables->is_natural_join)
5886
6062
        {
5887
 
          Table *field_table;
 
6063
          TABLE *field_table;
5888
6064
          /*
5889
6065
            In this case we are sure that the column ref will not be created
5890
6066
            because it was already created and stored with the natural join.
5951
6127
    false if all is OK
5952
6128
*/
5953
6129
 
5954
 
int setup_conds(THD *thd, TableList *tables __attribute__((unused)),
5955
 
                TableList *leaves,
 
6130
int setup_conds(THD *thd, TABLE_LIST *tables __attribute__((__unused__)),
 
6131
                TABLE_LIST *leaves,
5956
6132
                COND **conds)
5957
6133
{
5958
6134
  SELECT_LEX *select_lex= thd->lex->current_select;
5959
 
  TableList *table= NULL;       // For HP compilers
 
6135
  TABLE_LIST *table= NULL;      // For HP compilers
5960
6136
  void *save_thd_marker= thd->thd_marker;
5961
6137
  /*
5962
6138
    it_is_update set to true when tables of primary SELECT_LEX (SELECT_LEX
5990
6166
  */
5991
6167
  for (table= leaves; table; table= table->next_leaf)
5992
6168
  {
5993
 
    TableList *embedded; /* The table at the current level of nesting. */
5994
 
    TableList *embedding= table; /* The parent nested table reference. */
 
6169
    TABLE_LIST *embedded; /* The table at the current level of nesting. */
 
6170
    TABLE_LIST *embedding= table; /* The parent nested table reference. */
5995
6171
    do
5996
6172
    {
5997
6173
      embedded= embedding;
6054
6230
  List_iterator_fast<Item> f(fields),v(values);
6055
6231
  Item *value, *fld;
6056
6232
  Item_field *field;
6057
 
  Table *table= 0;
 
6233
  TABLE *table= 0;
6058
6234
 
6059
6235
  /*
6060
6236
    Reset the table->auto_increment_field_not_null as it is valid for
6124
6300
 
6125
6301
bool
6126
6302
fill_record(THD *thd, Field **ptr, List<Item> &values,
6127
 
            bool ignore_errors __attribute__((unused)))
 
6303
            bool ignore_errors __attribute__((__unused__)))
6128
6304
{
6129
6305
  List_iterator_fast<Item> v(values);
6130
6306
  Item *value;
6131
 
  Table *table= 0;
 
6307
  TABLE *table= 0;
6132
6308
 
6133
6309
  Field *field;
6134
6310
  /*
6162
6338
}
6163
6339
 
6164
6340
 
6165
 
bool mysql_rm_tmp_tables(void)
 
6341
my_bool mysql_rm_tmp_tables(void)
6166
6342
{
6167
 
  uint32_t i, idx;
 
6343
  uint i, idx;
6168
6344
  char  filePath[FN_REFLEN], *tmpdir, filePathCopy[FN_REFLEN];
6169
6345
  MY_DIR *dirp;
6170
6346
  FILEINFO *file;
6194
6370
                                   (file->name[1] == '.' &&  !file->name[2])))
6195
6371
        continue;
6196
6372
 
6197
 
      if (!memcmp(file->name, tmp_file_prefix, tmp_file_prefix_length))
 
6373
      if (!bcmp((uchar*) file->name, (uchar*) tmp_file_prefix,
 
6374
                tmp_file_prefix_length))
6198
6375
      {
6199
6376
        char *ext= fn_ext(file->name);
6200
 
        uint32_t ext_len= strlen(ext);
6201
 
        uint32_t filePath_len= snprintf(filePath, sizeof(filePath),
 
6377
        uint ext_len= strlen(ext);
 
6378
        uint filePath_len= snprintf(filePath, sizeof(filePath),
6202
6379
                                    "%s%c%s", tmpdir, FN_LIBCHAR,
6203
6380
                                    file->name);
6204
 
        if (!memcmp(reg_ext, ext, ext_len))
 
6381
        if (!bcmp((uchar*) reg_ext, (uchar*) ext, ext_len))
6205
6382
        {
6206
6383
          handler *handler_file= 0;
6207
6384
          /* We should cut file extention before deleting of table */
6222
6399
          So we hide error messages which happnes during deleting of these
6223
6400
          files(MYF(0)).
6224
6401
        */
6225
 
        my_delete(filePath, MYF(0)); 
 
6402
        VOID(my_delete(filePath, MYF(0))); 
6226
6403
      }
6227
6404
    }
6228
6405
    my_dirend(dirp);
6253
6430
 
6254
6431
void remove_db_from_cache(const char *db)
6255
6432
{
6256
 
  for (uint32_t idx=0 ; idx < open_cache.records ; idx++)
 
6433
  for (uint idx=0 ; idx < open_cache.records ; idx++)
6257
6434
  {
6258
 
    Table *table=(Table*) hash_element(&open_cache,idx);
 
6435
    TABLE *table=(TABLE*) hash_element(&open_cache,idx);
6259
6436
    if (!strcmp(table->s->db.str, db))
6260
6437
    {
6261
6438
      table->s->version= 0L;                    /* Free when thread is ready */
6264
6441
    }
6265
6442
  }
6266
6443
  while (unused_tables && !unused_tables->s->version)
6267
 
    hash_delete(&open_cache,(unsigned char*) unused_tables);
 
6444
    VOID(hash_delete(&open_cache,(uchar*) unused_tables));
6268
6445
}
6269
6446
 
6270
6447
 
6280
6457
{
6281
6458
  (void) pthread_mutex_lock(&LOCK_open);
6282
6459
  while (unused_tables)
6283
 
    hash_delete(&open_cache,(unsigned char*) unused_tables);
 
6460
    hash_delete(&open_cache,(uchar*) unused_tables);
6284
6461
  (void) pthread_mutex_unlock(&LOCK_open);
6285
6462
}
6286
6463
 
6301
6478
*/
6302
6479
 
6303
6480
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
6304
 
                             uint32_t flags)
 
6481
                             uint flags)
6305
6482
{
6306
6483
  char key[MAX_DBKEY_LENGTH];
6307
 
  uint32_t key_length;
6308
 
  Table *table;
 
6484
  uint key_length;
 
6485
  TABLE *table;
6309
6486
  TABLE_SHARE *share;
6310
6487
  bool result= 0, signalled= 0;
6311
6488
 
6312
 
  key_length=(uint) (my_stpcpy(my_stpcpy(key,db)+1,table_name)-key)+1;
 
6489
  key_length=(uint) (strmov(strmov(key,db)+1,table_name)-key)+1;
6313
6490
  for (;;)
6314
6491
  {
6315
6492
    HASH_SEARCH_STATE state;
6316
6493
    result= signalled= 0;
6317
6494
 
6318
 
    for (table= (Table*) hash_first(&open_cache, (unsigned char*) key, key_length,
 
6495
    for (table= (TABLE*) hash_first(&open_cache, (uchar*) key, key_length,
6319
6496
                                    &state);
6320
6497
         table;
6321
 
         table= (Table*) hash_next(&open_cache, (unsigned char*) key, key_length,
 
6498
         table= (TABLE*) hash_next(&open_cache, (uchar*) key, key_length,
6322
6499
                                   &state))
6323
6500
    {
6324
6501
      THD *in_use;
6349
6526
          open_tables list. Aborting the MERGE lock after a child was
6350
6527
          closed and before the parent is closed would be fatal.
6351
6528
        */
6352
 
        for (Table *thd_table= in_use->open_tables;
 
6529
        for (TABLE *thd_table= in_use->open_tables;
6353
6530
             thd_table ;
6354
6531
             thd_table= thd_table->next)
6355
6532
        {
6362
6539
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
6363
6540
    }
6364
6541
    while (unused_tables && !unused_tables->s->version)
6365
 
      hash_delete(&open_cache,(unsigned char*) unused_tables);
 
6542
      VOID(hash_delete(&open_cache,(uchar*) unused_tables));
6366
6543
 
6367
6544
    /* Remove table from table definition cache if it's not in use */
6368
 
    if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(unsigned char*) key,
 
6545
    if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key,
6369
6546
                                           key_length)))
6370
6547
    {
6371
6548
      share->version= 0;                          // Mark for delete
6372
6549
      if (share->ref_count == 0)
6373
6550
      {
6374
6551
        pthread_mutex_lock(&share->mutex);
6375
 
        hash_delete(&table_def_cache, (unsigned char*) share);
 
6552
        VOID(hash_delete(&table_def_cache, (uchar*) share));
6376
6553
      }
6377
6554
    }
6378
6555
 
6395
6572
            It can happen that another thread has opened the
6396
6573
            table but has not yet locked any table at all. Since
6397
6574
            it can be locked waiting for a table that our thread
6398
 
            has done LOCK Table x WRITE on previously, we need to
 
6575
            has done LOCK TABLE x WRITE on previously, we need to
6399
6576
            ensure that the thread actually hears our signal
6400
6577
            before we go to sleep. Thus we wait for a short time
6401
6578
            and then we retry another loop in the
6418
6595
{
6419
6596
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
6420
6597
}
 
6598
 
 
6599
 
 
6600
/*
 
6601
  Open and lock system tables for read.
 
6602
 
 
6603
  SYNOPSIS
 
6604
    open_system_tables_for_read()
 
6605
      thd         Thread context.
 
6606
      table_list  List of tables to open.
 
6607
      backup      Pointer to Open_tables_state instance where
 
6608
                  information about currently open tables will be
 
6609
                  saved, and from which will be restored when we will
 
6610
                  end work with system tables.
 
6611
 
 
6612
  NOTES
 
6613
    Thanks to restrictions which we put on opening and locking of
 
6614
    system tables for writing, we can open and lock them for reading
 
6615
    even when we already have some other tables open and locked.  One
 
6616
    must call close_system_tables() to close systems tables opened
 
6617
    with this call.
 
6618
 
 
6619
  RETURN
 
6620
    false   Success
 
6621
    true    Error
 
6622
*/
 
6623
 
 
6624
bool
 
6625
open_system_tables_for_read(THD *thd, TABLE_LIST *table_list,
 
6626
                            Open_tables_state *backup)
 
6627
{
 
6628
  thd->reset_n_backup_open_tables_state(backup);
 
6629
 
 
6630
  uint count= 0;
 
6631
  bool not_used;
 
6632
  for (TABLE_LIST *tables= table_list; tables; tables= tables->next_global)
 
6633
  {
 
6634
    TABLE *table= open_table(thd, tables, thd->mem_root, &not_used,
 
6635
                             MYSQL_LOCK_IGNORE_FLUSH);
 
6636
    if (!table)
 
6637
      goto error;
 
6638
 
 
6639
    assert(table->s->table_category == TABLE_CATEGORY_SYSTEM);
 
6640
 
 
6641
    table->use_all_columns();
 
6642
    table->reginfo.lock_type= tables->lock_type;
 
6643
    tables->table= table;
 
6644
    count++;
 
6645
  }
 
6646
 
 
6647
  {
 
6648
    TABLE **list= (TABLE**) thd->alloc(sizeof(TABLE*) * count);
 
6649
    TABLE **ptr= list;
 
6650
    for (TABLE_LIST *tables= table_list; tables; tables= tables->next_global)
 
6651
      *(ptr++)= tables->table;
 
6652
 
 
6653
    thd->lock= mysql_lock_tables(thd, list, count,
 
6654
                                 MYSQL_LOCK_IGNORE_FLUSH, &not_used);
 
6655
  }
 
6656
  if (thd->lock)
 
6657
    return(false);
 
6658
 
 
6659
error:
 
6660
  close_system_tables(thd, backup);
 
6661
 
 
6662
  return(true);
 
6663
}
 
6664
 
 
6665
 
 
6666
/*
 
6667
  Close system tables, opened with open_system_tables_for_read().
 
6668
 
 
6669
  SYNOPSIS
 
6670
    close_system_tables()
 
6671
      thd     Thread context
 
6672
      backup  Pointer to Open_tables_state instance which holds
 
6673
              information about tables which were open before we
 
6674
              decided to access system tables.
 
6675
*/
 
6676
 
 
6677
void
 
6678
close_system_tables(THD *thd, Open_tables_state *backup)
 
6679
{
 
6680
  close_thread_tables(thd);
 
6681
  thd->restore_backup_open_tables_state(backup);
 
6682
}
 
6683
 
 
6684
 
 
6685
/*
 
6686
  Open and lock one system table for update.
 
6687
 
 
6688
  SYNOPSIS
 
6689
    open_system_table_for_update()
 
6690
      thd        Thread context.
 
6691
      one_table  Table to open.
 
6692
 
 
6693
  NOTES
 
6694
    Table opened with this call should closed using close_thread_tables().
 
6695
 
 
6696
  RETURN
 
6697
    0   Error
 
6698
    #   Pointer to TABLE object of system table
 
6699
*/
 
6700
 
 
6701
TABLE *
 
6702
open_system_table_for_update(THD *thd, TABLE_LIST *one_table)
 
6703
{
 
6704
  TABLE *table= open_ltable(thd, one_table, one_table->lock_type, 0);
 
6705
  if (table)
 
6706
  {
 
6707
    assert(table->s->table_category == TABLE_CATEGORY_SYSTEM);
 
6708
    table->use_all_columns();
 
6709
  }
 
6710
 
 
6711
  return(table);
 
6712
}
 
6713
 
6421
6714
/**
6422
6715
  @} (end of group Data_Dictionary)
6423
6716
*/