← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_base.cc

  • Committer: Jay Pipes
  • Date: 2008-09-11 16:03:22 UTC
  • mto: (383.5.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 386.
  • Revision ID: jay@mysql.com-20080911160322-vrl0k1djo6q6ytv1
Removed SQL_MODE variances from comment_table.test and ensured correct error thrown when a comment that is too long was input.  After moving to proto buffer definition for table, the 2048 length will go away.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_base.cc
1
1
/* Copyright (C) 2000-2006 MySQL AB
2
2
 
3
 
  This program is free software; you can redistribute it and/or modify
4
 
  it under the terms of the GNU General Public License as published by
5
 
  the Free Software Foundation; version 2 of the License.
6
 
 
7
 
  This program is distributed in the hope that it will be useful,
8
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of
9
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10
 
  GNU General Public License for more details.
11
 
 
12
 
  You should have received a copy of the GNU General Public License
13
 
  along with this program; if not, write to the Free Software
14
 
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
 
17
17
/* Basic functions needed by many modules */
18
 
#include "config.h"
19
 
#include <assert.h>
20
 
 
21
 
#include <signal.h>
22
 
 
23
 
#if TIME_WITH_SYS_TIME
24
 
# include <sys/time.h>
25
 
# include <time.h>
26
 
#else
27
 
# if HAVE_SYS_TIME_H
28
 
#  include <sys/time.h>
29
 
# else
30
 
#  include <time.h>
31
 
# endif
32
 
#endif
33
 
#include "drizzled/internal/my_pthread.h"
34
 
#include "drizzled/internal/thread_var.h"
35
 
 
 
18
#include <drizzled/server_includes.h>
36
19
#include <drizzled/sql_select.h>
37
 
#include <drizzled/error.h>
38
 
#include <drizzled/gettext.h>
39
 
#include <drizzled/nested_join.h>
40
 
#include <drizzled/sql_base.h>
41
 
#include <drizzled/show.h>
42
 
#include <drizzled/item/cmpfunc.h>
43
 
#include <drizzled/replication_services.h>
44
 
#include <drizzled/check_stack_overrun.h>
45
 
#include <drizzled/lock.h>
46
 
#include <drizzled/plugin/listen.h>
47
 
#include "drizzled/cached_directory.h"
48
 
#include <drizzled/field/timestamp.h>
49
 
#include <drizzled/field/null.h>
50
 
#include "drizzled/sql_table.h"
51
 
#include "drizzled/global_charset_info.h"
52
 
#include "drizzled/pthread_globals.h"
53
 
#include "drizzled/internal/iocache.h"
54
 
#include "drizzled/drizzled.h"
55
 
#include "drizzled/plugin/authorization.h"
56
 
#include "drizzled/table/temporary.h"
57
 
#include "drizzled/table/placeholder.h"
58
 
#include "drizzled/table/unused.h"
59
 
 
60
 
using namespace std;
61
 
 
62
 
namespace drizzled
 
20
#include <mysys/my_dir.h>
 
21
#include <drizzled/drizzled_error_messages.h>
 
22
#include <libdrizzle/gettext.h>
 
23
 
 
24
#define FLAGSTR(S,F) ((S) & (F) ? #F " " : "")
 
25
 
 
26
/**
 
27
  @defgroup Data_Dictionary Data Dictionary
 
28
  @{
 
29
*/
 
30
Table *unused_tables;                           /* Used by mysql_test */
 
31
HASH open_cache;                                /* Used by mysql_test */
 
32
static HASH table_def_cache;
 
33
static TABLE_SHARE *oldest_unused_share, end_of_unused_share;
 
34
static pthread_mutex_t LOCK_table_share;
 
35
static bool table_def_inited= 0;
 
36
 
 
37
static int open_unireg_entry(THD *thd, Table *entry, TableList *table_list,
 
38
                             const char *alias,
 
39
                             char *cache_key, uint 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,
 
42
                                 bool send_refresh);
 
43
 
 
44
 
 
45
extern "C" uchar *table_cache_key(const uchar *record, size_t *length,
 
46
                                  bool not_used __attribute__((unused)))
63
47
{
 
48
  Table *entry=(Table*) record;
 
49
  *length= entry->s->table_cache_key.length;
 
50
  return (uchar*) entry->s->table_cache_key.str;
 
51
}
64
52
 
65
 
extern bool volatile shutdown_in_progress;
66
53
 
67
54
bool table_cache_init(void)
68
55
{
69
 
  return false;
70
 
}
71
 
 
72
 
uint32_t cached_open_tables(void)
73
 
{
74
 
  return table::getCache().size();
 
56
  return hash_init(&open_cache, &my_charset_bin, table_cache_size+16,
 
57
                   0, 0, table_cache_key,
 
58
                   (hash_free_key) free_cache_entry, 0);
75
59
}
76
60
 
77
61
void table_cache_free(void)
78
62
{
79
 
  refresh_version++;                            // Force close of open tables
80
 
 
81
 
  table::getUnused().clear();
82
 
  table::getCache().clear();
83
 
}
84
 
 
85
 
/*
86
 
  Close cursor handle, but leave the table in the table cache
87
 
 
88
 
  SYNOPSIS
89
 
  close_handle_and_leave_table_as_lock()
90
 
  table         Table Cursor
91
 
 
92
 
  NOTES
93
 
  By leaving the table in the table cache, it disallows any other thread
94
 
  to open the table
95
 
 
96
 
  session->getKilled() will be set if we run out of memory
97
 
 
98
 
  If closing a MERGE child, the calling function has to take care for
99
 
  closing the parent too, if necessary.
 
63
  if (table_def_inited)
 
64
  {
 
65
    close_cached_tables(NULL, NULL, false, false, false);
 
66
    if (!open_cache.records)                    // Safety first
 
67
      hash_free(&open_cache);
 
68
  }
 
69
  return;
 
70
}
 
71
 
 
72
uint cached_open_tables(void)
 
73
{
 
74
  return open_cache.records;
 
75
}
 
76
 
 
77
/*
 
78
  Create a table cache key
 
79
 
 
80
  SYNOPSIS
 
81
    create_table_def_key()
 
82
    thd                 Thread handler
 
83
    key                 Create key here (must be of size MAX_DBKEY_LENGTH)
 
84
    table_list          Table definition
 
85
    tmp_table           Set if table is a tmp table
 
86
 
 
87
 IMPLEMENTATION
 
88
    The table cache_key is created from:
 
89
    db_name + \0
 
90
    table_name + \0
 
91
 
 
92
    if the table is a tmp table, we add the following to make each tmp table
 
93
    unique on the slave:
 
94
 
 
95
    4 bytes for master thread id
 
96
    4 bytes pseudo thread id
 
97
 
 
98
  RETURN
 
99
    Length of key
 
100
*/
 
101
 
 
102
uint create_table_def_key(THD *thd, char *key, TableList *table_list,
 
103
                          bool tmp_table)
 
104
{
 
105
  uint key_length= (uint) (stpcpy(stpcpy(key, table_list->db)+1,
 
106
                                  table_list->table_name)-key)+1;
 
107
  if (tmp_table)
 
108
  {
 
109
    int4store(key + key_length, thd->server_id);
 
110
    int4store(key + key_length + 4, thd->variables.pseudo_thread_id);
 
111
    key_length+= TMP_TABLE_KEY_EXTRA;
 
112
  }
 
113
  return key_length;
 
114
}
 
115
 
 
116
 
 
117
 
 
118
/*****************************************************************************
 
119
  Functions to handle table definition cach (TABLE_SHARE)
 
120
*****************************************************************************/
 
121
 
 
122
extern "C" uchar *table_def_key(const uchar *record, size_t *length,
 
123
                                bool not_used __attribute__((unused)))
 
124
{
 
125
  TABLE_SHARE *entry=(TABLE_SHARE*) record;
 
126
  *length= entry->table_cache_key.length;
 
127
  return (uchar*) entry->table_cache_key.str;
 
128
}
 
129
 
 
130
 
 
131
static void table_def_free_entry(TABLE_SHARE *share)
 
132
{
 
133
  if (share->prev)
 
134
  {
 
135
    /* remove from old_unused_share list */
 
136
    pthread_mutex_lock(&LOCK_table_share);
 
137
    *share->prev= share->next;
 
138
    share->next->prev= share->prev;
 
139
    pthread_mutex_unlock(&LOCK_table_share);
 
140
  }
 
141
  free_table_share(share);
 
142
  return;
 
143
}
 
144
 
 
145
 
 
146
bool table_def_init(void)
 
147
{
 
148
  table_def_inited= 1;
 
149
  pthread_mutex_init(&LOCK_table_share, MY_MUTEX_INIT_FAST);
 
150
  oldest_unused_share= &end_of_unused_share;
 
151
  end_of_unused_share.prev= &oldest_unused_share;
 
152
 
 
153
  return hash_init(&table_def_cache, &my_charset_bin, table_def_size,
 
154
                   0, 0, table_def_key,
 
155
                   (hash_free_key) table_def_free_entry, 0);
 
156
}
 
157
 
 
158
 
 
159
void table_def_free(void)
 
160
{
 
161
  if (table_def_inited)
 
162
  {
 
163
    table_def_inited= 0;
 
164
    pthread_mutex_destroy(&LOCK_table_share);
 
165
    hash_free(&table_def_cache);
 
166
  }
 
167
  return;
 
168
}
 
169
 
 
170
 
 
171
uint cached_table_definitions(void)
 
172
{
 
173
  return table_def_cache.records;
 
174
}
 
175
 
 
176
 
 
177
/*
 
178
  Get TABLE_SHARE for a table.
 
179
 
 
180
  get_table_share()
 
181
  thd                   Thread handle
 
182
  table_list            Table that should be opened
 
183
  key                   Table cache key
 
184
  key_length            Length of key
 
185
  db_flags              Flags to open_table_def():
 
186
                        OPEN_VIEW
 
187
  error                 out: Error code from open_table_def()
 
188
 
 
189
  IMPLEMENTATION
 
190
    Get a table definition from the table definition cache.
 
191
    If it doesn't exist, create a new from the table definition file.
 
192
 
 
193
  NOTES
 
194
    We must have wrlock on LOCK_open when we come here
 
195
    (To be changed later)
 
196
 
 
197
  RETURN
 
198
   0  Error
 
199
   #  Share for table
 
200
*/
 
201
 
 
202
TABLE_SHARE *get_table_share(THD *thd, TableList *table_list, char *key,
 
203
                             uint key_length, uint db_flags, int *error)
 
204
{
 
205
  TABLE_SHARE *share;
 
206
 
 
207
  *error= 0;
 
208
 
 
209
  /* Read table definition from cache */
 
210
  if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key,
 
211
                                         key_length)))
 
212
    goto found;
 
213
 
 
214
  if (!(share= alloc_table_share(table_list, key, key_length)))
 
215
  {
 
216
    return(0);
 
217
  }
 
218
 
 
219
  /*
 
220
    Lock mutex to be able to read table definition from file without
 
221
    conflicts
 
222
  */
 
223
  (void) pthread_mutex_lock(&share->mutex);
 
224
 
 
225
  /*
 
226
    We assign a new table id under the protection of the LOCK_open and
 
227
    the share's own mutex.  We do this insted of creating a new mutex
 
228
    and using it for the sole purpose of serializing accesses to a
 
229
    static variable, we assign the table id here.  We assign it to the
 
230
    share before inserting it into the table_def_cache to be really
 
231
    sure that it cannot be read from the cache without having a table
 
232
    id assigned.
 
233
 
 
234
    CAVEAT. This means that the table cannot be used for
 
235
    binlogging/replication purposes, unless get_table_share() has been
 
236
    called directly or indirectly.
 
237
   */
 
238
  assign_new_table_id(share);
 
239
 
 
240
  if (my_hash_insert(&table_def_cache, (uchar*) share))
 
241
  {
 
242
    free_table_share(share);
 
243
    return(0);                          // return error
 
244
  }
 
245
  if (open_table_def(thd, share, db_flags))
 
246
  {
 
247
    *error= share->error;
 
248
    (void) hash_delete(&table_def_cache, (uchar*) share);
 
249
    return(0);
 
250
  }
 
251
  share->ref_count++;                           // Mark in use
 
252
  (void) pthread_mutex_unlock(&share->mutex);
 
253
  return(share);
 
254
 
 
255
found:
 
256
  /* 
 
257
     We found an existing table definition. Return it if we didn't get
 
258
     an error when reading the table definition from file.
 
259
  */
 
260
 
 
261
  /* We must do a lock to ensure that the structure is initialized */
 
262
  (void) pthread_mutex_lock(&share->mutex);
 
263
  if (share->error)
 
264
  {
 
265
    /* Table definition contained an error */
 
266
    open_table_error(share, share->error, share->open_errno, share->errarg);
 
267
    (void) pthread_mutex_unlock(&share->mutex);
 
268
    return(0);
 
269
  }
 
270
 
 
271
  if (!share->ref_count++ && share->prev)
 
272
  {
 
273
    /*
 
274
      Share was not used before and it was in the old_unused_share list
 
275
      Unlink share from this list
 
276
    */
 
277
    pthread_mutex_lock(&LOCK_table_share);
 
278
    *share->prev= share->next;
 
279
    share->next->prev= share->prev;
 
280
    share->next= 0;
 
281
    share->prev= 0;
 
282
    pthread_mutex_unlock(&LOCK_table_share);
 
283
  }
 
284
  (void) pthread_mutex_unlock(&share->mutex);
 
285
 
 
286
   /* Free cache if too big */
 
287
  while (table_def_cache.records > table_def_size &&
 
288
         oldest_unused_share->next)
 
289
  {
 
290
    pthread_mutex_lock(&oldest_unused_share->mutex);
 
291
    VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
 
292
  }
 
293
 
 
294
  return(share);
 
295
}
 
296
 
 
297
 
 
298
/*
 
299
  Get a table share. If it didn't exist, try creating it from engine
 
300
 
 
301
  For arguments and return values, see get_table_from_share()
 
302
*/
 
303
 
 
304
static TABLE_SHARE
 
305
*get_table_share_with_create(THD *thd, TableList *table_list,
 
306
                             char *key, uint key_length,
 
307
                             uint db_flags, int *error)
 
308
{
 
309
  TABLE_SHARE *share;
 
310
  int tmp;
 
311
 
 
312
  share= get_table_share(thd, table_list, key, key_length, db_flags, error);
 
313
  /*
 
314
    If share is not NULL, we found an existing share.
 
315
 
 
316
    If share is NULL, and there is no error, we're inside
 
317
    pre-locking, which silences 'ER_NO_SUCH_TABLE' errors
 
318
    with the intention to silently drop non-existing tables 
 
319
    from the pre-locking list. In this case we still need to try
 
320
    auto-discover before returning a NULL share.
 
321
 
 
322
    If share is NULL and the error is ER_NO_SUCH_TABLE, this is
 
323
    the same as above, only that the error was not silenced by 
 
324
    pre-locking. Once again, we need to try to auto-discover
 
325
    the share.
 
326
 
 
327
    Finally, if share is still NULL, it's a real error and we need
 
328
    to abort.
 
329
 
 
330
    @todo Rework alternative ways to deal with ER_NO_SUCH Table.
 
331
  */
 
332
  if (share || (thd->is_error() && (thd->main_da.sql_errno() != ER_NO_SUCH_TABLE)))
 
333
 
 
334
    return(share);
 
335
 
 
336
  /* Table didn't exist. Check if some engine can provide it */
 
337
  if ((tmp= ha_create_table_from_engine(thd, table_list->db,
 
338
                                        table_list->table_name)) < 0)
 
339
    return(0);
 
340
 
 
341
  if (tmp)
 
342
  {
 
343
    /* Give right error message */
 
344
    thd->clear_error();
 
345
    my_printf_error(ER_UNKNOWN_ERROR,
 
346
                    "Failed to open '%-.64s', error while "
 
347
                    "unpacking from engine",
 
348
                    MYF(0), table_list->table_name);
 
349
    return(0);
 
350
  }
 
351
  /* Table existed in engine. Let's open it */
 
352
  drizzle_reset_errors(thd, 1);                   // Clear warnings
 
353
  thd->clear_error();                           // Clear error message
 
354
  return(get_table_share(thd, table_list, key, key_length,
 
355
                              db_flags, error));
 
356
}
 
357
 
 
358
 
 
359
/* 
 
360
   Mark that we are not using table share anymore.
 
361
 
 
362
   SYNOPSIS
 
363
     release_table_share()
 
364
     share              Table share
 
365
     release_type       How the release should be done:
 
366
                        RELEASE_NORMAL
 
367
                         - Release without checking
 
368
                        RELEASE_WAIT_FOR_DROP
 
369
                         - Don't return until we get a signal that the
 
370
                           table is deleted or the thread is killed.
 
371
 
 
372
   IMPLEMENTATION
 
373
     If ref_count goes to zero and (we have done a refresh or if we have
 
374
     already too many open table shares) then delete the definition.
 
375
 
 
376
     If type == RELEASE_WAIT_FOR_DROP then don't return until we get a signal
 
377
     that the table is deleted or the thread is killed.
 
378
*/
 
379
 
 
380
void release_table_share(TABLE_SHARE *share,
 
381
                         enum release_type type __attribute__((unused)))
 
382
{
 
383
  bool to_be_deleted= 0;
 
384
 
 
385
  safe_mutex_assert_owner(&LOCK_open);
 
386
 
 
387
  pthread_mutex_lock(&share->mutex);
 
388
  if (!--share->ref_count)
 
389
  {
 
390
    if (share->version != refresh_version)
 
391
      to_be_deleted=1;
 
392
    else
 
393
    {
 
394
      /* Link share last in used_table_share list */
 
395
      assert(share->next == 0);
 
396
      pthread_mutex_lock(&LOCK_table_share);
 
397
      share->prev= end_of_unused_share.prev;
 
398
      *end_of_unused_share.prev= share;
 
399
      end_of_unused_share.prev= &share->next;
 
400
      share->next= &end_of_unused_share;
 
401
      pthread_mutex_unlock(&LOCK_table_share);
 
402
 
 
403
      to_be_deleted= (table_def_cache.records > table_def_size);
 
404
    }
 
405
  }
 
406
 
 
407
  if (to_be_deleted)
 
408
  {
 
409
    hash_delete(&table_def_cache, (uchar*) share);
 
410
    return;
 
411
  }
 
412
  pthread_mutex_unlock(&share->mutex);
 
413
  return;
 
414
}
 
415
 
 
416
 
 
417
/*
 
418
  Check if table definition exits in cache
 
419
 
 
420
  SYNOPSIS
 
421
    get_cached_table_share()
 
422
    db                  Database name
 
423
    table_name          Table name
 
424
 
 
425
  RETURN
 
426
    0  Not cached
 
427
    #  TABLE_SHARE for table
 
428
*/
 
429
 
 
430
TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name)
 
431
{
 
432
  char key[NAME_LEN*2+2];
 
433
  TableList table_list;
 
434
  uint key_length;
 
435
  safe_mutex_assert_owner(&LOCK_open);
 
436
 
 
437
  table_list.db= (char*) db;
 
438
  table_list.table_name= (char*) table_name;
 
439
  key_length= create_table_def_key((THD*) 0, key, &table_list, 0);
 
440
  return (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key, key_length);
 
441
}  
 
442
 
 
443
 
 
444
/*
 
445
  Close file handle, but leave the table in the table cache
 
446
 
 
447
  SYNOPSIS
 
448
    close_handle_and_leave_table_as_lock()
 
449
    table               Table handler
 
450
 
 
451
  NOTES
 
452
    By leaving the table in the table cache, it disallows any other thread
 
453
    to open the table
 
454
 
 
455
    thd->killed will be set if we run out of memory
 
456
 
 
457
    If closing a MERGE child, the calling function has to take care for
 
458
    closing the parent too, if necessary.
100
459
*/
101
460
 
102
461
 
103
462
void close_handle_and_leave_table_as_lock(Table *table)
104
463
{
 
464
  TABLE_SHARE *share, *old_share= table->s;
 
465
  char *key_buff;
 
466
  MEM_ROOT *mem_root= &table->mem_root;
 
467
 
105
468
  assert(table->db_stat);
106
 
  assert(table->getShare()->getType() == message::Table::STANDARD);
107
469
 
108
470
  /*
109
471
    Make a local copy of the table share and free the current one.
110
472
    This has to be done to ensure that the table share is removed from
111
473
    the table defintion cache as soon as the last instance is removed
112
474
  */
113
 
  TableIdentifier identifier(table->getShare()->getSchemaName(), table->getShare()->getTableName(), message::Table::INTERNAL);
114
 
  const TableIdentifier::Key &key(identifier.getKey());
115
 
  TableShare *share= new TableShare(identifier.getType(),
116
 
                                    identifier,
117
 
                                    const_cast<char *>(key.vector()),  static_cast<uint32_t>(table->getShare()->getCacheKeySize()));
118
 
 
119
 
  table->cursor->close();
120
 
  table->db_stat= 0;                            // Mark cursor closed
121
 
  TableShare::release(table->getMutableShare());
122
 
  table->setShare(share);
123
 
}
124
 
 
 
475
  if (multi_alloc_root(mem_root,
 
476
                       &share, sizeof(*share),
 
477
                       &key_buff, old_share->table_cache_key.length,
 
478
                       NULL))
 
479
  {
 
480
    memset(share, 0, sizeof(*share));
 
481
    share->set_table_cache_key(key_buff, old_share->table_cache_key.str,
 
482
                               old_share->table_cache_key.length);
 
483
    share->tmp_table= INTERNAL_TMP_TABLE;       // for intern_close_table()
 
484
  }
 
485
 
 
486
  table->file->close();
 
487
  table->db_stat= 0;                            // Mark file closed
 
488
  release_table_share(table->s, RELEASE_NORMAL);
 
489
  table->s= share;
 
490
  table->file->change_table_ptr(table, table->s);
 
491
 
 
492
  return;
 
493
}
 
494
 
 
495
 
 
496
 
 
497
/*
 
498
  Create a list for all open tables matching SQL expression
 
499
 
 
500
  SYNOPSIS
 
501
    list_open_tables()
 
502
    thd                 Thread THD
 
503
    wild                SQL like expression
 
504
 
 
505
  NOTES
 
506
    One gets only a list of tables for which one has any kind of privilege.
 
507
    db and table names are allocated in result struct, so one doesn't need
 
508
    a lock on LOCK_open when traversing the return list.
 
509
 
 
510
  RETURN VALUES
 
511
    NULL        Error (Probably OOM)
 
512
    #           Pointer to list of names of open tables.
 
513
*/
 
514
 
 
515
OPEN_TableList *list_open_tables(THD *thd __attribute__((unused)),
 
516
                                  const char *db, const char *wild)
 
517
{
 
518
  int result = 0;
 
519
  OPEN_TableList **start_list, *open_list;
 
520
  TableList table_list;
 
521
 
 
522
  VOID(pthread_mutex_lock(&LOCK_open));
 
523
  memset(&table_list, 0, sizeof(table_list));
 
524
  start_list= &open_list;
 
525
  open_list=0;
 
526
 
 
527
  for (uint idx=0 ; result == 0 && idx < open_cache.records; idx++)
 
528
  {
 
529
    OPEN_TableList *table;
 
530
    Table *entry=(Table*) hash_element(&open_cache,idx);
 
531
    TABLE_SHARE *share= entry->s;
 
532
 
 
533
    if (db && my_strcasecmp(system_charset_info, db, share->db.str))
 
534
      continue;
 
535
    if (wild && wild_compare(share->table_name.str, wild, 0))
 
536
      continue;
 
537
 
 
538
    /* Check if user has SELECT privilege for any column in the table */
 
539
    table_list.db=         share->db.str;
 
540
    table_list.table_name= share->table_name.str;
 
541
 
 
542
    /* need to check if we haven't already listed it */
 
543
    for (table= open_list  ; table ; table=table->next)
 
544
    {
 
545
      if (!strcmp(table->table, share->table_name.str) &&
 
546
          !strcmp(table->db,    share->db.str))
 
547
      {
 
548
        if (entry->in_use)
 
549
          table->in_use++;
 
550
        if (entry->locked_by_name)
 
551
          table->locked++;
 
552
        break;
 
553
      }
 
554
    }
 
555
    if (table)
 
556
      continue;
 
557
    if (!(*start_list = (OPEN_TableList *)
 
558
          sql_alloc(sizeof(**start_list)+share->table_cache_key.length)))
 
559
    {
 
560
      open_list=0;                              // Out of memory
 
561
      break;
 
562
    }
 
563
    stpcpy((*start_list)->table=
 
564
           stpcpy(((*start_list)->db= (char*) ((*start_list)+1)),
 
565
                  share->db.str)+1,
 
566
           share->table_name.str);
 
567
    (*start_list)->in_use= entry->in_use ? 1 : 0;
 
568
    (*start_list)->locked= entry->locked_by_name ? 1 : 0;
 
569
    start_list= &(*start_list)->next;
 
570
    *start_list=0;
 
571
  }
 
572
  VOID(pthread_mutex_unlock(&LOCK_open));
 
573
  return(open_list);
 
574
}
125
575
 
126
576
/*****************************************************************************
127
577
 *       Functions to free open table cache
128
578
 ****************************************************************************/
129
579
 
130
580
 
131
 
void Table::intern_close_table()
 
581
void intern_close_table(Table *table)
132
582
{                                               // Free all structures
133
 
  free_io_cache();
134
 
  if (cursor)                              // Not true if name lock
 
583
  free_io_cache(table);
 
584
  if (table->file)                              // Not true if name lock
 
585
    VOID(closefrm(table, 1));                   // close file
 
586
  return;
 
587
}
 
588
 
 
589
/*
 
590
  Remove table from the open table cache
 
591
 
 
592
  SYNOPSIS
 
593
    free_cache_entry()
 
594
    table               Table to remove
 
595
 
 
596
  NOTE
 
597
    We need to have a lock on LOCK_open when calling this
 
598
*/
 
599
 
 
600
static void free_cache_entry(Table *table)
 
601
{
 
602
  intern_close_table(table);
 
603
  if (!table->in_use)
135
604
  {
136
 
    delete_table(true);                 // close cursor
 
605
    table->next->prev=table->prev;              /* remove from used chain */
 
606
    table->prev->next=table->next;
 
607
    if (table == unused_tables)
 
608
    {
 
609
      unused_tables=unused_tables->next;
 
610
      if (table == unused_tables)
 
611
        unused_tables=0;
 
612
    }
137
613
  }
 
614
  my_free((uchar*) table,MYF(0));
 
615
  return;
138
616
}
139
617
 
140
618
/* Free resources allocated by filesort() and read_record() */
141
619
 
142
 
void Table::free_io_cache()
 
620
void free_io_cache(Table *table)
143
621
{
144
 
  if (sort.io_cache)
 
622
  if (table->sort.io_cache)
145
623
  {
146
 
    sort.io_cache->close_cached_file();
147
 
    delete sort.io_cache;
148
 
    sort.io_cache= 0;
 
624
    close_cached_file(table->sort.io_cache);
 
625
    my_free((uchar*) table->sort.io_cache,MYF(0));
 
626
    table->sort.io_cache=0;
149
627
  }
 
628
  return;
150
629
}
151
630
 
152
631
 
153
632
/*
154
633
  Close all tables which aren't in use by any thread
155
634
 
156
 
  @param session Thread context (may be NULL)
 
635
  @param thd Thread context
157
636
  @param tables List of tables to remove from the cache
158
 
  @param have_lock If table::Cache::singleton().mutex() is locked
 
637
  @param have_lock If LOCK_open is locked
159
638
  @param wait_for_refresh Wait for a impending flush
160
639
  @param wait_for_placeholders Wait for tables being reopened so that the GRL
161
 
  won't proceed while write-locked tables are being reopened by other
162
 
  threads.
163
 
 
164
 
  @remark Session can be NULL, but then wait_for_refresh must be false
165
 
  and tables must be NULL.
166
 
*/
167
 
 
168
 
bool Session::close_cached_tables(TableList *tables, bool wait_for_refresh, bool wait_for_placeholders)
169
 
{
 
640
         won't proceed while write-locked tables are being reopened by other
 
641
         threads.
 
642
 
 
643
  @remark THD can be NULL, but then wait_for_refresh must be false
 
644
          and tables must be NULL.
 
645
*/
 
646
 
 
647
bool close_cached_tables(THD *thd, TableList *tables, bool have_lock,
 
648
                         bool wait_for_refresh, bool wait_for_placeholders)
 
649
{
 
650
  bool result=0;
 
651
  assert(thd || (!wait_for_refresh && !tables));
 
652
 
 
653
  if (!have_lock)
 
654
    VOID(pthread_mutex_lock(&LOCK_open));
 
655
  if (!tables)
 
656
  {
 
657
    refresh_version++;                          // Force close of open tables
 
658
    while (unused_tables)
 
659
    {
 
660
#ifdef EXTRA_DEBUG
 
661
      if (hash_delete(&open_cache,(uchar*) unused_tables))
 
662
        printf("Warning: Couldn't delete open table from hash\n");
 
663
#else
 
664
      VOID(hash_delete(&open_cache,(uchar*) unused_tables));
 
665
#endif
 
666
    }
 
667
    /* Free table shares */
 
668
    while (oldest_unused_share->next)
 
669
    {
 
670
      pthread_mutex_lock(&oldest_unused_share->mutex);
 
671
      VOID(hash_delete(&table_def_cache, (uchar*) oldest_unused_share));
 
672
    }
 
673
    if (wait_for_refresh)
 
674
    {
 
675
      /*
 
676
        Other threads could wait in a loop in open_and_lock_tables(),
 
677
        trying to lock one or more of our tables.
 
678
 
 
679
        If they wait for the locks in thr_multi_lock(), their lock
 
680
        request is aborted. They loop in open_and_lock_tables() and
 
681
        enter open_table(). Here they notice the table is refreshed and
 
682
        wait for COND_refresh. Then they loop again in
 
683
        open_and_lock_tables() and this time open_table() succeeds. At
 
684
        this moment, if we (the FLUSH TABLES thread) are scheduled and
 
685
        on another FLUSH TABLES enter close_cached_tables(), they could
 
686
        awake while we sleep below, waiting for others threads (us) to
 
687
        close their open tables. If this happens, the other threads
 
688
        would find the tables unlocked. They would get the locks, one
 
689
        after the other, and could do their destructive work. This is an
 
690
        issue if we have LOCK TABLES in effect.
 
691
 
 
692
        The problem is that the other threads passed all checks in
 
693
        open_table() before we refresh the table.
 
694
 
 
695
        The fix for this problem is to set some_tables_deleted for all
 
696
        threads with open tables. These threads can still get their
 
697
        locks, but will immediately release them again after checking
 
698
        this variable. They will then loop in open_and_lock_tables()
 
699
        again. There they will wait until we update all tables version
 
700
        below.
 
701
 
 
702
        Setting some_tables_deleted is done by remove_table_from_cache()
 
703
        in the other branch.
 
704
 
 
705
        In other words (reviewer suggestion): You need this setting of
 
706
        some_tables_deleted for the case when table was opened and all
 
707
        related checks were passed before incrementing refresh_version
 
708
        (which you already have) but attempt to lock the table happened
 
709
        after the call to close_old_data_files() i.e. after removal of
 
710
        current thread locks.
 
711
      */
 
712
      for (uint idx=0 ; idx < open_cache.records ; idx++)
 
713
      {
 
714
        Table *table=(Table*) hash_element(&open_cache,idx);
 
715
        if (table->in_use)
 
716
          table->in_use->some_tables_deleted= 1;
 
717
      }
 
718
    }
 
719
  }
 
720
  else
 
721
  {
 
722
    bool found=0;
 
723
    for (TableList *table= tables; table; table= table->next_local)
 
724
    {
 
725
      if (remove_table_from_cache(thd, table->db, table->table_name,
 
726
                                  RTFC_OWNED_BY_THD_FLAG))
 
727
        found=1;
 
728
    }
 
729
    if (!found)
 
730
      wait_for_refresh=0;                       // Nothing to wait for
 
731
  }
 
732
 
 
733
  if (wait_for_refresh)
 
734
  {
 
735
    /*
 
736
      If there is any table that has a lower refresh_version, wait until
 
737
      this is closed (or this thread is killed) before returning
 
738
    */
 
739
    thd->mysys_var->current_mutex= &LOCK_open;
 
740
    thd->mysys_var->current_cond= &COND_refresh;
 
741
    thd_proc_info(thd, "Flushing tables");
 
742
 
 
743
    close_old_data_files(thd,thd->open_tables,1,1);
 
744
    mysql_ha_flush(thd);
 
745
 
 
746
    bool found=1;
 
747
    /* Wait until all threads has closed all the tables we had locked */
 
748
    while (found && ! thd->killed)
 
749
    {
 
750
      found=0;
 
751
      for (uint idx=0 ; idx < open_cache.records ; idx++)
 
752
      {
 
753
        Table *table=(Table*) hash_element(&open_cache,idx);
 
754
        /* Avoid a self-deadlock. */
 
755
        if (table->in_use == thd)
 
756
          continue;
 
757
        /*
 
758
          Note that we wait here only for tables which are actually open, and
 
759
          not for placeholders with Table::open_placeholder set. Waiting for
 
760
          latter will cause deadlock in the following scenario, for example:
 
761
 
 
762
          conn1: lock table t1 write;
 
763
          conn2: lock table t2 write;
 
764
          conn1: flush tables;
 
765
          conn2: flush tables;
 
766
 
 
767
          It also does not make sense to wait for those of placeholders that
 
768
          are employed by CREATE TABLE as in this case table simply does not
 
769
          exist yet.
 
770
        */
 
771
        if (table->needs_reopen_or_name_lock() && (table->db_stat ||
 
772
            (table->open_placeholder && wait_for_placeholders)))
 
773
        {
 
774
          found=1;
 
775
          pthread_cond_wait(&COND_refresh,&LOCK_open);
 
776
          break;
 
777
        }
 
778
      }
 
779
    }
 
780
    /*
 
781
      No other thread has the locked tables open; reopen them and get the
 
782
      old locks. This should always succeed (unless some external process
 
783
      has removed the tables)
 
784
    */
 
785
    thd->in_lock_tables=1;
 
786
    result=reopen_tables(thd,1,1);
 
787
    thd->in_lock_tables=0;
 
788
    /* Set version for table */
 
789
    for (Table *table=thd->open_tables; table ; table= table->next)
 
790
    {
 
791
      /*
 
792
        Preserve the version (0) of write locked tables so that a impending
 
793
        global read lock won't sneak in.
 
794
      */
 
795
      if (table->reginfo.lock_type < TL_WRITE_ALLOW_WRITE)
 
796
        table->s->version= refresh_version;
 
797
    }
 
798
  }
 
799
  if (!have_lock)
 
800
    VOID(pthread_mutex_unlock(&LOCK_open));
 
801
  if (wait_for_refresh)
 
802
  {
 
803
    pthread_mutex_lock(&thd->mysys_var->mutex);
 
804
    thd->mysys_var->current_mutex= 0;
 
805
    thd->mysys_var->current_cond= 0;
 
806
    thd_proc_info(thd, 0);
 
807
    pthread_mutex_unlock(&thd->mysys_var->mutex);
 
808
  }
 
809
  return(result);
 
810
}
 
811
 
 
812
 
 
813
/*
 
814
  Close all tables which match specified connection string or
 
815
  if specified string is NULL, then any table with a connection string.
 
816
*/
 
817
 
 
818
bool close_cached_connection_tables(THD *thd, bool if_wait_for_refresh,
 
819
                                    LEX_STRING *connection, bool have_lock)
 
820
{
 
821
  uint idx;
 
822
  TableList tmp, *tables= NULL;
170
823
  bool result= false;
171
 
  Session *session= this;
172
 
 
173
 
  {
174
 
    table::Cache::singleton().mutex().lock(); /* Optionally lock for remove tables from open_cahe if not in use */
175
 
 
176
 
    if (tables == NULL)
177
 
    {
178
 
      refresh_version++;                                // Force close of open tables
179
 
 
180
 
      table::getUnused().clear();
181
 
 
182
 
      if (wait_for_refresh)
183
 
      {
184
 
        /*
185
 
          Other threads could wait in a loop in open_and_lock_tables(),
186
 
          trying to lock one or more of our tables.
187
 
 
188
 
          If they wait for the locks in thr_multi_lock(), their lock
189
 
          request is aborted. They loop in open_and_lock_tables() and
190
 
          enter open_table(). Here they notice the table is refreshed and
191
 
          wait for COND_refresh. Then they loop again in
192
 
          openTablesLock() and this time open_table() succeeds. At
193
 
          this moment, if we (the FLUSH TABLES thread) are scheduled and
194
 
          on another FLUSH TABLES enter close_cached_tables(), they could
195
 
          awake while we sleep below, waiting for others threads (us) to
196
 
          close their open tables. If this happens, the other threads
197
 
          would find the tables unlocked. They would get the locks, one
198
 
          after the other, and could do their destructive work. This is an
199
 
          issue if we have LOCK TABLES in effect.
200
 
 
201
 
          The problem is that the other threads passed all checks in
202
 
          open_table() before we refresh the table.
203
 
 
204
 
          The fix for this problem is to set some_tables_deleted for all
205
 
          threads with open tables. These threads can still get their
206
 
          locks, but will immediately release them again after checking
207
 
          this variable. They will then loop in openTablesLock()
208
 
          again. There they will wait until we update all tables version
209
 
          below.
210
 
 
211
 
          Setting some_tables_deleted is done by table::Cache::singleton().removeTable()
212
 
          in the other branch.
213
 
 
214
 
          In other words (reviewer suggestion): You need this setting of
215
 
          some_tables_deleted for the case when table was opened and all
216
 
          related checks were passed before incrementing refresh_version
217
 
          (which you already have) but attempt to lock the table happened
218
 
          after the call to Session::close_old_data_files() i.e. after removal of
219
 
          current thread locks.
220
 
        */
221
 
        for (table::CacheMap::const_iterator iter= table::getCache().begin();
222
 
             iter != table::getCache().end();
223
 
             iter++)
224
 
        {
225
 
          Table *table= (*iter).second;
226
 
          if (table->in_use)
227
 
            table->in_use->some_tables_deleted= false;
228
 
        }
229
 
      }
230
 
    }
231
 
    else
232
 
    {
233
 
      bool found= false;
234
 
      for (TableList *table= tables; table; table= table->next_local)
235
 
      {
236
 
        TableIdentifier identifier(table->getSchemaName(), table->getTableName());
237
 
        if (table::Cache::singleton().removeTable(session, identifier,
238
 
                                    RTFC_OWNED_BY_Session_FLAG))
239
 
        {
240
 
          found= true;
241
 
        }
242
 
      }
243
 
      if (!found)
244
 
        wait_for_refresh= false;                        // Nothing to wait for
245
 
    }
246
 
 
247
 
    if (wait_for_refresh)
248
 
    {
249
 
      /*
250
 
        If there is any table that has a lower refresh_version, wait until
251
 
        this is closed (or this thread is killed) before returning
252
 
      */
253
 
      session->mysys_var->current_mutex= &table::Cache::singleton().mutex();
254
 
      session->mysys_var->current_cond= &COND_refresh;
255
 
      session->set_proc_info("Flushing tables");
256
 
 
257
 
      session->close_old_data_files();
258
 
 
259
 
      bool found= true;
260
 
      /* Wait until all threads has closed all the tables we had locked */
261
 
      while (found && ! session->getKilled())
262
 
      {
263
 
        found= false;
264
 
        for (table::CacheMap::const_iterator iter= table::getCache().begin();
265
 
             iter != table::getCache().end();
266
 
             iter++)
267
 
        {
268
 
          Table *table= (*iter).second;
269
 
          /* Avoid a self-deadlock. */
270
 
          if (table->in_use == session)
271
 
            continue;
272
 
          /*
273
 
            Note that we wait here only for tables which are actually open, and
274
 
            not for placeholders with Table::open_placeholder set. Waiting for
275
 
            latter will cause deadlock in the following scenario, for example:
276
 
 
277
 
            conn1-> lock table t1 write;
278
 
            conn2-> lock table t2 write;
279
 
            conn1-> flush tables;
280
 
            conn2-> flush tables;
281
 
 
282
 
            It also does not make sense to wait for those of placeholders that
283
 
            are employed by CREATE TABLE as in this case table simply does not
284
 
            exist yet.
285
 
          */
286
 
          if (table->needs_reopen_or_name_lock() && (table->db_stat ||
287
 
                                                     (table->open_placeholder && wait_for_placeholders)))
288
 
          {
289
 
            found= true;
290
 
            boost_unique_lock_t scoped(table::Cache::singleton().mutex(), boost::adopt_lock_t());
291
 
            COND_refresh.wait(scoped);
292
 
            scoped.release();
293
 
            break;
294
 
          }
295
 
        }
296
 
      }
297
 
      /*
298
 
        No other thread has the locked tables open; reopen them and get the
299
 
        old locks. This should always succeed (unless some external process
300
 
        has removed the tables)
301
 
      */
302
 
      result= session->reopen_tables(true, true);
303
 
 
304
 
      /* Set version for table */
305
 
      for (Table *table= session->open_tables; table ; table= table->getNext())
306
 
      {
307
 
        /*
308
 
          Preserve the version (0) of write locked tables so that a impending
309
 
          global read lock won't sneak in.
310
 
        */
311
 
        if (table->reginfo.lock_type < TL_WRITE_ALLOW_WRITE)
312
 
          table->getMutableShare()->refreshVersion();
313
 
      }
314
 
    }
315
 
 
316
 
    table::Cache::singleton().mutex().unlock();
317
 
  }
318
 
 
319
 
  if (wait_for_refresh)
320
 
  {
321
 
    boost_unique_lock_t scopedLock(session->mysys_var->mutex);
322
 
    session->mysys_var->current_mutex= 0;
323
 
    session->mysys_var->current_cond= 0;
324
 
    session->set_proc_info(0);
325
 
  }
326
 
 
327
 
  return result;
328
 
}
329
 
 
330
 
 
331
 
/**
332
 
  move one table to free list 
333
 
*/
334
 
 
335
 
bool Session::free_cached_table()
336
 
{
337
 
  bool found_old_table= false;
338
 
  table::Concurrent *table= static_cast<table::Concurrent *>(open_tables);
339
 
 
340
 
  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());
 
824
  assert(thd);
 
825
 
 
826
  memset(&tmp, 0, sizeof(TableList));
 
827
 
 
828
  if (!have_lock)
 
829
    VOID(pthread_mutex_lock(&LOCK_open));
 
830
 
 
831
  for (idx= 0; idx < table_def_cache.records; idx++)
 
832
  {
 
833
    TABLE_SHARE *share= (TABLE_SHARE *) hash_element(&table_def_cache, idx);
 
834
 
 
835
    /* Ignore if table is not open or does not have a connect_string */
 
836
    if (!share->connect_string.length || !share->ref_count)
 
837
      continue;
 
838
 
 
839
    /* Compare the connection string */
 
840
    if (connection &&
 
841
        (connection->length > share->connect_string.length ||
 
842
         (connection->length < share->connect_string.length &&
 
843
          (share->connect_string.str[connection->length] != '/' &&
 
844
           share->connect_string.str[connection->length] != '\\')) ||
 
845
         strncasecmp(connection->str, share->connect_string.str,
 
846
                     connection->length)))
 
847
      continue;
 
848
 
 
849
    /* close_cached_tables() only uses these elements */
 
850
    tmp.db= share->db.str;
 
851
    tmp.table_name= share->table_name.str;
 
852
    tmp.next_local= tables;
 
853
 
 
854
    tables= (TableList *) memdup_root(thd->mem_root, (char*)&tmp, 
 
855
                                       sizeof(TableList));
 
856
  }
 
857
 
 
858
  if (tables)
 
859
    result= close_cached_tables(thd, tables, true, false, false);
 
860
 
 
861
  if (!have_lock)
 
862
    VOID(pthread_mutex_unlock(&LOCK_open));
 
863
 
 
864
  if (if_wait_for_refresh)
 
865
  {
 
866
    pthread_mutex_lock(&thd->mysys_var->mutex);
 
867
    thd->mysys_var->current_mutex= 0;
 
868
    thd->mysys_var->current_cond= 0;
 
869
    thd->set_proc_info(0);
 
870
    pthread_mutex_unlock(&thd->mysys_var->mutex);
 
871
  }
 
872
 
 
873
  return(result);
 
874
}
 
875
 
 
876
 
 
877
/**
 
878
  Mark all temporary tables which were used by the current statement or
 
879
  substatement as free for reuse, but only if the query_id can be cleared.
 
880
 
 
881
  @param thd thread context
 
882
 
 
883
  @remark For temp tables associated with a open SQL HANDLER the query_id
 
884
          is not reset until the HANDLER is closed.
 
885
*/
 
886
 
 
887
static void mark_temp_tables_as_free_for_reuse(THD *thd)
 
888
{
 
889
  for (Table *table= thd->temporary_tables ; table ; table= table->next)
 
890
  {
 
891
    if ((table->query_id == thd->query_id) && ! table->open_by_handler)
 
892
    {
 
893
      table->query_id= 0;
 
894
      table->file->ha_reset();
 
895
    }
 
896
  }
 
897
}
 
898
 
 
899
 
 
900
/*
 
901
  Mark all tables in the list which were used by current substatement
 
902
  as free for reuse.
 
903
 
 
904
  SYNOPSIS
 
905
    mark_used_tables_as_free_for_reuse()
 
906
      thd   - thread context
 
907
      table - head of the list of tables
 
908
 
 
909
  DESCRIPTION
 
910
    Marks all tables in the list which were used by current substatement
 
911
    (they are marked by its query_id) as free for reuse.
 
912
 
 
913
  NOTE
 
914
    The reason we reset query_id is that it's not enough to just test
 
915
    if table->query_id != thd->query_id to know if a table is in use.
 
916
 
 
917
    For example
 
918
    SELECT f1_that_uses_t1() FROM t1;
 
919
    In f1_that_uses_t1() we will see one instance of t1 where query_id is
 
920
    set to query_id of original query.
 
921
*/
 
922
 
 
923
static void mark_used_tables_as_free_for_reuse(THD *thd, Table *table)
 
924
{
 
925
  for (; table ; table= table->next)
 
926
  {
 
927
    if (table->query_id == thd->query_id)
 
928
    {
 
929
      table->query_id= 0;
 
930
      table->file->ha_reset();
 
931
    }
 
932
  }
 
933
}
 
934
 
 
935
 
 
936
/**
 
937
  Auxiliary function to close all tables in the open_tables list.
 
938
 
 
939
  @param thd Thread context.
 
940
 
 
941
  @remark It should not ordinarily be called directly.
 
942
*/
 
943
 
 
944
static void close_open_tables(THD *thd)
 
945
{
 
946
  bool found_old_table= 0;
 
947
 
 
948
  safe_mutex_assert_not_owner(&LOCK_open);
 
949
 
 
950
  VOID(pthread_mutex_lock(&LOCK_open));
 
951
 
 
952
  while (thd->open_tables)
 
953
    found_old_table|= close_thread_table(thd, &thd->open_tables);
 
954
  thd->some_tables_deleted= 0;
 
955
 
 
956
  /* Free tables to hold down open files */
 
957
  while (open_cache.records > table_cache_size && unused_tables)
 
958
    VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
 
959
  if (found_old_table)
 
960
  {
 
961
    /* Tell threads waiting for refresh that something has happened */
 
962
    broadcast_refresh();
 
963
  }
 
964
 
 
965
  VOID(pthread_mutex_unlock(&LOCK_open));
 
966
}
 
967
 
 
968
 
 
969
/*
 
970
  Close all tables used by the current substatement, or all tables
 
971
  used by this thread if we are on the upper level.
 
972
 
 
973
  SYNOPSIS
 
974
    close_thread_tables()
 
975
    thd                 Thread handler
 
976
 
 
977
  IMPLEMENTATION
 
978
    Unlocks tables and frees derived tables.
 
979
    Put all normal tables used by thread in free list.
 
980
 
 
981
    It will only close/mark as free for reuse tables opened by this
 
982
    substatement, it will also check if we are closing tables after
 
983
    execution of complete query (i.e. we are on upper level) and will
 
984
    leave prelocked mode if needed.
 
985
*/
 
986
 
 
987
void close_thread_tables(THD *thd)
 
988
{
 
989
  Table *table;
 
990
 
 
991
  /*
 
992
    We are assuming here that thd->derived_tables contains ONLY derived
 
993
    tables for this substatement. i.e. instead of approach which uses
 
994
    query_id matching for determining which of the derived tables belong
 
995
    to this substatement we rely on the ability of substatements to
 
996
    save/restore thd->derived_tables during their execution.
 
997
 
 
998
    TODO: Probably even better approach is to simply associate list of
 
999
          derived tables with (sub-)statement instead of thread and destroy
 
1000
          them at the end of its execution.
 
1001
  */
 
1002
  if (thd->derived_tables)
 
1003
  {
 
1004
    Table *next;
 
1005
    /*
 
1006
      Close all derived tables generated in queries like
 
1007
      SELECT * FROM (SELECT * FROM t1)
 
1008
    */
 
1009
    for (table= thd->derived_tables ; table ; table= next)
 
1010
    {
 
1011
      next= table->next;
 
1012
      table->free_tmp_table(thd);
 
1013
    }
 
1014
    thd->derived_tables= 0;
 
1015
  }
 
1016
 
 
1017
  /*
 
1018
    Mark all temporary tables used by this statement as free for reuse.
 
1019
  */
 
1020
  mark_temp_tables_as_free_for_reuse(thd);
 
1021
  /*
 
1022
    Let us commit transaction for statement. Since in 5.0 we only have
 
1023
    one statement transaction and don't allow several nested statement
 
1024
    transactions this call will do nothing if we are inside of stored
 
1025
    function or trigger (i.e. statement transaction is already active and
 
1026
    does not belong to statement for which we do close_thread_tables()).
 
1027
    TODO: This should be fixed in later releases.
 
1028
   */
 
1029
  if (!(thd->state_flags & Open_tables_state::BACKUPS_AVAIL))
 
1030
  {
 
1031
    thd->main_da.can_overwrite_status= true;
 
1032
    ha_autocommit_or_rollback(thd, thd->is_error());
 
1033
    thd->main_da.can_overwrite_status= false;
 
1034
    thd->transaction.stmt.reset();
 
1035
  }
 
1036
 
 
1037
  if (thd->locked_tables)
 
1038
  {
 
1039
 
 
1040
    /* Ensure we are calling ha_reset() for all used tables */
 
1041
    mark_used_tables_as_free_for_reuse(thd, thd->open_tables);
 
1042
 
 
1043
    /*
 
1044
      We are under simple LOCK TABLES so should not do anything else.
 
1045
    */
 
1046
    return;
 
1047
  }
 
1048
 
 
1049
  if (thd->lock)
 
1050
  {
 
1051
    /*
 
1052
      For RBR we flush the pending event just before we unlock all the
 
1053
      tables.  This means that we are at the end of a topmost
 
1054
      statement, so we ensure that the STMT_END_F flag is set on the
 
1055
      pending event.  For statements that are *inside* stored
 
1056
      functions, the pending event will not be flushed: that will be
 
1057
      handled either before writing a query log event (inside
 
1058
      binlog_query()) or when preparing a pending event.
 
1059
     */
 
1060
    thd->binlog_flush_pending_rows_event(true);
 
1061
    mysql_unlock_tables(thd, thd->lock);
 
1062
    thd->lock=0;
 
1063
  }
 
1064
  /*
 
1065
    Note that we need to hold LOCK_open while changing the
 
1066
    open_tables list. Another thread may work on it.
 
1067
    (See: remove_table_from_cache(), mysql_wait_completed_table())
 
1068
    Closing a MERGE child before the parent would be fatal if the
 
1069
    other thread tries to abort the MERGE lock in between.
 
1070
  */
 
1071
  if (thd->open_tables)
 
1072
    close_open_tables(thd);
 
1073
 
 
1074
  return;
 
1075
}
 
1076
 
 
1077
 
 
1078
/* move one table to free list */
 
1079
 
 
1080
bool close_thread_table(THD *thd, Table **table_ptr)
 
1081
{
 
1082
  bool found_old_table= 0;
 
1083
  Table *table= *table_ptr;
 
1084
 
341
1085
  assert(table->key_read == 0);
342
 
  assert(!table->cursor || table->cursor->inited == Cursor::NONE);
 
1086
  assert(!table->file || table->file->inited == handler::NONE);
343
1087
 
344
 
  open_tables= table->getNext();
 
1088
  *table_ptr=table->next;
345
1089
 
346
1090
  if (table->needs_reopen_or_name_lock() ||
347
 
      version != refresh_version || !table->db_stat)
 
1091
      thd->version != refresh_version || !table->db_stat)
348
1092
  {
349
 
    table::remove_table(table);
350
 
    found_old_table= true;
 
1093
    VOID(hash_delete(&open_cache,(uchar*) table));
 
1094
    found_old_table=1;
351
1095
  }
352
1096
  else
353
1097
  {
355
1099
      Open placeholders have Table::db_stat set to 0, so they should be
356
1100
      handled by the first alternative.
357
1101
    */
358
 
    assert(not table->open_placeholder);
 
1102
    assert(!table->open_placeholder);
359
1103
 
360
1104
    /* Free memory and reset for next loop */
361
 
    table->cursor->ha_reset();
362
 
    table->in_use= NULL;
363
 
 
364
 
    table::getUnused().link(table);
 
1105
    table->file->ha_reset();
 
1106
    table->in_use=0;
 
1107
    if (unused_tables)
 
1108
    {
 
1109
      table->next=unused_tables;                /* Link in last */
 
1110
      table->prev=unused_tables->prev;
 
1111
      unused_tables->prev=table;
 
1112
      table->prev->next=table;
 
1113
    }
 
1114
    else
 
1115
      unused_tables=table->next=table->prev=table;
365
1116
  }
366
 
 
367
 
  return found_old_table;
368
 
}
369
 
 
370
 
 
371
 
/**
372
 
  Auxiliary function to close all tables in the open_tables list.
373
 
 
374
 
  @param session Thread context.
375
 
 
376
 
  @remark It should not ordinarily be called directly.
 
1117
  return(found_old_table);
 
1118
}
 
1119
 
 
1120
 
 
1121
/* close_temporary_tables' internal, 4 is due to uint4korr definition */
 
1122
static inline uint  tmpkeyval(THD *thd __attribute__((unused)),
 
1123
                              Table *table)
 
1124
{
 
1125
  return uint4korr(table->s->table_cache_key.str + table->s->table_cache_key.length - 4);
 
1126
}
 
1127
 
 
1128
 
 
1129
/*
 
1130
  Close all temporary tables created by 'CREATE TEMPORARY TABLE' for thread
 
1131
  creates one DROP TEMPORARY Table binlog event for each pseudo-thread 
377
1132
*/
378
1133
 
379
 
void Session::close_open_tables()
 
1134
void close_temporary_tables(THD *thd)
380
1135
{
381
 
  bool found_old_table= false;
382
 
 
383
 
  safe_mutex_assert_not_owner(table::Cache::singleton().mutex().native_handle());
384
 
 
385
 
  boost_unique_lock_t scoped_lock(table::Cache::singleton().mutex()); /* Close all open tables on Session */
386
 
 
387
 
  while (open_tables)
388
 
  {
389
 
    found_old_table|= free_cached_table();
390
 
  }
391
 
  some_tables_deleted= false;
392
 
 
393
 
  if (found_old_table)
394
 
  {
395
 
    /* Tell threads waiting for refresh that something has happened */
396
 
    locking::broadcast_refresh();
397
 
  }
 
1136
  Table *table;
 
1137
  Table *next= NULL;
 
1138
  Table *prev_table;
 
1139
  /* Assume thd->options has OPTION_QUOTE_SHOW_CREATE */
 
1140
  bool was_quote_show= true;
 
1141
 
 
1142
  if (!thd->temporary_tables)
 
1143
    return;
 
1144
 
 
1145
  if (!mysql_bin_log.is_open() || thd->current_stmt_binlog_row_based)
 
1146
  {
 
1147
    Table *tmp_next;
 
1148
    for (table= thd->temporary_tables; table; table= tmp_next)
 
1149
    {
 
1150
      tmp_next= table->next;
 
1151
      close_temporary(table, 1, 1);
 
1152
    }
 
1153
    thd->temporary_tables= 0;
 
1154
    return;
 
1155
  }
 
1156
 
 
1157
  /* Better add "if exists", in case a RESET MASTER has been done */
 
1158
  const char stub[]= "DROP /*!40005 TEMPORARY */ Table IF EXISTS ";
 
1159
  uint stub_len= sizeof(stub) - 1;
 
1160
  char buf[256];
 
1161
  String s_query= String(buf, sizeof(buf), system_charset_info);
 
1162
  bool found_user_tables= false;
 
1163
 
 
1164
  memcpy(buf, stub, stub_len);
 
1165
 
 
1166
  /*
 
1167
    Insertion sort of temp tables by pseudo_thread_id to build ordered list
 
1168
    of sublists of equal pseudo_thread_id
 
1169
  */
 
1170
 
 
1171
  for (prev_table= thd->temporary_tables, table= prev_table->next;
 
1172
       table;
 
1173
       prev_table= table, table= table->next)
 
1174
  {
 
1175
    Table *prev_sorted /* same as for prev_table */, *sorted;
 
1176
    if (is_user_table(table))
 
1177
    {
 
1178
      if (!found_user_tables)
 
1179
        found_user_tables= true;
 
1180
      for (prev_sorted= NULL, sorted= thd->temporary_tables; sorted != table;
 
1181
           prev_sorted= sorted, sorted= sorted->next)
 
1182
      {
 
1183
        if (!is_user_table(sorted) ||
 
1184
            tmpkeyval(thd, sorted) > tmpkeyval(thd, table))
 
1185
        {
 
1186
          /* move into the sorted part of the list from the unsorted */
 
1187
          prev_table->next= table->next;
 
1188
          table->next= sorted;
 
1189
          if (prev_sorted)
 
1190
          {
 
1191
            prev_sorted->next= table;
 
1192
          }
 
1193
          else
 
1194
          {
 
1195
            thd->temporary_tables= table;
 
1196
          }
 
1197
          table= prev_table;
 
1198
          break;
 
1199
        }
 
1200
      }
 
1201
    }
 
1202
  }
 
1203
 
 
1204
  /* We always quote db,table names though it is slight overkill */
 
1205
  if (found_user_tables &&
 
1206
      !(was_quote_show= test(thd->options & OPTION_QUOTE_SHOW_CREATE)))
 
1207
  {
 
1208
    thd->options |= OPTION_QUOTE_SHOW_CREATE;
 
1209
  }
 
1210
 
 
1211
  /* scan sorted tmps to generate sequence of DROP */
 
1212
  for (table= thd->temporary_tables; table; table= next)
 
1213
  {
 
1214
    if (is_user_table(table))
 
1215
    {
 
1216
      my_thread_id save_pseudo_thread_id= thd->variables.pseudo_thread_id;
 
1217
      /* Set pseudo_thread_id to be that of the processed table */
 
1218
      thd->variables.pseudo_thread_id= tmpkeyval(thd, table);
 
1219
      /*
 
1220
        Loop forward through all tables within the sublist of
 
1221
        common pseudo_thread_id to create single DROP query.
 
1222
      */
 
1223
      for (s_query.length(stub_len);
 
1224
           table && is_user_table(table) &&
 
1225
             tmpkeyval(thd, table) == thd->variables.pseudo_thread_id;
 
1226
           table= next)
 
1227
      {
 
1228
        /*
 
1229
          We are going to add 4 ` around the db/table names and possible more
 
1230
          due to special characters in the names
 
1231
        */
 
1232
        append_identifier(thd, &s_query, table->s->db.str, strlen(table->s->db.str));
 
1233
        s_query.append('.');
 
1234
        append_identifier(thd, &s_query, table->s->table_name.str,
 
1235
                          strlen(table->s->table_name.str));
 
1236
        s_query.append(',');
 
1237
        next= table->next;
 
1238
        close_temporary(table, 1, 1);
 
1239
      }
 
1240
      thd->clear_error();
 
1241
      const CHARSET_INFO * const cs_save= thd->variables.character_set_client;
 
1242
      thd->variables.character_set_client= system_charset_info;
 
1243
      Query_log_event qinfo(thd, s_query.ptr(),
 
1244
                            s_query.length() - 1 /* to remove trailing ',' */,
 
1245
                            0, false);
 
1246
      thd->variables.character_set_client= cs_save;
 
1247
      /*
 
1248
        Imagine the thread had created a temp table, then was doing a
 
1249
        SELECT, and the SELECT was killed. Then it's not clever to
 
1250
        mark the statement above as "killed", because it's not really
 
1251
        a statement updating data, and there are 99.99% chances it
 
1252
        will succeed on slave.  If a real update (one updating a
 
1253
        persistent table) was killed on the master, then this real
 
1254
        update will be logged with error_code=killed, rightfully
 
1255
        causing the slave to stop.
 
1256
      */
 
1257
      qinfo.error_code= 0;
 
1258
      mysql_bin_log.write(&qinfo);
 
1259
      thd->variables.pseudo_thread_id= save_pseudo_thread_id;
 
1260
    }
 
1261
    else
 
1262
    {
 
1263
      next= table->next;
 
1264
      close_temporary(table, 1, 1);
 
1265
    }
 
1266
  }
 
1267
  if (!was_quote_show)
 
1268
    thd->options&= ~OPTION_QUOTE_SHOW_CREATE; /* restore option */
 
1269
  thd->temporary_tables=0;
398
1270
}
399
1271
 
400
1272
/*
401
1273
  Find table in list.
402
1274
 
403
1275
  SYNOPSIS
404
 
  find_table_in_list()
405
 
  table         Pointer to table list
406
 
  offset                Offset to which list in table structure to use
407
 
  db_name               Data base name
408
 
  table_name            Table name
409
 
 
410
 
NOTES:
411
 
This is called by find_table_in_global_list().
412
 
 
413
 
RETURN VALUES
414
 
NULL    Table not found
415
 
#               Pointer to found table.
 
1276
    find_table_in_list()
 
1277
    table               Pointer to table list
 
1278
    offset              Offset to which list in table structure to use
 
1279
    db_name             Data base name
 
1280
    table_name          Table name
 
1281
 
 
1282
  NOTES:
 
1283
    This is called by find_table_in_local_list() and
 
1284
    find_table_in_global_list().
 
1285
 
 
1286
  RETURN VALUES
 
1287
    NULL        Table not found
 
1288
    #           Pointer to found table.
416
1289
*/
417
1290
 
418
1291
TableList *find_table_in_list(TableList *table,
419
 
                              TableList *TableList::*link,
420
 
                              const char *db_name,
421
 
                              const char *table_name)
 
1292
                               TableList *TableList::*link,
 
1293
                               const char *db_name,
 
1294
                               const char *table_name)
422
1295
{
423
1296
  for (; table; table= table->*link )
424
1297
  {
425
 
    if ((table->table == 0 || table->table->getShare()->getType() == message::Table::STANDARD) &&
426
 
        strcasecmp(table->getSchemaName(), db_name) == 0 &&
427
 
        strcasecmp(table->getTableName(), table_name) == 0)
 
1298
    if ((table->table == 0 || table->table->s->tmp_table == NO_TMP_TABLE) &&
 
1299
        strcmp(table->db, db_name) == 0 &&
 
1300
        strcmp(table->table_name, table_name) == 0)
428
1301
      break;
429
1302
  }
430
1303
  return table;
435
1308
  Test that table is unique (It's only exists once in the table list)
436
1309
 
437
1310
  SYNOPSIS
438
 
  unique_table()
439
 
  session                   thread handle
440
 
  table                 table which should be checked
441
 
  table_list            list of tables
442
 
  check_alias           whether to check tables' aliases
443
 
 
444
 
NOTE: to exclude derived tables from check we use following mechanism:
445
 
a) during derived table processing set Session::derived_tables_processing
446
 
b) JOIN::prepare set SELECT::exclude_from_table_unique_test if
447
 
Session::derived_tables_processing set. (we can't use JOIN::execute
448
 
because for PS we perform only JOIN::prepare, but we can't set this
449
 
flag in JOIN::prepare if we are not sure that we are in derived table
450
 
processing loop, because multi-update call fix_fields() for some its
451
 
items (which mean JOIN::prepare for subqueries) before unique_table
452
 
call to detect which tables should be locked for write).
453
 
c) unique_table skip all tables which belong to SELECT with
454
 
SELECT::exclude_from_table_unique_test set.
455
 
Also SELECT::exclude_from_table_unique_test used to exclude from check
456
 
tables of main SELECT of multi-delete and multi-update
457
 
 
458
 
We also skip tables with TableList::prelocking_placeholder set,
459
 
because we want to allow SELECTs from them, and their modification
460
 
will rise the error anyway.
461
 
 
462
 
TODO: when we will have table/view change detection we can do this check
463
 
only once for PS/SP
464
 
 
465
 
RETURN
466
 
found duplicate
467
 
0 if table is unique
 
1311
    unique_table()
 
1312
    thd                   thread handle
 
1313
    table                 table which should be checked
 
1314
    table_list            list of tables
 
1315
    check_alias           whether to check tables' aliases
 
1316
 
 
1317
  NOTE: to exclude derived tables from check we use following mechanism:
 
1318
    a) during derived table processing set THD::derived_tables_processing
 
1319
    b) JOIN::prepare set SELECT::exclude_from_table_unique_test if
 
1320
       THD::derived_tables_processing set. (we can't use JOIN::execute
 
1321
       because for PS we perform only JOIN::prepare, but we can't set this
 
1322
       flag in JOIN::prepare if we are not sure that we are in derived table
 
1323
       processing loop, because multi-update call fix_fields() for some its
 
1324
       items (which mean JOIN::prepare for subqueries) before unique_table
 
1325
       call to detect which tables should be locked for write).
 
1326
    c) unique_table skip all tables which belong to SELECT with
 
1327
       SELECT::exclude_from_table_unique_test set.
 
1328
    Also SELECT::exclude_from_table_unique_test used to exclude from check
 
1329
    tables of main SELECT of multi-delete and multi-update
 
1330
 
 
1331
    We also skip tables with TableList::prelocking_placeholder set,
 
1332
    because we want to allow SELECTs from them, and their modification
 
1333
    will rise the error anyway.
 
1334
 
 
1335
    TODO: when we will have table/view change detection we can do this check
 
1336
          only once for PS/SP
 
1337
 
 
1338
  RETURN
 
1339
    found duplicate
 
1340
    0 if table is unique
468
1341
*/
469
1342
 
470
 
TableList* unique_table(TableList *table, TableList *table_list,
471
 
                        bool check_alias)
 
1343
TableList* unique_table(THD *thd, TableList *table, TableList *table_list,
 
1344
                         bool check_alias)
472
1345
{
473
1346
  TableList *res;
474
1347
  const char *d_name, *t_name, *t_alias;
486
1359
  if (table->table)
487
1360
  {
488
1361
    /* temporary table is always unique */
489
 
    if (table->table && table->table->getShare()->getType() != message::Table::STANDARD)
490
 
      return 0;
 
1362
    if (table->table && table->table->s->tmp_table != NO_TMP_TABLE)
 
1363
      return(0);
491
1364
    table= table->find_underlying_table(table->table);
492
1365
    /*
493
1366
      as far as we have table->table we have to find real TableList of
495
1368
    */
496
1369
    assert(table);
497
1370
  }
498
 
  d_name= table->getSchemaName();
499
 
  t_name= table->getTableName();
 
1371
  d_name= table->db;
 
1372
  t_name= table->table_name;
500
1373
  t_alias= table->alias;
501
1374
 
502
1375
  for (;;)
503
1376
  {
504
 
    if ((! (res= find_table_in_global_list(table_list, d_name, t_name))) ||
 
1377
    if (((! (res= find_table_in_global_list(table_list, d_name, t_name))) &&
 
1378
         (! (res= mysql_lock_have_duplicate(thd, table, table_list)))) ||
505
1379
        ((!res->table || res->table != table->table) &&
506
 
         (!check_alias || !(my_strcasecmp(files_charset_info, t_alias, res->alias))) &&
 
1380
         (!check_alias || !(lower_case_table_names ?
 
1381
          my_strcasecmp(files_charset_info, t_alias, res->alias) :
 
1382
          strcmp(t_alias, res->alias))) &&
507
1383
         res->select_lex && !res->select_lex->exclude_from_table_unique_test))
508
1384
      break;
509
1385
    /*
517
1393
}
518
1394
 
519
1395
 
520
 
void Open_tables_state::doGetTableNames(const SchemaIdentifier &schema_identifier,
521
 
                                        std::set<std::string>& set_of_names)
522
 
{
523
 
  for (Table *table= getTemporaryTables() ; table ; table= table->getNext())
524
 
  {
525
 
    if (schema_identifier.compare(table->getShare()->getSchemaName()))
526
 
    {
527
 
      set_of_names.insert(table->getShare()->getTableName());
528
 
    }
529
 
  }
530
 
}
531
 
 
532
 
void Open_tables_state::doGetTableNames(CachedDirectory &,
533
 
                                        const SchemaIdentifier &schema_identifier,
534
 
                                        std::set<std::string> &set_of_names)
535
 
{
536
 
  doGetTableNames(schema_identifier, set_of_names);
537
 
}
538
 
 
539
 
void Open_tables_state::doGetTableIdentifiers(const SchemaIdentifier &schema_identifier,
540
 
                                              TableIdentifier::vector &set_of_identifiers)
541
 
{
542
 
  for (Table *table= getTemporaryTables() ; table ; table= table->getNext())
543
 
  {
544
 
    if (schema_identifier.compare(table->getShare()->getSchemaName()))
545
 
    {
546
 
      set_of_identifiers.push_back(TableIdentifier(table->getShare()->getSchemaName(),
547
 
                                                   table->getShare()->getTableName(),
548
 
                                                   table->getShare()->getPath()));
549
 
    }
550
 
  }
551
 
}
552
 
 
553
 
void Open_tables_state::doGetTableIdentifiers(CachedDirectory &,
554
 
                                              const SchemaIdentifier &schema_identifier,
555
 
                                              TableIdentifier::vector &set_of_identifiers)
556
 
{
557
 
  doGetTableIdentifiers(schema_identifier, set_of_identifiers);
558
 
}
559
 
 
560
 
bool Open_tables_state::doDoesTableExist(const TableIdentifier &identifier)
561
 
{
562
 
  for (Table *table= getTemporaryTables() ; table ; table= table->getNext())
563
 
  {
564
 
    if (table->getShare()->getType() == message::Table::TEMPORARY)
565
 
    {
566
 
      if (identifier.getKey() == table->getShare()->getCacheKey())
567
 
      {
568
 
        return true;
569
 
      }
570
 
    }
571
 
  }
572
 
 
573
 
  return false;
574
 
}
575
 
 
576
 
int Open_tables_state::doGetTableDefinition(const TableIdentifier &identifier,
577
 
                                  message::Table &table_proto)
578
 
{
579
 
  for (Table *table= getTemporaryTables() ; table ; table= table->getNext())
580
 
  {
581
 
    if (table->getShare()->getType() == message::Table::TEMPORARY)
582
 
    {
583
 
      if (identifier.getKey() == table->getShare()->getCacheKey())
584
 
      {
585
 
        table_proto.CopyFrom(*(table->getShare()->getTableProto()));
586
 
 
587
 
        return EEXIST;
588
 
      }
589
 
    }
590
 
  }
591
 
 
592
 
  return ENOENT;
593
 
}
594
 
 
595
 
Table *Open_tables_state::find_temporary_table(const TableIdentifier &identifier)
596
 
{
597
 
  for (Table *table= temporary_tables ; table ; table= table->getNext())
598
 
  {
599
 
    if (identifier.getKey() == table->getShare()->getCacheKey())
600
 
      return table;
601
 
  }
602
 
 
603
 
  return NULL;                               // Not a temporary table
 
1396
/*
 
1397
  Issue correct error message in case we found 2 duplicate tables which
 
1398
  prevent some update operation
 
1399
 
 
1400
  SYNOPSIS
 
1401
    update_non_unique_table_error()
 
1402
    update      table which we try to update
 
1403
    operation   name of update operation
 
1404
    duplicate   duplicate table which we found
 
1405
 
 
1406
  NOTE:
 
1407
    here we hide view underlying tables if we have them
 
1408
*/
 
1409
 
 
1410
void update_non_unique_table_error(TableList *update,
 
1411
                                   const char *operation __attribute__((unused)),
 
1412
                                   TableList *duplicate __attribute__((unused)))
 
1413
{
 
1414
  my_error(ER_UPDATE_TABLE_USED, MYF(0), update->alias);
 
1415
}
 
1416
 
 
1417
 
 
1418
Table *find_temporary_table(THD *thd, const char *db, const char *table_name)
 
1419
{
 
1420
  TableList table_list;
 
1421
 
 
1422
  table_list.db= (char*) db;
 
1423
  table_list.table_name= (char*) table_name;
 
1424
  return find_temporary_table(thd, &table_list);
 
1425
}
 
1426
 
 
1427
 
 
1428
Table *find_temporary_table(THD *thd, TableList *table_list)
 
1429
{
 
1430
  char  key[MAX_DBKEY_LENGTH];
 
1431
  uint  key_length;
 
1432
  Table *table;
 
1433
 
 
1434
  key_length= create_table_def_key(thd, key, table_list, 1);
 
1435
  for (table=thd->temporary_tables ; table ; table= table->next)
 
1436
  {
 
1437
    if (table->s->table_cache_key.length == key_length &&
 
1438
        !memcmp(table->s->table_cache_key.str, key, key_length))
 
1439
      return(table);
 
1440
  }
 
1441
  return(0);                               // Not a temporary table
604
1442
}
605
1443
 
606
1444
 
607
1445
/**
608
1446
  Drop a temporary table.
609
1447
 
610
 
  Try to locate the table in the list of session->temporary_tables.
 
1448
  Try to locate the table in the list of thd->temporary_tables.
611
1449
  If the table is found:
612
 
  - if the table is being used by some outer statement, fail.
613
 
  - if the table is in session->locked_tables, unlock it and
614
 
  remove it from the list of locked tables. Currently only transactional
615
 
  temporary tables are present in the locked_tables list.
616
 
  - Close the temporary table, remove its .FRM
617
 
  - remove the table from the list of temporary tables
 
1450
   - if the table is being used by some outer statement, fail.
 
1451
   - if the table is in thd->locked_tables, unlock it and
 
1452
     remove it from the list of locked tables. Currently only transactional
 
1453
     temporary tables are present in the locked_tables list.
 
1454
   - Close the temporary table, remove its .FRM
 
1455
   - remove the table from the list of temporary tables
618
1456
 
619
1457
  This function is used to drop user temporary tables, as well as
620
1458
  internal tables created in CREATE TEMPORARY TABLE ... SELECT
621
1459
  or ALTER Table. Even though part of the work done by this function
622
1460
  is redundant when the table is internal, as long as we
623
1461
  link both internal and user temporary tables into the same
624
 
  session->temporary_tables list, it's impossible to tell here whether
 
1462
  thd->temporary_tables list, it's impossible to tell here whether
625
1463
  we're dealing with an internal or a user temporary table.
626
1464
 
627
1465
  @retval  0  the table was found and dropped successfully.
628
1466
  @retval  1  the table was not found in the list of temporary tables
629
 
  of this thread
 
1467
              of this thread
630
1468
  @retval -1  the table is in use by a outer query
631
1469
*/
632
1470
 
633
 
int Open_tables_state::drop_temporary_table(const drizzled::TableIdentifier &identifier)
 
1471
int drop_temporary_table(THD *thd, TableList *table_list)
634
1472
{
635
1473
  Table *table;
636
1474
 
637
 
  if (not (table= find_temporary_table(identifier)))
638
 
    return 1;
 
1475
  if (!(table= find_temporary_table(thd, table_list)))
 
1476
    return(1);
639
1477
 
640
1478
  /* Table might be in use by some outer statement. */
641
 
  if (table->query_id && table->query_id != getQueryId())
642
 
  {
643
 
    my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->getAlias());
644
 
    return -1;
645
 
  }
646
 
 
647
 
  close_temporary_table(table);
648
 
 
649
 
  return 0;
 
1479
  if (table->query_id && table->query_id != thd->query_id)
 
1480
  {
 
1481
    my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
 
1482
    return(-1);
 
1483
  }
 
1484
 
 
1485
  /*
 
1486
    If LOCK TABLES list is not empty and contains this table,
 
1487
    unlock the table and remove the table from this list.
 
1488
  */
 
1489
  mysql_lock_remove(thd, thd->locked_tables, table, false);
 
1490
  close_temporary_table(thd, table, 1, 1);
 
1491
  return(0);
 
1492
}
 
1493
 
 
1494
/*
 
1495
  unlink from thd->temporary tables and close temporary table
 
1496
*/
 
1497
 
 
1498
void close_temporary_table(THD *thd, Table *table,
 
1499
                           bool free_share, bool delete_table)
 
1500
{
 
1501
  if (table->prev)
 
1502
  {
 
1503
    table->prev->next= table->next;
 
1504
    if (table->prev->next)
 
1505
      table->next->prev= table->prev;
 
1506
  }
 
1507
  else
 
1508
  {
 
1509
    /* removing the item from the list */
 
1510
    assert(table == thd->temporary_tables);
 
1511
    /*
 
1512
      slave must reset its temporary list pointer to zero to exclude
 
1513
      passing non-zero value to end_slave via rli->save_temporary_tables
 
1514
      when no temp tables opened, see an invariant below.
 
1515
    */
 
1516
    thd->temporary_tables= table->next;
 
1517
    if (thd->temporary_tables)
 
1518
      table->next->prev= 0;
 
1519
  }
 
1520
  if (thd->slave_thread)
 
1521
  {
 
1522
    /* natural invariant of temporary_tables */
 
1523
    assert(slave_open_temp_tables || !thd->temporary_tables);
 
1524
    slave_open_temp_tables--;
 
1525
  }
 
1526
  close_temporary(table, free_share, delete_table);
 
1527
  return;
 
1528
}
 
1529
 
 
1530
 
 
1531
/*
 
1532
  Close and delete a temporary table
 
1533
 
 
1534
  NOTE
 
1535
    This dosn't unlink table from thd->temporary
 
1536
    If this is needed, use close_temporary_table()
 
1537
*/
 
1538
 
 
1539
void close_temporary(Table *table, bool free_share, bool delete_table)
 
1540
{
 
1541
  handlerton *table_type= table->s->db_type();
 
1542
 
 
1543
  free_io_cache(table);
 
1544
  closefrm(table, 0);
 
1545
  /*
 
1546
     Check that temporary table has not been created with
 
1547
     frm_only because it has then not been created in any storage engine
 
1548
   */
 
1549
  if (delete_table)
 
1550
    rm_temporary_table(table_type, table->s->path.str, 
 
1551
                       table->s->tmp_table == TMP_TABLE_FRM_FILE_ONLY);
 
1552
  if (free_share)
 
1553
  {
 
1554
    free_table_share(table->s);
 
1555
    my_free((char*) table,MYF(0));
 
1556
  }
 
1557
  return;
 
1558
}
 
1559
 
 
1560
 
 
1561
/*
 
1562
  Used by ALTER Table when the table is a temporary one. It changes something
 
1563
  only if the ALTER contained a RENAME clause (otherwise, table_name is the old
 
1564
  name).
 
1565
  Prepares a table cache key, which is the concatenation of db, table_name and
 
1566
  thd->slave_proxy_id, separated by '\0'.
 
1567
*/
 
1568
 
 
1569
bool rename_temporary_table(THD* thd, Table *table, const char *db,
 
1570
                            const char *table_name)
 
1571
{
 
1572
  char *key;
 
1573
  uint key_length;
 
1574
  TABLE_SHARE *share= table->s;
 
1575
  TableList table_list;
 
1576
 
 
1577
  if (!(key=(char*) alloc_root(&share->mem_root, MAX_DBKEY_LENGTH)))
 
1578
    return(1);                          /* purecov: inspected */
 
1579
 
 
1580
  table_list.db= (char*) db;
 
1581
  table_list.table_name= (char*) table_name;
 
1582
  key_length= create_table_def_key(thd, key, &table_list, 1);
 
1583
  share->set_table_cache_key(key, key_length);
 
1584
  return(0);
 
1585
}
 
1586
 
 
1587
 
 
1588
        /* move table first in unused links */
 
1589
 
 
1590
static void relink_unused(Table *table)
 
1591
{
 
1592
  if (table != unused_tables)
 
1593
  {
 
1594
    table->prev->next=table->next;              /* Remove from unused list */
 
1595
    table->next->prev=table->prev;
 
1596
    table->next=unused_tables;                  /* Link in unused tables */
 
1597
    table->prev=unused_tables->prev;
 
1598
    unused_tables->prev->next=table;
 
1599
    unused_tables->prev=table;
 
1600
    unused_tables=table;
 
1601
  }
650
1602
}
651
1603
 
652
1604
 
653
1605
/**
654
 
  Remove all instances of table from thread's open list and
655
 
  table cache.
656
 
 
657
 
  @param  session     Thread context
658
 
  @param  find    Table to remove
659
 
 
660
 
  @note because we risk the chance of deleting the share, we can't assume that it will exist past, this should be modified once we can use a TableShare::shared_ptr here.
 
1606
    Remove all instances of table from thread's open list and
 
1607
    table cache.
 
1608
 
 
1609
    @param  thd     Thread context
 
1610
    @param  find    Table to remove
 
1611
    @param  unlock  true  - free all locks on tables removed that are
 
1612
                            done with LOCK TABLES
 
1613
                    false - otherwise
 
1614
 
 
1615
    @note When unlock parameter is false or current thread doesn't have
 
1616
          any tables locked with LOCK TABLES, tables are assumed to be
 
1617
          not locked (for example already unlocked).
661
1618
*/
662
1619
 
663
 
void Session::unlink_open_table(Table *find)
 
1620
void unlink_open_table(THD *thd, Table *find, bool unlock)
664
1621
{
665
 
  const TableIdentifier::Key find_key(find->getShare()->getCacheKey());
666
 
  Table **prev;
667
 
  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());
668
 
 
 
1622
  char key[MAX_DBKEY_LENGTH];
 
1623
  uint key_length= find->s->table_cache_key.length;
 
1624
  Table *list, **prev;
 
1625
 
 
1626
  safe_mutex_assert_owner(&LOCK_open);
 
1627
 
 
1628
  memcpy(key, find->s->table_cache_key.str, key_length);
669
1629
  /*
670
 
    Note that we need to hold table::Cache::singleton().mutex() while changing the
 
1630
    Note that we need to hold LOCK_open while changing the
671
1631
    open_tables list. Another thread may work on it.
672
 
    (See: table::Cache::singleton().removeTable(), mysql_wait_completed_table())
 
1632
    (See: remove_table_from_cache(), mysql_wait_completed_table())
673
1633
    Closing a MERGE child before the parent would be fatal if the
674
1634
    other thread tries to abort the MERGE lock in between.
675
1635
  */
676
 
  for (prev= &open_tables; *prev; )
 
1636
  for (prev= &thd->open_tables; *prev; )
677
1637
  {
678
 
    Table *list= *prev;
 
1638
    list= *prev;
679
1639
 
680
 
    if (list->getShare()->getCacheKey() == find_key)
 
1640
    if (list->s->table_cache_key.length == key_length &&
 
1641
        !memcmp(list->s->table_cache_key.str, key, key_length))
681
1642
    {
 
1643
      if (unlock && thd->locked_tables)
 
1644
        mysql_lock_remove(thd, thd->locked_tables, list, true);
 
1645
 
682
1646
      /* Remove table from open_tables list. */
683
 
      *prev= list->getNext();
684
 
 
 
1647
      *prev= list->next;
685
1648
      /* Close table. */
686
 
      table::remove_table(static_cast<table::Concurrent *>(list));
 
1649
      VOID(hash_delete(&open_cache,(uchar*) list)); // Close table
687
1650
    }
688
1651
    else
689
1652
    {
690
1653
      /* Step to next entry in open_tables list. */
691
 
      prev= list->getNextPtr();
 
1654
      prev= &list->next;
692
1655
    }
693
1656
  }
694
1657
 
695
1658
  // Notify any 'refresh' threads
696
 
  locking::broadcast_refresh();
 
1659
  broadcast_refresh();
 
1660
  return;
697
1661
}
698
1662
 
699
1663
 
700
1664
/**
701
 
  Auxiliary routine which closes and drops open table.
702
 
 
703
 
  @param  session         Thread handle
704
 
  @param  table       Table object for table to be dropped
705
 
  @param  db_name     Name of database for this table
706
 
  @param  table_name  Name of this table
707
 
 
708
 
  @note This routine assumes that table to be closed is open only
709
 
  by calling thread so we needn't wait until other threads
710
 
  will close the table. Also unless called under implicit or
711
 
  explicit LOCK TABLES mode it assumes that table to be
712
 
  dropped is already unlocked. In the former case it will
713
 
  also remove lock on the table. But one should not rely on
714
 
  this behaviour as it may change in future.
715
 
  Currently, however, this function is never called for a
716
 
  table that was locked with LOCK TABLES.
 
1665
    Auxiliary routine which closes and drops open table.
 
1666
 
 
1667
    @param  thd         Thread handle
 
1668
    @param  table       Table object for table to be dropped
 
1669
    @param  db_name     Name of database for this table
 
1670
    @param  table_name  Name of this table
 
1671
 
 
1672
    @note This routine assumes that table to be closed is open only
 
1673
          by calling thread so we needn't wait until other threads
 
1674
          will close the table. Also unless called under implicit or
 
1675
          explicit LOCK TABLES mode it assumes that table to be
 
1676
          dropped is already unlocked. In the former case it will
 
1677
          also remove lock on the table. But one should not rely on
 
1678
          this behaviour as it may change in future.
 
1679
          Currently, however, this function is never called for a
 
1680
          table that was locked with LOCK TABLES.
717
1681
*/
718
1682
 
719
 
void Session::drop_open_table(Table *table, const TableIdentifier &identifier)
 
1683
void drop_open_table(THD *thd, Table *table, const char *db_name,
 
1684
                     const char *table_name)
720
1685
{
721
 
  if (table->getShare()->getType())
722
 
  {
723
 
    close_temporary_table(table);
724
 
  }
 
1686
  if (table->s->tmp_table)
 
1687
    close_temporary_table(thd, table, 1, 1);
725
1688
  else
726
1689
  {
727
 
    boost_unique_lock_t scoped_lock(table::Cache::singleton().mutex()); /* Close and drop a table (AUX routine) */
 
1690
    handlerton *table_type= table->s->db_type();
 
1691
    VOID(pthread_mutex_lock(&LOCK_open));
728
1692
    /*
729
1693
      unlink_open_table() also tells threads waiting for refresh or close
730
1694
      that something has happened.
731
1695
    */
732
 
    unlink_open_table(table);
733
 
    plugin::StorageEngine::dropTable(*this, identifier);
 
1696
    unlink_open_table(thd, table, false);
 
1697
    quick_rm_table(table_type, db_name, table_name, 0);
 
1698
    VOID(pthread_mutex_unlock(&LOCK_open));
734
1699
  }
735
1700
}
736
1701
 
737
1702
 
738
1703
/*
739
 
  Wait for condition but allow the user to send a kill to mysqld
 
1704
   Wait for condition but allow the user to send a kill to mysqld
740
1705
 
741
 
  SYNOPSIS
742
 
  wait_for_condition()
743
 
  session       Thread Cursor
744
 
  mutex mutex that is currently hold that is associated with condition
745
 
  Will be unlocked on return
746
 
  cond  Condition to wait for
 
1706
   SYNOPSIS
 
1707
     wait_for_condition()
 
1708
     thd        Thread handler
 
1709
     mutex      mutex that is currently hold that is associated with condition
 
1710
                Will be unlocked on return     
 
1711
     cond       Condition to wait for
747
1712
*/
748
1713
 
749
 
void Session::wait_for_condition(boost::mutex &mutex, boost::condition_variable_any &cond)
 
1714
void wait_for_condition(THD *thd, pthread_mutex_t *mutex, pthread_cond_t *cond)
750
1715
{
751
1716
  /* Wait until the current table is up to date */
752
 
  const char *saved_proc_info;
753
 
  mysys_var->current_mutex= &mutex;
754
 
  mysys_var->current_cond= &cond;
755
 
  saved_proc_info= get_proc_info();
756
 
  set_proc_info("Waiting for table");
757
 
  {
758
 
    /*
759
 
      We must unlock mutex first to avoid deadlock becasue conditions are
760
 
      sent to this thread by doing locks in the following order:
761
 
      lock(mysys_var->mutex)
762
 
      lock(mysys_var->current_mutex)
763
 
 
764
 
      One by effect of this that one can only use wait_for_condition with
765
 
      condition variables that are guranteed to not disapper (freed) even if this
766
 
      mutex is unlocked
767
 
    */
768
 
    boost_unique_lock_t scopedLock(mutex, boost::adopt_lock_t());
769
 
    if (not getKilled())
770
 
    {
771
 
      cond.wait(scopedLock);
772
 
    }
773
 
  }
774
 
  boost_unique_lock_t mysys_scopedLock(mysys_var->mutex);
775
 
  mysys_var->current_mutex= 0;
776
 
  mysys_var->current_cond= 0;
777
 
  set_proc_info(saved_proc_info);
778
 
}
779
 
 
780
 
 
781
 
/**
782
 
  Create and insert into table cache placeholder for table
783
 
  which will prevent its opening (or creation) (a.k.a lock
784
 
  table name).
785
 
 
786
 
  @param session         Thread context
787
 
  @param key         Table cache key for name to be locked
788
 
  @param key_length  Table cache key length
789
 
 
790
 
  @return Pointer to Table object used for name locking or 0 in
791
 
  case of failure.
792
 
*/
793
 
 
794
 
table::Placeholder *Session::table_cache_insert_placeholder(const drizzled::TableIdentifier &arg)
795
 
{
796
 
  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());
 
1717
  const char *proc_info;
 
1718
  thd->mysys_var->current_mutex= mutex;
 
1719
  thd->mysys_var->current_cond= cond;
 
1720
  proc_info=thd->get_proc_info();
 
1721
  thd_proc_info(thd, "Waiting for table");
 
1722
  if (!thd->killed)
 
1723
    (void) pthread_cond_wait(cond, mutex);
 
1724
 
 
1725
  /*
 
1726
    We must unlock mutex first to avoid deadlock becasue conditions are
 
1727
    sent to this thread by doing locks in the following order:
 
1728
    lock(mysys_var->mutex)
 
1729
    lock(mysys_var->current_mutex)
 
1730
 
 
1731
    One by effect of this that one can only use wait_for_condition with
 
1732
    condition variables that are guranteed to not disapper (freed) even if this
 
1733
    mutex is unlocked
 
1734
  */
 
1735
    
 
1736
  pthread_mutex_unlock(mutex);
 
1737
  pthread_mutex_lock(&thd->mysys_var->mutex);
 
1738
  thd->mysys_var->current_mutex= 0;
 
1739
  thd->mysys_var->current_cond= 0;
 
1740
  thd_proc_info(thd, proc_info);
 
1741
  pthread_mutex_unlock(&thd->mysys_var->mutex);
 
1742
  return;
 
1743
}
 
1744
 
 
1745
 
 
1746
/**
 
1747
  Exclusively name-lock a table that is already write-locked by the
 
1748
  current thread.
 
1749
 
 
1750
  @param thd current thread context
 
1751
  @param tables table list containing one table to open.
 
1752
 
 
1753
  @return false on success, true otherwise.
 
1754
*/
 
1755
 
 
1756
bool name_lock_locked_table(THD *thd, TableList *tables)
 
1757
{
 
1758
  /* Under LOCK TABLES we must only accept write locked tables. */
 
1759
  tables->table= find_locked_table(thd, tables->db, tables->table_name);
 
1760
 
 
1761
  if (!tables->table)
 
1762
    my_error(ER_TABLE_NOT_LOCKED, MYF(0), tables->alias);
 
1763
  else if (tables->table->reginfo.lock_type < TL_WRITE_LOW_PRIORITY)
 
1764
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0), tables->alias);
 
1765
  else
 
1766
  {
 
1767
    /*
 
1768
      Ensures that table is opened only by this thread and that no
 
1769
      other statement will open this table.
 
1770
    */
 
1771
    wait_while_table_is_used(thd, tables->table, HA_EXTRA_FORCE_REOPEN);
 
1772
    return(false);
 
1773
  }
 
1774
 
 
1775
  return(true);
 
1776
}
 
1777
 
 
1778
 
 
1779
/*
 
1780
  Open table which is already name-locked by this thread.
 
1781
 
 
1782
  SYNOPSIS
 
1783
    reopen_name_locked_table()
 
1784
      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
 
1787
                  name-locking.
 
1788
      link_in     true  - if Table object for table to be opened should be
 
1789
                          linked into THD::open_tables list.
 
1790
                  false - placeholder used for name-locking is already in
 
1791
                          this list so we only need to preserve Table::next
 
1792
                          pointer.
 
1793
 
 
1794
  NOTE
 
1795
    This function assumes that its caller already acquired LOCK_open mutex.
 
1796
 
 
1797
  RETURN VALUE
 
1798
    false - Success
 
1799
    true  - Error
 
1800
*/
 
1801
 
 
1802
bool reopen_name_locked_table(THD* thd, TableList* table_list, bool link_in)
 
1803
{
 
1804
  Table *table= table_list->table;
 
1805
  TABLE_SHARE *share;
 
1806
  char *table_name= table_list->table_name;
 
1807
  Table orig_table;
 
1808
 
 
1809
  safe_mutex_assert_owner(&LOCK_open);
 
1810
 
 
1811
  if (thd->killed || !table)
 
1812
    return(true);
 
1813
 
 
1814
  orig_table= *table;
 
1815
 
 
1816
  if (open_unireg_entry(thd, table, table_list, table_name,
 
1817
                        table->s->table_cache_key.str,
 
1818
                        table->s->table_cache_key.length))
 
1819
  {
 
1820
    intern_close_table(table);
 
1821
    /*
 
1822
      If there was an error during opening of table (for example if it
 
1823
      does not exist) '*table' object can be wiped out. To be able
 
1824
      properly release name-lock in this case we should restore this
 
1825
      object to its original state.
 
1826
    */
 
1827
    *table= orig_table;
 
1828
    return(true);
 
1829
  }
 
1830
 
 
1831
  share= table->s;
 
1832
  /*
 
1833
    We want to prevent other connections from opening this table until end
 
1834
    of statement as it is likely that modifications of table's metadata are
 
1835
    not yet finished (for example CREATE TRIGGER have to change .TRG file,
 
1836
    or we might want to drop table if CREATE TABLE ... SELECT fails).
 
1837
    This also allows us to assume that no other connection will sneak in
 
1838
    before we will get table-level lock on this table.
 
1839
  */
 
1840
  share->version=0;
 
1841
  table->in_use = thd;
 
1842
 
 
1843
  if (link_in)
 
1844
  {
 
1845
    table->next= thd->open_tables;
 
1846
    thd->open_tables= table;
 
1847
  }
 
1848
  else
 
1849
  {
 
1850
    /*
 
1851
      Table object should be already in THD::open_tables list so we just
 
1852
      need to set Table::next correctly.
 
1853
    */
 
1854
    table->next= orig_table.next;
 
1855
  }
 
1856
 
 
1857
  table->tablenr=thd->current_tablenr++;
 
1858
  table->used_fields=0;
 
1859
  table->const_table=0;
 
1860
  table->null_row= false;
 
1861
  table->maybe_null= false;
 
1862
  table->force_index= false;
 
1863
  table->status=STATUS_NO_RECORD;
 
1864
  return false;
 
1865
}
 
1866
 
 
1867
 
 
1868
/**
 
1869
    Create and insert into table cache placeholder for table
 
1870
    which will prevent its opening (or creation) (a.k.a lock
 
1871
    table name).
 
1872
 
 
1873
    @param thd         Thread context
 
1874
    @param key         Table cache key for name to be locked
 
1875
    @param key_length  Table cache key length
 
1876
 
 
1877
    @return Pointer to Table object used for name locking or 0 in
 
1878
            case of failure.
 
1879
*/
 
1880
 
 
1881
Table *table_cache_insert_placeholder(THD *thd, const char *key,
 
1882
                                      uint key_length)
 
1883
{
 
1884
  Table *table;
 
1885
  TABLE_SHARE *share;
 
1886
  char *key_buff;
 
1887
 
 
1888
  safe_mutex_assert_owner(&LOCK_open);
797
1889
 
798
1890
  /*
799
1891
    Create a table entry with the right key and with an old refresh version
 
1892
    Note that we must use my_multi_malloc() here as this is freed by the
 
1893
    table cache
800
1894
  */
801
 
  TableIdentifier identifier(arg.getSchemaName(), arg.getTableName(), message::Table::INTERNAL);
802
 
  table::Placeholder *table= new table::Placeholder(this, identifier);
803
 
 
804
 
  if (not table::Cache::singleton().insert(table))
 
1895
  if (!my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
 
1896
                       &table, sizeof(*table),
 
1897
                       &share, sizeof(*share),
 
1898
                       &key_buff, key_length,
 
1899
                       NULL))
 
1900
    return(NULL);
 
1901
 
 
1902
  table->s= share;
 
1903
  share->set_table_cache_key(key_buff, key, key_length);
 
1904
  share->tmp_table= INTERNAL_TMP_TABLE;  // for intern_close_table
 
1905
  table->in_use= thd;
 
1906
  table->locked_by_name=1;
 
1907
 
 
1908
  if (my_hash_insert(&open_cache, (uchar*)table))
805
1909
  {
806
 
    delete table;
807
 
 
808
 
    return NULL;
 
1910
    my_free((uchar*) table, MYF(0));
 
1911
    return(NULL);
809
1912
  }
810
1913
 
811
 
  return table;
 
1914
  return(table);
812
1915
}
813
1916
 
814
1917
 
815
1918
/**
816
 
  Obtain an exclusive name lock on the table if it is not cached
817
 
  in the table cache.
818
 
 
819
 
  @param      session         Thread context
820
 
  @param      db          Name of database
821
 
  @param      table_name  Name of table
822
 
  @param[out] table       Out parameter which is either:
823
 
  - set to NULL if table cache contains record for
824
 
  the table or
825
 
  - set to point to the Table instance used for
826
 
  name-locking.
827
 
 
828
 
  @note This function takes into account all records for table in table
829
 
  cache, even placeholders used for name-locking. This means that
830
 
  'table' parameter can be set to NULL for some situations when
831
 
  table does not really exist.
832
 
 
833
 
  @retval  true   Error occured (OOM)
834
 
  @retval  false  Success. 'table' parameter set according to above rules.
 
1919
    Obtain an exclusive name lock on the table if it is not cached
 
1920
    in the table cache.
 
1921
 
 
1922
    @param      thd         Thread context
 
1923
    @param      db          Name of database
 
1924
    @param      table_name  Name of table
 
1925
    @param[out] table       Out parameter which is either:
 
1926
                            - set to NULL if table cache contains record for
 
1927
                              the table or
 
1928
                            - set to point to the Table instance used for
 
1929
                              name-locking.
 
1930
 
 
1931
    @note This function takes into account all records for table in table
 
1932
          cache, even placeholders used for name-locking. This means that
 
1933
          'table' parameter can be set to NULL for some situations when
 
1934
          table does not really exist.
 
1935
 
 
1936
    @retval  true   Error occured (OOM)
 
1937
    @retval  false  Success. 'table' parameter set according to above rules.
835
1938
*/
836
 
bool Session::lock_table_name_if_not_cached(const TableIdentifier &identifier, Table **table)
 
1939
 
 
1940
bool lock_table_name_if_not_cached(THD *thd, const char *db,
 
1941
                                   const char *table_name, Table **table)
837
1942
{
838
 
  const TableIdentifier::Key &key(identifier.getKey());
839
 
 
840
 
  boost_unique_lock_t scope_lock(table::Cache::singleton().mutex()); /* Obtain a name lock even though table is not in cache (like for create table)  */
841
 
 
842
 
  table::CacheMap::iterator iter;
843
 
 
844
 
  iter= table::getCache().find(key);
845
 
 
846
 
  if (iter != table::getCache().end())
 
1943
  char key[MAX_DBKEY_LENGTH];
 
1944
  uint key_length;
 
1945
 
 
1946
  key_length= (uint)(stpcpy(stpcpy(key, db) + 1, table_name) - key) + 1;
 
1947
  VOID(pthread_mutex_lock(&LOCK_open));
 
1948
 
 
1949
  if (hash_search(&open_cache, (uchar *)key, key_length))
847
1950
  {
 
1951
    VOID(pthread_mutex_unlock(&LOCK_open));
848
1952
    *table= 0;
849
 
    return false;
850
 
  }
851
 
 
852
 
  if (not (*table= table_cache_insert_placeholder(identifier)))
853
 
  {
854
 
    return true;
855
 
  }
856
 
  (*table)->open_placeholder= true;
857
 
  (*table)->setNext(open_tables);
858
 
  open_tables= *table;
859
 
 
860
 
  return false;
861
 
}
 
1953
    return(false);
 
1954
  }
 
1955
  if (!(*table= table_cache_insert_placeholder(thd, key, key_length)))
 
1956
  {
 
1957
    VOID(pthread_mutex_unlock(&LOCK_open));
 
1958
    return(true);
 
1959
  }
 
1960
  (*table)->open_placeholder= 1;
 
1961
  (*table)->next= thd->open_tables;
 
1962
  thd->open_tables= *table;
 
1963
  VOID(pthread_mutex_unlock(&LOCK_open));
 
1964
  return(false);
 
1965
}
 
1966
 
 
1967
 
 
1968
/**
 
1969
    Check that table exists in table definition cache, on disk
 
1970
    or in some storage engine.
 
1971
 
 
1972
    @param       thd     Thread context
 
1973
    @param       table   Table list element
 
1974
    @param[out]  exists  Out parameter which is set to true if table
 
1975
                         exists and to false otherwise.
 
1976
 
 
1977
    @note This function assumes that caller owns LOCK_open mutex.
 
1978
          It also assumes that the fact that there are no name-locks
 
1979
          on the table was checked beforehand.
 
1980
 
 
1981
    @note If there is no .FRM file for the table but it exists in one
 
1982
          of engines (e.g. it was created on another node of NDB cluster)
 
1983
          this function will fetch and create proper .FRM file for it.
 
1984
 
 
1985
    @retval  true   Some error occured
 
1986
    @retval  false  No error. 'exists' out parameter set accordingly.
 
1987
*/
 
1988
 
 
1989
bool check_if_table_exists(THD *thd, TableList *table, bool *exists)
 
1990
{
 
1991
  char path[FN_REFLEN];
 
1992
  int rc;
 
1993
 
 
1994
  safe_mutex_assert_owner(&LOCK_open);
 
1995
 
 
1996
  *exists= true;
 
1997
 
 
1998
  if (get_cached_table_share(table->db, table->table_name))
 
1999
    return(false);
 
2000
 
 
2001
  build_table_filename(path, sizeof(path) - 1, table->db, table->table_name,
 
2002
                       reg_ext, 0);
 
2003
 
 
2004
  if (!access(path, F_OK))
 
2005
    return(false);
 
2006
 
 
2007
  /* .FRM file doesn't exist. Check if some engine can provide it. */
 
2008
 
 
2009
  rc= ha_create_table_from_engine(thd, table->db, table->table_name);
 
2010
 
 
2011
  if (rc < 0)
 
2012
  {
 
2013
    /* Table does not exists in engines as well. */
 
2014
    *exists= false;
 
2015
    return(false);
 
2016
  }
 
2017
  else if (!rc)
 
2018
  {
 
2019
    /* Table exists in some engine and .FRM for it was created. */
 
2020
    return(false);
 
2021
  }
 
2022
  else /* (rc > 0) */
 
2023
  {
 
2024
    my_printf_error(ER_UNKNOWN_ERROR, "Failed to open '%-.64s', error while "
 
2025
                    "unpacking from engine", MYF(0), table->table_name);
 
2026
    return(true);
 
2027
  }
 
2028
}
 
2029
 
862
2030
 
863
2031
/*
864
2032
  Open a table.
865
2033
 
866
2034
  SYNOPSIS
867
 
  open_table()
868
 
  session                 Thread context.
869
 
  table_list          Open first table in list.
870
 
  refresh      INOUT  Pointer to memory that will be set to 1 if
871
 
  we need to close all tables and reopen them.
872
 
  If this is a NULL pointer, then the table is not
873
 
  put in the thread-open-list.
874
 
  flags               Bitmap of flags to modify how open works:
875
 
  DRIZZLE_LOCK_IGNORE_FLUSH - Open table even if
876
 
  someone has done a flush or namelock on it.
877
 
  No version number checking is done.
878
 
  DRIZZLE_OPEN_TEMPORARY_ONLY - Open only temporary
879
 
  table not the base table or view.
 
2035
    open_table()
 
2036
    thd                 Thread context.
 
2037
    table_list          Open first table in list.
 
2038
    refresh      INOUT  Pointer to memory that will be set to 1 if
 
2039
                        we need to close all tables and reopen them.
 
2040
                        If this is a NULL pointer, then the table is not
 
2041
                        put in the thread-open-list.
 
2042
    flags               Bitmap of flags to modify how open works:
 
2043
                          DRIZZLE_LOCK_IGNORE_FLUSH - Open table even if
 
2044
                          someone has done a flush or namelock on it.
 
2045
                          No version number checking is done.
 
2046
                          DRIZZLE_OPEN_TEMPORARY_ONLY - Open only temporary
 
2047
                          table not the base table or view.
880
2048
 
881
2049
  IMPLEMENTATION
882
 
  Uses a cache of open tables to find a table not in use.
 
2050
    Uses a cache of open tables to find a table not in use.
883
2051
 
884
 
  If table list element for the table to be opened has "create" flag
885
 
  set and table does not exist, this function will automatically insert
886
 
  a placeholder for exclusive name lock into the open tables cache and
887
 
  will return the Table instance that corresponds to this placeholder.
 
2052
    If table list element for the table to be opened has "create" flag
 
2053
    set and table does not exist, this function will automatically insert
 
2054
    a placeholder for exclusive name lock into the open tables cache and
 
2055
    will return the Table instance that corresponds to this placeholder.
888
2056
 
889
2057
  RETURN
890
 
  NULL  Open failed.  If refresh is set then one should close
891
 
  all other tables and retry the open.
892
 
#     Success. Pointer to Table object for open table.
 
2058
    NULL  Open failed.  If refresh is set then one should close
 
2059
          all other tables and retry the open.
 
2060
    #     Success. Pointer to Table object for open table.
893
2061
*/
894
2062
 
895
2063
 
896
 
Table *Session::openTable(TableList *table_list, bool *refresh, uint32_t flags)
 
2064
Table *open_table(THD *thd, TableList *table_list, bool *refresh, uint flags)
897
2065
{
898
 
  Table *table;
899
 
  const char *alias= table_list->alias;
 
2066
  register Table *table;
 
2067
  char key[MAX_DBKEY_LENGTH];
 
2068
  unsigned int key_length;
 
2069
  char *alias= table_list->alias;
 
2070
  HASH_SEARCH_STATE state;
900
2071
 
901
 
  /* Parsing of partitioning information from .frm needs session->lex set up. */
902
 
  assert(lex->is_lex_started);
 
2072
  /* Parsing of partitioning information from .frm needs thd->lex set up. */
 
2073
  assert(thd->lex->is_lex_started);
903
2074
 
904
2075
  /* find a unused table in the open table cache */
905
2076
  if (refresh)
906
 
    *refresh= false;
 
2077
    *refresh=0;
907
2078
 
908
2079
  /* an open table operation needs a lot of the stack space */
909
 
  if (check_stack_overrun(this, STACK_MIN_SIZE_FOR_OPEN, (unsigned char *)&alias))
910
 
    return NULL;
911
 
 
912
 
  if (getKilled())
913
 
    return NULL;
914
 
 
915
 
  TableIdentifier identifier(table_list->getSchemaName(), table_list->getTableName());
916
 
  const TableIdentifier::Key &key(identifier.getKey());
917
 
  table::CacheRange ppp;
 
2080
  if (check_stack_overrun(thd, STACK_MIN_SIZE_FOR_OPEN, (uchar *)&alias))
 
2081
    return(0);
 
2082
 
 
2083
  if (thd->killed)
 
2084
    return(0);
 
2085
 
 
2086
  key_length= (create_table_def_key(thd, key, table_list, 1) -
 
2087
               TMP_TABLE_KEY_EXTRA);
918
2088
 
919
2089
  /*
920
2090
    Unless requested otherwise, try to resolve this table in the list
921
2091
    of temporary tables of this thread. In MySQL temporary tables
922
2092
    are always thread-local and "shadow" possible base tables with the
923
2093
    same name. This block implements the behaviour.
924
 
    TODO -> move this block into a separate function.
 
2094
    TODO: move this block into a separate function.
925
2095
  */
926
 
  bool reset= false;
927
 
  for (table= getTemporaryTables(); table ; table=table->getNext())
928
 
  {
929
 
    if (table->getShare()->getCacheKey() == key)
930
 
    {
931
 
      /*
932
 
        We're trying to use the same temporary table twice in a query.
933
 
        Right now we don't support this because a temporary table
934
 
        is always represented by only one Table object in Session, and
935
 
        it can not be cloned. Emit an error for an unsupported behaviour.
936
 
      */
937
 
      if (table->query_id)
938
 
      {
939
 
        my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->getAlias());
940
 
        return NULL;
941
 
      }
942
 
      table->query_id= getQueryId();
943
 
      reset= true;
944
 
      break;
945
 
    }
946
 
  }
947
 
 
948
 
  if (not reset)
949
 
  {
950
 
    if (flags & DRIZZLE_OPEN_TEMPORARY_ONLY)
951
 
    {
952
 
      my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->getSchemaName(), table_list->getTableName());
953
 
      return NULL;
954
 
    }
955
 
 
956
 
    /*
957
 
      If it's the first table from a list of tables used in a query,
958
 
      remember refresh_version (the version of open_cache state).
959
 
      If the version changes while we're opening the remaining tables,
960
 
      we will have to back off, close all the tables opened-so-far,
961
 
      and try to reopen them.
962
 
 
963
 
      Note-> refresh_version is currently changed only during FLUSH TABLES.
964
 
    */
965
 
    if (!open_tables)
966
 
    {
967
 
      version= refresh_version;
968
 
    }
969
 
    else if ((version != refresh_version) &&
970
 
             ! (flags & DRIZZLE_LOCK_IGNORE_FLUSH))
971
 
    {
972
 
      /* Someone did a refresh while thread was opening tables */
973
 
      if (refresh)
974
 
        *refresh= true;
975
 
 
976
 
      return NULL;
977
 
    }
978
 
 
979
 
    /*
980
 
      Before we test the global cache, we test our local session cache.
981
 
    */
982
 
    if (cached_table)
983
 
    {
984
 
      assert(false); /* Not implemented yet */
985
 
    }
986
 
 
987
 
    /*
988
 
      Non pre-locked/LOCK TABLES mode, and the table is not temporary:
989
 
      this is the normal use case.
990
 
      Now we should:
991
 
      - try to find the table in the table cache.
992
 
      - if one of the discovered Table instances is name-locked
993
 
      (table->getShare()->version == 0) back off -- we have to wait
994
 
      until no one holds a name lock on the table.
995
 
      - if there is no such Table in the name cache, read the table definition
996
 
      and insert it into the cache.
997
 
      We perform all of the above under table::Cache::singleton().mutex() which currently protects
998
 
      the open cache (also known as table cache) and table definitions stored
999
 
      on disk.
1000
 
    */
1001
 
 
1002
 
    {
1003
 
      table::Cache::singleton().mutex().lock(); /* Lock for FLUSH TABLES for open table */
1004
 
 
1005
 
      /*
1006
 
        Actually try to find the table in the open_cache.
1007
 
        The cache may contain several "Table" instances for the same
1008
 
        physical table. The instances that are currently "in use" by
1009
 
        some thread have their "in_use" member != NULL.
1010
 
        There is no good reason for having more than one entry in the
1011
 
        hash for the same physical table, except that we use this as
1012
 
        an implicit "pending locks queue" - see
1013
 
        wait_for_locked_table_names for details.
1014
 
      */
1015
 
      ppp= table::getCache().equal_range(key);
1016
 
 
1017
 
      table= NULL;
1018
 
      for (table::CacheMap::const_iterator iter= ppp.first;
1019
 
           iter != ppp.second; ++iter, table= NULL)
1020
 
      {
1021
 
        table= (*iter).second;
1022
 
 
1023
 
        if (not table->in_use)
1024
 
          break;
 
2096
  {
 
2097
    for (table= thd->temporary_tables; table ; table=table->next)
 
2098
    {
 
2099
      if (table->s->table_cache_key.length == key_length +
 
2100
          TMP_TABLE_KEY_EXTRA &&
 
2101
          !memcmp(table->s->table_cache_key.str, key,
 
2102
                  key_length + TMP_TABLE_KEY_EXTRA))
 
2103
      {
1025
2104
        /*
1026
 
          Here we flush tables marked for flush.
1027
 
          Normally, table->getShare()->version contains the value of
1028
 
          refresh_version from the moment when this table was
1029
 
          (re-)opened and added to the cache.
1030
 
          If since then we did (or just started) FLUSH TABLES
1031
 
          statement, refresh_version has been increased.
1032
 
          For "name-locked" Table instances, table->getShare()->version is set
1033
 
          to 0 (see lock_table_name for details).
1034
 
          In case there is a pending FLUSH TABLES or a name lock, we
1035
 
          need to back off and re-start opening tables.
1036
 
          If we do not back off now, we may dead lock in case of lock
1037
 
          order mismatch with some other thread:
1038
 
          c1-> name lock t1; -- sort of exclusive lock
1039
 
          c2-> open t2;      -- sort of shared lock
1040
 
          c1-> name lock t2; -- blocks
1041
 
          c2-> open t1; -- blocks
 
2105
          We're trying to use the same temporary table twice in a query.
 
2106
          Right now we don't support this because a temporary table
 
2107
          is always represented by only one Table object in THD, and
 
2108
          it can not be cloned. Emit an error for an unsupported behaviour.
1042
2109
        */
1043
 
        if (table->needs_reopen_or_name_lock())
 
2110
        if (table->query_id)
 
2111
        {
 
2112
          my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
 
2113
          return(0);
 
2114
        }
 
2115
        table->query_id= thd->query_id;
 
2116
        thd->thread_specific_used= true;
 
2117
        goto reset;
 
2118
      }
 
2119
    }
 
2120
  }
 
2121
 
 
2122
  if (flags & DRIZZLE_OPEN_TEMPORARY_ONLY)
 
2123
  {
 
2124
    my_error(ER_NO_SUCH_TABLE, MYF(0), table_list->db, table_list->table_name);
 
2125
    return(0);
 
2126
  }
 
2127
 
 
2128
  /*
 
2129
    The table is not temporary - if we're in pre-locked or LOCK TABLES
 
2130
    mode, let's try to find the requested table in the list of pre-opened
 
2131
    and locked tables. If the table is not there, return an error - we can't
 
2132
    open not pre-opened tables in pre-locked/LOCK TABLES mode.
 
2133
    TODO: move this block into a separate function.
 
2134
  */
 
2135
  if (thd->locked_tables)
 
2136
  {                                             // Using table locks
 
2137
    Table *best_table= 0;
 
2138
    int best_distance= INT_MIN;
 
2139
    bool check_if_used= false;
 
2140
    for (table=thd->open_tables; table ; table=table->next)
 
2141
    {
 
2142
      if (table->s->table_cache_key.length == key_length &&
 
2143
          !memcmp(table->s->table_cache_key.str, key, key_length))
 
2144
      {
 
2145
        if (check_if_used && table->query_id &&
 
2146
            table->query_id != thd->query_id)
1044
2147
        {
1045
 
          if (flags & DRIZZLE_LOCK_IGNORE_FLUSH)
1046
 
          {
1047
 
            /* Force close at once after usage */
1048
 
            version= table->getShare()->getVersion();
1049
 
            continue;
1050
 
          }
1051
 
 
1052
 
          /* Avoid self-deadlocks by detecting self-dependencies. */
1053
 
          if (table->open_placeholder && table->in_use == this)
1054
 
          {
1055
 
            table::Cache::singleton().mutex().unlock();
1056
 
            my_error(ER_UPDATE_TABLE_USED, MYF(0), table->getShare()->getTableName());
1057
 
            return NULL;
1058
 
          }
1059
 
 
1060
 
          /*
1061
 
            Back off, part 1: mark the table as "unused" for the
1062
 
            purpose of name-locking by setting table->db_stat to 0. Do
1063
 
            that only for the tables in this thread that have an old
1064
 
            table->getShare()->version (this is an optimization (?)).
1065
 
            table->db_stat == 0 signals wait_for_locked_table_names
1066
 
            that the tables in question are not used any more. See
1067
 
            table_is_used call for details.
1068
 
          */
1069
 
          close_old_data_files(false, false);
1070
 
 
1071
 
          /*
1072
 
            Back-off part 2: try to avoid "busy waiting" on the table:
1073
 
            if the table is in use by some other thread, we suspend
1074
 
            and wait till the operation is complete: when any
1075
 
            operation that juggles with table->getShare()->version completes,
1076
 
            it broadcasts COND_refresh condition variable.
1077
 
            If 'old' table we met is in use by current thread we return
1078
 
            without waiting since in this situation it's this thread
1079
 
            which is responsible for broadcasting on COND_refresh
1080
 
            (and this was done already in Session::close_old_data_files()).
1081
 
            Good example of such situation is when we have statement
1082
 
            that needs two instances of table and FLUSH TABLES comes
1083
 
            after we open first instance but before we open second
1084
 
            instance.
1085
 
          */
1086
 
          if (table->in_use != this)
1087
 
          {
1088
 
            /* wait_for_conditionwill unlock table::Cache::singleton().mutex() for us */
1089
 
            wait_for_condition(table::Cache::singleton().mutex(), COND_refresh);
1090
 
          }
1091
 
          else
1092
 
          {
1093
 
            table::Cache::singleton().mutex().unlock();
1094
 
          }
1095
 
          /*
1096
 
            There is a refresh in progress for this table.
1097
 
            Signal the caller that it has to try again.
1098
 
          */
1099
 
          if (refresh)
1100
 
            *refresh= true;
1101
 
          return NULL;
 
2148
          /*
 
2149
            If we are in stored function or trigger we should ensure that
 
2150
            we won't change table that is already used by calling statement.
 
2151
            So if we are opening table for writing, we should check that it
 
2152
            is not already open by some calling stamement.
 
2153
          */
 
2154
          my_error(ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG, MYF(0),
 
2155
                   table->s->table_name.str);
 
2156
          return(0);
1102
2157
        }
1103
 
      }
1104
 
      if (table)
1105
 
      {
1106
 
        table::getUnused().unlink(static_cast<table::Concurrent *>(table));
1107
 
        table->in_use= this;
1108
 
      }
1109
 
      else
1110
 
      {
1111
 
        /* Insert a new Table instance into the open cache */
1112
 
        int error;
1113
 
        /* Free cache if too big */
1114
 
        table::getUnused().cull();
1115
 
 
1116
 
        if (table_list->isCreate())
 
2158
        /*
 
2159
          When looking for a usable Table, ignore MERGE children, as they
 
2160
          belong to their parent and cannot be used explicitly.
 
2161
        */
 
2162
        if (!my_strcasecmp(system_charset_info, table->alias, alias) &&
 
2163
            table->query_id != thd->query_id)  /* skip tables already used */
1117
2164
        {
1118
 
          TableIdentifier  lock_table_identifier(table_list->getSchemaName(), table_list->getTableName(), message::Table::STANDARD);
 
2165
          int distance= ((int) table->reginfo.lock_type -
 
2166
                         (int) table_list->lock_type);
 
2167
          /*
 
2168
            Find a table that either has the exact lock type requested,
 
2169
            or has the best suitable lock. In case there is no locked
 
2170
            table that has an equal or higher lock than requested,
 
2171
            we us the closest matching lock to be able to produce an error
 
2172
            message about wrong lock mode on the table. The best_table
 
2173
            is changed if bd < 0 <= d or bd < d < 0 or 0 <= d < bd.
1119
2174
 
1120
 
          if (not plugin::StorageEngine::doesTableExist(*this, lock_table_identifier))
 
2175
            distance <  0 - No suitable lock found
 
2176
            distance >  0 - we have lock mode higher then we require
 
2177
            distance == 0 - we have lock mode exactly which we need
 
2178
          */
 
2179
          if ((best_distance < 0 && distance > best_distance) || (distance >= 0 && distance < best_distance))
1121
2180
          {
1122
 
            /*
1123
 
              Table to be created, so we need to create placeholder in table-cache.
1124
 
            */
1125
 
            if (!(table= table_cache_insert_placeholder(lock_table_identifier)))
 
2181
            best_distance= distance;
 
2182
            best_table= table;
 
2183
            if (best_distance == 0 && !check_if_used)
1126
2184
            {
1127
 
              table::Cache::singleton().mutex().unlock();
1128
 
              return NULL;
 
2185
              /*
 
2186
                If we have found perfect match and we don't need to check that
 
2187
                table is not used by one of calling statements (assuming that
 
2188
                we are inside of function or trigger) we can finish iterating
 
2189
                through open tables list.
 
2190
              */
 
2191
              break;
1129
2192
            }
1130
 
            /*
1131
 
              Link placeholder to the open tables list so it will be automatically
1132
 
              removed once tables are closed. Also mark it so it won't be ignored
1133
 
              by other trying to take name-lock.
1134
 
            */
1135
 
            table->open_placeholder= true;
1136
 
            table->setNext(open_tables);
1137
 
            open_tables= table;
1138
 
            table::Cache::singleton().mutex().unlock();
1139
 
 
1140
 
            return table ;
1141
 
          }
1142
 
          /* Table exists. Let us try to open it. */
1143
 
        }
1144
 
 
1145
 
        /* make a new table */
1146
 
        {
1147
 
          table::Concurrent *new_table= new table::Concurrent;
1148
 
          table= new_table;
1149
 
          if (new_table == NULL)
1150
 
          {
1151
 
            table::Cache::singleton().mutex().unlock();
1152
 
            return NULL;
1153
 
          }
1154
 
 
1155
 
          error= new_table->open_unireg_entry(this, alias, identifier);
1156
 
          if (error != 0)
1157
 
          {
1158
 
            delete new_table;
1159
 
            table::Cache::singleton().mutex().unlock();
1160
 
            return NULL;
1161
 
          }
1162
 
          (void)table::Cache::singleton().insert(new_table);
 
2193
          }
1163
2194
        }
1164
2195
      }
1165
 
 
1166
 
      table::Cache::singleton().mutex().unlock();
1167
 
    }
 
2196
    }
 
2197
    if (best_table)
 
2198
    {
 
2199
      table= best_table;
 
2200
      table->query_id= thd->query_id;
 
2201
      goto reset;
 
2202
    }
 
2203
    /*
 
2204
      No table in the locked tables list. In case of explicit LOCK TABLES
 
2205
      this can happen if a user did not include the able into the list.
 
2206
      In case of pre-locked mode locked tables list is generated automatically,
 
2207
      so we may only end up here if the table did not exist when
 
2208
      locked tables list was created.
 
2209
    */
 
2210
    my_error(ER_TABLE_NOT_LOCKED, MYF(0), alias);
 
2211
    return(0);
 
2212
  }
 
2213
 
 
2214
  /*
 
2215
    Non pre-locked/LOCK TABLES mode, and the table is not temporary:
 
2216
    this is the normal use case.
 
2217
    Now we should:
 
2218
    - try to find the table in the table cache.
 
2219
    - if one of the discovered Table instances is name-locked
 
2220
      (table->s->version == 0) or some thread has started FLUSH TABLES
 
2221
      (refresh_version > table->s->version), back off -- we have to wait
 
2222
      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
 
2224
    and insert it into the cache.
 
2225
    We perform all of the above under LOCK_open which currently protects
 
2226
    the open cache (also known as table cache) and table definitions stored
 
2227
    on disk.
 
2228
  */
 
2229
 
 
2230
  VOID(pthread_mutex_lock(&LOCK_open));
 
2231
 
 
2232
  /*
 
2233
    If it's the first table from a list of tables used in a query,
 
2234
    remember refresh_version (the version of open_cache state).
 
2235
    If the version changes while we're opening the remaining tables,
 
2236
    we will have to back off, close all the tables opened-so-far,
 
2237
    and try to reopen them.
 
2238
    Note: refresh_version is currently changed only during FLUSH TABLES.
 
2239
  */
 
2240
  if (!thd->open_tables)
 
2241
    thd->version=refresh_version;
 
2242
  else if ((thd->version != refresh_version) &&
 
2243
           ! (flags & DRIZZLE_LOCK_IGNORE_FLUSH))
 
2244
  {
 
2245
    /* Someone did a refresh while thread was opening tables */
1168
2246
    if (refresh)
1169
 
    {
1170
 
      table->setNext(open_tables); /* Link into simple list */
1171
 
      open_tables= table;
1172
 
    }
1173
 
    table->reginfo.lock_type= TL_READ; /* Assume read */
1174
 
 
1175
 
  }
1176
 
  assert(table->getShare()->getTableCount() > 0 || table->getShare()->getType() != message::Table::STANDARD);
1177
 
 
 
2247
      *refresh=1;
 
2248
    VOID(pthread_mutex_unlock(&LOCK_open));
 
2249
    return(0);
 
2250
  }
 
2251
 
 
2252
  /*
 
2253
    In order for the back off and re-start process to work properly,
 
2254
    handler tables having old versions (due to FLUSH TABLES or pending
 
2255
    name-lock) MUST be closed. This is specially important if a name-lock
 
2256
    is pending for any table of the handler_tables list, otherwise a
 
2257
    deadlock may occur.
 
2258
  */
 
2259
  if (thd->handler_tables)
 
2260
    mysql_ha_flush(thd);
 
2261
 
 
2262
  /*
 
2263
    Actually try to find the table in the open_cache.
 
2264
    The cache may contain several "Table" instances for the same
 
2265
    physical table. The instances that are currently "in use" by
 
2266
    some thread have their "in_use" member != NULL.
 
2267
    There is no good reason for having more than one entry in the
 
2268
    hash for the same physical table, except that we use this as
 
2269
    an implicit "pending locks queue" - see
 
2270
    wait_for_locked_table_names for details.
 
2271
  */
 
2272
  for (table= (Table*) hash_first(&open_cache, (uchar*) key, key_length,
 
2273
                                  &state);
 
2274
       table && table->in_use ;
 
2275
       table= (Table*) hash_next(&open_cache, (uchar*) key, key_length,
 
2276
                                 &state))
 
2277
  {
 
2278
    /*
 
2279
      Here we flush tables marked for flush.
 
2280
      Normally, table->s->version contains the value of
 
2281
      refresh_version from the moment when this table was
 
2282
      (re-)opened and added to the cache.
 
2283
      If since then we did (or just started) FLUSH TABLES
 
2284
      statement, refresh_version has been increased.
 
2285
      For "name-locked" Table instances, table->s->version is set
 
2286
      to 0 (see lock_table_name for details).
 
2287
      In case there is a pending FLUSH TABLES or a name lock, we
 
2288
      need to back off and re-start opening tables.
 
2289
      If we do not back off now, we may dead lock in case of lock
 
2290
      order mismatch with some other thread:
 
2291
      c1: name lock t1; -- sort of exclusive lock 
 
2292
      c2: open t2;      -- sort of shared lock
 
2293
      c1: name lock t2; -- blocks
 
2294
      c2: open t1; -- blocks
 
2295
    */
 
2296
    if (table->needs_reopen_or_name_lock())
 
2297
    {
 
2298
      if (flags & DRIZZLE_LOCK_IGNORE_FLUSH)
 
2299
      {
 
2300
        /* Force close at once after usage */
 
2301
        thd->version= table->s->version;
 
2302
        continue;
 
2303
      }
 
2304
 
 
2305
      /* Avoid self-deadlocks by detecting self-dependencies. */
 
2306
      if (table->open_placeholder && table->in_use == thd)
 
2307
      {
 
2308
        VOID(pthread_mutex_unlock(&LOCK_open));
 
2309
        my_error(ER_UPDATE_TABLE_USED, MYF(0), table->s->table_name.str);
 
2310
        return(0);
 
2311
      }
 
2312
 
 
2313
      /*
 
2314
        Back off, part 1: mark the table as "unused" for the
 
2315
        purpose of name-locking by setting table->db_stat to 0. Do
 
2316
        that only for the tables in this thread that have an old
 
2317
        table->s->version (this is an optimization (?)).
 
2318
        table->db_stat == 0 signals wait_for_locked_table_names
 
2319
        that the tables in question are not used any more. See
 
2320
        table_is_used call for details.
 
2321
 
 
2322
        Notice that HANDLER tables were already taken care of by
 
2323
        the earlier call to mysql_ha_flush() in this same critical
 
2324
        section.
 
2325
      */
 
2326
      close_old_data_files(thd,thd->open_tables,0,0);
 
2327
      /*
 
2328
        Back-off part 2: try to avoid "busy waiting" on the table:
 
2329
        if the table is in use by some other thread, we suspend
 
2330
        and wait till the operation is complete: when any
 
2331
        operation that juggles with table->s->version completes,
 
2332
        it broadcasts COND_refresh condition variable.
 
2333
        If 'old' table we met is in use by current thread we return
 
2334
        without waiting since in this situation it's this thread
 
2335
        which is responsible for broadcasting on COND_refresh
 
2336
        (and this was done already in close_old_data_files()).
 
2337
        Good example of such situation is when we have statement
 
2338
        that needs two instances of table and FLUSH TABLES comes
 
2339
        after we open first instance but before we open second
 
2340
        instance.
 
2341
      */
 
2342
      if (table->in_use != thd)
 
2343
      {
 
2344
        /* wait_for_conditionwill unlock LOCK_open for us */
 
2345
        wait_for_condition(thd, &LOCK_open, &COND_refresh);
 
2346
      }
 
2347
      else
 
2348
      {
 
2349
        VOID(pthread_mutex_unlock(&LOCK_open));
 
2350
      }
 
2351
      /*
 
2352
        There is a refresh in progress for this table.
 
2353
        Signal the caller that it has to try again.
 
2354
      */
 
2355
      if (refresh)
 
2356
        *refresh=1;
 
2357
      return(0);
 
2358
    }
 
2359
  }
 
2360
  if (table)
 
2361
  {
 
2362
    /* Unlink the table from "unused_tables" list. */
 
2363
    if (table == unused_tables)
 
2364
    {                                           // First unused
 
2365
      unused_tables=unused_tables->next;        // Remove from link
 
2366
      if (table == unused_tables)
 
2367
        unused_tables=0;
 
2368
    }
 
2369
    table->prev->next=table->next;              /* Remove from unused list */
 
2370
    table->next->prev=table->prev;
 
2371
    table->in_use= thd;
 
2372
  }
 
2373
  else
 
2374
  {
 
2375
    /* Insert a new Table instance into the open cache */
 
2376
    int error;
 
2377
    /* Free cache if too big */
 
2378
    while (open_cache.records > table_cache_size && unused_tables)
 
2379
      VOID(hash_delete(&open_cache,(uchar*) unused_tables)); /* purecov: tested */
 
2380
 
 
2381
    if (table_list->create)
 
2382
    {
 
2383
      bool exists;
 
2384
 
 
2385
      if (check_if_table_exists(thd, table_list, &exists))
 
2386
      {
 
2387
        VOID(pthread_mutex_unlock(&LOCK_open));
 
2388
        return(NULL);
 
2389
      }
 
2390
 
 
2391
      if (!exists)
 
2392
      {
 
2393
        /*
 
2394
          Table to be created, so we need to create placeholder in table-cache.
 
2395
        */
 
2396
        if (!(table= table_cache_insert_placeholder(thd, key, key_length)))
 
2397
        {
 
2398
          VOID(pthread_mutex_unlock(&LOCK_open));
 
2399
          return(NULL);
 
2400
        }
 
2401
        /*
 
2402
          Link placeholder to the open tables list so it will be automatically
 
2403
          removed once tables are closed. Also mark it so it won't be ignored
 
2404
          by other trying to take name-lock.
 
2405
        */
 
2406
        table->open_placeholder= 1;
 
2407
        table->next= thd->open_tables;
 
2408
        thd->open_tables= table;
 
2409
        VOID(pthread_mutex_unlock(&LOCK_open));
 
2410
        return(table);
 
2411
      }
 
2412
      /* Table exists. Let us try to open it. */
 
2413
    }
 
2414
 
 
2415
    /* make a new table */
 
2416
    if (!(table=(Table*) my_malloc(sizeof(*table),MYF(MY_WME))))
 
2417
    {
 
2418
      VOID(pthread_mutex_unlock(&LOCK_open));
 
2419
      return(NULL);
 
2420
    }
 
2421
 
 
2422
    error= open_unireg_entry(thd, table, table_list, alias, key, key_length);
 
2423
    /* Combine the follow two */
 
2424
    if (error > 0)
 
2425
    {
 
2426
      my_free((uchar*)table, MYF(0));
 
2427
      VOID(pthread_mutex_unlock(&LOCK_open));
 
2428
      return(NULL);
 
2429
    }
 
2430
    if (error < 0)
 
2431
    {
 
2432
      my_free((uchar*)table, MYF(0));
 
2433
      VOID(pthread_mutex_unlock(&LOCK_open));
 
2434
      return(0); // VIEW
 
2435
    }
 
2436
    VOID(my_hash_insert(&open_cache,(uchar*) table));
 
2437
  }
 
2438
 
 
2439
  VOID(pthread_mutex_unlock(&LOCK_open));
 
2440
  if (refresh)
 
2441
  {
 
2442
    table->next=thd->open_tables;               /* Link into simple list */
 
2443
    thd->open_tables=table;
 
2444
  }
 
2445
  table->reginfo.lock_type=TL_READ;             /* Assume read */
 
2446
 
 
2447
 reset:
 
2448
  assert(table->s->ref_count > 0 || table->s->tmp_table != NO_TMP_TABLE);
 
2449
 
 
2450
  if (thd->lex->need_correct_ident())
 
2451
    table->alias_name_used= my_strcasecmp(table_alias_charset,
 
2452
                                          table->s->table_name.str, alias);
1178
2453
  /* Fix alias if table name changes */
1179
 
  if (strcmp(table->getAlias(), alias))
 
2454
  if (strcmp(table->alias, alias))
1180
2455
  {
1181
 
    table->setAlias(alias);
 
2456
    uint length=(uint) strlen(alias)+1;
 
2457
    table->alias= (char*) my_realloc((char*) table->alias, length,
 
2458
                                     MYF(MY_WME));
 
2459
    memcpy((void*) table->alias, alias, length);
1182
2460
  }
1183
 
 
1184
2461
  /* These variables are also set in reopen_table() */
1185
 
  table->tablenr= current_tablenr++;
1186
 
  table->used_fields= 0;
1187
 
  table->const_table= 0;
 
2462
  table->tablenr=thd->current_tablenr++;
 
2463
  table->used_fields=0;
 
2464
  table->const_table=0;
1188
2465
  table->null_row= false;
1189
2466
  table->maybe_null= false;
1190
2467
  table->force_index= false;
1191
2468
  table->status=STATUS_NO_RECORD;
1192
 
  table->insert_values.clear();
 
2469
  table->insert_values= 0;
1193
2470
  /* Catch wrong handling of the auto_increment_field_not_null. */
1194
2471
  assert(!table->auto_increment_field_not_null);
1195
2472
  table->auto_increment_field_not_null= false;
1196
2473
  if (table->timestamp_field)
1197
 
  {
1198
2474
    table->timestamp_field_type= table->timestamp_field->get_auto_set_type();
1199
 
  }
1200
2475
  table->pos_in_table_list= table_list;
1201
2476
  table->clear_column_bitmaps();
1202
2477
  assert(table->key_read == 0);
1203
 
 
1204
 
  return table;
 
2478
  return(table);
 
2479
}
 
2480
 
 
2481
 
 
2482
Table *find_locked_table(THD *thd, const char *db,const char *table_name)
 
2483
{
 
2484
  char  key[MAX_DBKEY_LENGTH];
 
2485
  uint key_length=(uint) (stpcpy(stpcpy(key,db)+1,table_name)-key)+1;
 
2486
 
 
2487
  for (Table *table=thd->open_tables; table ; table=table->next)
 
2488
  {
 
2489
    if (table->s->table_cache_key.length == key_length &&
 
2490
        !memcmp(table->s->table_cache_key.str, key, key_length))
 
2491
      return table;
 
2492
  }
 
2493
  return(0);
 
2494
}
 
2495
 
 
2496
 
 
2497
/*
 
2498
  Reopen an table because the definition has changed.
 
2499
 
 
2500
  SYNOPSIS
 
2501
    reopen_table()
 
2502
    table       Table object
 
2503
 
 
2504
  NOTES
 
2505
   The data file for the table is already closed and the share is released
 
2506
   The table has a 'dummy' share that mainly contains database and table name.
 
2507
 
 
2508
 RETURN
 
2509
   0  ok
 
2510
   1  error. The old table object is not changed.
 
2511
*/
 
2512
 
 
2513
bool reopen_table(Table *table)
 
2514
{
 
2515
  Table tmp;
 
2516
  bool error= 1;
 
2517
  Field **field;
 
2518
  uint key,part;
 
2519
  TableList table_list;
 
2520
  THD *thd= table->in_use;
 
2521
 
 
2522
  assert(table->s->ref_count == 0);
 
2523
  assert(!table->sort.io_cache);
 
2524
 
 
2525
#ifdef EXTRA_DEBUG
 
2526
  if (table->db_stat)
 
2527
    sql_print_error(_("Table %s had a open data handler in reopen_table"),
 
2528
                    table->alias);
 
2529
#endif
 
2530
  memset(&table_list, 0, sizeof(TableList));
 
2531
  table_list.db=         table->s->db.str;
 
2532
  table_list.table_name= table->s->table_name.str;
 
2533
  table_list.table=      table;
 
2534
 
 
2535
  if (wait_for_locked_table_names(thd, &table_list))
 
2536
    return(1);                             // Thread was killed
 
2537
 
 
2538
  if (open_unireg_entry(thd, &tmp, &table_list,
 
2539
                        table->alias,
 
2540
                        table->s->table_cache_key.str,
 
2541
                        table->s->table_cache_key.length))
 
2542
    goto end;
 
2543
 
 
2544
  /* This list copies variables set by open_table */
 
2545
  tmp.tablenr=          table->tablenr;
 
2546
  tmp.used_fields=      table->used_fields;
 
2547
  tmp.const_table=      table->const_table;
 
2548
  tmp.null_row=         table->null_row;
 
2549
  tmp.maybe_null=       table->maybe_null;
 
2550
  tmp.status=           table->status;
 
2551
 
 
2552
  tmp.s->table_map_id=  table->s->table_map_id;
 
2553
 
 
2554
  /* Get state */
 
2555
  tmp.in_use=           thd;
 
2556
  tmp.reginfo.lock_type=table->reginfo.lock_type;
 
2557
 
 
2558
  /* Replace table in open list */
 
2559
  tmp.next=             table->next;
 
2560
  tmp.prev=             table->prev;
 
2561
 
 
2562
  if (table->file)
 
2563
    VOID(closefrm(table, 1));           // close file, free everything
 
2564
 
 
2565
  *table= tmp;
 
2566
  table->default_column_bitmaps();
 
2567
  table->file->change_table_ptr(table, table->s);
 
2568
 
 
2569
  assert(table->alias != 0);
 
2570
  for (field=table->field ; *field ; field++)
 
2571
  {
 
2572
    (*field)->table= (*field)->orig_table= table;
 
2573
    (*field)->table_name= &table->alias;
 
2574
  }
 
2575
  for (key=0 ; key < table->s->keys ; key++)
 
2576
  {
 
2577
    for (part=0 ; part < table->key_info[key].usable_key_parts ; part++)
 
2578
      table->key_info[key].key_part[part].field->table= table;
 
2579
  }
 
2580
  /*
 
2581
    Do not attach MERGE children here. The children might be reopened
 
2582
    after the parent. Attach children after reopening all tables that
 
2583
    require reopen. See for example reopen_tables().
 
2584
  */
 
2585
 
 
2586
  broadcast_refresh();
 
2587
  error=0;
 
2588
 
 
2589
 end:
 
2590
  return(error);
1205
2591
}
1206
2592
 
1207
2593
 
1208
2594
/**
1209
 
  Close all instances of a table open by this thread and replace
1210
 
  them with exclusive name-locks.
1211
 
 
1212
 
  @param session        Thread context
1213
 
  @param db         Database name for the table to be closed
1214
 
  @param table_name Name of the table to be closed
1215
 
 
1216
 
  @note This function assumes that if we are not under LOCK TABLES,
1217
 
  then there is only one table open and locked. This means that
1218
 
  the function probably has to be adjusted before it can be used
1219
 
  anywhere outside ALTER Table.
1220
 
 
1221
 
  @note Must not use TableShare::table_name/db of the table being closed,
1222
 
  the strings are used in a loop even after the share may be freed.
 
2595
    Close all instances of a table open by this thread and replace
 
2596
    them with exclusive name-locks.
 
2597
 
 
2598
    @param thd        Thread context
 
2599
    @param db         Database name for the table to be closed
 
2600
    @param table_name Name of the table to be closed
 
2601
 
 
2602
    @note This function assumes that if we are not under LOCK TABLES,
 
2603
          then there is only one table open and locked. This means that
 
2604
          the function probably has to be adjusted before it can be used
 
2605
          anywhere outside ALTER Table.
 
2606
 
 
2607
    @note Must not use TABLE_SHARE::table_name/db of the table being closed,
 
2608
          the strings are used in a loop even after the share may be freed.
1223
2609
*/
1224
2610
 
1225
 
void Session::close_data_files_and_morph_locks(const TableIdentifier &identifier)
 
2611
void close_data_files_and_morph_locks(THD *thd, const char *db,
 
2612
                                      const char *table_name)
1226
2613
{
1227
 
  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle()); /* Adjust locks at the end of ALTER TABLEL */
1228
 
 
1229
 
  if (lock)
 
2614
  Table *table;
 
2615
 
 
2616
  safe_mutex_assert_owner(&LOCK_open);
 
2617
 
 
2618
  if (thd->lock)
1230
2619
  {
1231
2620
    /*
1232
2621
      If we are not under LOCK TABLES we should have only one table
1233
2622
      open and locked so it makes sense to remove the lock at once.
1234
2623
    */
1235
 
    unlockTables(lock);
1236
 
    lock= 0;
 
2624
    mysql_unlock_tables(thd, thd->lock);
 
2625
    thd->lock= 0;
1237
2626
  }
1238
2627
 
1239
2628
  /*
1241
2630
    for target table name if we process ALTER Table ... RENAME.
1242
2631
    So loop below makes sense even if we are not under LOCK TABLES.
1243
2632
  */
1244
 
  for (Table *table= open_tables; table ; table=table->getNext())
 
2633
  for (table=thd->open_tables; table ; table=table->next)
1245
2634
  {
1246
 
    if (table->getShare()->getCacheKey() == identifier.getKey())
 
2635
    if (!strcmp(table->s->table_name.str, table_name) &&
 
2636
        !strcmp(table->s->db.str, db))
1247
2637
    {
1248
 
      table->open_placeholder= true;
 
2638
      if (thd->locked_tables)
 
2639
      {
 
2640
        mysql_lock_remove(thd, thd->locked_tables, table, true);
 
2641
      }
 
2642
      table->open_placeholder= 1;
1249
2643
      close_handle_and_leave_table_as_lock(table);
1250
2644
    }
1251
2645
  }
 
2646
  return;
1252
2647
}
1253
2648
 
1254
2649
 
1255
2650
/**
1256
 
  Reopen all tables with closed data files.
1257
 
 
1258
 
  @param session         Thread context
1259
 
  @param get_locks   Should we get locks after reopening tables ?
1260
 
  @param mark_share_as_old  Mark share as old to protect from a impending
1261
 
  global read lock.
1262
 
 
1263
 
  @note Since this function can't properly handle prelocking and
1264
 
  create placeholders it should be used in very special
1265
 
  situations like FLUSH TABLES or ALTER Table. In general
1266
 
  case one should just repeat open_tables()/lock_tables()
1267
 
  combination when one needs tables to be reopened (for
1268
 
  example see openTablesLock()).
1269
 
 
1270
 
  @note One should have lock on table::Cache::singleton().mutex() when calling this.
1271
 
 
1272
 
  @return false in case of success, true - otherwise.
 
2651
    Reopen all tables with closed data files.
 
2652
 
 
2653
    @param thd         Thread context
 
2654
    @param get_locks   Should we get locks after reopening tables ?
 
2655
    @param mark_share_as_old  Mark share as old to protect from a impending
 
2656
                              global read lock.
 
2657
 
 
2658
    @note Since this function can't properly handle prelocking and
 
2659
          create placeholders it should be used in very special
 
2660
          situations like FLUSH TABLES or ALTER Table. In general
 
2661
          case one should just repeat open_tables()/lock_tables()
 
2662
          combination when one needs tables to be reopened (for
 
2663
          example see open_and_lock_tables()).
 
2664
 
 
2665
    @note One should have lock on LOCK_open when calling this.
 
2666
 
 
2667
    @return false in case of success, true - otherwise.
1273
2668
*/
1274
2669
 
1275
 
bool Session::reopen_tables(bool get_locks, bool)
 
2670
bool reopen_tables(THD *thd, bool get_locks, bool mark_share_as_old)
1276
2671
{
1277
2672
  Table *table,*next,**prev;
1278
2673
  Table **tables,**tables_ptr;                  // For locks
1279
2674
  bool error=0, not_used;
1280
 
  const uint32_t flags= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN |
1281
 
    DRIZZLE_LOCK_IGNORE_GLOBAL_READ_LOCK |
1282
 
    DRIZZLE_LOCK_IGNORE_FLUSH;
1283
 
 
1284
 
  if (open_tables == NULL)
1285
 
    return false;
1286
 
 
1287
 
  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());
 
2675
  const uint flags= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN |
 
2676
                    DRIZZLE_LOCK_IGNORE_GLOBAL_READ_LOCK |
 
2677
                    DRIZZLE_LOCK_IGNORE_FLUSH;
 
2678
 
 
2679
  if (!thd->open_tables)
 
2680
    return(0);
 
2681
 
 
2682
  safe_mutex_assert_owner(&LOCK_open);
1288
2683
  if (get_locks)
1289
2684
  {
1290
2685
    /*
1291
2686
      The ptr is checked later
1292
2687
      Do not handle locks of MERGE children.
1293
2688
    */
1294
 
    uint32_t opens= 0;
1295
 
 
1296
 
    for (table= open_tables; table ; table=table->getNext())
1297
 
    {
 
2689
    uint opens=0;
 
2690
    for (table= thd->open_tables; table ; table=table->next)
1298
2691
      opens++;
1299
 
    }
1300
 
    tables= new Table *[opens];
 
2692
    tables= (Table**) my_alloca(sizeof(Table*)*opens);
1301
2693
  }
1302
2694
  else
1303
 
  {
1304
 
    tables= &open_tables;
1305
 
  }
 
2695
    tables= &thd->open_tables;
1306
2696
  tables_ptr =tables;
1307
2697
 
1308
 
  prev= &open_tables;
1309
 
  for (table= open_tables; table ; table=next)
 
2698
  prev= &thd->open_tables;
 
2699
  for (table=thd->open_tables; table ; table=next)
1310
2700
  {
1311
 
    next= table->getNext();
1312
 
 
1313
 
    my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->getAlias());
1314
 
    table::remove_table(static_cast<table::Concurrent *>(table));
1315
 
    error= 1;
 
2701
    uint db_stat=table->db_stat;
 
2702
    next=table->next;
 
2703
    if (!tables || (!db_stat && reopen_table(table)))
 
2704
    {
 
2705
      my_error(ER_CANT_REOPEN_TABLE, MYF(0), table->alias);
 
2706
      VOID(hash_delete(&open_cache,(uchar*) table));
 
2707
      error=1;
 
2708
    }
 
2709
    else
 
2710
    {
 
2711
      *prev= table;
 
2712
      prev= &table->next;
 
2713
      /* Do not handle locks of MERGE children. */
 
2714
      if (get_locks && !db_stat)
 
2715
        *tables_ptr++= table;                   // need new lock on this
 
2716
      if (mark_share_as_old)
 
2717
      {
 
2718
        table->s->version=0;
 
2719
        table->open_placeholder= 0;
 
2720
      }
 
2721
    }
1316
2722
  }
1317
2723
  *prev=0;
1318
2724
  if (tables != tables_ptr)                     // Should we get back old locks
1319
2725
  {
1320
 
    DrizzleLock *local_lock;
 
2726
    DRIZZLE_LOCK *lock;
1321
2727
    /*
1322
2728
      We should always get these locks. Anyway, we must not go into
1323
 
      wait_for_tables() as it tries to acquire table::Cache::singleton().mutex(), which is
 
2729
      wait_for_tables() as it tries to acquire LOCK_open, which is
1324
2730
      already locked.
1325
2731
    */
1326
 
    some_tables_deleted= false;
1327
 
 
1328
 
    if ((local_lock= lockTables(tables, (uint32_t) (tables_ptr - tables),
1329
 
                                       flags, &not_used)))
 
2732
    thd->some_tables_deleted=0;
 
2733
    if ((lock= mysql_lock_tables(thd, tables, (uint) (tables_ptr - tables),
 
2734
                                 flags, &not_used)))
1330
2735
    {
1331
 
      /* unused */
 
2736
      thd->locked_tables=mysql_lock_merge(thd->locked_tables,lock);
1332
2737
    }
1333
2738
    else
1334
2739
    {
1341
2746
      error=1;
1342
2747
    }
1343
2748
  }
1344
 
 
1345
2749
  if (get_locks && tables)
1346
 
    delete [] tables;
1347
 
 
1348
 
  locking::broadcast_refresh();
1349
 
 
 
2750
  {
 
2751
    my_afree((uchar*) tables);
 
2752
  }
 
2753
  broadcast_refresh();
1350
2754
  return(error);
1351
2755
}
1352
2756
 
1353
2757
 
1354
2758
/**
1355
 
  Close handlers for tables in list, but leave the Table structure
1356
 
  intact so that we can re-open these quickly.
 
2759
    Close handlers for tables in list, but leave the Table structure
 
2760
    intact so that we can re-open these quickly.
1357
2761
 
1358
 
  @param session           Thread context
1359
 
  @param table         Head of the list of Table objects
1360
 
  @param morph_locks   true  - remove locks which we have on tables being closed
1361
 
  but ensure that no DML or DDL will sneak in before
1362
 
  we will re-open the table (i.e. temporarily morph
1363
 
  our table-level locks into name-locks).
1364
 
  false - otherwise
1365
 
  @param send_refresh  Should we awake waiters even if we didn't close any tables?
 
2762
    @param thd           Thread context
 
2763
    @param table         Head of the list of Table objects
 
2764
    @param morph_locks   true  - remove locks which we have on tables being closed
 
2765
                                 but ensure that no DML or DDL will sneak in before
 
2766
                                 we will re-open the table (i.e. temporarily morph
 
2767
                                 our table-level locks into name-locks).
 
2768
                         false - otherwise
 
2769
    @param send_refresh  Should we awake waiters even if we didn't close any tables?
1366
2770
*/
1367
2771
 
1368
 
void Session::close_old_data_files(bool morph_locks, bool send_refresh)
 
2772
static void close_old_data_files(THD *thd, Table *table, bool morph_locks,
 
2773
                                 bool send_refresh)
1369
2774
{
1370
2775
  bool found= send_refresh;
1371
2776
 
1372
 
  Table *table= open_tables;
1373
 
 
1374
 
  for (; table ; table=table->getNext())
 
2777
  for (; table ; table=table->next)
1375
2778
  {
1376
2779
    /*
1377
2780
      Reopen marked for flush.
1381
2784
      found=1;
1382
2785
      if (table->db_stat)
1383
2786
      {
1384
 
        if (morph_locks)
1385
 
        {
 
2787
        if (morph_locks)
 
2788
        {
1386
2789
          Table *ulcktbl= table;
1387
2790
          if (ulcktbl->lock_count)
1388
2791
          {
1392
2795
              lock on it. This will also give them a chance to close their
1393
2796
              instances of this table.
1394
2797
            */
1395
 
            abortLock(ulcktbl);
1396
 
            removeLock(ulcktbl);
 
2798
            mysql_lock_abort(thd, ulcktbl, true);
 
2799
            mysql_lock_remove(thd, thd->locked_tables, ulcktbl, true);
1397
2800
            ulcktbl->lock_count= 0;
1398
2801
          }
1399
2802
          if ((ulcktbl != table) && ulcktbl->db_stat)
1404
2807
              as a placeholder. When this happens, do not clear the
1405
2808
              placeholder flag. See the branch below ("***").
1406
2809
            */
1407
 
            ulcktbl->open_placeholder= true;
 
2810
            ulcktbl->open_placeholder= 1;
1408
2811
            close_handle_and_leave_table_as_lock(ulcktbl);
1409
2812
          }
1410
2813
          /*
1411
2814
            We want to protect the table from concurrent DDL operations
1412
2815
            (like RENAME Table) until we will re-open and re-lock it.
1413
2816
          */
1414
 
          table->open_placeholder= true;
1415
 
        }
 
2817
          table->open_placeholder= 1;
 
2818
        }
1416
2819
        close_handle_and_leave_table_as_lock(table);
1417
2820
      }
1418
2821
      else if (table->open_placeholder && !morph_locks)
1428
2831
          flag has been set because of a former close through a child.
1429
2832
          See above the comment that refers to this note.
1430
2833
        */
1431
 
        table->open_placeholder= false;
 
2834
        table->open_placeholder= 0;
1432
2835
      }
1433
2836
    }
1434
2837
  }
1435
2838
  if (found)
1436
 
    locking::broadcast_refresh();
 
2839
    broadcast_refresh();
 
2840
  return;
 
2841
}
 
2842
 
 
2843
 
 
2844
/*
 
2845
  Wait until all threads has closed the tables in the list
 
2846
  We have also to wait if there is thread that has a lock on this table even
 
2847
  if the table is closed
 
2848
*/
 
2849
 
 
2850
bool table_is_used(Table *table, bool wait_for_name_lock)
 
2851
{
 
2852
  do
 
2853
  {
 
2854
    char *key= table->s->table_cache_key.str;
 
2855
    uint key_length= table->s->table_cache_key.length;
 
2856
 
 
2857
    HASH_SEARCH_STATE state;
 
2858
    for (Table *search= (Table*) hash_first(&open_cache, (uchar*) key,
 
2859
                                             key_length, &state);
 
2860
         search ;
 
2861
         search= (Table*) hash_next(&open_cache, (uchar*) key,
 
2862
                                    key_length, &state))
 
2863
    {
 
2864
      if (search->in_use == table->in_use)
 
2865
        continue;                               // Name locked by this thread
 
2866
      /*
 
2867
        We can't use the table under any of the following conditions:
 
2868
        - There is an name lock on it (Table is to be deleted or altered)
 
2869
        - If we are in flush table and we didn't execute the flush
 
2870
        - If the table engine is open and it's an old version
 
2871
        (We must wait until all engines are shut down to use the table)
 
2872
      */
 
2873
      if ( (search->locked_by_name && wait_for_name_lock) ||
 
2874
           (search->is_name_opened() && search->needs_reopen_or_name_lock()))
 
2875
        return(1);
 
2876
    }
 
2877
  } while ((table=table->next));
 
2878
  return(0);
1437
2879
}
1438
2880
 
1439
2881
 
1440
2882
/* Wait until all used tables are refreshed */
1441
2883
 
1442
 
bool wait_for_tables(Session *session)
 
2884
bool wait_for_tables(THD *thd)
1443
2885
{
1444
2886
  bool result;
1445
2887
 
1446
 
  session->set_proc_info("Waiting for tables");
1447
 
  {
1448
 
    boost_unique_lock_t lock(table::Cache::singleton().mutex());
1449
 
    while (not session->getKilled())
1450
 
    {
1451
 
      session->some_tables_deleted= false;
1452
 
      session->close_old_data_files(false, dropping_tables != 0);
1453
 
      if (not table::Cache::singleton().areTablesUsed(session->open_tables, 1))
1454
 
      {
1455
 
        break;
1456
 
      }
1457
 
      COND_refresh.wait(lock);
1458
 
    }
1459
 
    if (session->getKilled())
1460
 
      result= true;                                     // aborted
1461
 
    else
1462
 
    {
1463
 
      /* Now we can open all tables without any interference */
1464
 
      session->set_proc_info("Reopen tables");
1465
 
      session->version= refresh_version;
1466
 
      result= session->reopen_tables(false, false);
1467
 
    }
1468
 
  }
1469
 
  session->set_proc_info(0);
1470
 
 
1471
 
  return result;
 
2888
  thd_proc_info(thd, "Waiting for tables");
 
2889
  pthread_mutex_lock(&LOCK_open);
 
2890
  while (!thd->killed)
 
2891
  {
 
2892
    thd->some_tables_deleted=0;
 
2893
    close_old_data_files(thd,thd->open_tables,0,dropping_tables != 0);
 
2894
    mysql_ha_flush(thd);
 
2895
    if (!table_is_used(thd->open_tables,1))
 
2896
      break;
 
2897
    (void) pthread_cond_wait(&COND_refresh,&LOCK_open);
 
2898
  }
 
2899
  if (thd->killed)
 
2900
    result= 1;                                  // aborted
 
2901
  else
 
2902
  {
 
2903
    /* Now we can open all tables without any interference */
 
2904
    thd_proc_info(thd, "Reopen tables");
 
2905
    thd->version= refresh_version;
 
2906
    result=reopen_tables(thd,0,0);
 
2907
  }
 
2908
  pthread_mutex_unlock(&LOCK_open);
 
2909
  thd_proc_info(thd, 0);
 
2910
  return(result);
1472
2911
}
1473
2912
 
1474
2913
 
1476
2915
  drop tables from locked list
1477
2916
 
1478
2917
  SYNOPSIS
1479
 
  drop_locked_tables()
1480
 
  session                       Thread thandler
1481
 
  db                    Database
1482
 
  table_name            Table name
 
2918
    drop_locked_tables()
 
2919
    thd                 Thread thandler
 
2920
    db                  Database
 
2921
    table_name          Table name
1483
2922
 
1484
2923
  INFORMATION
1485
 
  This is only called on drop tables
 
2924
    This is only called on drop tables
1486
2925
 
1487
 
  The Table object for the dropped table is unlocked but still kept around
1488
 
  as a name lock, which means that the table will be available for other
1489
 
  thread as soon as we call unlock_table_names().
1490
 
  If there is multiple copies of the table locked, all copies except
1491
 
  the first, which acts as a name lock, is removed.
 
2926
    The Table object for the dropped table is unlocked but still kept around
 
2927
    as a name lock, which means that the table will be available for other
 
2928
    thread as soon as we call unlock_table_names().
 
2929
    If there is multiple copies of the table locked, all copies except
 
2930
    the first, which acts as a name lock, is removed.
1492
2931
 
1493
2932
  RETURN
1494
 
#    If table existed, return table
1495
 
0        Table was not locked
 
2933
    #    If table existed, return table
 
2934
    0    Table was not locked
1496
2935
*/
1497
2936
 
1498
2937
 
1499
 
Table *drop_locked_tables(Session *session, const drizzled::TableIdentifier &identifier)
 
2938
Table *drop_locked_tables(THD *thd,const char *db, const char *table_name)
1500
2939
{
1501
2940
  Table *table,*next,**prev, *found= 0;
1502
 
  prev= &session->open_tables;
 
2941
  prev= &thd->open_tables;
1503
2942
 
1504
2943
  /*
1505
 
    Note that we need to hold table::Cache::singleton().mutex() while changing the
 
2944
    Note that we need to hold LOCK_open while changing the
1506
2945
    open_tables list. Another thread may work on it.
1507
 
    (See: table::Cache::singleton().removeTable(), mysql_wait_completed_table())
 
2946
    (See: remove_table_from_cache(), mysql_wait_completed_table())
1508
2947
    Closing a MERGE child before the parent would be fatal if the
1509
2948
    other thread tries to abort the MERGE lock in between.
1510
2949
  */
1511
 
  for (table= session->open_tables; table ; table=next)
 
2950
  for (table= thd->open_tables; table ; table=next)
1512
2951
  {
1513
 
    next=table->getNext();
1514
 
    if (table->getShare()->getCacheKey() == identifier.getKey())
 
2952
    next=table->next;
 
2953
    if (!strcmp(table->s->table_name.str, table_name) &&
 
2954
        !strcmp(table->s->db.str, db))
1515
2955
    {
1516
 
      session->removeLock(table);
 
2956
      mysql_lock_remove(thd, thd->locked_tables, table, true);
1517
2957
 
1518
2958
      if (!found)
1519
2959
      {
1522
2962
        if (table->db_stat)
1523
2963
        {
1524
2964
          table->db_stat= 0;
1525
 
          table->cursor->close();
 
2965
          table->file->close();
1526
2966
        }
1527
2967
      }
1528
2968
      else
1529
2969
      {
1530
2970
        /* We already have a name lock, remove copy */
1531
 
        table::remove_table(static_cast<table::Concurrent *>(table));
 
2971
        VOID(hash_delete(&open_cache,(uchar*) table));
1532
2972
      }
1533
2973
    }
1534
2974
    else
1535
2975
    {
1536
2976
      *prev=table;
1537
 
      prev= table->getNextPtr();
 
2977
      prev= &table->next;
1538
2978
    }
1539
2979
  }
1540
2980
  *prev=0;
1541
2981
  if (found)
1542
 
    locking::broadcast_refresh();
1543
 
 
 
2982
    broadcast_refresh();
 
2983
  if (thd->locked_tables && thd->locked_tables->table_count == 0)
 
2984
  {
 
2985
    my_free((uchar*) thd->locked_tables,MYF(0));
 
2986
    thd->locked_tables=0;
 
2987
  }
1544
2988
  return(found);
1545
2989
}
1546
2990
 
1551
2995
  other threads trying to get the lock.
1552
2996
*/
1553
2997
 
1554
 
void abort_locked_tables(Session *session, const drizzled::TableIdentifier &identifier)
 
2998
void abort_locked_tables(THD *thd,const char *db, const char *table_name)
1555
2999
{
1556
3000
  Table *table;
1557
 
  for (table= session->open_tables; table ; table= table->getNext())
 
3001
  for (table= thd->open_tables; table ; table= table->next)
1558
3002
  {
1559
 
    if (table->getShare()->getCacheKey() == identifier.getKey())
 
3003
    if (!strcmp(table->s->table_name.str, table_name) &&
 
3004
        !strcmp(table->s->db.str, db))
1560
3005
    {
1561
3006
      /* If MERGE child, forward lock handling to parent. */
1562
 
      session->abortLock(table);
 
3007
      mysql_lock_abort(thd, table, true);
1563
3008
      break;
1564
3009
    }
1565
3010
  }
1567
3012
 
1568
3013
 
1569
3014
/*
 
3015
  Function to assign a new table map id to a table share.
 
3016
 
 
3017
  PARAMETERS
 
3018
 
 
3019
    share - Pointer to table share structure
 
3020
 
 
3021
  DESCRIPTION
 
3022
 
 
3023
    We are intentionally not checking that share->mutex is locked
 
3024
    since this function should only be called when opening a table
 
3025
    share and before it is entered into the table_def_cache (meaning
 
3026
    that it cannot be fetched by another thread, even accidentally).
 
3027
 
 
3028
  PRE-CONDITION(S)
 
3029
 
 
3030
    share is non-NULL
 
3031
    The LOCK_open mutex is locked
 
3032
 
 
3033
  POST-CONDITION(S)
 
3034
 
 
3035
    share->table_map_id is given a value that with a high certainty is
 
3036
    not used by any other table (the only case where a table id can be
 
3037
    reused is on wrap-around, which means more than 4 billion table
 
3038
    share opens have been executed while one table was open all the
 
3039
    time).
 
3040
 
 
3041
    share->table_map_id is not UINT32_MAX.
 
3042
 */
 
3043
void assign_new_table_id(TABLE_SHARE *share)
 
3044
{
 
3045
  static uint32_t last_table_id= UINT32_MAX;
 
3046
 
 
3047
  /* Preconditions */
 
3048
  assert(share != NULL);
 
3049
  safe_mutex_assert_owner(&LOCK_open);
 
3050
 
 
3051
  ulong tid= ++last_table_id;                   /* get next id */
 
3052
  /*
 
3053
    There is one reserved number that cannot be used.  Remember to
 
3054
    change this when 6-byte global table id's are introduced.
 
3055
  */
 
3056
  if (unlikely(tid == UINT32_MAX))
 
3057
    tid= ++last_table_id;
 
3058
  share->table_map_id= tid;
 
3059
 
 
3060
  /* Post conditions */
 
3061
  assert(share->table_map_id != UINT32_MAX);
 
3062
 
 
3063
  return;
 
3064
}
 
3065
 
 
3066
/*
 
3067
  Load a table definition from file and open unireg table
 
3068
 
 
3069
  SYNOPSIS
 
3070
    open_unireg_entry()
 
3071
    thd                 Thread handle
 
3072
    entry               Store open table definition here
 
3073
    table_list          TableList with db, table_name
 
3074
    alias               Alias name
 
3075
    cache_key           Key for share_cache
 
3076
    cache_key_length    length of cache_key
 
3077
 
 
3078
  NOTES
 
3079
   Extra argument for open is taken from thd->open_options
 
3080
   One must have a lock on LOCK_open when calling this function
 
3081
 
 
3082
  RETURN
 
3083
    0   ok
 
3084
    #   Error
 
3085
*/
 
3086
 
 
3087
static int open_unireg_entry(THD *thd, Table *entry, TableList *table_list,
 
3088
                             const char *alias,
 
3089
                             char *cache_key, uint cache_key_length)
 
3090
{
 
3091
  int error;
 
3092
  TABLE_SHARE *share;
 
3093
  uint discover_retry_count= 0;
 
3094
 
 
3095
  safe_mutex_assert_owner(&LOCK_open);
 
3096
retry:
 
3097
  if (!(share= get_table_share_with_create(thd, table_list, cache_key,
 
3098
                                           cache_key_length, 
 
3099
                                           table_list->i_s_requested_object,
 
3100
                                           &error)))
 
3101
    return(1);
 
3102
 
 
3103
  while ((error= open_table_from_share(thd, share, alias,
 
3104
                                       (uint) (HA_OPEN_KEYFILE |
 
3105
                                               HA_OPEN_RNDFILE |
 
3106
                                               HA_GET_INDEX |
 
3107
                                               HA_TRY_READ_ONLY),
 
3108
                                       (EXTRA_RECORD),
 
3109
                                       thd->open_options, entry, OTM_OPEN)))
 
3110
  {
 
3111
    if (error == 7)                             // Table def changed
 
3112
    {
 
3113
      share->version= 0;                        // Mark share as old
 
3114
      if (discover_retry_count++)               // Retry once
 
3115
        goto err;
 
3116
 
 
3117
      /*
 
3118
        TODO:
 
3119
        Here we should wait until all threads has released the table.
 
3120
        For now we do one retry. This may cause a deadlock if there
 
3121
        is other threads waiting for other tables used by this thread.
 
3122
        
 
3123
        Proper fix would be to if the second retry failed:
 
3124
        - Mark that table def changed
 
3125
        - Return from open table
 
3126
        - Close all tables used by this thread
 
3127
        - Start waiting that the share is released
 
3128
        - Retry by opening all tables again
 
3129
      */
 
3130
      if (ha_create_table_from_engine(thd, table_list->db,
 
3131
                                      table_list->table_name))
 
3132
        goto err;
 
3133
      /*
 
3134
        TO BE FIXED
 
3135
        To avoid deadlock, only wait for release if no one else is
 
3136
        using the share.
 
3137
      */
 
3138
      if (share->ref_count != 1)
 
3139
        goto err;
 
3140
      /* Free share and wait until it's released by all threads */
 
3141
      release_table_share(share, RELEASE_WAIT_FOR_DROP);
 
3142
      if (!thd->killed)
 
3143
      {
 
3144
        drizzle_reset_errors(thd, 1);         // Clear warnings
 
3145
        thd->clear_error();                 // Clear error message
 
3146
        goto retry;
 
3147
      }
 
3148
      return(1);
 
3149
    }
 
3150
    if (!entry->s || !entry->s->crashed)
 
3151
      goto err;
 
3152
     // Code below is for repairing a crashed file
 
3153
     if ((error= lock_table_name(thd, table_list, true)))
 
3154
     {
 
3155
       if (error < 0)
 
3156
        goto err;
 
3157
       if (wait_for_locked_table_names(thd, table_list))
 
3158
       {
 
3159
        unlock_table_name(thd, table_list);
 
3160
        goto err;
 
3161
       }
 
3162
     }
 
3163
     pthread_mutex_unlock(&LOCK_open);
 
3164
     thd->clear_error();                                // Clear error message
 
3165
     error= 0;
 
3166
     if (open_table_from_share(thd, share, alias,
 
3167
                               (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
 
3168
                                       HA_GET_INDEX |
 
3169
                                       HA_TRY_READ_ONLY),
 
3170
                               EXTRA_RECORD,
 
3171
                               ha_open_options | HA_OPEN_FOR_REPAIR,
 
3172
                               entry, OTM_OPEN) || ! entry->file ||
 
3173
        (entry->file->is_crashed() && entry->file->ha_check_and_repair(thd)))
 
3174
     {
 
3175
       /* Give right error message */
 
3176
       thd->clear_error();
 
3177
       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,
 
3179
                       share->table_name.str);
 
3180
       if (entry->file)
 
3181
        closefrm(entry, 0);
 
3182
       error=1;
 
3183
     }
 
3184
     else
 
3185
       thd->clear_error();                      // Clear error message
 
3186
     pthread_mutex_lock(&LOCK_open);
 
3187
     unlock_table_name(thd, table_list);
 
3188
 
 
3189
     if (error)
 
3190
       goto err;
 
3191
     break;
 
3192
   }
 
3193
 
 
3194
  /*
 
3195
    If we are here, there was no fatal error (but error may be still
 
3196
    unitialized).
 
3197
  */
 
3198
  if (unlikely(entry->file->implicit_emptied))
 
3199
  {
 
3200
    entry->file->implicit_emptied= 0;
 
3201
    if (mysql_bin_log.is_open())
 
3202
    {
 
3203
      char *query, *end;
 
3204
      uint query_buf_size= 20 + share->db.length + share->table_name.length +1;
 
3205
      if ((query= (char*) my_malloc(query_buf_size,MYF(MY_WME))))
 
3206
      {
 
3207
        /* this DELETE FROM is needed even with row-based binlogging */
 
3208
        end = strxmov(stpcpy(query, "DELETE FROM `"),
 
3209
                      share->db.str,"`.`",share->table_name.str,"`", NullS);
 
3210
        thd->binlog_query(THD::STMT_QUERY_TYPE,
 
3211
                          query, (ulong)(end-query), false, false);
 
3212
        my_free(query, MYF(0));
 
3213
      }
 
3214
      else
 
3215
      {
 
3216
        /*
 
3217
          As replication is maybe going to be corrupted, we need to warn the
 
3218
          DBA on top of warning the client (which will automatically be done
 
3219
          because of MYF(MY_WME) in my_malloc() above).
 
3220
        */
 
3221
        sql_print_error(_("When opening HEAP table, could not allocate memory "
 
3222
                          "to write 'DELETE FROM `%s`.`%s`' to the binary log"),
 
3223
                        table_list->db, table_list->table_name);
 
3224
        closefrm(entry, 0);
 
3225
        goto err;
 
3226
      }
 
3227
    }
 
3228
  }
 
3229
  return(0);
 
3230
 
 
3231
err:
 
3232
  release_table_share(share, RELEASE_NORMAL);
 
3233
  return(1);
 
3234
}
 
3235
 
 
3236
 
 
3237
/*
1570
3238
  Open all tables in list
1571
3239
 
1572
3240
  SYNOPSIS
1573
 
  open_tables()
1574
 
  session - thread Cursor
1575
 
  start - list of tables in/out
1576
 
  counter - number of opened tables will be return using this parameter
1577
 
  flags   - bitmap of flags to modify how the tables will be open:
1578
 
  DRIZZLE_LOCK_IGNORE_FLUSH - open table even if someone has
1579
 
  done a flush or namelock on it.
 
3241
    open_tables()
 
3242
    thd - thread handler
 
3243
    start - list of tables in/out
 
3244
    counter - number of opened tables will be return using this parameter
 
3245
    flags   - bitmap of flags to modify how the tables will be open:
 
3246
              DRIZZLE_LOCK_IGNORE_FLUSH - open table even if someone has
 
3247
              done a flush or namelock on it.
1580
3248
 
1581
3249
  NOTE
1582
 
  Unless we are already in prelocked mode, this function will also precache
1583
 
  all SP/SFs explicitly or implicitly (via views and triggers) used by the
1584
 
  query and add tables needed for their execution to table list. If resulting
1585
 
  tables list will be non empty it will mark query as requiring precaching.
1586
 
  Prelocked mode will be enabled for such query during lock_tables() call.
 
3250
    Unless we are already in prelocked mode, this function will also precache
 
3251
    all SP/SFs explicitly or implicitly (via views and triggers) used by the
 
3252
    query and add tables needed for their execution to table list. If resulting
 
3253
    tables list will be non empty it will mark query as requiring precaching.
 
3254
    Prelocked mode will be enabled for such query during lock_tables() call.
1587
3255
 
1588
 
  If query for which we are opening tables is already marked as requiring
1589
 
  prelocking it won't do such precaching and will simply reuse table list
1590
 
  which is already built.
 
3256
    If query for which we are opening tables is already marked as requiring
 
3257
    prelocking it won't do such precaching and will simply reuse table list
 
3258
    which is already built.
1591
3259
 
1592
3260
  RETURN
1593
 
  0  - OK
1594
 
  -1 - error
 
3261
    0  - OK
 
3262
    -1 - error
1595
3263
*/
1596
3264
 
1597
 
int Session::open_tables_from_list(TableList **start, uint32_t *counter, uint32_t flags)
 
3265
int open_tables(THD *thd, TableList **start, uint *counter, uint flags)
1598
3266
{
1599
3267
  TableList *tables= NULL;
1600
3268
  bool refresh;
1601
 
  int result= 0;
 
3269
  int result=0;
 
3270
  MEM_ROOT new_frm_mem;
1602
3271
  /* Also used for indicating that prelocking is need */
1603
3272
  bool safe_to_ignore_table;
1604
3273
 
1605
 
  current_tablenr= 0;
1606
 
restart:
 
3274
  /*
 
3275
    temporary mem_root for new .frm parsing.
 
3276
    TODO: variables for size
 
3277
  */
 
3278
  init_sql_alloc(&new_frm_mem, 8024, 8024);
 
3279
 
 
3280
  thd->current_tablenr= 0;
 
3281
 restart:
1607
3282
  *counter= 0;
1608
 
  set_proc_info("Opening tables");
 
3283
  thd_proc_info(thd, "Opening tables");
1609
3284
 
1610
3285
  /*
1611
3286
    For every table in the list of tables to open, try to find or open
1620
3295
      processing, link to created temporary table will be put here.
1621
3296
      If this is derived table for view then we still want to process
1622
3297
      routines used by this view.
1623
 
    */
 
3298
     */
1624
3299
    if (tables->derived)
1625
3300
    {
1626
3301
      continue;
1627
3302
    }
 
3303
    /*
 
3304
      If this TableList object is a placeholder for an information_schema
 
3305
      table, create a temporary table to represent the information_schema
 
3306
      table in the query. Do not fill it yet - will be filled during
 
3307
      execution.
 
3308
    */
 
3309
    if (tables->schema_table)
 
3310
    {
 
3311
      if (!mysql_schema_table(thd, thd->lex, tables))
 
3312
        continue;
 
3313
      return(-1);
 
3314
    }
1628
3315
    (*counter)++;
1629
3316
 
1630
3317
    /*
1631
 
     * Is the user authorized to see this table? Do this before we check
1632
 
     * to see if it exists so that an unauthorized user cannot phish for
1633
 
     * table/schema information via error messages
1634
 
     */
1635
 
    TableIdentifier the_table(tables->getSchemaName(), tables->getTableName());
1636
 
    if (not plugin::Authorization::isAuthorized(getSecurityContext(),
1637
 
                                                the_table))
1638
 
    {
1639
 
      result= -1;                               // Fatal error
1640
 
      break;
1641
 
    }
1642
 
 
1643
 
 
1644
 
    /*
1645
3318
      Not a placeholder: must be a base table or a view, and the table is
1646
3319
      not opened yet. Try to open the table.
1647
3320
    */
1648
 
    if (tables->table == NULL)
1649
 
      tables->table= openTable(tables, &refresh, flags);
 
3321
    if (!tables->table)
 
3322
      tables->table= open_table(thd, tables, &refresh, flags);
1650
3323
 
1651
 
    if (tables->table == NULL)
 
3324
    if (!tables->table)
1652
3325
    {
 
3326
      free_root(&new_frm_mem, MYF(MY_KEEP_PREALLOC));
 
3327
 
1653
3328
      if (refresh)                              // Refresh in progress
1654
3329
      {
1655
3330
        /*
1666
3341
          we pretend that we have finished calculation which we were doing
1667
3342
          currently.
1668
3343
        */
1669
 
        close_tables_for_reopen(start);
1670
 
        goto restart;
 
3344
        close_tables_for_reopen(thd, start);
 
3345
        goto restart;
1671
3346
      }
1672
3347
 
1673
3348
      if (safe_to_ignore_table)
1676
3351
      result= -1;                               // Fatal error
1677
3352
      break;
1678
3353
    }
1679
 
    if (tables->lock_type != TL_UNLOCK)
 
3354
    if (tables->lock_type != TL_UNLOCK && ! thd->locked_tables)
1680
3355
    {
1681
3356
      if (tables->lock_type == TL_WRITE_DEFAULT)
1682
 
        tables->table->reginfo.lock_type= update_lock_default;
1683
 
      else if (tables->table->getShare()->getType() == message::Table::STANDARD)
 
3357
        tables->table->reginfo.lock_type= thd->update_lock_default;
 
3358
      else if (tables->table->s->tmp_table == NO_TMP_TABLE)
1684
3359
        tables->table->reginfo.lock_type= tables->lock_type;
1685
3360
    }
1686
3361
  }
1687
3362
 
1688
 
  set_proc_info(0);
 
3363
  thd_proc_info(thd, 0);
 
3364
  free_root(&new_frm_mem, MYF(0));              // Free pre-alloced block
1689
3365
 
1690
3366
  if (result && tables)
1691
3367
  {
1692
3368
    /*
1693
3369
      Some functions determine success as (tables->table != NULL).
1694
 
      tables->table is in session->open_tables.
 
3370
      tables->table is in thd->open_tables.
1695
3371
    */
1696
3372
    tables->table= NULL;
1697
3373
  }
1698
 
 
1699
3374
  return(result);
1700
3375
}
1701
3376
 
1702
3377
 
1703
3378
/*
 
3379
  Check that lock is ok for tables; Call start stmt if ok
 
3380
 
 
3381
  SYNOPSIS
 
3382
    check_lock_and_start_stmt()
 
3383
    thd                 Thread handle
 
3384
    table_list          Table to check
 
3385
    lock_type           Lock used for table
 
3386
 
 
3387
  RETURN VALUES
 
3388
  0     ok
 
3389
  1     error
 
3390
*/
 
3391
 
 
3392
static bool check_lock_and_start_stmt(THD *thd, Table *table,
 
3393
                                      thr_lock_type lock_type)
 
3394
{
 
3395
  int error;
 
3396
 
 
3397
  if ((int) lock_type >= (int) TL_WRITE_ALLOW_READ &&
 
3398
      (int) table->reginfo.lock_type < (int) TL_WRITE_ALLOW_READ)
 
3399
  {
 
3400
    my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),table->alias);
 
3401
    return(1);
 
3402
  }
 
3403
  if ((error=table->file->start_stmt(thd, lock_type)))
 
3404
  {
 
3405
    table->file->print_error(error,MYF(0));
 
3406
    return(1);
 
3407
  }
 
3408
  return(0);
 
3409
}
 
3410
 
 
3411
 
 
3412
/**
 
3413
  @brief Open and lock one table
 
3414
 
 
3415
  @param[in]    thd             thread handle
 
3416
  @param[in]    table_l         table to open is first table in this list
 
3417
  @param[in]    lock_type       lock to use for table
 
3418
 
 
3419
  @return       table
 
3420
    @retval     != NULL         OK, opened table returned
 
3421
    @retval     NULL            Error
 
3422
 
 
3423
  @note
 
3424
    If ok, the following are also set:
 
3425
      table_list->lock_type     lock_type
 
3426
      table_list->table         table
 
3427
 
 
3428
  @note
 
3429
    If table_l is a list, not a single table, the list is temporarily
 
3430
    broken.
 
3431
 
 
3432
  @detail
 
3433
    This function is meant as a replacement for open_ltable() when
 
3434
    MERGE tables can be opened. open_ltable() cannot open MERGE tables.
 
3435
 
 
3436
    There may be more differences between open_n_lock_single_table() and
 
3437
    open_ltable(). One known difference is that open_ltable() does
 
3438
    neither call decide_logging_format() nor handle some other logging
 
3439
    and locking issues because it does not call lock_tables().
 
3440
*/
 
3441
 
 
3442
Table *open_n_lock_single_table(THD *thd, TableList *table_l,
 
3443
                                thr_lock_type lock_type)
 
3444
{
 
3445
  TableList *save_next_global;
 
3446
 
 
3447
  /* Remember old 'next' pointer. */
 
3448
  save_next_global= table_l->next_global;
 
3449
  /* Break list. */
 
3450
  table_l->next_global= NULL;
 
3451
 
 
3452
  /* Set requested lock type. */
 
3453
  table_l->lock_type= lock_type;
 
3454
 
 
3455
  /* Open the table. */
 
3456
  if (simple_open_n_lock_tables(thd, table_l))
 
3457
    table_l->table= NULL; /* Just to be sure. */
 
3458
 
 
3459
  /* Restore list. */
 
3460
  table_l->next_global= save_next_global;
 
3461
 
 
3462
  return(table_l->table);
 
3463
}
 
3464
 
 
3465
 
 
3466
/*
1704
3467
  Open and lock one table
1705
3468
 
1706
3469
  SYNOPSIS
1707
 
  openTableLock()
1708
 
  session                       Thread Cursor
1709
 
  table_list            Table to open is first table in this list
1710
 
  lock_type             Lock to use for open
1711
 
  lock_flags          Flags passed to mysql_lock_table
 
3470
    open_ltable()
 
3471
    thd                 Thread handler
 
3472
    table_list          Table to open is first table in this list
 
3473
    lock_type           Lock to use for open
 
3474
    lock_flags          Flags passed to mysql_lock_table
1712
3475
 
1713
3476
  NOTE
1714
 
  This function don't do anything like SP/SF/views/triggers analysis done
1715
 
  in open_tables(). It is intended for opening of only one concrete table.
1716
 
  And used only in special contexts.
 
3477
    This function don't do anything like SP/SF/views/triggers analysis done
 
3478
    in open_tables(). It is intended for opening of only one concrete table.
 
3479
    And used only in special contexts.
1717
3480
 
1718
3481
  RETURN VALUES
1719
 
  table         Opened table
1720
 
  0                     Error
1721
 
 
1722
 
  If ok, the following are also set:
1723
 
  table_list->lock_type         lock_type
1724
 
  table_list->table             table
 
3482
    table               Opened table
 
3483
    0                   Error
 
3484
  
 
3485
    If ok, the following are also set:
 
3486
      table_list->lock_type     lock_type
 
3487
      table_list->table         table
1725
3488
*/
1726
3489
 
1727
 
Table *Session::openTableLock(TableList *table_list, thr_lock_type lock_type)
 
3490
Table *open_ltable(THD *thd, TableList *table_list, thr_lock_type lock_type,
 
3491
                   uint lock_flags)
1728
3492
{
1729
3493
  Table *table;
1730
3494
  bool refresh;
1731
3495
 
1732
 
  set_proc_info("Opening table");
1733
 
  current_tablenr= 0;
1734
 
  while (!(table= openTable(table_list, &refresh)) &&
 
3496
  thd_proc_info(thd, "Opening table");
 
3497
  thd->current_tablenr= 0;
 
3498
  while (!(table= open_table(thd, table_list, &refresh, 0)) &&
1735
3499
         refresh)
1736
3500
    ;
1737
3501
 
1739
3503
  {
1740
3504
    table_list->lock_type= lock_type;
1741
3505
    table_list->table=     table;
1742
 
 
1743
 
    assert(lock == 0);  // You must lock everything at once
1744
 
    if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
1745
 
      if (! (lock= lockTables(&table_list->table, 1, 0, &refresh)))
1746
 
        table= 0;
1747
 
  }
1748
 
 
1749
 
  set_proc_info(0);
1750
 
 
1751
 
  return table;
 
3506
    if (thd->locked_tables)
 
3507
    {
 
3508
      if (check_lock_and_start_stmt(thd, table, lock_type))
 
3509
        table= 0;
 
3510
    }
 
3511
    else
 
3512
    {
 
3513
      assert(thd->lock == 0);   // You must lock everything at once
 
3514
      if ((table->reginfo.lock_type= lock_type) != TL_UNLOCK)
 
3515
        if (! (thd->lock= mysql_lock_tables(thd, &table_list->table, 1,
 
3516
                                            lock_flags, &refresh)))
 
3517
          table= 0;
 
3518
    }
 
3519
  }
 
3520
 
 
3521
  thd_proc_info(thd, 0);
 
3522
  return(table);
 
3523
}
 
3524
 
 
3525
 
 
3526
/*
 
3527
  Open all tables in list, locks them and optionally process derived tables.
 
3528
 
 
3529
  SYNOPSIS
 
3530
    open_and_lock_tables_derived()
 
3531
    thd         - thread handler
 
3532
    tables      - list of tables for open&locking
 
3533
    derived     - if to handle derived tables
 
3534
 
 
3535
  RETURN
 
3536
    false - ok
 
3537
    true  - error
 
3538
 
 
3539
  NOTE
 
3540
    The lock will automaticaly be freed by close_thread_tables()
 
3541
 
 
3542
  NOTE
 
3543
    There are two convenience functions:
 
3544
    - simple_open_n_lock_tables(thd, tables)  without derived handling
 
3545
    - open_and_lock_tables(thd, tables)       with derived handling
 
3546
    Both inline functions call open_and_lock_tables_derived() with
 
3547
    the third argument set appropriately.
 
3548
*/
 
3549
 
 
3550
int open_and_lock_tables_derived(THD *thd, TableList *tables, bool derived)
 
3551
{
 
3552
  uint counter;
 
3553
  bool need_reopen;
 
3554
 
 
3555
  for ( ; ; ) 
 
3556
  {
 
3557
    if (open_tables(thd, &tables, &counter, 0))
 
3558
      return(-1);
 
3559
 
 
3560
    if (!lock_tables(thd, tables, counter, &need_reopen))
 
3561
      break;
 
3562
    if (!need_reopen)
 
3563
      return(-1);
 
3564
    close_tables_for_reopen(thd, &tables);
 
3565
  }
 
3566
  if (derived &&
 
3567
      (mysql_handle_derived(thd->lex, &mysql_derived_prepare) ||
 
3568
       (thd->fill_derived_tables() &&
 
3569
        mysql_handle_derived(thd->lex, &mysql_derived_filling))))
 
3570
    return(true); /* purecov: inspected */
 
3571
  return(0);
 
3572
}
 
3573
 
 
3574
 
 
3575
/*
 
3576
  Open all tables in list and process derived tables
 
3577
 
 
3578
  SYNOPSIS
 
3579
    open_normal_and_derived_tables
 
3580
    thd         - thread handler
 
3581
    tables      - list of tables for open
 
3582
    flags       - bitmap of flags to modify how the tables will be open:
 
3583
                  DRIZZLE_LOCK_IGNORE_FLUSH - open table even if someone has
 
3584
                  done a flush or namelock on it.
 
3585
 
 
3586
  RETURN
 
3587
    false - ok
 
3588
    true  - error
 
3589
 
 
3590
  NOTE 
 
3591
    This is to be used on prepare stage when you don't read any
 
3592
    data from the tables.
 
3593
*/
 
3594
 
 
3595
bool open_normal_and_derived_tables(THD *thd, TableList *tables, uint flags)
 
3596
{
 
3597
  uint counter;
 
3598
  assert(!thd->fill_derived_tables());
 
3599
  if (open_tables(thd, &tables, &counter, flags) ||
 
3600
      mysql_handle_derived(thd->lex, &mysql_derived_prepare))
 
3601
    return(true); /* purecov: inspected */
 
3602
  return(0);
 
3603
}
 
3604
 
 
3605
 
 
3606
/**
 
3607
   Decide on logging format to use for the statement.
 
3608
 
 
3609
   Compute the capabilities vector for the involved storage engines
 
3610
   and mask out the flags for the binary log. Right now, the binlog
 
3611
   flags only include the capabilities of the storage engines, so this
 
3612
   is safe.
 
3613
 
 
3614
   We now have three alternatives that prevent the statement from
 
3615
   being loggable:
 
3616
 
 
3617
   1. If there are no capabilities left (all flags are clear) it is
 
3618
      not possible to log the statement at all, so we roll back the
 
3619
      statement and report an error.
 
3620
 
 
3621
   2. Statement mode is set, but the capabilities indicate that
 
3622
      statement format is not possible.
 
3623
 
 
3624
   3. Row mode is set, but the capabilities indicate that row
 
3625
      format is not possible.
 
3626
 
 
3627
   4. Statement is unsafe, but the capabilities indicate that row
 
3628
      format is not possible.
 
3629
 
 
3630
   If we are in MIXED mode, we then decide what logging format to use:
 
3631
 
 
3632
   1. If the statement is unsafe, row-based logging is used.
 
3633
 
 
3634
   2. If statement-based logging is not possible, row-based logging is
 
3635
      used.
 
3636
 
 
3637
   3. Otherwise, statement-based logging is used.
 
3638
 
 
3639
   @param thd    Client thread
 
3640
   @param tables Tables involved in the query
 
3641
 */
 
3642
 
 
3643
int decide_logging_format(THD *thd, TableList *tables)
 
3644
{
 
3645
  if (mysql_bin_log.is_open() && (thd->options & OPTION_BIN_LOG))
 
3646
  {
 
3647
    handler::Table_flags flags_some_set= handler::Table_flags();
 
3648
    handler::Table_flags flags_all_set= ~handler::Table_flags();
 
3649
    bool multi_engine= false;
 
3650
    void* prev_ht= NULL;
 
3651
    for (TableList *table= tables; table; table= table->next_global)
 
3652
    {
 
3653
      if (!table->placeholder() && table->lock_type >= TL_WRITE_ALLOW_WRITE)
 
3654
      {
 
3655
        uint64_t const flags= table->table->file->ha_table_flags();
 
3656
        if (prev_ht && prev_ht != table->table->file->ht)
 
3657
          multi_engine= true;
 
3658
        prev_ht= table->table->file->ht;
 
3659
        flags_all_set &= flags;
 
3660
        flags_some_set |= flags;
 
3661
      }
 
3662
    }
 
3663
 
 
3664
    int error= 0;
 
3665
    if (flags_all_set == 0)
 
3666
    {
 
3667
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
 
3668
               "Statement cannot be logged to the binary log in"
 
3669
               " row-based nor statement-based format");
 
3670
    }
 
3671
    else if (thd->variables.binlog_format == BINLOG_FORMAT_STMT &&
 
3672
             (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
 
3673
    {
 
3674
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
 
3675
                "Statement-based format required for this statement,"
 
3676
                " but not allowed by this combination of engines");
 
3677
    }
 
3678
    else if ((thd->variables.binlog_format == BINLOG_FORMAT_ROW ||
 
3679
              thd->lex->is_stmt_unsafe()) &&
 
3680
             (flags_all_set & HA_BINLOG_ROW_CAPABLE) == 0)
 
3681
    {
 
3682
      my_error((error= ER_BINLOG_LOGGING_IMPOSSIBLE), MYF(0),
 
3683
                "Row-based format required for this statement,"
 
3684
                " but not allowed by this combination of engines");
 
3685
    }
 
3686
 
 
3687
    /*
 
3688
      If more than one engine is involved in the statement and at
 
3689
      least one is doing it's own logging (is *self-logging*), the
 
3690
      statement cannot be logged atomically, so we generate an error
 
3691
      rather than allowing the binlog to become corrupt.
 
3692
     */
 
3693
    if (multi_engine &&
 
3694
        (flags_some_set & HA_HAS_OWN_BINLOGGING))
 
3695
    {
 
3696
      error= ER_BINLOG_LOGGING_IMPOSSIBLE;
 
3697
      my_error(error, MYF(0),
 
3698
               "Statement cannot be written atomically since more"
 
3699
               " than one engine involved and at least one engine"
 
3700
               " is self-logging");
 
3701
    }
 
3702
 
 
3703
    if (error)
 
3704
      return -1;
 
3705
 
 
3706
    /*
 
3707
      We switch to row-based format if we are in mixed mode and one of
 
3708
      the following are true:
 
3709
 
 
3710
      1. If the statement is unsafe
 
3711
      2. If statement format cannot be used
 
3712
 
 
3713
      Observe that point to cannot be decided before the tables
 
3714
      involved in a statement has been checked, i.e., we cannot put
 
3715
      this code in reset_current_stmt_binlog_row_based(), it has to be
 
3716
      here.
 
3717
    */
 
3718
    if (thd->lex->is_stmt_unsafe() ||
 
3719
        (flags_all_set & HA_BINLOG_STMT_CAPABLE) == 0)
 
3720
    {
 
3721
      thd->set_current_stmt_binlog_row_based_if_mixed();
 
3722
    }
 
3723
  }
 
3724
 
 
3725
  return 0;
1752
3726
}
1753
3727
 
1754
3728
/*
1755
3729
  Lock all tables in list
1756
3730
 
1757
3731
  SYNOPSIS
1758
 
  lock_tables()
1759
 
  session                       Thread Cursor
1760
 
  tables                Tables to lock
1761
 
  count         Number of opened tables
1762
 
  need_reopen         Out parameter which if true indicates that some
1763
 
  tables were dropped or altered during this call
1764
 
  and therefore invoker should reopen tables and
1765
 
  try to lock them once again (in this case
1766
 
  lock_tables() will also return error).
 
3732
    lock_tables()
 
3733
    thd                 Thread handler
 
3734
    tables              Tables to lock
 
3735
    count               Number of opened tables
 
3736
    need_reopen         Out parameter which if true indicates that some
 
3737
                        tables were dropped or altered during this call
 
3738
                        and therefore invoker should reopen tables and
 
3739
                        try to lock them once again (in this case
 
3740
                        lock_tables() will also return error).
1767
3741
 
1768
3742
  NOTES
1769
 
  You can't call lock_tables twice, as this would break the dead-lock-free
1770
 
  handling thr_lock gives us.  You most always get all needed locks at
1771
 
  once.
 
3743
    You can't call lock_tables twice, as this would break the dead-lock-free
 
3744
    handling thr_lock gives us.  You most always get all needed locks at
 
3745
    once.
1772
3746
 
1773
 
  If query for which we are calling this function marked as requring
1774
 
  prelocking, this function will do implicit LOCK TABLES and change
1775
 
  session::prelocked_mode accordingly.
 
3747
    If query for which we are calling this function marked as requring
 
3748
    prelocking, this function will do implicit LOCK TABLES and change
 
3749
    thd::prelocked_mode accordingly.
1776
3750
 
1777
3751
  RETURN VALUES
1778
 
  0     ok
1779
 
  -1    Error
 
3752
   0    ok
 
3753
   -1   Error
1780
3754
*/
1781
3755
 
1782
 
int Session::lock_tables(TableList *tables, uint32_t count, bool *need_reopen)
 
3756
int lock_tables(THD *thd, TableList *tables, uint count, bool *need_reopen)
1783
3757
{
1784
3758
  TableList *table;
1785
 
  Session *session= this;
1786
3759
 
1787
3760
  /*
1788
3761
    We can't meet statement requiring prelocking if we already
1790
3763
  */
1791
3764
  *need_reopen= false;
1792
3765
 
1793
 
  if (tables == NULL)
1794
 
    return 0;
1795
 
 
1796
 
  assert(session->lock == 0);   // You must lock everything at once
1797
 
  Table **start,**ptr;
1798
 
  uint32_t lock_flag= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN;
1799
 
 
1800
 
  if (!(ptr=start=(Table**) session->alloc(sizeof(Table*)*count)))
1801
 
    return -1;
1802
 
  for (table= tables; table; table= table->next_global)
1803
 
  {
1804
 
    if (!table->placeholder())
1805
 
      *(ptr++)= table->table;
1806
 
  }
1807
 
 
1808
 
  if (!(session->lock= session->lockTables(start, (uint32_t) (ptr - start), lock_flag, need_reopen)))
1809
 
  {
1810
 
    return -1;
1811
 
  }
1812
 
 
1813
 
  return 0;
 
3766
  if (!tables)
 
3767
    return(decide_logging_format(thd, tables));
 
3768
 
 
3769
  if (!thd->locked_tables)
 
3770
  {
 
3771
    assert(thd->lock == 0);     // You must lock everything at once
 
3772
    Table **start,**ptr;
 
3773
    uint lock_flag= DRIZZLE_LOCK_NOTIFY_IF_NEED_REOPEN;
 
3774
 
 
3775
    if (!(ptr=start=(Table**) thd->alloc(sizeof(Table*)*count)))
 
3776
      return(-1);
 
3777
    for (table= tables; table; table= table->next_global)
 
3778
    {
 
3779
      if (!table->placeholder())
 
3780
        *(ptr++)= table->table;
 
3781
    }
 
3782
 
 
3783
    if (!(thd->lock= mysql_lock_tables(thd, start, (uint) (ptr - start),
 
3784
                                       lock_flag, need_reopen)))
 
3785
    {
 
3786
      return(-1);
 
3787
    }
 
3788
  }
 
3789
  else
 
3790
  {
 
3791
    TableList *first_not_own= thd->lex->first_not_own_table();
 
3792
    /*
 
3793
      When open_and_lock_tables() is called for a single table out of
 
3794
      a table list, the 'next_global' chain is temporarily broken. We
 
3795
      may not find 'first_not_own' before the end of the "list".
 
3796
      Look for example at those places where open_n_lock_single_table()
 
3797
      is called. That function implements the temporary breaking of
 
3798
      a table list for opening a single table.
 
3799
    */
 
3800
    for (table= tables;
 
3801
         table && table != first_not_own;
 
3802
         table= table->next_global)
 
3803
    {
 
3804
      if (!table->placeholder() &&
 
3805
          check_lock_and_start_stmt(thd, table->table, table->lock_type))
 
3806
      {
 
3807
        return(-1);
 
3808
      }
 
3809
    }
 
3810
  }
 
3811
 
 
3812
  return(decide_logging_format(thd, tables));
 
3813
}
 
3814
 
 
3815
 
 
3816
/*
 
3817
  Prepare statement for reopening of tables and recalculation of set of
 
3818
  prelocked tables.
 
3819
 
 
3820
  SYNOPSIS
 
3821
    close_tables_for_reopen()
 
3822
      thd    in     Thread context
 
3823
      tables in/out List of tables which we were trying to open and lock
 
3824
 
 
3825
*/
 
3826
 
 
3827
void close_tables_for_reopen(THD *thd, TableList **tables)
 
3828
{
 
3829
  /*
 
3830
    If table list consists only from tables from prelocking set, table list
 
3831
    for new attempt should be empty, so we have to update list's root pointer.
 
3832
  */
 
3833
  if (thd->lex->first_not_own_table() == *tables)
 
3834
    *tables= 0;
 
3835
  thd->lex->chop_off_not_own_tables();
 
3836
  for (TableList *tmp= *tables; tmp; tmp= tmp->next_global)
 
3837
    tmp->table= 0;
 
3838
  close_thread_tables(thd);
1814
3839
}
1815
3840
 
1816
3841
 
1818
3843
  Open a single table without table caching and don't set it in open_list
1819
3844
 
1820
3845
  SYNPOSIS
1821
 
  open_temporary_table()
1822
 
  session                 Thread object
1823
 
  path    Path (without .frm)
1824
 
  db              database
1825
 
  table_name      Table name
1826
 
  link_in_list  1 if table should be linked into session->temporary_tables
1827
 
 
1828
 
NOTES:
1829
 
Used by alter_table to open a temporary table and when creating
1830
 
a temporary table with CREATE TEMPORARY ...
1831
 
 
1832
 
RETURN
1833
 
0  Error
1834
 
#  Table object
 
3846
    open_temporary_table()
 
3847
    thd           Thread object
 
3848
    path          Path (without .frm)
 
3849
    db            database
 
3850
    table_name    Table name
 
3851
    link_in_list  1 if table should be linked into thd->temporary_tables
 
3852
 
 
3853
 NOTES:
 
3854
    Used by alter_table to open a temporary table and when creating
 
3855
    a temporary table with CREATE TEMPORARY ...
 
3856
 
 
3857
 RETURN
 
3858
   0  Error
 
3859
   #  Table object
1835
3860
*/
1836
3861
 
1837
 
Table *Open_tables_state::open_temporary_table(const TableIdentifier &identifier,
1838
 
                                               bool link_in_list)
 
3862
Table *open_temporary_table(THD *thd, const char *path, const char *db,
 
3863
                            const char *table_name, bool link_in_list,
 
3864
                            open_table_mode open_mode)
1839
3865
{
1840
 
  assert(identifier.isTmp());
1841
 
 
1842
 
 
1843
 
  table::Temporary *new_tmp_table= new table::Temporary(identifier.getType(),
1844
 
                                                        identifier,
1845
 
                                                        const_cast<char *>(const_cast<TableIdentifier&>(identifier).getPath().c_str()),
1846
 
                                                        static_cast<uint32_t>(identifier.getPath().length()));
1847
 
  if (not new_tmp_table)
1848
 
    return NULL;
1849
 
 
1850
 
  /*
1851
 
    First open the share, and then open the table from the share we just opened.
1852
 
  */
1853
 
  if (new_tmp_table->getMutableShare()->open_table_def(*static_cast<Session *>(this), identifier) ||
1854
 
      new_tmp_table->getMutableShare()->open_table_from_share(static_cast<Session *>(this), identifier, identifier.getTableName().c_str(),
1855
 
                                                              (uint32_t) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
1856
 
                                                                          HA_GET_INDEX),
1857
 
                                                              ha_open_options,
1858
 
                                                              *new_tmp_table))
 
3866
  Table *tmp_table;
 
3867
  TABLE_SHARE *share;
 
3868
  char cache_key[MAX_DBKEY_LENGTH], *saved_cache_key, *tmp_path;
 
3869
  uint key_length;
 
3870
  TableList table_list;
 
3871
 
 
3872
  table_list.db=         (char*) db;
 
3873
  table_list.table_name= (char*) table_name;
 
3874
  /* Create the cache_key for temporary tables */
 
3875
  key_length= create_table_def_key(thd, cache_key, &table_list, 1);
 
3876
 
 
3877
  if (!(tmp_table= (Table*) my_malloc(sizeof(*tmp_table) + sizeof(*share) +
 
3878
                                      strlen(path)+1 + key_length,
 
3879
                                      MYF(MY_WME))))
 
3880
    return(0);                          /* purecov: inspected */
 
3881
 
 
3882
  share= (TABLE_SHARE*) (tmp_table+1);
 
3883
  tmp_path= (char*) (share+1);
 
3884
  saved_cache_key= stpcpy(tmp_path, path)+1;
 
3885
  memcpy(saved_cache_key, cache_key, key_length);
 
3886
 
 
3887
  init_tmp_table_share(thd, share, saved_cache_key, key_length,
 
3888
                       strchr(saved_cache_key, '\0')+1, tmp_path);
 
3889
 
 
3890
  if (open_table_def(thd, share, 0) ||
 
3891
      open_table_from_share(thd, share, table_name,
 
3892
                            (open_mode == OTM_ALTER) ? 0 :
 
3893
                            (uint) (HA_OPEN_KEYFILE | HA_OPEN_RNDFILE |
 
3894
                                    HA_GET_INDEX),
 
3895
                            (open_mode == OTM_ALTER) ?
 
3896
                              (EXTRA_RECORD | OPEN_FRM_FILE_ONLY)
 
3897
                            : (EXTRA_RECORD),
 
3898
                            ha_open_options,
 
3899
                            tmp_table, open_mode))
1859
3900
  {
1860
3901
    /* No need to lock share->mutex as this is not needed for tmp tables */
1861
 
    delete new_tmp_table->getMutableShare();
1862
 
    delete new_tmp_table;
1863
 
 
1864
 
    return 0;
1865
 
  }
1866
 
 
1867
 
  new_tmp_table->reginfo.lock_type= TL_WRITE;    // Simulate locked
 
3902
    free_table_share(share);
 
3903
    my_free((char*) tmp_table,MYF(0));
 
3904
    return(0);
 
3905
  }
 
3906
 
 
3907
  tmp_table->reginfo.lock_type= TL_WRITE;        // Simulate locked
 
3908
  if (open_mode == OTM_ALTER)
 
3909
  {
 
3910
    /*
 
3911
       Temporary table has been created with frm_only
 
3912
       and has not been created in any storage engine
 
3913
    */
 
3914
    share->tmp_table= TMP_TABLE_FRM_FILE_ONLY;
 
3915
  }
 
3916
  else
 
3917
    share->tmp_table= (tmp_table->file->has_transactions() ?
 
3918
                       TRANSACTIONAL_TMP_TABLE : NON_TRANSACTIONAL_TMP_TABLE);
1868
3919
 
1869
3920
  if (link_in_list)
1870
3921
  {
1871
3922
    /* growing temp list at the head */
1872
 
    new_tmp_table->setNext(this->temporary_tables);
1873
 
    if (new_tmp_table->getNext())
1874
 
    {
1875
 
      new_tmp_table->getNext()->setPrev(new_tmp_table);
1876
 
    }
1877
 
    this->temporary_tables= new_tmp_table;
1878
 
    this->temporary_tables->setPrev(0);
1879
 
  }
1880
 
  new_tmp_table->pos_in_table_list= 0;
1881
 
 
1882
 
  return new_tmp_table;
 
3923
    tmp_table->next= thd->temporary_tables;
 
3924
    if (tmp_table->next)
 
3925
      tmp_table->next->prev= tmp_table;
 
3926
    thd->temporary_tables= tmp_table;
 
3927
    thd->temporary_tables->prev= 0;
 
3928
    if (thd->slave_thread)
 
3929
      slave_open_temp_tables++;
 
3930
  }
 
3931
  tmp_table->pos_in_table_list= 0;
 
3932
  return(tmp_table);
 
3933
}
 
3934
 
 
3935
 
 
3936
bool rm_temporary_table(handlerton *base, char *path, bool frm_only)
 
3937
{
 
3938
  bool error=0;
 
3939
  handler *file;
 
3940
  char *ext;
 
3941
 
 
3942
  stpcpy(ext= strchr(path, '\0'), reg_ext);
 
3943
  if (my_delete(path,MYF(0)))
 
3944
    error=1; /* purecov: inspected */
 
3945
  *ext= 0;                              // remove extension
 
3946
  file= get_new_handler((TABLE_SHARE*) 0, current_thd->mem_root, base);
 
3947
  if (!frm_only && file && file->ha_delete_table(path))
 
3948
  {
 
3949
    error=1;
 
3950
    sql_print_warning(_("Could not remove temporary table: '%s', error: %d"),
 
3951
                      path, my_errno);
 
3952
  }
 
3953
  delete file;
 
3954
  return(error);
1883
3955
}
1884
3956
 
1885
3957
 
1886
3958
/*****************************************************************************
1887
 
 * The following find_field_in_XXX procedures implement the core of the
1888
 
 * name resolution functionality. The entry point to resolve a column name in a
1889
 
 * list of tables is 'find_field_in_tables'. It calls 'find_field_in_table_ref'
1890
 
 * for each table reference. In turn, depending on the type of table reference,
1891
 
 * 'find_field_in_table_ref' calls one of the 'find_field_in_XXX' procedures
1892
 
 * below specific for the type of table reference.
1893
 
 ******************************************************************************/
 
3959
* The following find_field_in_XXX procedures implement the core of the
 
3960
* name resolution functionality. The entry point to resolve a column name in a
 
3961
* list of tables is 'find_field_in_tables'. It calls 'find_field_in_table_ref'
 
3962
* for each table reference. In turn, depending on the type of table reference,
 
3963
* 'find_field_in_table_ref' calls one of the 'find_field_in_XXX' procedures
 
3964
* below specific for the type of table reference.
 
3965
******************************************************************************/
1894
3966
 
1895
3967
/* Special Field pointers as return values of find_field_in_XXX functions. */
1896
3968
Field *not_found_field= (Field*) 0x1;
1897
 
Field *view_ref_found= (Field*) 0x2;
1898
 
 
1899
 
static void update_field_dependencies(Session *session, Field *field, Table *table)
 
3969
Field *view_ref_found= (Field*) 0x2; 
 
3970
 
 
3971
#define WRONG_GRANT (Field*) -1
 
3972
 
 
3973
static void update_field_dependencies(THD *thd, Field *field, Table *table)
1900
3974
{
1901
 
  if (session->mark_used_columns != MARK_COLUMNS_NONE)
 
3975
  if (thd->mark_used_columns != MARK_COLUMNS_NONE)
1902
3976
  {
1903
 
    boost::dynamic_bitset<> *current_bitmap= NULL;
 
3977
    MY_BITMAP *current_bitmap, *other_bitmap;
1904
3978
 
1905
3979
    /*
1906
3980
      We always want to register the used keys, as the column bitmap may have
1907
3981
      been set for all fields (for example for view).
1908
3982
    */
1909
 
 
1910
 
    table->covering_keys&= field->part_of_key;
1911
 
    table->merge_keys|= field->part_of_key;
1912
 
 
1913
 
    if (session->mark_used_columns == MARK_COLUMNS_READ)
 
3983
      
 
3984
    table->covering_keys.intersect(field->part_of_key);
 
3985
    table->merge_keys.merge(field->part_of_key);
 
3986
 
 
3987
    if (thd->mark_used_columns == MARK_COLUMNS_READ)
1914
3988
    {
1915
3989
      current_bitmap= table->read_set;
 
3990
      other_bitmap=   table->write_set;
1916
3991
    }
1917
3992
    else
1918
3993
    {
1919
3994
      current_bitmap= table->write_set;
 
3995
      other_bitmap=   table->read_set;
1920
3996
    }
1921
3997
 
1922
 
    //if (current_bitmap->testAndSet(field->position()))
1923
 
    if (current_bitmap->test(field->position()))
 
3998
    if (bitmap_fast_test_and_set(current_bitmap, field->field_index))
1924
3999
    {
1925
 
      if (session->mark_used_columns == MARK_COLUMNS_WRITE)
1926
 
        session->dup_field= field;
 
4000
      if (thd->mark_used_columns == MARK_COLUMNS_WRITE)
 
4001
        thd->dup_field= field;
1927
4002
      return;
1928
4003
    }
 
4004
    if (table->get_fields_in_item_tree)
 
4005
      field->flags|= GET_FIXED_FIELDS_FLAG;
1929
4006
    table->used_fields++;
1930
4007
  }
 
4008
  else if (table->get_fields_in_item_tree)
 
4009
    field->flags|= GET_FIXED_FIELDS_FLAG;
 
4010
  return;
1931
4011
}
1932
4012
 
1933
4013
 
1935
4015
  Find field by name in a NATURAL/USING join table reference.
1936
4016
 
1937
4017
  SYNOPSIS
1938
 
  find_field_in_natural_join()
1939
 
  session                        [in]  thread Cursor
1940
 
  table_ref            [in]  table reference to search
1941
 
  name           [in]  name of field
1942
 
  length                 [in]  length of name
1943
 
  ref                  [in/out] if 'name' is resolved to a view field, ref is
1944
 
  set to point to the found view field
1945
 
  register_tree_change [in]  true if ref is not stack variable and we
1946
 
  need register changes in item tree
1947
 
  actual_table         [out] the original table reference where the field
1948
 
  belongs - differs from 'table_list' only for
1949
 
  NATURAL/USING joins
 
4018
    find_field_in_natural_join()
 
4019
    thd                  [in]  thread handler
 
4020
    table_ref            [in]  table reference to search
 
4021
    name                 [in]  name of field
 
4022
    length               [in]  length of name
 
4023
    ref                  [in/out] if 'name' is resolved to a view field, ref is
 
4024
                               set to point to the found view field
 
4025
    register_tree_change [in]  true if ref is not stack variable and we
 
4026
                               need register changes in item tree
 
4027
    actual_table         [out] the original table reference where the field
 
4028
                               belongs - differs from 'table_list' only for
 
4029
                               NATURAL/USING joins
1950
4030
 
1951
4031
  DESCRIPTION
1952
 
  Search for a field among the result fields of a NATURAL/USING join.
1953
 
  Notice that this procedure is called only for non-qualified field
1954
 
  names. In the case of qualified fields, we search directly the base
1955
 
  tables of a natural join.
 
4032
    Search for a field among the result fields of a NATURAL/USING join.
 
4033
    Notice that this procedure is called only for non-qualified field
 
4034
    names. In the case of qualified fields, we search directly the base
 
4035
    tables of a natural join.
1956
4036
 
1957
4037
  RETURN
1958
 
  NULL        if the field was not found
1959
 
  PTR         Pointer to the found Field
 
4038
    NULL        if the field was not found
 
4039
    WRONG_GRANT if no access rights to the found field
 
4040
    #           Pointer to the found Field
1960
4041
*/
1961
4042
 
1962
4043
static Field *
1963
 
find_field_in_natural_join(Session *session, TableList *table_ref,
1964
 
                           const char *name, uint32_t , Item **,
1965
 
                           bool, TableList **actual_table)
 
4044
find_field_in_natural_join(THD *thd, TableList *table_ref, const char *name,
 
4045
                           uint length __attribute__((unused)),
 
4046
                           Item **ref __attribute__((unused)), bool register_tree_change __attribute__((unused)),
 
4047
                           TableList **actual_table)
1966
4048
{
1967
4049
  List_iterator_fast<Natural_join_column>
1968
4050
    field_it(*(table_ref->join_columns));
1972
4054
  assert(table_ref->is_natural_join && table_ref->join_columns);
1973
4055
  assert(*actual_table == NULL);
1974
4056
 
1975
 
  for (nj_col= NULL, curr_nj_col= field_it++; curr_nj_col;
 
4057
  for (nj_col= NULL, curr_nj_col= field_it++; curr_nj_col; 
1976
4058
       curr_nj_col= field_it++)
1977
4059
  {
1978
4060
    if (!my_strcasecmp(system_charset_info, curr_nj_col->name(), name))
1979
4061
    {
1980
4062
      if (nj_col)
1981
4063
      {
1982
 
        my_error(ER_NON_UNIQ_ERROR, MYF(0), name, session->where);
1983
 
        return NULL;
 
4064
        my_error(ER_NON_UNIQ_ERROR, MYF(0), name, thd->where);
 
4065
        return(NULL);
1984
4066
      }
1985
4067
      nj_col= curr_nj_col;
1986
4068
    }
1987
4069
  }
1988
4070
  if (!nj_col)
1989
 
    return NULL;
 
4071
    return(NULL);
1990
4072
  {
1991
4073
    /* This is a base table. */
1992
 
    assert(nj_col->table_ref->table == nj_col->table_field->getTable());
 
4074
    assert(nj_col->table_ref->table == nj_col->table_field->table);
1993
4075
    found_field= nj_col->table_field;
1994
 
    update_field_dependencies(session, found_field, nj_col->table_ref->table);
 
4076
    update_field_dependencies(thd, found_field, nj_col->table_ref->table);
1995
4077
  }
1996
4078
 
1997
4079
  *actual_table= nj_col->table_ref;
1998
 
 
 
4080
  
1999
4081
  return(found_field);
2000
4082
}
2001
4083
 
2004
4086
  Find field by name in a base table or a view with temp table algorithm.
2005
4087
 
2006
4088
  SYNOPSIS
2007
 
  find_field_in_table()
2008
 
  session                               thread Cursor
2009
 
  table                 table where to search for the field
2010
 
  name                  name of field
2011
 
  length                        length of name
2012
 
  allow_rowid                   do allow finding of "_rowid" field?
2013
 
  cached_field_index_ptr        cached position in field list (used to speedup
2014
 
  lookup for fields in prepared tables)
 
4089
    find_field_in_table()
 
4090
    thd                         thread handler
 
4091
    table                       table where to search for the field
 
4092
    name                        name of field
 
4093
    length                      length of name
 
4094
    allow_rowid                 do allow finding of "_rowid" field?
 
4095
    cached_field_index_ptr      cached position in field list (used to speedup
 
4096
                                lookup for fields in prepared tables)
2015
4097
 
2016
4098
  RETURN
2017
 
  0     field is not found
2018
 
#       pointer to field
 
4099
    0   field is not found
 
4100
    #   pointer to field
2019
4101
*/
2020
4102
 
2021
4103
Field *
2022
 
find_field_in_table(Session *session, Table *table, const char *name, uint32_t length,
2023
 
                    bool allow_rowid, uint32_t *cached_field_index_ptr)
 
4104
find_field_in_table(THD *thd, Table *table, const char *name, uint length,
 
4105
                    bool allow_rowid, uint *cached_field_index_ptr)
2024
4106
{
2025
4107
  Field **field_ptr, *field;
2026
 
  uint32_t cached_field_index= *cached_field_index_ptr;
 
4108
  uint cached_field_index= *cached_field_index_ptr;
2027
4109
 
2028
4110
  /* We assume here that table->field < NO_CACHED_FIELD_INDEX = UINT_MAX */
2029
 
  if (cached_field_index < table->getShare()->sizeFields() &&
 
4111
  if (cached_field_index < table->s->fields &&
2030
4112
      !my_strcasecmp(system_charset_info,
2031
 
                     table->getField(cached_field_index)->field_name, name))
2032
 
  {
2033
 
    field_ptr= table->getFields() + cached_field_index;
2034
 
  }
2035
 
  else if (table->getShare()->getNamedFieldSize())
2036
 
  {
2037
 
    field_ptr= table->getMutableShare()->getNamedField(std::string(name, length));
 
4113
                     table->field[cached_field_index]->field_name, name))
 
4114
    field_ptr= table->field + cached_field_index;
 
4115
  else if (table->s->name_hash.records)
 
4116
  {
 
4117
    field_ptr= (Field**) hash_search(&table->s->name_hash, (uchar*) name,
 
4118
                                     length);
2038
4119
    if (field_ptr)
2039
4120
    {
2040
4121
      /*
2041
 
        field_ptr points to field in TableShare. Convert it to the matching
 
4122
        field_ptr points to field in TABLE_SHARE. Convert it to the matching
2042
4123
        field in table
2043
4124
      */
2044
 
      field_ptr= (table->getFields() + table->getShare()->positionFields(field_ptr));
 
4125
      field_ptr= (table->field + (field_ptr - table->s->field));
2045
4126
    }
2046
4127
  }
2047
4128
  else
2048
4129
  {
2049
 
    if (!(field_ptr= table->getFields()))
 
4130
    if (!(field_ptr= table->field))
2050
4131
      return((Field *)0);
2051
4132
    for (; *field_ptr; ++field_ptr)
2052
4133
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
2055
4136
 
2056
4137
  if (field_ptr && *field_ptr)
2057
4138
  {
2058
 
    *cached_field_index_ptr= field_ptr - table->getFields();
 
4139
    *cached_field_index_ptr= field_ptr - table->field;
2059
4140
    field= *field_ptr;
2060
4141
  }
2061
4142
  else
2062
4143
  {
2063
4144
    if (!allow_rowid ||
2064
4145
        my_strcasecmp(system_charset_info, name, "_rowid") ||
2065
 
        table->getShare()->rowid_field_offset == 0)
 
4146
        table->s->rowid_field_offset == 0)
2066
4147
      return((Field*) 0);
2067
 
    field= table->getField(table->getShare()->rowid_field_offset-1);
 
4148
    field= table->field[table->s->rowid_field_offset-1];
2068
4149
  }
2069
4150
 
2070
 
  update_field_dependencies(session, field, table);
 
4151
  update_field_dependencies(thd, field, table);
2071
4152
 
2072
 
  return field;
 
4153
  return(field);
2073
4154
}
2074
4155
 
2075
4156
 
2077
4158
  Find field in a table reference.
2078
4159
 
2079
4160
  SYNOPSIS
2080
 
  find_field_in_table_ref()
2081
 
  session                          [in]  thread Cursor
2082
 
  table_list               [in]  table reference to search
2083
 
  name             [in]  name of field
2084
 
  length                   [in]  field length of name
2085
 
  item_name              [in]  name of item if it will be created (VIEW)
2086
 
  db_name                [in]  optional database name that qualifies the
2087
 
  table_name             [in]  optional table name that qualifies the field
2088
 
  ref                  [in/out] if 'name' is resolved to a view field, ref
2089
 
  is set to point to the found view field
2090
 
  allow_rowid              [in]  do allow finding of "_rowid" field?
2091
 
  cached_field_index_ptr [in]  cached position in field list (used to
2092
 
  speedup lookup for fields in prepared tables)
2093
 
  register_tree_change   [in]  true if ref is not stack variable and we
2094
 
  need register changes in item tree
2095
 
  actual_table           [out] the original table reference where the field
2096
 
  belongs - differs from 'table_list' only for
2097
 
  NATURAL_USING joins.
 
4161
    find_field_in_table_ref()
 
4162
    thd                    [in]  thread handler
 
4163
    table_list             [in]  table reference to search
 
4164
    name                   [in]  name of field
 
4165
    length                 [in]  field length of name
 
4166
    item_name              [in]  name of item if it will be created (VIEW)
 
4167
    db_name                [in]  optional database name that qualifies the
 
4168
    table_name             [in]  optional table name that qualifies the field
 
4169
    ref                [in/out] if 'name' is resolved to a view field, ref
 
4170
                                 is set to point to the found view field
 
4171
    check_privileges       [in]  check privileges
 
4172
    allow_rowid            [in]  do allow finding of "_rowid" field?
 
4173
    cached_field_index_ptr [in]  cached position in field list (used to
 
4174
                                 speedup lookup for fields in prepared tables)
 
4175
    register_tree_change   [in]  true if ref is not stack variable and we
 
4176
                                 need register changes in item tree
 
4177
    actual_table           [out] the original table reference where the field
 
4178
                                 belongs - differs from 'table_list' only for
 
4179
                                 NATURAL_USING joins.
2098
4180
 
2099
4181
  DESCRIPTION
2100
 
  Find a field in a table reference depending on the type of table
2101
 
  reference. There are three types of table references with respect
2102
 
  to the representation of their result columns:
2103
 
  - an array of Field_translator objects for MERGE views and some
2104
 
  information_schema tables,
2105
 
  - an array of Field objects (and possibly a name hash) for stored
2106
 
  tables,
2107
 
  - a list of Natural_join_column objects for NATURAL/USING joins.
2108
 
  This procedure detects the type of the table reference 'table_list'
2109
 
  and calls the corresponding search routine.
 
4182
    Find a field in a table reference depending on the type of table
 
4183
    reference. There are three types of table references with respect
 
4184
    to the representation of their result columns:
 
4185
    - an array of Field_translator objects for MERGE views and some
 
4186
      information_schema tables,
 
4187
    - an array of Field objects (and possibly a name hash) for stored
 
4188
      tables,
 
4189
    - a list of Natural_join_column objects for NATURAL/USING joins.
 
4190
    This procedure detects the type of the table reference 'table_list'
 
4191
    and calls the corresponding search routine.
2110
4192
 
2111
4193
  RETURN
2112
 
  0                     field is not found
2113
 
  view_ref_found        found value in VIEW (real result is in *ref)
2114
 
#                       pointer to field
 
4194
    0                   field is not found
 
4195
    view_ref_found      found value in VIEW (real result is in *ref)
 
4196
    #                   pointer to field
2115
4197
*/
2116
4198
 
2117
4199
Field *
2118
 
find_field_in_table_ref(Session *session, TableList *table_list,
2119
 
                        const char *name, uint32_t length,
 
4200
find_field_in_table_ref(THD *thd, TableList *table_list,
 
4201
                        const char *name, uint length,
2120
4202
                        const char *item_name, const char *db_name,
2121
4203
                        const char *table_name, Item **ref,
2122
 
                        bool allow_rowid,
2123
 
                        uint32_t *cached_field_index_ptr,
 
4204
                        bool check_privileges, bool allow_rowid,
 
4205
                        uint *cached_field_index_ptr,
2124
4206
                        bool register_tree_change, TableList **actual_table)
2125
4207
{
2126
4208
  Field *fld= NULL;
2143
4225
    inside the view, but we want to search directly in the view columns
2144
4226
    which are represented as a 'field_translation'.
2145
4227
 
2146
 
    TODO-> Ensure that table_name, db_name and tables->db always points to something !
 
4228
    TODO: Ensure that table_name, db_name and tables->db always points to
 
4229
          something !
2147
4230
  */
2148
4231
  if (/* Exclude nested joins. */
2149
 
      (!table_list->getNestedJoin()) &&
2150
 
      /* Include merge views and information schema tables. */
 
4232
      (!table_list->nested_join ||
 
4233
       /* Include merge views and information schema tables. */
 
4234
       table_list->field_translation) &&
2151
4235
      /*
2152
4236
        Test if the field qualifiers match the table reference we plan
2153
4237
        to search.
2154
4238
      */
2155
4239
      table_name && table_name[0] &&
2156
4240
      (my_strcasecmp(table_alias_charset, table_list->alias, table_name) ||
2157
 
       (db_name && db_name[0] && table_list->getSchemaName() && table_list->getSchemaName()[0] &&
2158
 
        strcmp(db_name, table_list->getSchemaName()))))
2159
 
    return 0;
 
4241
       (db_name && db_name[0] && table_list->db && table_list->db[0] &&
 
4242
        strcmp(db_name, table_list->db))))
 
4243
    return(0);
2160
4244
 
2161
4245
  *actual_table= NULL;
2162
4246
 
2163
 
  if (!table_list->getNestedJoin())
 
4247
  if (table_list->field_translation)
 
4248
  {
 
4249
  }
 
4250
  else if (!table_list->nested_join)
2164
4251
  {
2165
4252
    /* 'table_list' is a stored table. */
2166
4253
    assert(table_list->table);
2167
 
    if ((fld= find_field_in_table(session, table_list->table, name, length,
 
4254
    if ((fld= find_field_in_table(thd, table_list->table, name, length,
2168
4255
                                  allow_rowid,
2169
4256
                                  cached_field_index_ptr)))
2170
4257
      *actual_table= table_list;
2180
4267
    */
2181
4268
    if (table_name && table_name[0])
2182
4269
    {
2183
 
      List_iterator<TableList> it(table_list->getNestedJoin()->join_list);
 
4270
      List_iterator<TableList> it(table_list->nested_join->join_list);
2184
4271
      TableList *table;
2185
4272
      while ((table= it++))
2186
4273
      {
2187
 
        if ((fld= find_field_in_table_ref(session, table, name, length, item_name,
 
4274
        if ((fld= find_field_in_table_ref(thd, table, name, length, item_name,
2188
4275
                                          db_name, table_name, ref,
2189
 
                                          allow_rowid,
 
4276
                                          check_privileges, allow_rowid,
2190
4277
                                          cached_field_index_ptr,
2191
4278
                                          register_tree_change, actual_table)))
2192
 
          return fld;
 
4279
          return(fld);
2193
4280
      }
2194
 
      return NULL;
 
4281
      return(0);
2195
4282
    }
2196
4283
    /*
2197
4284
      Non-qualified field, search directly in the result columns of the
2199
4286
      natural join, thus if the field is not qualified, we will search
2200
4287
      directly the top-most NATURAL/USING join.
2201
4288
    */
2202
 
    fld= find_field_in_natural_join(session, table_list, name, length, ref,
 
4289
    fld= find_field_in_natural_join(thd, table_list, name, length, ref,
2203
4290
                                    register_tree_change, actual_table);
2204
4291
  }
2205
4292
 
2206
4293
  if (fld)
2207
4294
  {
2208
 
    if (session->mark_used_columns != MARK_COLUMNS_NONE)
2209
 
    {
2210
 
      /*
2211
 
        Get rw_set correct for this field so that the Cursor
2212
 
        knows that this field is involved in the query and gets
2213
 
        retrieved/updated
2214
 
      */
2215
 
      Field *field_to_set= NULL;
2216
 
      if (fld == view_ref_found)
2217
 
      {
2218
 
        Item *it= (*ref)->real_item();
2219
 
        if (it->type() == Item::FIELD_ITEM)
2220
 
          field_to_set= ((Item_field*)it)->field;
2221
 
        else
2222
 
        {
2223
 
          if (session->mark_used_columns == MARK_COLUMNS_READ)
2224
 
            it->walk(&Item::register_field_in_read_map, 1, (unsigned char *) 0);
2225
 
        }
2226
 
      }
2227
 
      else
2228
 
        field_to_set= fld;
2229
 
      if (field_to_set)
2230
 
      {
2231
 
        Table *table= field_to_set->getTable();
2232
 
        if (session->mark_used_columns == MARK_COLUMNS_READ)
2233
 
          table->setReadSet(field_to_set->position());
2234
 
        else
2235
 
          table->setWriteSet(field_to_set->position());
2236
 
      }
2237
 
    }
 
4295
      if (thd->mark_used_columns != MARK_COLUMNS_NONE)
 
4296
      {
 
4297
        /*
 
4298
          Get rw_set correct for this field so that the handler
 
4299
          knows that this field is involved in the query and gets
 
4300
          retrieved/updated
 
4301
         */
 
4302
        Field *field_to_set= NULL;
 
4303
        if (fld == view_ref_found)
 
4304
        {
 
4305
          Item *it= (*ref)->real_item();
 
4306
          if (it->type() == Item::FIELD_ITEM)
 
4307
            field_to_set= ((Item_field*)it)->field;
 
4308
          else
 
4309
          {
 
4310
            if (thd->mark_used_columns == MARK_COLUMNS_READ)
 
4311
              it->walk(&Item::register_field_in_read_map, 1, (uchar *) 0);
 
4312
          }
 
4313
        }
 
4314
        else
 
4315
          field_to_set= fld;
 
4316
        if (field_to_set)
 
4317
        {
 
4318
          Table *table= field_to_set->table;
 
4319
          if (thd->mark_used_columns == MARK_COLUMNS_READ)
 
4320
            bitmap_set_bit(table->read_set, field_to_set->field_index);
 
4321
          else
 
4322
            bitmap_set_bit(table->write_set, field_to_set->field_index);
 
4323
        }
 
4324
      }
2238
4325
  }
2239
4326
  return(fld);
2240
4327
}
2241
4328
 
2242
4329
 
2243
4330
/*
 
4331
  Find field in table, no side effects, only purpose is to check for field
 
4332
  in table object and get reference to the field if found.
 
4333
 
 
4334
  SYNOPSIS
 
4335
  find_field_in_table_sef()
 
4336
 
 
4337
  table                         table where to find
 
4338
  name                          Name of field searched for
 
4339
 
 
4340
  RETURN
 
4341
    0                   field is not found
 
4342
    #                   pointer to field
 
4343
*/
 
4344
 
 
4345
Field *find_field_in_table_sef(Table *table, const char *name)
 
4346
{
 
4347
  Field **field_ptr;
 
4348
  if (table->s->name_hash.records)
 
4349
  {
 
4350
    field_ptr= (Field**)hash_search(&table->s->name_hash,(uchar*) name,
 
4351
                                    strlen(name));
 
4352
    if (field_ptr)
 
4353
    {
 
4354
      /*
 
4355
        field_ptr points to field in TABLE_SHARE. Convert it to the matching
 
4356
        field in table
 
4357
      */
 
4358
      field_ptr= (table->field + (field_ptr - table->s->field));
 
4359
    }
 
4360
  }
 
4361
  else
 
4362
  {
 
4363
    if (!(field_ptr= table->field))
 
4364
      return (Field *)0;
 
4365
    for (; *field_ptr; ++field_ptr)
 
4366
      if (!my_strcasecmp(system_charset_info, (*field_ptr)->field_name, name))
 
4367
        break;
 
4368
  }
 
4369
  if (field_ptr)
 
4370
    return *field_ptr;
 
4371
  else
 
4372
    return (Field *)0;
 
4373
}
 
4374
 
 
4375
 
 
4376
/*
2244
4377
  Find field in table list.
2245
4378
 
2246
4379
  SYNOPSIS
2247
 
  find_field_in_tables()
2248
 
  session                         pointer to current thread structure
2249
 
  item            field item that should be found
2250
 
  first_table           list of tables to be searched for item
2251
 
  last_table            end of the list of tables to search for item. If NULL
2252
 
  then search to the end of the list 'first_table'.
2253
 
  ref                     if 'item' is resolved to a view field, ref is set to
2254
 
  point to the found view field
2255
 
  report_error    Degree of error reporting:
2256
 
  - IGNORE_ERRORS then do not report any error
2257
 
  - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
2258
 
  fields, suppress all other errors
2259
 
  - REPORT_EXCEPT_NON_UNIQUE report all other errors
2260
 
  except when non-unique fields were found
2261
 
  - REPORT_ALL_ERRORS
2262
 
  register_tree_change  true if ref is not a stack variable and we
2263
 
  to need register changes in item tree
 
4380
    find_field_in_tables()
 
4381
    thd                   pointer to current thread structure
 
4382
    item                  field item that should be found
 
4383
    first_table           list of tables to be searched for item
 
4384
    last_table            end of the list of tables to search for item. If NULL
 
4385
                          then search to the end of the list 'first_table'.
 
4386
    ref                   if 'item' is resolved to a view field, ref is set to
 
4387
                          point to the found view field
 
4388
    report_error          Degree of error reporting:
 
4389
                          - IGNORE_ERRORS then do not report any error
 
4390
                          - IGNORE_EXCEPT_NON_UNIQUE report only non-unique
 
4391
                            fields, suppress all other errors
 
4392
                          - REPORT_EXCEPT_NON_UNIQUE report all other errors
 
4393
                            except when non-unique fields were found
 
4394
                          - REPORT_ALL_ERRORS
 
4395
    check_privileges      need to check privileges
 
4396
    register_tree_change  true if ref is not a stack variable and we
 
4397
                          to need register changes in item tree
2264
4398
 
2265
4399
  RETURN VALUES
2266
 
  0                     If error: the found field is not unique, or there are
2267
 
  no sufficient access priviliges for the found field,
2268
 
  or the field is qualified with non-existing table.
2269
 
  not_found_field       The function was called with report_error ==
2270
 
  (IGNORE_ERRORS || IGNORE_EXCEPT_NON_UNIQUE) and a
2271
 
  field was not found.
2272
 
  view_ref_found        View field is found, item passed through ref parameter
2273
 
  found field         If a item was resolved to some field
 
4400
    0                   If error: the found field is not unique, or there are
 
4401
                        no sufficient access priviliges for the found field,
 
4402
                        or the field is qualified with non-existing table.
 
4403
    not_found_field     The function was called with report_error ==
 
4404
                        (IGNORE_ERRORS || IGNORE_EXCEPT_NON_UNIQUE) and a
 
4405
                        field was not found.
 
4406
    view_ref_found      View field is found, item passed through ref parameter
 
4407
    found field         If a item was resolved to some field
2274
4408
*/
2275
4409
 
2276
4410
Field *
2277
 
find_field_in_tables(Session *session, Item_ident *item,
 
4411
find_field_in_tables(THD *thd, Item_ident *item,
2278
4412
                     TableList *first_table, TableList *last_table,
2279
 
                     Item **ref, find_item_error_report_type report_error,
2280
 
                     bool register_tree_change)
 
4413
                     Item **ref, find_item_error_report_type report_error,
 
4414
                     bool check_privileges, bool register_tree_change)
2281
4415
{
2282
4416
  Field *found=0;
2283
4417
  const char *db= item->db_name;
2284
4418
  const char *table_name= item->table_name;
2285
4419
  const char *name= item->field_name;
2286
 
  uint32_t length=(uint32_t) strlen(name);
 
4420
  uint length=(uint) strlen(name);
2287
4421
  char name_buff[NAME_LEN+1];
2288
4422
  TableList *cur_table= first_table;
2289
4423
  TableList *actual_table;
2313
4447
      The condition (table_ref->view == NULL) ensures that we will call
2314
4448
      find_field_in_table even in the case of information schema tables
2315
4449
      when table_ref->field_translation != NULL.
2316
 
    */
 
4450
      */
2317
4451
    if (table_ref->table)
2318
 
      found= find_field_in_table(session, table_ref->table, name, length,
 
4452
      found= find_field_in_table(thd, table_ref->table, name, length,
2319
4453
                                 true, &(item->cached_field_index));
2320
4454
    else
2321
 
      found= find_field_in_table_ref(session, table_ref, name, length, item->name,
2322
 
                                     NULL, NULL, ref,
 
4455
      found= find_field_in_table_ref(thd, table_ref, name, length, item->name,
 
4456
                                     NULL, NULL, ref, check_privileges,
2323
4457
                                     true, &(item->cached_field_index),
2324
4458
                                     register_tree_change,
2325
4459
                                     &actual_table);
2326
4460
    if (found)
2327
4461
    {
 
4462
      if (found == WRONG_GRANT)
 
4463
        return (Field*) 0;
 
4464
 
2328
4465
      /*
2329
4466
        Only views fields should be marked as dependent, not an underlying
2330
4467
        fields.
2331
4468
      */
2332
4469
      {
2333
 
        Select_Lex *current_sel= session->lex->current_select;
2334
 
        Select_Lex *last_select= table_ref->select_lex;
 
4470
        SELECT_LEX *current_sel= thd->lex->current_select;
 
4471
        SELECT_LEX *last_select= table_ref->select_lex;
2335
4472
        /*
2336
4473
          If the field was an outer referencee, mark all selects using this
2337
4474
          sub query as dependent on the outer query
2338
4475
        */
2339
4476
        if (current_sel != last_select)
2340
 
          mark_select_range_as_dependent(session, last_select, current_sel,
 
4477
          mark_select_range_as_dependent(thd, last_select, current_sel,
2341
4478
                                         found, *ref, item);
2342
4479
      }
2343
4480
      return found;
2344
4481
    }
2345
4482
  }
2346
4483
 
2347
 
  if (db)
 
4484
  if (db && lower_case_table_names)
2348
4485
  {
2349
4486
    /*
2350
4487
      convert database to lower case for comparison.
2351
4488
      We can't do this in Item_field as this would change the
2352
4489
      'name' of the item which may be used in the select list
2353
4490
    */
2354
 
    strncpy(name_buff, db, sizeof(name_buff)-1);
 
4491
    strmake(name_buff, db, sizeof(name_buff)-1);
2355
4492
    my_casedn_str(files_charset_info, name_buff);
2356
4493
    db= name_buff;
2357
4494
  }
2362
4499
  for (; cur_table != last_table ;
2363
4500
       cur_table= cur_table->next_name_resolution_table)
2364
4501
  {
2365
 
    Field *cur_field= find_field_in_table_ref(session, cur_table, name, length,
 
4502
    Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
2366
4503
                                              item->name, db, table_name, ref,
 
4504
                                              (thd->lex->sql_command ==
 
4505
                                               SQLCOM_SHOW_FIELDS)
 
4506
                                              ? false : check_privileges,
2367
4507
                                              allow_rowid,
2368
4508
                                              &(item->cached_field_index),
2369
4509
                                              register_tree_change,
2370
4510
                                              &actual_table);
2371
4511
    if (cur_field)
2372
4512
    {
 
4513
      if (cur_field == WRONG_GRANT)
 
4514
      {
 
4515
        if (thd->lex->sql_command != SQLCOM_SHOW_FIELDS)
 
4516
          return (Field*) 0;
 
4517
 
 
4518
        thd->clear_error();
 
4519
        cur_field= find_field_in_table_ref(thd, cur_table, name, length,
 
4520
                                           item->name, db, table_name, ref,
 
4521
                                           false,
 
4522
                                           allow_rowid,
 
4523
                                           &(item->cached_field_index),
 
4524
                                           register_tree_change,
 
4525
                                           &actual_table);
 
4526
        if (cur_field)
 
4527
        {
 
4528
          Field *nf=new Field_null(NULL,0,Field::NONE,
 
4529
                                   cur_field->field_name,
 
4530
                                   &my_charset_bin);
 
4531
          nf->init(cur_table->table);
 
4532
          cur_field= nf;
 
4533
        }
 
4534
      }
 
4535
 
2373
4536
      /*
2374
4537
        Store the original table of the field, which may be different from
2375
4538
        cur_table in the case of NATURAL/USING join.
2376
4539
      */
2377
 
      item->cached_table= found ?  0 : actual_table;
 
4540
      item->cached_table= (!actual_table->cacheable_table || found) ?
 
4541
                          0 : actual_table;
2378
4542
 
2379
 
      assert(session->where);
 
4543
      assert(thd->where);
2380
4544
      /*
2381
4545
        If we found a fully qualified field we return it directly as it can't
2382
4546
        have duplicates.
2383
 
      */
 
4547
       */
2384
4548
      if (db)
2385
4549
        return cur_field;
2386
4550
 
2389
4553
        if (report_error == REPORT_ALL_ERRORS ||
2390
4554
            report_error == IGNORE_EXCEPT_NON_UNIQUE)
2391
4555
          my_error(ER_NON_UNIQ_ERROR, MYF(0),
2392
 
                   table_name ? item->full_name() : name, session->where);
 
4556
                   table_name ? item->full_name() : name, thd->where);
2393
4557
        return (Field*) 0;
2394
4558
      }
2395
4559
      found= cur_field;
2413
4577
    char buff[NAME_LEN*2+1];
2414
4578
    if (db && db[0])
2415
4579
    {
2416
 
      /* We're in an error condition, two extra strlen's aren't going
2417
 
       * to kill us */
2418
 
      assert(strlen(db) <= NAME_LEN);
2419
 
      assert(strlen(table_name) <= NAME_LEN);
2420
 
      strcpy(buff, db);
2421
 
      strcat(buff,".");
2422
 
      strcat(buff, table_name);
 
4580
      strxnmov(buff,sizeof(buff)-1,db,".",table_name,NullS);
2423
4581
      table_name=buff;
2424
4582
    }
2425
 
    my_error(ER_UNKNOWN_TABLE, MYF(0), table_name, session->where);
 
4583
    my_error(ER_UNKNOWN_TABLE, MYF(0), table_name, thd->where);
2426
4584
  }
2427
4585
  else
2428
4586
  {
2429
4587
    if (report_error == REPORT_ALL_ERRORS ||
2430
4588
        report_error == REPORT_EXCEPT_NON_UNIQUE)
2431
 
      my_error(ER_BAD_FIELD_ERROR, MYF(0), item->full_name(), session->where);
 
4589
      my_error(ER_BAD_FIELD_ERROR, MYF(0), item->full_name(), thd->where);
2432
4590
    else
2433
4591
      found= not_found_field;
2434
4592
  }
2440
4598
  Find Item in list of items (find_field_in_tables analog)
2441
4599
 
2442
4600
  TODO
2443
 
  is it better return only counter?
 
4601
    is it better return only counter?
2444
4602
 
2445
4603
  SYNOPSIS
2446
 
  find_item_in_list()
2447
 
  find                  Item to find
2448
 
  items                 List of items
2449
 
  counter                       To return number of found item
2450
 
  report_error
2451
 
  REPORT_ALL_ERRORS             report errors, return 0 if error
2452
 
  REPORT_EXCEPT_NOT_FOUND       Do not report 'not found' error and
2453
 
  return not_found_item, report other errors,
2454
 
  return 0
2455
 
  IGNORE_ERRORS         Do not report errors, return 0 if error
2456
 
  resolution                  Set to the resolution type if the item is found
2457
 
  (it says whether the item is resolved
2458
 
  against an alias name,
2459
 
  or as a field name without alias,
2460
 
  or as a field hidden by alias,
2461
 
  or ignoring alias)
2462
 
 
 
4604
    find_item_in_list()
 
4605
    find                        Item to find
 
4606
    items                       List of items
 
4607
    counter                     To return number of found item
 
4608
    report_error
 
4609
      REPORT_ALL_ERRORS         report errors, return 0 if error
 
4610
      REPORT_EXCEPT_NOT_FOUND   Do not report 'not found' error and
 
4611
                                return not_found_item, report other errors,
 
4612
                                return 0
 
4613
      IGNORE_ERRORS             Do not report errors, return 0 if error
 
4614
    resolution                  Set to the resolution type if the item is found 
 
4615
                                (it says whether the item is resolved 
 
4616
                                 against an alias name,
 
4617
                                 or as a field name without alias,
 
4618
                                 or as a field hidden by alias,
 
4619
                                 or ignoring alias)
 
4620
                                
2463
4621
  RETURN VALUES
2464
 
  0                     Item is not found or item is not unique,
2465
 
  error message is reported
2466
 
  not_found_item        Function was called with
2467
 
  report_error == REPORT_EXCEPT_NOT_FOUND and
2468
 
  item was not found. No error message was reported
2469
 
  found field
 
4622
    0                   Item is not found or item is not unique,
 
4623
                        error message is reported
 
4624
    not_found_item      Function was called with
 
4625
                        report_error == REPORT_EXCEPT_NOT_FOUND and
 
4626
                        item was not found. No error message was reported
 
4627
                        found field
2470
4628
*/
2471
4629
 
2472
4630
/* Special Item pointer to serve as a return value from find_item_in_list(). */
2474
4632
 
2475
4633
 
2476
4634
Item **
2477
 
find_item_in_list(Session *session,
2478
 
                  Item *find, List<Item> &items, uint32_t *counter,
 
4635
find_item_in_list(Item *find, List<Item> &items, uint *counter,
2479
4636
                  find_item_error_report_type report_error,
2480
4637
                  enum_resolution_type *resolution)
2481
4638
{
2490
4647
    (and not an item that happens to have a name).
2491
4648
  */
2492
4649
  bool is_ref_by_name= 0;
2493
 
  uint32_t unaliased_counter= 0;
 
4650
  uint unaliased_counter= 0;
2494
4651
 
2495
4652
  *resolution= NOT_RESOLVED;
2496
4653
 
2497
 
  is_ref_by_name= (find->type() == Item::FIELD_ITEM  ||
 
4654
  is_ref_by_name= (find->type() == Item::FIELD_ITEM  || 
2498
4655
                   find->type() == Item::REF_ITEM);
2499
4656
  if (is_ref_by_name)
2500
4657
  {
2503
4660
    db_name=    ((Item_ident*) find)->db_name;
2504
4661
  }
2505
4662
 
2506
 
  for (uint32_t i= 0; (item=li++); i++)
 
4663
  for (uint i= 0; (item=li++); i++)
2507
4664
  {
2508
4665
    if (field_name && item->real_item()->type() == Item::FIELD_ITEM)
2509
4666
    {
2510
4667
      Item_ident *item_field= (Item_ident*) item;
2511
4668
 
2512
4669
      /*
2513
 
        In case of group_concat() with ORDER BY condition in the QUERY
2514
 
        item_field can be field of temporary table without item name
2515
 
        (if this field created from expression argument of group_concat()),
2516
 
        => we have to check presence of name before compare
2517
 
      */
 
4670
        In case of group_concat() with ORDER BY condition in the QUERY
 
4671
        item_field can be field of temporary table without item name 
 
4672
        (if this field created from expression argument of group_concat()),
 
4673
        => we have to check presence of name before compare
 
4674
      */ 
2518
4675
      if (!item_field->name)
2519
4676
        continue;
2520
4677
 
2533
4690
          case sensitive. In cases where they are not case sensitive, they
2534
4691
          are always in lower case.
2535
4692
 
2536
 
          item_field->field_name and item_field->table_name can be 0x0 if
2537
 
          item is not fix_field()'ed yet.
 
4693
          item_field->field_name and item_field->table_name can be 0x0 if
 
4694
          item is not fix_field()'ed yet.
2538
4695
        */
2539
4696
        if (item_field->field_name && item_field->table_name &&
2540
 
            !my_strcasecmp(system_charset_info, item_field->field_name,
 
4697
            !my_strcasecmp(system_charset_info, item_field->field_name,
2541
4698
                           field_name) &&
2542
 
            !my_strcasecmp(table_alias_charset, item_field->table_name,
 
4699
            !my_strcasecmp(table_alias_charset, item_field->table_name, 
2543
4700
                           table_name) &&
2544
4701
            (!db_name || (item_field->db_name &&
2545
4702
                          !strcmp(item_field->db_name, db_name))))
2555
4712
            */
2556
4713
            if (report_error != IGNORE_ERRORS)
2557
4714
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
2558
 
                       find->full_name(), session->where);
 
4715
                       find->full_name(), current_thd->where);
2559
4716
            return (Item**) 0;
2560
4717
          }
2561
4718
          found_unaliased= li.ref();
2586
4743
              continue;                           // Same field twice
2587
4744
            if (report_error != IGNORE_ERRORS)
2588
4745
              my_error(ER_NON_UNIQ_ERROR, MYF(0),
2589
 
                       find->full_name(), session->where);
 
4746
                       find->full_name(), current_thd->where);
2590
4747
            return (Item**) 0;
2591
4748
          }
2592
4749
          found= li.ref();
2593
4750
          *counter= i;
2594
4751
          *resolution= fname_cmp ? RESOLVED_AGAINST_ALIAS:
2595
 
            RESOLVED_WITH_NO_ALIAS;
 
4752
                                   RESOLVED_WITH_NO_ALIAS;
2596
4753
        }
2597
4754
        else if (!fname_cmp)
2598
4755
        {
2614
4771
      }
2615
4772
    }
2616
4773
    else if (!table_name)
2617
 
    {
 
4774
    { 
2618
4775
      if (is_ref_by_name && find->name && item->name &&
2619
 
          !my_strcasecmp(system_charset_info,item->name,find->name))
 
4776
          !my_strcasecmp(system_charset_info,item->name,find->name))
2620
4777
      {
2621
4778
        found= li.ref();
2622
4779
        *counter= i;
2631
4788
        break;
2632
4789
      }
2633
4790
    }
 
4791
    else if (table_name && item->type() == Item::REF_ITEM &&
 
4792
             ((Item_ref *)item)->ref_type() == Item_ref::VIEW_REF)
 
4793
    {
 
4794
      /*
 
4795
        TODO:Here we process prefixed view references only. What we should 
 
4796
        really do is process all types of Item_refs. But this will currently 
 
4797
        lead to a clash with the way references to outer SELECTs (from the 
 
4798
        HAVING clause) are handled in e.g. :
 
4799
        SELECT 1 FROM t1 AS t1_o GROUP BY a
 
4800
          HAVING (SELECT t1_o.a FROM t1 AS t1_i GROUP BY t1_i.a LIMIT 1).
 
4801
        Processing all Item_refs here will cause t1_o.a to resolve to itself.
 
4802
        We still need to process the special case of Item_direct_view_ref 
 
4803
        because in the context of views they have the same meaning as 
 
4804
        Item_field for tables.
 
4805
      */
 
4806
      Item_ident *item_ref= (Item_ident *) item;
 
4807
      if (item_ref->name && item_ref->table_name &&
 
4808
          !my_strcasecmp(system_charset_info, item_ref->name, field_name) &&
 
4809
          !my_strcasecmp(table_alias_charset, item_ref->table_name,
 
4810
                         table_name) &&
 
4811
          (!db_name || (item_ref->db_name && 
 
4812
                        !strcmp (item_ref->db_name, db_name))))
 
4813
      {
 
4814
        found= li.ref();
 
4815
        *counter= i;
 
4816
        *resolution= RESOLVED_IGNORING_ALIAS;
 
4817
        break;
 
4818
      }
 
4819
    }
2634
4820
  }
2635
4821
  if (!found)
2636
4822
  {
2638
4824
    {
2639
4825
      if (report_error != IGNORE_ERRORS)
2640
4826
        my_error(ER_NON_UNIQ_ERROR, MYF(0),
2641
 
                 find->full_name(), session->where);
 
4827
                 find->full_name(), current_thd->where);
2642
4828
      return (Item **) 0;
2643
4829
    }
2644
4830
    if (found_unaliased)
2654
4840
  {
2655
4841
    if (report_error == REPORT_ALL_ERRORS)
2656
4842
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
2657
 
               find->full_name(), session->where);
 
4843
               find->full_name(), current_thd->where);
2658
4844
    return (Item **) 0;
2659
4845
  }
2660
4846
  else
2666
4852
  Test if a string is a member of a list of strings.
2667
4853
 
2668
4854
  SYNOPSIS
2669
 
  test_if_string_in_list()
2670
 
  find      the string to look for
2671
 
  str_list  a list of strings to be searched
 
4855
    test_if_string_in_list()
 
4856
    find      the string to look for
 
4857
    str_list  a list of strings to be searched
2672
4858
 
2673
4859
  DESCRIPTION
2674
 
  Sequentially search a list of strings for a string, and test whether
2675
 
  the list contains the same string.
 
4860
    Sequentially search a list of strings for a string, and test whether
 
4861
    the list contains the same string.
2676
4862
 
2677
4863
  RETURN
2678
 
  true  if find is in str_list
2679
 
  false otherwise
 
4864
    true  if find is in str_list
 
4865
    false otherwise
2680
4866
*/
2681
4867
 
2682
4868
static bool
2701
4887
  being resolved in a specific table reference.
2702
4888
 
2703
4889
  SYNOPSIS
2704
 
  set_new_item_local_context()
2705
 
  session        pointer to current thread
2706
 
  item       item for which new context is created and set
2707
 
  table_ref  table ref where an item showld be resolved
 
4890
    set_new_item_local_context()
 
4891
    thd        pointer to current thread
 
4892
    item       item for which new context is created and set
 
4893
    table_ref  table ref where an item showld be resolved
2708
4894
 
2709
4895
  DESCRIPTION
2710
 
  Create a new name resolution context for an item, so that the item
2711
 
  is resolved only the supplied 'table_ref'.
 
4896
    Create a new name resolution context for an item, so that the item
 
4897
    is resolved only the supplied 'table_ref'.
2712
4898
 
2713
4899
  RETURN
2714
 
  false  if all OK
2715
 
  true   otherwise
 
4900
    false  if all OK
 
4901
    true   otherwise
2716
4902
*/
2717
4903
 
2718
4904
static bool
2719
 
set_new_item_local_context(Session *session, Item_ident *item, TableList *table_ref)
 
4905
set_new_item_local_context(THD *thd, Item_ident *item, TableList *table_ref)
2720
4906
{
2721
4907
  Name_resolution_context *context;
2722
 
  if (!(context= new (session->mem_root) Name_resolution_context))
 
4908
  if (!(context= new (thd->mem_root) Name_resolution_context))
2723
4909
    return true;
2724
4910
  context->init();
2725
4911
  context->first_name_resolution_table=
2733
4919
  Find and mark the common columns of two table references.
2734
4920
 
2735
4921
  SYNOPSIS
2736
 
  mark_common_columns()
2737
 
  session                [in] current thread
2738
 
  table_ref_1        [in] the first (left) join operand
2739
 
  table_ref_2        [in] the second (right) join operand
2740
 
  using_fields       [in] if the join is JOIN...USING - the join columns,
2741
 
  if NATURAL join, then NULL
2742
 
  found_using_fields [out] number of fields from the USING clause that were
2743
 
  found among the common fields
 
4922
    mark_common_columns()
 
4923
    thd                [in] current thread
 
4924
    table_ref_1        [in] the first (left) join operand
 
4925
    table_ref_2        [in] the second (right) join operand
 
4926
    using_fields       [in] if the join is JOIN...USING - the join columns,
 
4927
                            if NATURAL join, then NULL
 
4928
    found_using_fields [out] number of fields from the USING clause that were
 
4929
                             found among the common fields
2744
4930
 
2745
4931
  DESCRIPTION
2746
 
  The procedure finds the common columns of two relations (either
2747
 
  tables or intermediate join results), and adds an equi-join condition
2748
 
  to the ON clause of 'table_ref_2' for each pair of matching columns.
2749
 
  If some of table_ref_XXX represents a base table or view, then we
2750
 
  create new 'Natural_join_column' instances for each column
2751
 
  reference and store them in the 'join_columns' of the table
2752
 
  reference.
 
4932
    The procedure finds the common columns of two relations (either
 
4933
    tables or intermediate join results), and adds an equi-join condition
 
4934
    to the ON clause of 'table_ref_2' for each pair of matching columns.
 
4935
    If some of table_ref_XXX represents a base table or view, then we
 
4936
    create new 'Natural_join_column' instances for each column
 
4937
    reference and store them in the 'join_columns' of the table
 
4938
    reference.
2753
4939
 
2754
4940
  IMPLEMENTATION
2755
 
  The procedure assumes that store_natural_using_join_columns() was
2756
 
  called for the previous level of NATURAL/USING joins.
 
4941
    The procedure assumes that store_natural_using_join_columns() was
 
4942
    called for the previous level of NATURAL/USING joins.
2757
4943
 
2758
4944
  RETURN
2759
 
  true   error when some common column is non-unique, or out of memory
2760
 
  false  OK
 
4945
    true   error when some common column is non-unique, or out of memory
 
4946
    false  OK
2761
4947
*/
2762
4948
 
2763
4949
static bool
2764
 
mark_common_columns(Session *session, TableList *table_ref_1, TableList *table_ref_2,
2765
 
                    List<String> *using_fields, uint32_t *found_using_fields)
 
4950
mark_common_columns(THD *thd, TableList *table_ref_1, TableList *table_ref_2,
 
4951
                    List<String> *using_fields, uint *found_using_fields)
2766
4952
{
2767
4953
  Field_iterator_table_ref it_1, it_2;
2768
4954
  Natural_join_column *nj_col_1, *nj_col_2;
2772
4958
    Leaf table references to which new natural join columns are added
2773
4959
    if the leaves are != NULL.
2774
4960
  */
2775
 
  TableList *leaf_1= (table_ref_1->getNestedJoin() &&
2776
 
                      ! table_ref_1->is_natural_join) ?
2777
 
    NULL : table_ref_1;
2778
 
  TableList *leaf_2= (table_ref_2->getNestedJoin() &&
2779
 
                      ! table_ref_2->is_natural_join) ?
2780
 
    NULL : table_ref_2;
 
4961
  TableList *leaf_1= (table_ref_1->nested_join &&
 
4962
                       !table_ref_1->is_natural_join) ?
 
4963
                      NULL : table_ref_1;
 
4964
  TableList *leaf_2= (table_ref_2->nested_join &&
 
4965
                       !table_ref_2->is_natural_join) ?
 
4966
                      NULL : table_ref_2;
2781
4967
 
2782
4968
  *found_using_fields= 0;
2783
4969
 
2788
4974
    /* true if field_name_1 is a member of using_fields */
2789
4975
    bool is_using_column_1;
2790
4976
    if (!(nj_col_1= it_1.get_or_create_column_ref(leaf_1)))
2791
 
      return(result);
 
4977
      goto err;
2792
4978
    field_name_1= nj_col_1->name();
2793
 
    is_using_column_1= using_fields &&
 
4979
    is_using_column_1= using_fields && 
2794
4980
      test_if_string_in_list(field_name_1, using_fields);
2795
4981
 
2796
4982
    /*
2806
4992
      Natural_join_column *cur_nj_col_2;
2807
4993
      const char *cur_field_name_2;
2808
4994
      if (!(cur_nj_col_2= it_2.get_or_create_column_ref(leaf_2)))
2809
 
        return(result);
 
4995
        goto err;
2810
4996
      cur_field_name_2= cur_nj_col_2->name();
2811
4997
 
2812
4998
      /*
2817
5003
        (then cur_nj_col_2->is_common == true).
2818
5004
        Note that it is too early to check the columns outside of the
2819
5005
        USING list for ambiguity because they are not actually "referenced"
2820
 
        here. These columns must be checked only on unqualified reference
 
5006
        here. These columns must be checked only on unqualified reference 
2821
5007
        by name (e.g. in SELECT list).
2822
5008
      */
2823
5009
      if (!my_strcasecmp(system_charset_info, field_name_1, cur_field_name_2))
2825
5011
        if (cur_nj_col_2->is_common ||
2826
5012
            (found && (!using_fields || is_using_column_1)))
2827
5013
        {
2828
 
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, session->where);
2829
 
          return(result);
 
5014
          my_error(ER_NON_UNIQ_ERROR, MYF(0), field_name_1, thd->where);
 
5015
          goto err;
2830
5016
        }
2831
5017
        nj_col_2= cur_nj_col_2;
2832
5018
        found= true;
2851
5037
    */
2852
5038
    if (nj_col_2 && (!using_fields ||is_using_column_1))
2853
5039
    {
2854
 
      Item *item_1=   nj_col_1->create_item(session);
2855
 
      Item *item_2=   nj_col_2->create_item(session);
 
5040
      Item *item_1=   nj_col_1->create_item(thd);
 
5041
      Item *item_2=   nj_col_2->create_item(thd);
2856
5042
      Field *field_1= nj_col_1->field();
2857
5043
      Field *field_2= nj_col_2->field();
2858
5044
      Item_ident *item_ident_1, *item_ident_2;
2859
5045
      Item_func_eq *eq_cond;
2860
5046
 
2861
5047
      if (!item_1 || !item_2)
2862
 
        return(result); // out of memory
 
5048
        goto err;                               // out of memory
2863
5049
 
2864
5050
      /*
2865
5051
        In the case of no_wrap_view_item == 0, the created items must be
2866
5052
        of sub-classes of Item_ident.
2867
5053
      */
2868
5054
      assert(item_1->type() == Item::FIELD_ITEM ||
2869
 
             item_1->type() == Item::REF_ITEM);
 
5055
                  item_1->type() == Item::REF_ITEM);
2870
5056
      assert(item_2->type() == Item::FIELD_ITEM ||
2871
 
             item_2->type() == Item::REF_ITEM);
 
5057
                  item_2->type() == Item::REF_ITEM);
2872
5058
 
2873
5059
      /*
2874
5060
        We need to cast item_1,2 to Item_ident, because we need to hook name
2882
5068
        resolution of these items, and to enable proper name resolution of
2883
5069
        the items during the execute phase of PS.
2884
5070
      */
2885
 
      if (set_new_item_local_context(session, item_ident_1, nj_col_1->table_ref) ||
2886
 
          set_new_item_local_context(session, item_ident_2, nj_col_2->table_ref))
2887
 
        return(result);
 
5071
      if (set_new_item_local_context(thd, item_ident_1, nj_col_1->table_ref) ||
 
5072
          set_new_item_local_context(thd, item_ident_2, nj_col_2->table_ref))
 
5073
        goto err;
2888
5074
 
2889
5075
      if (!(eq_cond= new Item_func_eq(item_ident_1, item_ident_2)))
2890
 
        return(result);                               /* Out of memory. */
 
5076
        goto err;                               /* Out of memory. */
2891
5077
 
2892
5078
      /*
2893
5079
        Add the new equi-join condition to the ON clause. Notice that
2894
5080
        fix_fields() is applied to all ON conditions in setup_conds()
2895
5081
        so we don't do it here.
2896
 
      */
 
5082
       */
2897
5083
      add_join_on((table_ref_1->outer_join & JOIN_TYPE_RIGHT ?
2898
5084
                   table_ref_1 : table_ref_2),
2899
5085
                  eq_cond);
2904
5090
      {
2905
5091
        Table *table_1= nj_col_1->table_ref->table;
2906
5092
        /* Mark field_1 used for table cache. */
2907
 
        table_1->setReadSet(field_1->position());
2908
 
        table_1->covering_keys&= field_1->part_of_key;
2909
 
        table_1->merge_keys|= field_1->part_of_key;
 
5093
        bitmap_set_bit(table_1->read_set, field_1->field_index);
 
5094
        table_1->covering_keys.intersect(field_1->part_of_key);
 
5095
        table_1->merge_keys.merge(field_1->part_of_key);
2910
5096
      }
2911
5097
      if (field_2)
2912
5098
      {
2913
5099
        Table *table_2= nj_col_2->table_ref->table;
2914
5100
        /* Mark field_2 used for table cache. */
2915
 
        table_2->setReadSet(field_2->position());
2916
 
        table_2->covering_keys&= field_2->part_of_key;
2917
 
        table_2->merge_keys|= field_2->part_of_key;
 
5101
        bitmap_set_bit(table_2->read_set, field_2->field_index);
 
5102
        table_2->covering_keys.intersect(field_2->part_of_key);
 
5103
        table_2->merge_keys.merge(field_2->part_of_key);
2918
5104
      }
2919
5105
 
2920
5106
      if (using_fields != NULL)
2933
5119
  */
2934
5120
  result= false;
2935
5121
 
 
5122
err:
2936
5123
  return(result);
2937
5124
}
2938
5125
 
2942
5129
  Materialize and store the row type of NATURAL/USING join.
2943
5130
 
2944
5131
  SYNOPSIS
2945
 
  store_natural_using_join_columns()
2946
 
  session                current thread
2947
 
  natural_using_join the table reference of the NATURAL/USING join
2948
 
  table_ref_1        the first (left) operand (of a NATURAL/USING join).
2949
 
  table_ref_2        the second (right) operand (of a NATURAL/USING join).
2950
 
  using_fields       if the join is JOIN...USING - the join columns,
2951
 
  if NATURAL join, then NULL
2952
 
  found_using_fields number of fields from the USING clause that were
2953
 
  found among the common fields
 
5132
    store_natural_using_join_columns()
 
5133
    thd                current thread
 
5134
    natural_using_join the table reference of the NATURAL/USING join
 
5135
    table_ref_1        the first (left) operand (of a NATURAL/USING join).
 
5136
    table_ref_2        the second (right) operand (of a NATURAL/USING join).
 
5137
    using_fields       if the join is JOIN...USING - the join columns,
 
5138
                       if NATURAL join, then NULL
 
5139
    found_using_fields number of fields from the USING clause that were
 
5140
                       found among the common fields
2954
5141
 
2955
5142
  DESCRIPTION
2956
 
  Iterate over the columns of both join operands and sort and store
2957
 
  all columns into the 'join_columns' list of natural_using_join
2958
 
  where the list is formed by three parts:
2959
 
part1: The coalesced columns of table_ref_1 and table_ref_2,
2960
 
sorted according to the column order of the first table.
2961
 
part2: The other columns of the first table, in the order in
2962
 
which they were defined in CREATE TABLE.
2963
 
part3: The other columns of the second table, in the order in
2964
 
which they were defined in CREATE TABLE.
2965
 
Time complexity - O(N1+N2), where Ni = length(table_ref_i).
2966
 
 
2967
 
IMPLEMENTATION
2968
 
The procedure assumes that mark_common_columns() has been called
2969
 
for the join that is being processed.
2970
 
 
2971
 
RETURN
2972
 
true    error: Some common column is ambiguous
2973
 
false   OK
 
5143
    Iterate over the columns of both join operands and sort and store
 
5144
    all columns into the 'join_columns' list of natural_using_join
 
5145
    where the list is formed by three parts:
 
5146
      part1: The coalesced columns of table_ref_1 and table_ref_2,
 
5147
             sorted according to the column order of the first table.
 
5148
      part2: The other columns of the first table, in the order in
 
5149
             which they were defined in CREATE TABLE.
 
5150
      part3: The other columns of the second table, in the order in
 
5151
             which they were defined in CREATE TABLE.
 
5152
    Time complexity - O(N1+N2), where Ni = length(table_ref_i).
 
5153
 
 
5154
  IMPLEMENTATION
 
5155
    The procedure assumes that mark_common_columns() has been called
 
5156
    for the join that is being processed.
 
5157
 
 
5158
  RETURN
 
5159
    true    error: Some common column is ambiguous
 
5160
    false   OK
2974
5161
*/
2975
5162
 
2976
5163
static bool
2977
 
store_natural_using_join_columns(Session *session,
 
5164
store_natural_using_join_columns(THD *thd __attribute__((unused)),
2978
5165
                                 TableList *natural_using_join,
2979
5166
                                 TableList *table_ref_1,
2980
5167
                                 TableList *table_ref_2,
2981
5168
                                 List<String> *using_fields,
2982
 
                                 uint32_t found_using_fields)
 
5169
                                 uint found_using_fields)
2983
5170
{
2984
5171
  Field_iterator_table_ref it_1, it_2;
2985
5172
  Natural_join_column *nj_col_1, *nj_col_2;
2990
5177
 
2991
5178
  if (!(non_join_columns= new List<Natural_join_column>) ||
2992
5179
      !(natural_using_join->join_columns= new List<Natural_join_column>))
2993
 
  {
2994
 
    return(result);
2995
 
  }
 
5180
    goto err;
2996
5181
 
2997
5182
  /* Append the columns of the first join operand. */
2998
5183
  for (it_1.set(table_ref_1); !it_1.end_of_fields(); it_1.next())
3030
5215
        if (!(common_field= it++))
3031
5216
        {
3032
5217
          my_error(ER_BAD_FIELD_ERROR, MYF(0), using_field_name_ptr,
3033
 
                   session->where);
3034
 
          return(result);
 
5218
                   current_thd->where);
 
5219
          goto err;
3035
5220
        }
3036
5221
        if (!my_strcasecmp(system_charset_info,
3037
5222
                           common_field->name(), using_field_name_ptr))
3059
5244
 
3060
5245
  result= false;
3061
5246
 
 
5247
err:
3062
5248
  return(result);
3063
5249
}
3064
5250
 
3067
5253
  Precompute and store the row types of the top-most NATURAL/USING joins.
3068
5254
 
3069
5255
  SYNOPSIS
3070
 
  store_top_level_join_columns()
3071
 
  session            current thread
3072
 
  table_ref      nested join or table in a FROM clause
3073
 
  left_neighbor  neighbor table reference to the left of table_ref at the
3074
 
  same level in the join tree
3075
 
  right_neighbor neighbor table reference to the right of table_ref at the
3076
 
  same level in the join tree
 
5256
    store_top_level_join_columns()
 
5257
    thd            current thread
 
5258
    table_ref      nested join or table in a FROM clause
 
5259
    left_neighbor  neighbor table reference to the left of table_ref at the
 
5260
                   same level in the join tree
 
5261
    right_neighbor neighbor table reference to the right of table_ref at the
 
5262
                   same level in the join tree
3077
5263
 
3078
5264
  DESCRIPTION
3079
 
  The procedure performs a post-order traversal of a nested join tree
3080
 
  and materializes the row types of NATURAL/USING joins in a
3081
 
  bottom-up manner until it reaches the TableList elements that
3082
 
  represent the top-most NATURAL/USING joins. The procedure should be
3083
 
  applied to each element of Select_Lex::top_join_list (i.e. to each
3084
 
  top-level element of the FROM clause).
 
5265
    The procedure performs a post-order traversal of a nested join tree
 
5266
    and materializes the row types of NATURAL/USING joins in a
 
5267
    bottom-up manner until it reaches the TableList elements that
 
5268
    represent the top-most NATURAL/USING joins. The procedure should be
 
5269
    applied to each element of SELECT_LEX::top_join_list (i.e. to each
 
5270
    top-level element of the FROM clause).
3085
5271
 
3086
5272
  IMPLEMENTATION
3087
 
  Notice that the table references in the list nested_join->join_list
3088
 
  are in reverse order, thus when we iterate over it, we are moving
3089
 
  from the right to the left in the FROM clause.
 
5273
    Notice that the table references in the list nested_join->join_list
 
5274
    are in reverse order, thus when we iterate over it, we are moving
 
5275
    from the right to the left in the FROM clause.
3090
5276
 
3091
5277
  RETURN
3092
 
  true   Error
3093
 
  false  OK
 
5278
    true   Error
 
5279
    false  OK
3094
5280
*/
3095
5281
 
3096
5282
static bool
3097
 
store_top_level_join_columns(Session *session, TableList *table_ref,
 
5283
store_top_level_join_columns(THD *thd, TableList *table_ref,
3098
5284
                             TableList *left_neighbor,
3099
5285
                             TableList *right_neighbor)
3100
5286
{
3101
5287
  bool result= true;
3102
5288
 
3103
5289
  /* Call the procedure recursively for each nested table reference. */
3104
 
  if (table_ref->getNestedJoin())
 
5290
  if (table_ref->nested_join)
3105
5291
  {
3106
 
    List_iterator_fast<TableList> nested_it(table_ref->getNestedJoin()->join_list);
 
5292
    List_iterator_fast<TableList> nested_it(table_ref->nested_join->join_list);
3107
5293
    TableList *same_level_left_neighbor= nested_it++;
3108
5294
    TableList *same_level_right_neighbor= NULL;
3109
5295
    /* Left/right-most neighbors, possibly at higher levels in the join tree. */
3128
5314
          cur_table_ref->outer_join & JOIN_TYPE_RIGHT)
3129
5315
      {
3130
5316
        /* This can happen only for JOIN ... ON. */
3131
 
        assert(table_ref->getNestedJoin()->join_list.elements == 2);
 
5317
        assert(table_ref->nested_join->join_list.elements == 2);
3132
5318
        std::swap(same_level_left_neighbor, cur_table_ref);
3133
5319
      }
3134
5320
 
3137
5323
        neighbors at the same level.
3138
5324
      */
3139
5325
      real_left_neighbor=  (same_level_left_neighbor) ?
3140
 
        same_level_left_neighbor : left_neighbor;
 
5326
                           same_level_left_neighbor : left_neighbor;
3141
5327
      real_right_neighbor= (same_level_right_neighbor) ?
3142
 
        same_level_right_neighbor : right_neighbor;
 
5328
                           same_level_right_neighbor : right_neighbor;
3143
5329
 
3144
 
      if (cur_table_ref->getNestedJoin() &&
3145
 
          store_top_level_join_columns(session, cur_table_ref,
 
5330
      if (cur_table_ref->nested_join &&
 
5331
          store_top_level_join_columns(thd, cur_table_ref,
3146
5332
                                       real_left_neighbor, real_right_neighbor))
3147
 
        return(result);
 
5333
        goto err;
3148
5334
      same_level_right_neighbor= cur_table_ref;
3149
5335
    }
3150
5336
  }
3155
5341
  */
3156
5342
  if (table_ref->is_natural_join)
3157
5343
  {
3158
 
    assert(table_ref->getNestedJoin() &&
3159
 
           table_ref->getNestedJoin()->join_list.elements == 2);
3160
 
    List_iterator_fast<TableList> operand_it(table_ref->getNestedJoin()->join_list);
 
5344
    assert(table_ref->nested_join &&
 
5345
                table_ref->nested_join->join_list.elements == 2);
 
5346
    List_iterator_fast<TableList> operand_it(table_ref->nested_join->join_list);
3161
5347
    /*
3162
5348
      Notice that the order of join operands depends on whether table_ref
3163
5349
      represents a LEFT or a RIGHT join. In a RIGHT join, the operands are
3164
5350
      in inverted order.
3165
 
    */
 
5351
     */
3166
5352
    TableList *table_ref_2= operand_it++; /* Second NATURAL join operand.*/
3167
5353
    TableList *table_ref_1= operand_it++; /* First NATURAL join operand. */
3168
5354
    List<String> *using_fields= table_ref->join_using_fields;
3169
 
    uint32_t found_using_fields;
 
5355
    uint found_using_fields;
3170
5356
 
3171
5357
    /*
3172
5358
      The two join operands were interchanged in the parser, change the order
3174
5360
    */
3175
5361
    if (table_ref_2->outer_join & JOIN_TYPE_RIGHT)
3176
5362
      std::swap(table_ref_1, table_ref_2);
3177
 
    if (mark_common_columns(session, table_ref_1, table_ref_2,
 
5363
    if (mark_common_columns(thd, table_ref_1, table_ref_2,
3178
5364
                            using_fields, &found_using_fields))
3179
 
      return(result);
 
5365
      goto err;
3180
5366
 
3181
5367
    /*
3182
5368
      Swap the join operands back, so that we pick the columns of the second
3185
5371
    */
3186
5372
    if (table_ref_1->outer_join & JOIN_TYPE_RIGHT)
3187
5373
      std::swap(table_ref_1, table_ref_2);
3188
 
    if (store_natural_using_join_columns(session, table_ref, table_ref_1,
 
5374
    if (store_natural_using_join_columns(thd, table_ref, table_ref_1,
3189
5375
                                         table_ref_2, using_fields,
3190
5376
                                         found_using_fields))
3191
 
      return(result);
 
5377
      goto err;
3192
5378
 
3193
5379
    /*
3194
5380
      Change NATURAL JOIN to JOIN ... ON. We do this for both operands
3221
5407
  }
3222
5408
  result= false; /* All is OK. */
3223
5409
 
 
5410
err:
3224
5411
  return(result);
3225
5412
}
3226
5413
 
3230
5417
  in a FROM clause.
3231
5418
 
3232
5419
  SYNOPSIS
3233
 
  setup_natural_join_row_types()
3234
 
  session          current thread
3235
 
  from_clause  list of top-level table references in a FROM clause
 
5420
    setup_natural_join_row_types()
 
5421
    thd          current thread
 
5422
    from_clause  list of top-level table references in a FROM clause
3236
5423
 
3237
5424
  DESCRIPTION
3238
 
  Apply the procedure 'store_top_level_join_columns' to each of the
3239
 
  top-level table referencs of the FROM clause. Adjust the list of tables
3240
 
  for name resolution - context->first_name_resolution_table to the
3241
 
  top-most, lef-most NATURAL/USING join.
 
5425
    Apply the procedure 'store_top_level_join_columns' to each of the
 
5426
    top-level table referencs of the FROM clause. Adjust the list of tables
 
5427
    for name resolution - context->first_name_resolution_table to the
 
5428
    top-most, lef-most NATURAL/USING join.
3242
5429
 
3243
5430
  IMPLEMENTATION
3244
 
  Notice that the table references in 'from_clause' are in reverse
3245
 
  order, thus when we iterate over it, we are moving from the right
3246
 
  to the left in the FROM clause.
 
5431
    Notice that the table references in 'from_clause' are in reverse
 
5432
    order, thus when we iterate over it, we are moving from the right
 
5433
    to the left in the FROM clause.
3247
5434
 
3248
5435
  RETURN
3249
 
  true   Error
3250
 
  false  OK
 
5436
    true   Error
 
5437
    false  OK
3251
5438
*/
3252
 
static bool setup_natural_join_row_types(Session *session,
 
5439
static bool setup_natural_join_row_types(THD *thd,
3253
5440
                                         List<TableList> *from_clause,
3254
5441
                                         Name_resolution_context *context)
3255
5442
{
3256
 
  session->where= "from clause";
 
5443
  thd->where= "from clause";
3257
5444
  if (from_clause->elements == 0)
3258
5445
    return false; /* We come here in the case of UNIONs. */
3259
5446
 
3269
5456
  {
3270
5457
    table_ref= left_neighbor;
3271
5458
    left_neighbor= table_ref_it++;
3272
 
    if (store_top_level_join_columns(session, table_ref,
3273
 
                                     left_neighbor, right_neighbor))
3274
 
      return true;
3275
 
    if (left_neighbor)
 
5459
    /* For stored procedures do not redo work if already done. */
 
5460
    if (context->select_lex->first_execution)
3276
5461
    {
3277
 
      TableList *first_leaf_on_the_right;
3278
 
      first_leaf_on_the_right= table_ref->first_leaf_for_name_resolution();
3279
 
      left_neighbor->next_name_resolution_table= first_leaf_on_the_right;
 
5462
      if (store_top_level_join_columns(thd, table_ref,
 
5463
                                       left_neighbor, right_neighbor))
 
5464
        return true;
 
5465
      if (left_neighbor)
 
5466
      {
 
5467
        TableList *first_leaf_on_the_right;
 
5468
        first_leaf_on_the_right= table_ref->first_leaf_for_name_resolution();
 
5469
        left_neighbor->next_name_resolution_table= first_leaf_on_the_right;
 
5470
      }
3280
5471
    }
3281
5472
    right_neighbor= table_ref;
3282
5473
  }
3296
5487
 
3297
5488
 
3298
5489
/****************************************************************************
3299
 
 ** Expand all '*' in given fields
3300
 
 ****************************************************************************/
 
5490
** Expand all '*' in given fields
 
5491
****************************************************************************/
3301
5492
 
3302
 
int setup_wild(Session *session, List<Item> &fields,
 
5493
int setup_wild(THD *thd,
 
5494
               TableList *tables __attribute__((unused)),
 
5495
               List<Item> &fields,
3303
5496
               List<Item> *sum_func_list,
3304
 
               uint32_t wild_num)
 
5497
               uint wild_num)
3305
5498
{
3306
5499
  if (!wild_num)
3307
 
    return 0;
 
5500
    return(0);
3308
5501
 
3309
5502
  Item *item;
3310
5503
  List_iterator<Item> it(fields);
3311
5504
 
3312
 
  session->lex->current_select->cur_pos_in_select_list= 0;
 
5505
  thd->lex->current_select->cur_pos_in_select_list= 0;
3313
5506
  while (wild_num && (item= it++))
3314
5507
  {
3315
5508
    if (item->type() == Item::FIELD_ITEM &&
3316
5509
        ((Item_field*) item)->field_name &&
3317
 
        ((Item_field*) item)->field_name[0] == '*' &&
3318
 
        !((Item_field*) item)->field)
 
5510
        ((Item_field*) item)->field_name[0] == '*' &&
 
5511
        !((Item_field*) item)->field)
3319
5512
    {
3320
 
      uint32_t elem= fields.elements;
 
5513
      uint elem= fields.elements;
3321
5514
      bool any_privileges= ((Item_field *) item)->any_privileges;
3322
 
      Item_subselect *subsel= session->lex->current_select->master_unit()->item;
 
5515
      Item_subselect *subsel= thd->lex->current_select->master_unit()->item;
3323
5516
      if (subsel &&
3324
5517
          subsel->substype() == Item_subselect::EXISTS_SUBS)
3325
5518
      {
3331
5524
        it.replace(new Item_int("Not_used", (int64_t) 1,
3332
5525
                                MY_INT64_NUM_DECIMAL_DIGITS));
3333
5526
      }
3334
 
      else if (insert_fields(session, ((Item_field*) item)->context,
 
5527
      else if (insert_fields(thd, ((Item_field*) item)->context,
3335
5528
                             ((Item_field*) item)->db_name,
3336
5529
                             ((Item_field*) item)->table_name, &it,
3337
5530
                             any_privileges))
3338
5531
      {
3339
 
        return -1;
 
5532
        return(-1);
3340
5533
      }
3341
5534
      if (sum_func_list)
3342
5535
      {
3343
 
        /*
3344
 
          sum_func_list is a list that has the fields list as a tail.
3345
 
          Because of this we have to update the element count also for this
3346
 
          list after expanding the '*' entry.
3347
 
        */
3348
 
        sum_func_list->elements+= fields.elements - elem;
 
5536
        /*
 
5537
          sum_func_list is a list that has the fields list as a tail.
 
5538
          Because of this we have to update the element count also for this
 
5539
          list after expanding the '*' entry.
 
5540
        */
 
5541
        sum_func_list->elements+= fields.elements - elem;
3349
5542
      }
3350
5543
      wild_num--;
3351
5544
    }
3352
5545
    else
3353
 
      session->lex->current_select->cur_pos_in_select_list++;
 
5546
      thd->lex->current_select->cur_pos_in_select_list++;
3354
5547
  }
3355
 
  session->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
3356
 
 
3357
 
  return 0;
 
5548
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
 
5549
  return(0);
3358
5550
}
3359
5551
 
3360
5552
/****************************************************************************
3361
 
 ** Check that all given fields exists and fill struct with current data
3362
 
 ****************************************************************************/
 
5553
** Check that all given fields exists and fill struct with current data
 
5554
****************************************************************************/
3363
5555
 
3364
 
bool setup_fields(Session *session, Item **ref_pointer_array,
 
5556
bool setup_fields(THD *thd, Item **ref_pointer_array,
3365
5557
                  List<Item> &fields, enum_mark_columns mark_used_columns,
3366
5558
                  List<Item> *sum_func_list, bool allow_sum_func)
3367
5559
{
3368
5560
  register Item *item;
3369
 
  enum_mark_columns save_mark_used_columns= session->mark_used_columns;
3370
 
  nesting_map save_allow_sum_func= session->lex->allow_sum_func;
 
5561
  enum_mark_columns save_mark_used_columns= thd->mark_used_columns;
 
5562
  nesting_map save_allow_sum_func= thd->lex->allow_sum_func;
3371
5563
  List_iterator<Item> it(fields);
3372
5564
  bool save_is_item_list_lookup;
3373
5565
 
3374
 
  session->mark_used_columns= mark_used_columns;
 
5566
  thd->mark_used_columns= mark_used_columns;
3375
5567
  if (allow_sum_func)
3376
 
    session->lex->allow_sum_func|= 1 << session->lex->current_select->nest_level;
3377
 
  session->where= Session::DEFAULT_WHERE;
3378
 
  save_is_item_list_lookup= session->lex->current_select->is_item_list_lookup;
3379
 
  session->lex->current_select->is_item_list_lookup= 0;
 
5568
    thd->lex->allow_sum_func|= 1 << thd->lex->current_select->nest_level;
 
5569
  thd->where= THD::DEFAULT_WHERE;
 
5570
  save_is_item_list_lookup= thd->lex->current_select->is_item_list_lookup;
 
5571
  thd->lex->current_select->is_item_list_lookup= 0;
3380
5572
 
3381
5573
  /*
3382
5574
    To prevent fail on forward lookup we fill it with zerows,
3386
5578
    There is other way to solve problem: fill array with pointers to list,
3387
5579
    but it will be slower.
3388
5580
 
3389
 
TODO: remove it when (if) we made one list for allfields and
3390
 
ref_pointer_array
 
5581
    TODO: remove it when (if) we made one list for allfields and
 
5582
    ref_pointer_array
3391
5583
  */
3392
5584
  if (ref_pointer_array)
3393
5585
    memset(ref_pointer_array, 0, sizeof(Item *) * fields.elements);
3394
5586
 
3395
5587
  Item **ref= ref_pointer_array;
3396
 
  session->lex->current_select->cur_pos_in_select_list= 0;
 
5588
  thd->lex->current_select->cur_pos_in_select_list= 0;
3397
5589
  while ((item= it++))
3398
5590
  {
3399
 
    if ((!item->fixed && item->fix_fields(session, it.ref())) || (item= *(it.ref()))->check_cols(1))
 
5591
    if ((!item->fixed && item->fix_fields(thd, it.ref())) || (item= *(it.ref()))->check_cols(1))
3400
5592
    {
3401
 
      session->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
3402
 
      session->lex->allow_sum_func= save_allow_sum_func;
3403
 
      session->mark_used_columns= save_mark_used_columns;
3404
 
      return true;
 
5593
      thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
 
5594
      thd->lex->allow_sum_func= save_allow_sum_func;
 
5595
      thd->mark_used_columns= save_mark_used_columns;
 
5596
      return(true); /* purecov: inspected */
3405
5597
    }
3406
5598
    if (ref)
3407
5599
      *(ref++)= item;
3408
5600
    if (item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM &&
3409
 
        sum_func_list)
3410
 
      item->split_sum_func(session, ref_pointer_array, *sum_func_list);
3411
 
    session->used_tables|= item->used_tables();
3412
 
    session->lex->current_select->cur_pos_in_select_list++;
 
5601
        sum_func_list)
 
5602
      item->split_sum_func(thd, ref_pointer_array, *sum_func_list);
 
5603
    thd->used_tables|= item->used_tables();
 
5604
    thd->lex->current_select->cur_pos_in_select_list++;
3413
5605
  }
3414
 
  session->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
3415
 
  session->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
 
5606
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
 
5607
  thd->lex->current_select->cur_pos_in_select_list= UNDEF_POS;
3416
5608
 
3417
 
  session->lex->allow_sum_func= save_allow_sum_func;
3418
 
  session->mark_used_columns= save_mark_used_columns;
3419
 
  return(test(session->is_error()));
 
5609
  thd->lex->allow_sum_func= save_allow_sum_func;
 
5610
  thd->mark_used_columns= save_mark_used_columns;
 
5611
  return(test(thd->is_error()));
3420
5612
}
3421
5613
 
3422
5614
 
3424
5616
  make list of leaves of join table tree
3425
5617
 
3426
5618
  SYNOPSIS
3427
 
  make_leaves_list()
3428
 
  list    pointer to pointer on list first element
3429
 
  tables  table list
 
5619
    make_leaves_list()
 
5620
    list    pointer to pointer on list first element
 
5621
    tables  table list
3430
5622
 
3431
5623
  RETURN pointer on pointer to next_leaf of last element
3432
5624
*/
3433
5625
 
3434
 
static TableList **make_leaves_list(TableList **list, TableList *tables)
 
5626
TableList **make_leaves_list(TableList **list, TableList *tables)
3435
5627
{
3436
5628
  for (TableList *table= tables; table; table= table->next_local)
3437
5629
  {
3447
5639
  prepare tables
3448
5640
 
3449
5641
  SYNOPSIS
3450
 
  setup_tables()
3451
 
  session                 Thread Cursor
3452
 
  context       name resolution contest to setup table list there
3453
 
  from_clause   Top-level list of table references in the FROM clause
3454
 
  tables          Table list (select_lex->table_list)
3455
 
  leaves        List of join table leaves list (select_lex->leaf_tables)
3456
 
  refresh       It is onle refresh for subquery
3457
 
  select_insert It is SELECT ... INSERT command
 
5642
    setup_tables()
 
5643
    thd           Thread handler
 
5644
    context       name resolution contest to setup table list there
 
5645
    from_clause   Top-level list of table references in the FROM clause
 
5646
    tables        Table list (select_lex->table_list)
 
5647
    leaves        List of join table leaves list (select_lex->leaf_tables)
 
5648
    refresh       It is onle refresh for subquery
 
5649
    select_insert It is SELECT ... INSERT command
3458
5650
 
3459
5651
  NOTE
3460
 
  Check also that the 'used keys' and 'ignored keys' exists and set up the
3461
 
  table structure accordingly.
3462
 
  Create a list of leaf tables. For queries with NATURAL/USING JOINs,
3463
 
  compute the row types of the top most natural/using join table references
3464
 
  and link these into a list of table references for name resolution.
 
5652
    Check also that the 'used keys' and 'ignored keys' exists and set up the
 
5653
    table structure accordingly.
 
5654
    Create a list of leaf tables. For queries with NATURAL/USING JOINs,
 
5655
    compute the row types of the top most natural/using join table references
 
5656
    and link these into a list of table references for name resolution.
3465
5657
 
3466
 
  This has to be called for all tables that are used by items, as otherwise
3467
 
  table->map is not set and all Item_field will be regarded as const items.
 
5658
    This has to be called for all tables that are used by items, as otherwise
 
5659
    table->map is not set and all Item_field will be regarded as const items.
3468
5660
 
3469
5661
  RETURN
3470
 
  false ok;  In this case *map will includes the chosen index
3471
 
  true  error
 
5662
    false ok;  In this case *map will includes the chosen index
 
5663
    true  error
3472
5664
*/
3473
5665
 
3474
 
bool setup_tables(Session *session, Name_resolution_context *context,
 
5666
bool setup_tables(THD *thd, Name_resolution_context *context,
3475
5667
                  List<TableList> *from_clause, TableList *tables,
3476
5668
                  TableList **leaves, bool select_insert)
3477
5669
{
3478
 
  uint32_t tablenr= 0;
 
5670
  uint tablenr= 0;
3479
5671
 
3480
 
  assert ((select_insert && !tables->next_name_resolution_table) || !tables ||
3481
 
          (context->table_list && context->first_name_resolution_table));
 
5672
  assert ((select_insert && !tables->next_name_resolution_table) || !tables || 
 
5673
               (context->table_list && context->first_name_resolution_table));
3482
5674
  /*
3483
5675
    this is used for INSERT ... SELECT.
3484
5676
    For select we setup tables except first (and its underlying tables)
3485
5677
  */
3486
 
  TableList *first_select_table= (select_insert ?  tables->next_local: NULL);
3487
 
 
 
5678
  TableList *first_select_table= (select_insert ?
 
5679
                                   tables->next_local:
 
5680
                                   0);
3488
5681
  if (!(*leaves))
3489
5682
    make_leaves_list(leaves, tables);
3490
5683
 
3502
5695
      first_select_table= 0;
3503
5696
      tablenr= 0;
3504
5697
    }
3505
 
    table->setup_table_map(table_list, tablenr);
 
5698
    setup_table_map(table, table_list, tablenr);
3506
5699
    if (table_list->process_index_hints(table))
3507
 
      return 1;
 
5700
      return(1);
3508
5701
  }
3509
5702
  if (tablenr > MAX_TABLES)
3510
5703
  {
3511
5704
    my_error(ER_TOO_MANY_TABLES,MYF(0),MAX_TABLES);
3512
 
    return 1;
 
5705
    return(1);
3513
5706
  }
3514
5707
 
3515
5708
  /* Precompute and store the row types of NATURAL/USING joins. */
3516
 
  if (setup_natural_join_row_types(session, from_clause, context))
3517
 
    return 1;
 
5709
  if (setup_natural_join_row_types(thd, from_clause, context))
 
5710
    return(1);
3518
5711
 
3519
 
  return 0;
 
5712
  return(0);
3520
5713
}
3521
5714
 
3522
5715
 
3524
5717
  prepare tables and check access for the view tables
3525
5718
 
3526
5719
  SYNOPSIS
3527
 
  setup_tables_and_check_view_access()
3528
 
  session                 Thread Cursor
3529
 
  context       name resolution contest to setup table list there
3530
 
  from_clause   Top-level list of table references in the FROM clause
3531
 
  tables          Table list (select_lex->table_list)
3532
 
  conds   Condition of current SELECT (can be changed by VIEW)
3533
 
  leaves        List of join table leaves list (select_lex->leaf_tables)
3534
 
  refresh       It is onle refresh for subquery
3535
 
  select_insert It is SELECT ... INSERT command
3536
 
  want_access   what access is needed
 
5720
    setup_tables_and_check_view_access()
 
5721
    thd           Thread handler
 
5722
    context       name resolution contest to setup table list there
 
5723
    from_clause   Top-level list of table references in the FROM clause
 
5724
    tables        Table list (select_lex->table_list)
 
5725
    conds         Condition of current SELECT (can be changed by VIEW)
 
5726
    leaves        List of join table leaves list (select_lex->leaf_tables)
 
5727
    refresh       It is onle refresh for subquery
 
5728
    select_insert It is SELECT ... INSERT command
 
5729
    want_access   what access is needed
3537
5730
 
3538
5731
  NOTE
3539
 
  a wrapper for check_tables that will also check the resulting
3540
 
  table leaves list for access to all the tables that belong to a view
 
5732
    a wrapper for check_tables that will also check the resulting
 
5733
    table leaves list for access to all the tables that belong to a view
3541
5734
 
3542
5735
  RETURN
3543
 
  false ok;  In this case *map will include the chosen index
3544
 
  true  error
 
5736
    false ok;  In this case *map will include the chosen index
 
5737
    true  error
3545
5738
*/
3546
 
bool setup_tables_and_check_access(Session *session,
 
5739
bool setup_tables_and_check_access(THD *thd, 
3547
5740
                                   Name_resolution_context *context,
3548
5741
                                   List<TableList> *from_clause,
3549
5742
                                   TableList *tables,
3551
5744
                                   bool select_insert)
3552
5745
{
3553
5746
  TableList *leaves_tmp= NULL;
 
5747
  bool first_table= true;
3554
5748
 
3555
 
  if (setup_tables(session, context, from_clause, tables,
 
5749
  if (setup_tables(thd, context, from_clause, tables,
3556
5750
                   &leaves_tmp, select_insert))
3557
5751
    return true;
3558
5752
 
3559
5753
  if (leaves)
3560
5754
    *leaves= leaves_tmp;
3561
5755
 
 
5756
  for (; leaves_tmp; leaves_tmp= leaves_tmp->next_leaf)
 
5757
  {
 
5758
    first_table= 0;
 
5759
  }
3562
5760
  return false;
3563
5761
}
3564
5762
 
3565
5763
 
3566
5764
/*
 
5765
   Create a key_map from a list of index names
 
5766
 
 
5767
   SYNOPSIS
 
5768
     get_key_map_from_key_list()
 
5769
     map                key_map to fill in
 
5770
     table              Table
 
5771
     index_list         List of index names
 
5772
 
 
5773
   RETURN
 
5774
     0  ok;  In this case *map will includes the choosed index
 
5775
     1  error
 
5776
*/
 
5777
 
 
5778
bool get_key_map_from_key_list(key_map *map, Table *table,
 
5779
                               List<String> *index_list)
 
5780
{
 
5781
  List_iterator_fast<String> it(*index_list);
 
5782
  String *name;
 
5783
  uint pos;
 
5784
 
 
5785
  map->clear_all();
 
5786
  while ((name=it++))
 
5787
  {
 
5788
    if (table->s->keynames.type_names == 0 ||
 
5789
        (pos= find_type(&table->s->keynames, name->ptr(),
 
5790
                        name->length(), 1)) <=
 
5791
        0)
 
5792
    {
 
5793
      my_error(ER_KEY_DOES_NOT_EXITS, MYF(0), name->c_ptr(),
 
5794
               table->pos_in_table_list->alias);
 
5795
      map->set_all();
 
5796
      return 1;
 
5797
    }
 
5798
    map->set_bit(pos-1);
 
5799
  }
 
5800
  return 0;
 
5801
}
 
5802
 
 
5803
 
 
5804
/*
3567
5805
  Drops in all fields instead of current '*' field
3568
5806
 
3569
5807
  SYNOPSIS
3570
 
  insert_fields()
3571
 
  session                       Thread Cursor
3572
 
  context             Context for name resolution
3573
 
  db_name               Database name in case of 'database_name.table_name.*'
3574
 
  table_name            Table name in case of 'table_name.*'
3575
 
  it                    Pointer to '*'
3576
 
  any_privileges        0 If we should ensure that we have SELECT privileges
3577
 
  for all columns
3578
 
  1 If any privilege is ok
 
5808
    insert_fields()
 
5809
    thd                 Thread handler
 
5810
    context             Context for name resolution
 
5811
    db_name             Database name in case of 'database_name.table_name.*'
 
5812
    table_name          Table name in case of 'table_name.*'
 
5813
    it                  Pointer to '*'
 
5814
    any_privileges      0 If we should ensure that we have SELECT privileges
 
5815
                          for all columns
 
5816
                        1 If any privilege is ok
3579
5817
  RETURN
3580
 
  0     ok     'it' is updated to point at last inserted
3581
 
  1     error.  Error message is generated but not sent to client
 
5818
    0   ok     'it' is updated to point at last inserted
 
5819
    1   error.  Error message is generated but not sent to client
3582
5820
*/
3583
5821
 
3584
5822
bool
3585
 
insert_fields(Session *session, Name_resolution_context *context, const char *db_name,
 
5823
insert_fields(THD *thd, Name_resolution_context *context, const char *db_name,
3586
5824
              const char *table_name, List_iterator<Item> *it,
3587
 
              bool )
 
5825
              bool any_privileges __attribute__((unused)))
3588
5826
{
3589
5827
  Field_iterator_table_ref field_iterator;
3590
5828
  bool found;
3591
5829
  char name_buff[NAME_LEN+1];
3592
5830
 
3593
 
  if (db_name)
 
5831
  if (db_name && lower_case_table_names)
3594
5832
  {
3595
5833
    /*
3596
5834
      convert database to lower case for comparison
3597
5835
      We can't do this in Item_field as this would change the
3598
5836
      'name' of the item which may be used in the select list
3599
5837
    */
3600
 
    strncpy(name_buff, db_name, sizeof(name_buff)-1);
 
5838
    strmake(name_buff, db_name, sizeof(name_buff)-1);
3601
5839
    my_casedn_str(files_charset_info, name_buff);
3602
5840
    db_name= name_buff;
3603
5841
  }
3610
5848
    tables.
3611
5849
  */
3612
5850
  for (TableList *tables= (table_name ? context->table_list :
3613
 
                           context->first_name_resolution_table);
 
5851
                            context->first_name_resolution_table);
3614
5852
       tables;
3615
5853
       tables= (table_name ? tables->next_local :
3616
5854
                tables->next_name_resolution_table)
3617
 
      )
 
5855
       )
3618
5856
  {
3619
5857
    Field *field;
3620
5858
    Table *table= tables->table;
3621
5859
 
3622
5860
    assert(tables->is_leaf_for_name_resolution());
3623
5861
 
3624
 
    if ((table_name && my_strcasecmp(table_alias_charset, table_name, tables->alias)) ||
3625
 
        (db_name && strcasecmp(tables->getSchemaName(),db_name)))
 
5862
    if ((table_name && my_strcasecmp(table_alias_charset, table_name, tables->alias)) || 
 
5863
        (db_name && strcmp(tables->db,db_name)))
3626
5864
      continue;
3627
5865
 
3628
5866
    /*
3630
5868
      views and natural joins this update is performed inside the loop below.
3631
5869
    */
3632
5870
    if (table)
3633
 
      session->used_tables|= table->map;
 
5871
      thd->used_tables|= table->map;
3634
5872
 
3635
5873
    /*
3636
5874
      Initialize a generic field iterator for the current table reference.
3644
5882
    {
3645
5883
      Item *item;
3646
5884
 
3647
 
      if (!(item= field_iterator.create_item(session)))
3648
 
        return true;
 
5885
      if (!(item= field_iterator.create_item(thd)))
 
5886
        return(true);
3649
5887
 
3650
5888
      if (!found)
3651
5889
      {
3658
5896
      if ((field= field_iterator.field()))
3659
5897
      {
3660
5898
        /* Mark fields as used to allow storage engine to optimze access */
3661
 
        field->getTable()->setReadSet(field->position());
 
5899
        bitmap_set_bit(field->table->read_set, field->field_index);
3662
5900
        if (table)
3663
5901
        {
3664
 
          table->covering_keys&= field->part_of_key;
3665
 
          table->merge_keys|= field->part_of_key;
 
5902
          table->covering_keys.intersect(field->part_of_key);
 
5903
          table->merge_keys.merge(field->part_of_key);
3666
5904
        }
3667
5905
        if (tables->is_natural_join)
3668
5906
        {
3673
5911
          */
3674
5912
          Natural_join_column *nj_col;
3675
5913
          if (!(nj_col= field_iterator.get_natural_column_ref()))
3676
 
            return true;
 
5914
            return(true);
3677
5915
          assert(nj_col->table_field);
3678
5916
          field_table= nj_col->table_ref->table;
3679
5917
          if (field_table)
3680
5918
          {
3681
 
            session->used_tables|= field_table->map;
3682
 
            field_table->covering_keys&= field->part_of_key;
3683
 
            field_table->merge_keys|= field->part_of_key;
 
5919
            thd->used_tables|= field_table->map;
 
5920
            field_table->covering_keys.intersect(field->part_of_key);
 
5921
            field_table->merge_keys.merge(field->part_of_key);
3684
5922
            field_table->used_fields++;
3685
5923
          }
3686
5924
        }
3687
5925
      }
3688
5926
      else
3689
 
        session->used_tables|= item->used_tables();
3690
 
      session->lex->current_select->cur_pos_in_select_list++;
 
5927
        thd->used_tables|= item->used_tables();
 
5928
      thd->lex->current_select->cur_pos_in_select_list++;
3691
5929
    }
3692
5930
    /*
3693
5931
      In case of stored tables, all fields are considered as used,
3696
5934
      For NATURAL joins, used_tables is updated in the IF above.
3697
5935
    */
3698
5936
    if (table)
3699
 
      table->used_fields= table->getShare()->sizeFields();
 
5937
      table->used_fields= table->s->fields;
3700
5938
  }
3701
5939
  if (found)
3702
 
    return false;
 
5940
    return(false);
3703
5941
 
3704
5942
  /*
3705
 
    @TODO in the case when we skipped all columns because there was a
 
5943
    TODO: in the case when we skipped all columns because there was a
3706
5944
    qualified '*', and all columns were coalesced, we have to give a more
3707
5945
    meaningful message than ER_BAD_TABLE_ERROR.
3708
5946
  */
3711
5949
  else
3712
5950
    my_error(ER_BAD_TABLE_ERROR, MYF(0), table_name);
3713
5951
 
3714
 
  return true;
 
5952
  return(true);
3715
5953
}
3716
5954
 
3717
5955
 
3719
5957
  Fix all conditions and outer join expressions.
3720
5958
 
3721
5959
  SYNOPSIS
3722
 
  setup_conds()
3723
 
  session     thread Cursor
3724
 
  tables  list of tables for name resolving (select_lex->table_list)
3725
 
  leaves  list of leaves of join table tree (select_lex->leaf_tables)
3726
 
  conds   WHERE clause
 
5960
    setup_conds()
 
5961
    thd     thread handler
 
5962
    tables  list of tables for name resolving (select_lex->table_list)
 
5963
    leaves  list of leaves of join table tree (select_lex->leaf_tables)
 
5964
    conds   WHERE clause
3727
5965
 
3728
5966
  DESCRIPTION
3729
 
  TODO
 
5967
    TODO
3730
5968
 
3731
5969
  RETURN
3732
 
  true  if some error occured (e.g. out of memory)
3733
 
  false if all is OK
 
5970
    true  if some error occured (e.g. out of memory)
 
5971
    false if all is OK
3734
5972
*/
3735
5973
 
3736
 
int Session::setup_conds(TableList *leaves, COND **conds)
 
5974
int setup_conds(THD *thd, TableList *tables __attribute__((unused)),
 
5975
                TableList *leaves,
 
5976
                COND **conds)
3737
5977
{
3738
 
  Session *session= this;
3739
 
  Select_Lex *select_lex= session->lex->current_select;
 
5978
  SELECT_LEX *select_lex= thd->lex->current_select;
3740
5979
  TableList *table= NULL;       // For HP compilers
3741
 
  void *save_session_marker= session->session_marker;
 
5980
  void *save_thd_marker= thd->thd_marker;
3742
5981
  /*
3743
 
    it_is_update set to true when tables of primary Select_Lex (Select_Lex
 
5982
    it_is_update set to true when tables of primary SELECT_LEX (SELECT_LEX
3744
5983
    which belong to LEX, i.e. most up SELECT) will be updated by
3745
5984
    INSERT/UPDATE/LOAD
3746
 
    NOTE-> using this condition helps to prevent call of prepare_check_option()
 
5985
    NOTE: using this condition helps to prevent call of prepare_check_option()
3747
5986
    from subquery of VIEW, because tables of subquery belongs to VIEW
3748
5987
    (see condition before prepare_check_option() call)
3749
5988
  */
3750
5989
  bool save_is_item_list_lookup= select_lex->is_item_list_lookup;
3751
5990
  select_lex->is_item_list_lookup= 0;
3752
5991
 
3753
 
  session->mark_used_columns= MARK_COLUMNS_READ;
 
5992
  thd->mark_used_columns= MARK_COLUMNS_READ;
3754
5993
  select_lex->cond_count= 0;
3755
5994
  select_lex->between_count= 0;
3756
5995
  select_lex->max_equal_elems= 0;
3757
5996
 
3758
 
  session->session_marker= (void*)1;
 
5997
  thd->thd_marker= (void*)1;
3759
5998
  if (*conds)
3760
5999
  {
3761
 
    session->where="where clause";
3762
 
    if ((!(*conds)->fixed && (*conds)->fix_fields(session, conds)) ||
3763
 
        (*conds)->check_cols(1))
 
6000
    thd->where="where clause";
 
6001
    if ((!(*conds)->fixed && (*conds)->fix_fields(thd, conds)) ||
 
6002
        (*conds)->check_cols(1))
3764
6003
      goto err_no_arena;
3765
6004
  }
3766
 
  session->session_marker= save_session_marker;
 
6005
  thd->thd_marker= save_thd_marker;
3767
6006
 
3768
6007
  /*
3769
6008
    Apply fix_fields() to all ON clauses at all levels of nesting,
3779
6018
      if (embedded->on_expr)
3780
6019
      {
3781
6020
        /* Make a join an a expression */
3782
 
        session->session_marker= (void*)embedded;
3783
 
        session->where="on clause";
3784
 
        if ((!embedded->on_expr->fixed && embedded->on_expr->fix_fields(session, &embedded->on_expr)) ||
3785
 
            embedded->on_expr->check_cols(1))
3786
 
          goto err_no_arena;
 
6021
        thd->thd_marker= (void*)embedded;
 
6022
        thd->where="on clause";
 
6023
        if ((!embedded->on_expr->fixed && embedded->on_expr->fix_fields(thd, &embedded->on_expr)) ||
 
6024
            embedded->on_expr->check_cols(1))
 
6025
          goto err_no_arena;
3787
6026
        select_lex->cond_count++;
3788
6027
      }
3789
 
      embedding= embedded->getEmbedding();
 
6028
      embedding= embedded->embedding;
3790
6029
    }
3791
6030
    while (embedding &&
3792
 
           embedding->getNestedJoin()->join_list.head() == embedded);
 
6031
           embedding->nested_join->join_list.head() == embedded);
3793
6032
 
3794
6033
  }
3795
 
  session->session_marker= save_session_marker;
 
6034
  thd->thd_marker= save_thd_marker;
3796
6035
 
3797
 
  session->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
3798
 
  return(test(session->is_error()));
 
6036
  thd->lex->current_select->is_item_list_lookup= save_is_item_list_lookup;
 
6037
  return(test(thd->is_error()));
3799
6038
 
3800
6039
err_no_arena:
3801
6040
  select_lex->is_item_list_lookup= save_is_item_list_lookup;
3802
 
 
3803
 
  return 1;
 
6041
  return(1);
3804
6042
}
3805
6043
 
3806
6044
 
3807
6045
/******************************************************************************
3808
 
 ** Fill a record with data (for INSERT or UPDATE)
3809
 
 ** Returns : 1 if some field has wrong type
3810
 
 ******************************************************************************/
 
6046
** Fill a record with data (for INSERT or UPDATE)
 
6047
** Returns : 1 if some field has wrong type
 
6048
******************************************************************************/
3811
6049
 
3812
6050
 
3813
6051
/*
3814
6052
  Fill fields with given items.
3815
6053
 
3816
6054
  SYNOPSIS
3817
 
  fill_record()
3818
 
  fields        Item_fields list to be filled
3819
 
  values        values to fill with
3820
 
  ignore_errors true if we should ignore errors
 
6055
    fill_record()
 
6056
    thd           thread handler
 
6057
    fields        Item_fields list to be filled
 
6058
    values        values to fill with
 
6059
    ignore_errors true if we should ignore errors
3821
6060
 
3822
6061
  NOTE
3823
 
  fill_record() may set table->auto_increment_field_not_null and a
3824
 
  caller should make sure that it is reset after their last call to this
3825
 
  function.
 
6062
    fill_record() may set table->auto_increment_field_not_null and a
 
6063
    caller should make sure that it is reset after their last call to this
 
6064
    function.
3826
6065
 
3827
6066
  RETURN
3828
 
  false   OK
3829
 
  true    error occured
 
6067
    false   OK
 
6068
    true    error occured
3830
6069
*/
3831
6070
 
3832
6071
bool
3833
 
fill_record(Session *session, List<Item> &fields, List<Item> &values, bool ignore_errors)
 
6072
fill_record(THD * thd, List<Item> &fields, List<Item> &values, bool ignore_errors)
3834
6073
{
3835
6074
  List_iterator_fast<Item> f(fields),v(values);
3836
 
  Item *value;
 
6075
  Item *value, *fld;
3837
6076
  Item_field *field;
3838
 
  Table *table;
 
6077
  Table *table= 0;
3839
6078
 
3840
6079
  /*
3841
6080
    Reset the table->auto_increment_field_not_null as it is valid for
3847
6086
      On INSERT or UPDATE fields are checked to be from the same table,
3848
6087
      thus we safely can take table from the first field.
3849
6088
    */
3850
 
    field= static_cast<Item_field *>(f++);
3851
 
    table= field->field->getTable();
 
6089
    fld= (Item_field*)f++;
 
6090
    if (!(field= fld->filed_for_view_update()))
 
6091
    {
 
6092
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
 
6093
      goto err;
 
6094
    }
 
6095
    table= field->field->table;
3852
6096
    table->auto_increment_field_not_null= false;
3853
6097
    f.rewind();
3854
6098
  }
3855
 
 
3856
 
  while ((field= static_cast<Item_field *>(f++)))
 
6099
  while ((fld= f++))
3857
6100
  {
3858
 
    value= v++;
3859
 
 
 
6101
    if (!(field= fld->filed_for_view_update()))
 
6102
    {
 
6103
      my_error(ER_NONUPDATEABLE_COLUMN, MYF(0), fld->name);
 
6104
      goto err;
 
6105
    }
 
6106
    value=v++;
3860
6107
    Field *rfield= field->field;
3861
 
    table= rfield->getTable();
3862
 
 
 
6108
    table= rfield->table;
3863
6109
    if (rfield == table->next_number_field)
3864
6110
      table->auto_increment_field_not_null= true;
3865
6111
    if ((value->save_in_field(rfield, 0) < 0) && !ignore_errors)
3866
6112
    {
3867
6113
      my_message(ER_UNKNOWN_ERROR, ER(ER_UNKNOWN_ERROR), MYF(0));
3868
 
      if (table)
3869
 
        table->auto_increment_field_not_null= false;
3870
 
 
3871
 
      return true;
 
6114
      goto err;
3872
6115
    }
3873
6116
  }
3874
 
 
3875
 
  return session->is_error();
 
6117
  return(thd->is_error());
 
6118
err:
 
6119
  if (table)
 
6120
    table->auto_increment_field_not_null= false;
 
6121
  return(true);
3876
6122
}
3877
6123
 
3878
6124
 
3880
6126
  Fill field buffer with values from Field list
3881
6127
 
3882
6128
  SYNOPSIS
3883
 
  fill_record()
3884
 
  ptr           pointer on pointer to record
3885
 
  values        list of fields
3886
 
  ignore_errors true if we should ignore errors
 
6129
    fill_record()
 
6130
    thd           thread handler
 
6131
    ptr           pointer on pointer to record
 
6132
    values        list of fields
 
6133
    ignore_errors true if we should ignore errors
3887
6134
 
3888
6135
  NOTE
3889
 
  fill_record() may set table->auto_increment_field_not_null and a
3890
 
  caller should make sure that it is reset after their last call to this
3891
 
  function.
 
6136
    fill_record() may set table->auto_increment_field_not_null and a
 
6137
    caller should make sure that it is reset after their last call to this
 
6138
    function.
3892
6139
 
3893
6140
  RETURN
3894
 
  false   OK
3895
 
  true    error occured
 
6141
    false   OK
 
6142
    true    error occured
3896
6143
*/
3897
6144
 
3898
 
bool fill_record(Session *session, Field **ptr, List<Item> &values, bool)
 
6145
bool
 
6146
fill_record(THD *thd, Field **ptr, List<Item> &values,
 
6147
            bool ignore_errors __attribute__((unused)))
3899
6148
{
3900
6149
  List_iterator_fast<Item> v(values);
3901
6150
  Item *value;
3902
6151
  Table *table= 0;
 
6152
 
3903
6153
  Field *field;
3904
 
 
3905
6154
  /*
3906
6155
    Reset the table->auto_increment_field_not_null as it is valid for
3907
6156
    only one row.
3912
6161
      On INSERT or UPDATE fields are checked to be from the same table,
3913
6162
      thus we safely can take table from the first field.
3914
6163
    */
3915
 
    table= (*ptr)->getTable();
 
6164
    table= (*ptr)->table;
3916
6165
    table->auto_increment_field_not_null= false;
3917
6166
  }
3918
 
  while ((field = *ptr++) && ! session->is_error())
 
6167
  while ((field = *ptr++) && ! thd->is_error())
3919
6168
  {
3920
6169
    value=v++;
3921
 
    table= field->getTable();
 
6170
    table= field->table;
3922
6171
    if (field == table->next_number_field)
3923
6172
      table->auto_increment_field_not_null= true;
3924
6173
    if (value->save_in_field(field, 0) < 0)
 
6174
      goto err;
 
6175
  }
 
6176
  return(thd->is_error());
 
6177
 
 
6178
err:
 
6179
  if (table)
 
6180
    table->auto_increment_field_not_null= false;
 
6181
  return(true);
 
6182
}
 
6183
 
 
6184
 
 
6185
bool mysql_rm_tmp_tables(void)
 
6186
{
 
6187
  uint i, idx;
 
6188
  char  filePath[FN_REFLEN], *tmpdir, filePathCopy[FN_REFLEN];
 
6189
  MY_DIR *dirp;
 
6190
  FILEINFO *file;
 
6191
  TABLE_SHARE share;
 
6192
  THD *thd;
 
6193
 
 
6194
  if (!(thd= new THD))
 
6195
    return(1);
 
6196
  thd->thread_stack= (char*) &thd;
 
6197
  thd->store_globals();
 
6198
 
 
6199
  for (i=0; i<=mysql_tmpdir_list.max; i++)
 
6200
  {
 
6201
    tmpdir=mysql_tmpdir_list.list[i];
 
6202
    /* See if the directory exists */
 
6203
    if (!(dirp = my_dir(tmpdir,MYF(MY_WME | MY_DONT_SORT))))
 
6204
      continue;
 
6205
 
 
6206
    /* Remove all SQLxxx tables from directory */
 
6207
 
 
6208
    for (idx=0 ; idx < (uint) dirp->number_off_files ; idx++)
3925
6209
    {
3926
 
      if (table)
3927
 
        table->auto_increment_field_not_null= false;
3928
 
 
3929
 
      return true;
 
6210
      file=dirp->dir_entry+idx;
 
6211
 
 
6212
      /* skiping . and .. */
 
6213
      if (file->name[0] == '.' && (!file->name[1] ||
 
6214
                                   (file->name[1] == '.' &&  !file->name[2])))
 
6215
        continue;
 
6216
 
 
6217
      if (!memcmp(file->name, tmp_file_prefix, tmp_file_prefix_length))
 
6218
      {
 
6219
        char *ext= fn_ext(file->name);
 
6220
        uint ext_len= strlen(ext);
 
6221
        uint filePath_len= snprintf(filePath, sizeof(filePath),
 
6222
                                    "%s%c%s", tmpdir, FN_LIBCHAR,
 
6223
                                    file->name);
 
6224
        if (!memcmp(reg_ext, ext, ext_len))
 
6225
        {
 
6226
          handler *handler_file= 0;
 
6227
          /* We should cut file extention before deleting of table */
 
6228
          memcpy(filePathCopy, filePath, filePath_len - ext_len);
 
6229
          filePathCopy[filePath_len - ext_len]= 0;
 
6230
          init_tmp_table_share(thd, &share, "", 0, "", filePathCopy);
 
6231
          if (!open_table_def(thd, &share, 0) &&
 
6232
              ((handler_file= get_new_handler(&share, thd->mem_root,
 
6233
                                              share.db_type()))))
 
6234
          {
 
6235
            handler_file->ha_delete_table(filePathCopy);
 
6236
            delete handler_file;
 
6237
          }
 
6238
          free_table_share(&share);
 
6239
        }
 
6240
        /*
 
6241
          File can be already deleted by tmp_table.file->delete_table().
 
6242
          So we hide error messages which happnes during deleting of these
 
6243
          files(MYF(0)).
 
6244
        */
 
6245
        VOID(my_delete(filePath, MYF(0))); 
 
6246
      }
3930
6247
    }
 
6248
    my_dirend(dirp);
3931
6249
  }
3932
 
 
3933
 
  return(session->is_error());
3934
 
}
3935
 
 
3936
 
 
3937
 
bool drizzle_rm_tmp_tables()
3938
 
{
3939
 
  Session *session;
3940
 
 
3941
 
  assert(drizzle_tmpdir.size());
3942
 
 
3943
 
  if (!(session= new Session(plugin::Listen::getNullClient())))
3944
 
    return true;
3945
 
  session->thread_stack= (char*) &session;
3946
 
  session->storeGlobals();
3947
 
 
3948
 
  plugin::StorageEngine::removeLostTemporaryTables(*session, drizzle_tmpdir.c_str());
3949
 
 
3950
 
  delete session;
3951
 
 
3952
 
  return false;
 
6250
  delete thd;
 
6251
  my_pthread_setspecific_ptr(THR_THD,  0);
 
6252
  return(0);
3953
6253
}
3954
6254
 
3955
6255
 
3956
6256
 
3957
6257
/*****************************************************************************
3958
 
  unireg support functions
3959
 
 *****************************************************************************/
3960
 
 
3961
 
 
3962
 
 
3963
 
 
 
6258
        unireg support functions
 
6259
*****************************************************************************/
 
6260
 
 
6261
/*
 
6262
  Invalidate any cache entries that are for some DB
 
6263
 
 
6264
  SYNOPSIS
 
6265
    remove_db_from_cache()
 
6266
    db          Database name. This will be in lower case if
 
6267
                lower_case_table_name is set
 
6268
 
 
6269
  NOTE:
 
6270
  We can't use hash_delete when looping hash_elements. We mark them first
 
6271
  and afterwards delete those marked unused.
 
6272
*/
 
6273
 
 
6274
void remove_db_from_cache(const char *db)
 
6275
{
 
6276
  for (uint idx=0 ; idx < open_cache.records ; idx++)
 
6277
  {
 
6278
    Table *table=(Table*) hash_element(&open_cache,idx);
 
6279
    if (!strcmp(table->s->db.str, db))
 
6280
    {
 
6281
      table->s->version= 0L;                    /* Free when thread is ready */
 
6282
      if (!table->in_use)
 
6283
        relink_unused(table);
 
6284
    }
 
6285
  }
 
6286
  while (unused_tables && !unused_tables->s->version)
 
6287
    VOID(hash_delete(&open_cache,(uchar*) unused_tables));
 
6288
}
 
6289
 
 
6290
 
 
6291
/*
 
6292
  free all unused tables
 
6293
 
 
6294
  NOTE
 
6295
    This is called by 'handle_manager' when one wants to periodicly flush
 
6296
    all not used tables.
 
6297
*/
 
6298
 
 
6299
void flush_tables()
 
6300
{
 
6301
  (void) pthread_mutex_lock(&LOCK_open);
 
6302
  while (unused_tables)
 
6303
    hash_delete(&open_cache,(uchar*) unused_tables);
 
6304
  (void) pthread_mutex_unlock(&LOCK_open);
 
6305
}
 
6306
 
 
6307
 
 
6308
/*
 
6309
  Mark all entries with the table as deleted to force an reopen of the table
 
6310
 
 
6311
  The table will be closed (not stored in cache) by the current thread when
 
6312
  close_thread_tables() is called.
 
6313
 
 
6314
  PREREQUISITES
 
6315
    Lock on LOCK_open()
 
6316
 
 
6317
  RETURN
 
6318
    0  This thread now have exclusive access to this table and no other thread
 
6319
       can access the table until close_thread_tables() is called.
 
6320
    1  Table is in use by another thread
 
6321
*/
 
6322
 
 
6323
bool remove_table_from_cache(THD *thd, const char *db, const char *table_name,
 
6324
                             uint flags)
 
6325
{
 
6326
  char key[MAX_DBKEY_LENGTH];
 
6327
  uint key_length;
 
6328
  Table *table;
 
6329
  TABLE_SHARE *share;
 
6330
  bool result= 0, signalled= 0;
 
6331
 
 
6332
  key_length=(uint) (stpcpy(stpcpy(key,db)+1,table_name)-key)+1;
 
6333
  for (;;)
 
6334
  {
 
6335
    HASH_SEARCH_STATE state;
 
6336
    result= signalled= 0;
 
6337
 
 
6338
    for (table= (Table*) hash_first(&open_cache, (uchar*) key, key_length,
 
6339
                                    &state);
 
6340
         table;
 
6341
         table= (Table*) hash_next(&open_cache, (uchar*) key, key_length,
 
6342
                                   &state))
 
6343
    {
 
6344
      THD *in_use;
 
6345
 
 
6346
      table->s->version=0L;             /* Free when thread is ready */
 
6347
      if (!(in_use=table->in_use))
 
6348
      {
 
6349
        relink_unused(table);
 
6350
      }
 
6351
      else if (in_use != thd)
 
6352
      {
 
6353
        /*
 
6354
          Mark that table is going to be deleted from cache. This will
 
6355
          force threads that are in mysql_lock_tables() (but not yet
 
6356
          in thr_multi_lock()) to abort it's locks, close all tables and retry
 
6357
        */
 
6358
        in_use->some_tables_deleted= 1;
 
6359
        if (table->is_name_opened())
 
6360
        {
 
6361
          result=1;
 
6362
        }
 
6363
        /*
 
6364
          Now we must abort all tables locks used by this thread
 
6365
          as the thread may be waiting to get a lock for another table.
 
6366
          Note that we need to hold LOCK_open while going through the
 
6367
          list. So that the other thread cannot change it. The other
 
6368
          thread must also hold LOCK_open whenever changing the
 
6369
          open_tables list. Aborting the MERGE lock after a child was
 
6370
          closed and before the parent is closed would be fatal.
 
6371
        */
 
6372
        for (Table *thd_table= in_use->open_tables;
 
6373
             thd_table ;
 
6374
             thd_table= thd_table->next)
 
6375
        {
 
6376
          /* Do not handle locks of MERGE children. */
 
6377
          if (thd_table->db_stat)       // If table is open
 
6378
            signalled|= mysql_lock_abort_for_thread(thd, thd_table);
 
6379
        }
 
6380
      }
 
6381
      else
 
6382
        result= result || (flags & RTFC_OWNED_BY_THD_FLAG);
 
6383
    }
 
6384
    while (unused_tables && !unused_tables->s->version)
 
6385
      VOID(hash_delete(&open_cache,(uchar*) unused_tables));
 
6386
 
 
6387
    /* Remove table from table definition cache if it's not in use */
 
6388
    if ((share= (TABLE_SHARE*) hash_search(&table_def_cache,(uchar*) key,
 
6389
                                           key_length)))
 
6390
    {
 
6391
      share->version= 0;                          // Mark for delete
 
6392
      if (share->ref_count == 0)
 
6393
      {
 
6394
        pthread_mutex_lock(&share->mutex);
 
6395
        VOID(hash_delete(&table_def_cache, (uchar*) share));
 
6396
      }
 
6397
    }
 
6398
 
 
6399
    if (result && (flags & RTFC_WAIT_OTHER_THREAD_FLAG))
 
6400
    {
 
6401
      /*
 
6402
        Signal any thread waiting for tables to be freed to
 
6403
        reopen their tables
 
6404
      */
 
6405
      broadcast_refresh();
 
6406
      if (!(flags & RTFC_CHECK_KILLED_FLAG) || !thd->killed)
 
6407
      {
 
6408
        dropping_tables++;
 
6409
        if (likely(signalled))
 
6410
          (void) pthread_cond_wait(&COND_refresh, &LOCK_open);
 
6411
        else
 
6412
        {
 
6413
          struct timespec abstime;
 
6414
          /*
 
6415
            It can happen that another thread has opened the
 
6416
            table but has not yet locked any table at all. Since
 
6417
            it can be locked waiting for a table that our thread
 
6418
            has done LOCK Table x WRITE on previously, we need to
 
6419
            ensure that the thread actually hears our signal
 
6420
            before we go to sleep. Thus we wait for a short time
 
6421
            and then we retry another loop in the
 
6422
            remove_table_from_cache routine.
 
6423
          */
 
6424
          set_timespec(abstime, 10);
 
6425
          pthread_cond_timedwait(&COND_refresh, &LOCK_open, &abstime);
 
6426
        }
 
6427
        dropping_tables--;
 
6428
        continue;
 
6429
      }
 
6430
    }
 
6431
    break;
 
6432
  }
 
6433
  return(result);
 
6434
}
 
6435
 
 
6436
 
 
6437
bool is_equal(const LEX_STRING *a, const LEX_STRING *b)
 
6438
{
 
6439
  return a->length == b->length && !strncmp(a->str, b->str, a->length);
 
6440
}
3964
6441
/**
3965
6442
  @} (end of group Data_Dictionary)
3966
6443
*/
3967
 
 
3968
 
void kill_drizzle(void)
3969
 
{
3970
 
  pthread_kill(signal_thread, SIGTERM);
3971
 
  shutdown_in_progress= 1;                      // Safety if kill didn't work
3972
 
}
3973
 
 
3974
 
} /* namespace drizzled */