← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_parse.cc

  • Committer: Monty Taylor
  • Date: 2009-04-25 20:45:19 UTC
  • mto: (997.2.5 mordred)
  • mto: This revision was merged to the branch mainline in revision 1003.
  • Revision ID: mordred@inaugust.com-20090425204519-lgrl7mz2r66v0jby
Blackhole.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_parse.cc
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
 
#include "config.h"
17
 
 
18
16
#define DRIZZLE_LEX 1
19
 
 
20
 
#include <drizzled/my_hash.h>
 
17
#include <drizzled/server_includes.h>
 
18
#include <mysys/hash.h>
 
19
#include <drizzled/logging.h>
 
20
#include <drizzled/db.h>
21
21
#include <drizzled/error.h>
22
22
#include <drizzled/nested_join.h>
23
23
#include <drizzled/query_id.h>
24
 
#include "drizzled/transaction_services.h"
25
24
#include <drizzled/sql_parse.h>
26
25
#include <drizzled/data_home.h>
27
26
#include <drizzled/sql_base.h>
28
27
#include <drizzled/show.h>
29
 
#include <drizzled/db.h>
 
28
#include <drizzled/rename.h>
30
29
#include <drizzled/function/time/unix_timestamp.h>
31
30
#include <drizzled/function/get_system_var.h>
32
31
#include <drizzled/item/cmpfunc.h>
33
32
#include <drizzled/item/null.h>
34
33
#include <drizzled/session.h>
35
34
#include <drizzled/sql_load.h>
 
35
#include <drizzled/connect.h>
36
36
#include <drizzled/lock.h>
37
37
#include <drizzled/select_send.h>
38
 
#include <drizzled/plugin/client.h>
39
 
#include <drizzled/statement.h>
40
 
#include <drizzled/statement/alter_table.h>
41
 
#include "drizzled/probes.h"
42
 
#include "drizzled/session_list.h"
43
 
#include "drizzled/global_charset_info.h"
44
 
 
45
 
#include "drizzled/plugin/logging.h"
46
 
#include "drizzled/plugin/query_rewrite.h"
47
 
#include "drizzled/plugin/authorization.h"
48
 
#include "drizzled/optimizer/explain_plan.h"
49
 
#include "drizzled/pthread_globals.h"
50
 
 
51
 
#include <limits.h>
52
 
 
53
38
#include <bitset>
54
 
#include <algorithm>
55
 
 
56
 
#include "drizzled/internal/my_sys.h"
57
39
 
58
40
using namespace std;
59
41
 
60
 
extern int DRIZZLEparse(void *session); // from sql_yacc.cc
61
 
 
62
 
namespace drizzled
63
 
{
64
 
 
65
 
/* Prototypes */
66
 
bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
67
 
static bool parse_sql(Session *session, Lex_input_stream *lip);
68
 
void mysql_parse(Session *session, const char *inBuf, uint32_t length);
69
 
 
70
42
/**
71
43
  @defgroup Runtime_Environment Runtime Environment
72
44
  @{
74
46
 
75
47
extern size_t my_thread_stack_size;
76
48
extern const CHARSET_INFO *character_set_filesystem;
 
49
const char *any_db="*any*";     // Special symbol for check_access
77
50
 
78
51
const LEX_STRING command_name[COM_END+1]={
79
52
  { C_STRING_WITH_LEN("Sleep") },
90
63
  "NON-EXISTING", "ACTIVE", "IDLE", "PREPARED"
91
64
};
92
65
 
 
66
static void unlock_locked_tables(Session *session)
 
67
{
 
68
  if (session->locked_tables)
 
69
  {
 
70
    session->lock=session->locked_tables;
 
71
    session->locked_tables=0;                   // Will be automatically closed
 
72
    close_thread_tables(session);                       // Free tables
 
73
  }
 
74
}
 
75
 
93
76
/**
94
77
  Mark all commands that somehow changes a table.
95
78
 
123
106
  sql_command_flags[SQLCOM_DROP_INDEX]=     CF_CHANGES_DATA;
124
107
 
125
108
  sql_command_flags[SQLCOM_UPDATE]=         CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
 
109
  sql_command_flags[SQLCOM_UPDATE_MULTI]=   CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
126
110
  sql_command_flags[SQLCOM_INSERT]=         CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
127
111
  sql_command_flags[SQLCOM_INSERT_SELECT]=  CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
128
112
  sql_command_flags[SQLCOM_DELETE]=         CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
 
113
  sql_command_flags[SQLCOM_DELETE_MULTI]=   CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
129
114
  sql_command_flags[SQLCOM_REPLACE]=        CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
130
115
  sql_command_flags[SQLCOM_REPLACE_SELECT]= CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
131
116
 
 
117
  sql_command_flags[SQLCOM_SHOW_STATUS]=      CF_STATUS_COMMAND;
 
118
  sql_command_flags[SQLCOM_SHOW_DATABASES]=   CF_STATUS_COMMAND;
 
119
  sql_command_flags[SQLCOM_SHOW_OPEN_TABLES]= CF_STATUS_COMMAND;
 
120
  sql_command_flags[SQLCOM_SHOW_FIELDS]=      CF_STATUS_COMMAND;
 
121
  sql_command_flags[SQLCOM_SHOW_KEYS]=        CF_STATUS_COMMAND;
 
122
  sql_command_flags[SQLCOM_SHOW_VARIABLES]=   CF_STATUS_COMMAND;
132
123
  sql_command_flags[SQLCOM_SHOW_WARNS]= CF_STATUS_COMMAND;
133
124
  sql_command_flags[SQLCOM_SHOW_ERRORS]= CF_STATUS_COMMAND;
 
125
  sql_command_flags[SQLCOM_SHOW_ENGINE_STATUS]= CF_STATUS_COMMAND;
 
126
  sql_command_flags[SQLCOM_SHOW_PROCESSLIST]= CF_STATUS_COMMAND;
134
127
  sql_command_flags[SQLCOM_SHOW_CREATE_DB]=  CF_STATUS_COMMAND;
135
128
  sql_command_flags[SQLCOM_SHOW_CREATE]=  CF_STATUS_COMMAND;
136
129
 
 
130
   sql_command_flags[SQLCOM_SHOW_TABLES]=       (CF_STATUS_COMMAND |
 
131
                                               CF_SHOW_TABLE_COMMAND);
 
132
  sql_command_flags[SQLCOM_SHOW_TABLE_STATUS]= (CF_STATUS_COMMAND |
 
133
                                                CF_SHOW_TABLE_COMMAND);
137
134
  /*
138
135
    The following admin table operations are allowed
139
136
    on log tables.
140
137
  */
 
138
  sql_command_flags[SQLCOM_REPAIR]=           CF_WRITE_LOGS_COMMAND;
 
139
  sql_command_flags[SQLCOM_OPTIMIZE]=         CF_WRITE_LOGS_COMMAND;
141
140
  sql_command_flags[SQLCOM_ANALYZE]=          CF_WRITE_LOGS_COMMAND;
142
141
}
143
142
 
 
143
 
 
144
bool is_update_query(enum enum_sql_command command)
 
145
{
 
146
  assert(command >= 0 && command <= SQLCOM_END);
 
147
  return (sql_command_flags[command].test(CF_BIT_CHANGES_DATA));
 
148
}
 
149
 
144
150
/**
145
151
  Perform one connection-level (COM_XXXX) command.
146
152
 
168
174
  bool error= 0;
169
175
  Query_id &query_id= Query_id::get_query_id();
170
176
 
171
 
  DRIZZLE_COMMAND_START(session->thread_id,
172
 
                        command);
173
 
 
174
 
  session->command= command;
 
177
  session->command=command;
175
178
  session->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
176
179
  session->set_time();
177
 
  session->setQueryId(query_id.value());
 
180
  session->query_id= query_id.value();
178
181
 
179
182
  switch( command ) {
180
183
  /* Ignore these statements. */
188
191
 
189
192
  /* TODO: set session->lex->sql_command to SQLCOM_END here */
190
193
 
191
 
  plugin::Logging::preDo(session);
 
194
  logging_pre_do(session);
192
195
 
193
196
  session->server_status&=
194
197
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
195
198
  switch (command) {
196
199
  case COM_INIT_DB:
197
200
  {
 
201
    LEX_STRING tmp;
198
202
    status_var_increment(session->status_var.com_stat[SQLCOM_CHANGE_DB]);
199
 
    if (packet_length == 0)
200
 
    {
201
 
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
202
 
      break;
203
 
    }
204
 
 
205
 
    string tmp(packet, packet_length);
206
 
 
207
 
    SchemaIdentifier identifier(tmp);
208
 
 
209
 
    if (not mysql_change_db(session, identifier))
 
203
    session->convert_string(&tmp, system_charset_info,
 
204
                        packet, packet_length, session->charset());
 
205
    if (!mysql_change_db(session, &tmp, false))
210
206
    {
211
207
      session->my_ok();
212
208
    }
216
212
  {
217
213
    if (! session->readAndStoreQuery(packet, packet_length))
218
214
      break;                                    // fatal error is set
219
 
    DRIZZLE_QUERY_START(session->query.c_str(),
220
 
                        session->thread_id,
221
 
                        const_cast<const char *>(session->db.empty() ? "" : session->db.c_str()));
 
215
    const char* end_of_stmt= NULL;
222
216
 
223
 
    plugin::QueryRewriter::rewriteQuery(session->db, session->query);
224
 
    mysql_parse(session, session->query.c_str(), session->query.length());
 
217
    mysql_parse(session, session->query, session->query_length, &end_of_stmt);
225
218
 
226
219
    break;
227
220
  }
228
221
  case COM_QUIT:
229
222
    /* We don't calculate statistics for this command */
 
223
    session->protocol->setError(0);
230
224
    session->main_da.disable_status();              // Don't send anything back
231
225
    error=true;                                 // End server
232
226
    break;
234
228
  {
235
229
    status_var_increment(session->status_var.com_other);
236
230
    session->my_eof();
237
 
    session->close_thread_tables();                     // Free before kill
 
231
    close_thread_tables(session);                       // Free before kill
238
232
    kill_drizzle();
239
233
    error=true;
240
234
    break;
253
247
 
254
248
  /* If commit fails, we should be able to reset the OK status. */
255
249
  session->main_da.can_overwrite_status= true;
256
 
  TransactionServices &transaction_services= TransactionServices::singleton();
257
 
  transaction_services.ha_autocommit_or_rollback(session, session->is_error());
 
250
  ha_autocommit_or_rollback(session, session->is_error());
258
251
  session->main_da.can_overwrite_status= false;
259
252
 
260
253
  session->transaction.stmt.reset();
279
272
  {
280
273
  case Diagnostics_area::DA_ERROR:
281
274
    /* The query failed, send error to log and abort bootstrap. */
282
 
    session->client->sendError(session->main_da.sql_errno(),
283
 
                               session->main_da.message());
 
275
    session->protocol->sendError(session->main_da.sql_errno(),
 
276
                                 session->main_da.message());
284
277
    break;
285
278
 
286
279
  case Diagnostics_area::DA_EOF:
287
 
    session->client->sendEOF();
 
280
    session->protocol->sendEOF();
288
281
    break;
289
282
 
290
283
  case Diagnostics_area::DA_OK:
291
 
    session->client->sendOK();
 
284
    session->protocol->sendOK();
292
285
    break;
293
286
 
294
287
  case Diagnostics_area::DA_DISABLED:
296
289
 
297
290
  case Diagnostics_area::DA_EMPTY:
298
291
  default:
299
 
    session->client->sendOK();
 
292
    session->protocol->sendOK();
300
293
    break;
301
294
  }
302
295
 
304
297
 
305
298
  session->set_proc_info("closing tables");
306
299
  /* Free tables */
307
 
  session->close_thread_tables();
 
300
  close_thread_tables(session);
308
301
 
309
 
  plugin::Logging::postDo(session);
 
302
  log_slow_statement(session);
310
303
 
311
304
  /* Store temp state for processlist */
312
305
  session->set_proc_info("cleaning up");
313
 
  session->command= COM_SLEEP;
314
 
  memset(session->process_list_info, 0, PROCESS_LIST_WIDTH);
315
 
  session->query.clear();
 
306
  session->command=COM_SLEEP;
 
307
  session->process_list_info[0]= 0;
 
308
  session->query=0;
 
309
  session->query_length=0;
316
310
 
317
311
  session->set_proc_info(NULL);
318
 
  free_root(session->mem_root,MYF(memory::KEEP_PREALLOC));
319
 
 
320
 
  if (DRIZZLE_QUERY_DONE_ENABLED() || DRIZZLE_COMMAND_DONE_ENABLED())
321
 
  {
322
 
    if (command == COM_QUERY)
323
 
    {
324
 
      DRIZZLE_QUERY_DONE(session->is_error());
325
 
    }
326
 
    DRIZZLE_COMMAND_DONE(session->is_error());
327
 
  }
328
 
 
329
 
  return error;
 
312
  session->packet.shrink(session->variables.net_buffer_length); // Reclaim some memory
 
313
  free_root(session->mem_root,MYF(MY_KEEP_PREALLOC));
 
314
  return(error);
 
315
}
 
316
 
 
317
 
 
318
void log_slow_statement(Session *session)
 
319
{
 
320
  logging_post_do(session);
 
321
 
 
322
  return;
330
323
}
331
324
 
332
325
 
338
331
    It prepares a Select_Lex and a TableList object to represent the
339
332
    given command as a SELECT parse tree.
340
333
 
341
 
  @param session           thread handle
342
 
  @param lex               current lex
343
 
  @param table_ident       table alias if it's used
344
 
  @param schema_table_name the name of the INFORMATION_SCHEMA table to be
345
 
                           created
 
334
  @param session              thread handle
 
335
  @param lex              current lex
 
336
  @param table_ident      table alias if it's used
 
337
  @param schema_table_idx the type of the INFORMATION_SCHEMA table to be
 
338
                          created
346
339
 
347
340
  @note
348
341
    Due to the way this function works with memory and LEX it cannot
355
348
    1                 out of memory or SHOW commands are not allowed
356
349
                      in this version of the server.
357
350
*/
358
 
static bool _schema_select(Session *session, Select_Lex *sel,
359
 
                           const string& schema_table_name)
360
 
{
361
 
  LEX_STRING db, table;
362
 
  /*
363
 
     We have to make non const db_name & table_name
364
 
     because of lower_case_table_names
365
 
  */
366
 
  session->make_lex_string(&db, "data_dictionary", sizeof("data_dictionary"), false);
367
 
  session->make_lex_string(&table, schema_table_name, false);
368
 
 
369
 
  if (! sel->add_table_to_list(session, new Table_ident(db, table),
370
 
                               NULL, 0, TL_READ))
371
 
  {
372
 
    return true;
373
 
  }
374
 
  return false;
375
 
}
376
 
 
377
 
int prepare_new_schema_table(Session *session, LEX *lex,
378
 
                             const string& schema_table_name)
 
351
 
 
352
int prepare_schema_table(Session *session, LEX *lex, Table_ident *table_ident,
 
353
                         enum enum_schema_tables schema_table_idx)
379
354
{
380
355
  Select_Lex *schema_select_lex= NULL;
381
356
 
 
357
  switch (schema_table_idx) {
 
358
  case SCH_SCHEMATA:
 
359
    break;
 
360
  case SCH_TABLE_NAMES:
 
361
  case SCH_TABLES:
 
362
    {
 
363
      LEX_STRING db;
 
364
      size_t dummy;
 
365
      if (lex->select_lex.db == NULL &&
 
366
          lex->copy_db_to(&lex->select_lex.db, &dummy))
 
367
      {
 
368
        return(1);
 
369
      }
 
370
      schema_select_lex= new Select_Lex();
 
371
      db.str= schema_select_lex->db= lex->select_lex.db;
 
372
      schema_select_lex->table_list.first= NULL;
 
373
      db.length= strlen(db.str);
 
374
 
 
375
      if (check_db_name(&db))
 
376
      {
 
377
        my_error(ER_WRONG_DB_NAME, MYF(0), db.str);
 
378
        return(1);
 
379
      }
 
380
      break;
 
381
    }
 
382
  case SCH_COLUMNS:
 
383
  case SCH_STATISTICS:
 
384
  {
 
385
    assert(table_ident);
 
386
    TableList **query_tables_last= lex->query_tables_last;
 
387
    schema_select_lex= new Select_Lex();
 
388
    /* 'parent_lex' is used in init_query() so it must be before it. */
 
389
    schema_select_lex->parent_lex= lex;
 
390
    schema_select_lex->init_query();
 
391
    if (!schema_select_lex->add_table_to_list(session, table_ident, 0, 0, TL_READ))
 
392
      return(1);
 
393
    lex->query_tables_last= query_tables_last;
 
394
    break;
 
395
  }
 
396
  case SCH_OPEN_TABLES:
 
397
  case SCH_VARIABLES:
 
398
  case SCH_STATUS:
 
399
  case SCH_CHARSETS:
 
400
  case SCH_COLLATIONS:
 
401
  case SCH_COLLATION_CHARACTER_SET_APPLICABILITY:
 
402
  case SCH_TABLE_CONSTRAINTS:
 
403
  case SCH_KEY_COLUMN_USAGE:
 
404
  default:
 
405
    break;
 
406
  }
 
407
 
382
408
  Select_Lex *select_lex= lex->current_select;
383
409
  assert(select_lex);
384
 
  if (_schema_select(session, select_lex, schema_table_name))
 
410
  if (make_schema_select(session, select_lex, schema_table_idx))
385
411
  {
386
412
    return(1);
387
413
  }
388
414
  TableList *table_list= (TableList*) select_lex->table_list.first;
389
415
  assert(table_list);
390
416
  table_list->schema_select_lex= schema_select_lex;
391
 
 
392
 
  return 0;
 
417
  table_list->schema_table_reformed= 1;
 
418
  return(0);
393
419
}
394
420
 
395
421
/**
422
448
    true        Error
423
449
*/
424
450
 
425
 
static int
 
451
int
426
452
mysql_execute_command(Session *session)
427
453
{
428
 
  bool res= false;
 
454
  int res= false;
 
455
  bool need_start_waiting= false; // have protection against global read lock
429
456
  LEX  *lex= session->lex;
430
457
  /* first Select_Lex (have special meaning for many of non-SELECTcommands) */
431
458
  Select_Lex *select_lex= &lex->select_lex;
 
459
  /* first table of first Select_Lex */
 
460
  TableList *first_table= (TableList*) select_lex->table_list.first;
432
461
  /* list of all tables in query */
433
462
  TableList *all_tables;
434
 
  /* A peek into the query string */
435
 
  size_t proc_info_len= session->query.length() > PROCESS_LIST_WIDTH ?
436
 
                        PROCESS_LIST_WIDTH : session->query.length();
437
 
 
438
 
  memcpy(session->process_list_info, session->query.c_str(), proc_info_len);
439
 
  session->process_list_info[proc_info_len]= '\0';
 
463
  /* most outer Select_Lex_Unit of query */
 
464
  Select_Lex_Unit *unit= &lex->unit;
 
465
  /* Saved variable value */
440
466
 
441
467
  /*
442
468
    In many cases first table of main Select_Lex have special meaning =>
468
494
    variables, but for now this is probably good enough.
469
495
    Don't reset warnings when executing a stored routine.
470
496
  */
471
 
  if (all_tables || ! lex->is_single_level_stmt())
472
 
  {
 
497
  if (all_tables || !lex->is_single_level_stmt())
473
498
    drizzle_reset_errors(session, 0);
474
 
  }
475
499
 
476
500
  status_var_increment(session->status_var.com_stat[lex->sql_command]);
477
501
 
478
 
  assert(session->transaction.stmt.hasModifiedNonTransData() == false);
479
 
 
480
 
  /* now we are ready to execute the statement */
481
 
  res= lex->statement->execute();
482
 
 
 
502
  assert(session->transaction.stmt.modified_non_trans_table == false);
 
503
 
 
504
  switch (lex->sql_command) {
 
505
  case SQLCOM_SHOW_STATUS:
 
506
  {
 
507
    system_status_var old_status_var= session->status_var;
 
508
    session->initial_status_var= &old_status_var;
 
509
    res= execute_sqlcom_select(session, all_tables);
 
510
    /* Don't log SHOW STATUS commands to slow query log */
 
511
    session->server_status&= ~(SERVER_QUERY_NO_INDEX_USED |
 
512
                           SERVER_QUERY_NO_GOOD_INDEX_USED);
 
513
    /*
 
514
      restore status variables, as we don't want 'show status' to cause
 
515
      changes
 
516
    */
 
517
    pthread_mutex_lock(&LOCK_status);
 
518
    add_diff_to_status(&global_status_var, &session->status_var,
 
519
                       &old_status_var);
 
520
    session->status_var= old_status_var;
 
521
    pthread_mutex_unlock(&LOCK_status);
 
522
    break;
 
523
  }
 
524
  case SQLCOM_SHOW_DATABASES:
 
525
  case SQLCOM_SHOW_TABLES:
 
526
  case SQLCOM_SHOW_TABLE_STATUS:
 
527
  case SQLCOM_SHOW_OPEN_TABLES:
 
528
  case SQLCOM_SHOW_FIELDS:
 
529
  case SQLCOM_SHOW_KEYS:
 
530
  case SQLCOM_SHOW_VARIABLES:
 
531
  case SQLCOM_SELECT:
 
532
  {
 
533
    session->status_var.last_query_cost= 0.0;
 
534
    res= execute_sqlcom_select(session, all_tables);
 
535
    break;
 
536
  }
 
537
  case SQLCOM_EMPTY_QUERY:
 
538
    session->my_ok();
 
539
    break;
 
540
 
 
541
  case SQLCOM_SHOW_WARNS:
 
542
  {
 
543
    res= mysqld_show_warnings(session, (uint32_t)
 
544
                              ((1L << (uint32_t) DRIZZLE_ERROR::WARN_LEVEL_NOTE) |
 
545
                               (1L << (uint32_t) DRIZZLE_ERROR::WARN_LEVEL_WARN) |
 
546
                               (1L << (uint32_t) DRIZZLE_ERROR::WARN_LEVEL_ERROR)
 
547
                               ));
 
548
    break;
 
549
  }
 
550
  case SQLCOM_SHOW_ERRORS:
 
551
  {
 
552
    res= mysqld_show_warnings(session, (uint32_t)
 
553
                              (1L << (uint32_t) DRIZZLE_ERROR::WARN_LEVEL_ERROR));
 
554
    break;
 
555
  }
 
556
  case SQLCOM_ASSIGN_TO_KEYCACHE:
 
557
  {
 
558
    assert(first_table == all_tables && first_table != 0);
 
559
    res= mysql_assign_to_keycache(session, first_table, &lex->ident);
 
560
    break;
 
561
  }
 
562
  case SQLCOM_SHOW_ENGINE_STATUS:
 
563
    {
 
564
      res = ha_show_status(session, lex->create_info.db_type, HA_ENGINE_STATUS);
 
565
      break;
 
566
    }
 
567
  case SQLCOM_CREATE_TABLE:
 
568
  {
 
569
    /* If CREATE TABLE of non-temporary table, do implicit commit */
 
570
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
 
571
    {
 
572
      if (! session->endActiveTransaction())
 
573
      {
 
574
        res= -1;
 
575
        break;
 
576
      }
 
577
    }
 
578
    assert(first_table == all_tables && first_table != 0);
 
579
    bool link_to_local;
 
580
    // Skip first table, which is the table we are creating
 
581
    TableList *create_table= lex->unlink_first_table(&link_to_local);
 
582
    TableList *select_tables= lex->query_tables;
 
583
    /*
 
584
      Code below (especially in mysql_create_table() and select_create
 
585
      methods) may modify HA_CREATE_INFO structure in LEX, so we have to
 
586
      use a copy of this structure to make execution prepared statement-
 
587
      safe. A shallow copy is enough as this code won't modify any memory
 
588
      referenced from this structure.
 
589
    */
 
590
    HA_CREATE_INFO create_info(lex->create_info);
 
591
    /*
 
592
      We need to copy alter_info for the same reasons of re-execution
 
593
      safety, only in case of Alter_info we have to do (almost) a deep
 
594
      copy.
 
595
    */
 
596
    Alter_info alter_info(lex->alter_info, session->mem_root);
 
597
 
 
598
    if (session->is_fatal_error)
 
599
    {
 
600
      /* If out of memory when creating a copy of alter_info. */
 
601
      res= 1;
 
602
      goto end_with_restore_list;
 
603
    }
 
604
 
 
605
    if ((res= create_table_precheck(session, select_tables, create_table)))
 
606
      goto end_with_restore_list;
 
607
 
 
608
    /* Might have been updated in create_table_precheck */
 
609
    create_info.alias= create_table->alias;
 
610
 
 
611
#ifdef HAVE_READLINK
 
612
    /* Fix names if symlinked tables */
 
613
    if (append_file_to_dir(session, &create_info.data_file_name,
 
614
                           create_table->table_name) ||
 
615
        append_file_to_dir(session, &create_info.index_file_name,
 
616
                           create_table->table_name))
 
617
      goto end_with_restore_list;
 
618
#endif
 
619
    /*
 
620
      The create-select command will open and read-lock the select table
 
621
      and then create, open and write-lock the new table. If a global
 
622
      read lock steps in, we get a deadlock. The write lock waits for
 
623
      the global read lock, while the global read lock waits for the
 
624
      select table to be closed. So we wait until the global readlock is
 
625
      gone before starting both steps. Note that
 
626
      wait_if_global_read_lock() sets a protection against a new global
 
627
      read lock when it succeeds. This needs to be released by
 
628
      start_waiting_global_read_lock(). We protect the normal CREATE
 
629
      TABLE in the same way. That way we avoid that a new table is
 
630
      created during a gobal read lock.
 
631
    */
 
632
    if (!session->locked_tables &&
 
633
        !(need_start_waiting= !wait_if_global_read_lock(session, 0, 1)))
 
634
    {
 
635
      res= 1;
 
636
      goto end_with_restore_list;
 
637
    }
 
638
    if (select_lex->item_list.elements)         // With select
 
639
    {
 
640
      select_result *result;
 
641
 
 
642
      select_lex->options|= SELECT_NO_UNLOCK;
 
643
      unit->set_limit(select_lex);
 
644
 
 
645
      if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
 
646
      {
 
647
        lex->link_first_table_back(create_table, link_to_local);
 
648
        create_table->create= true;
 
649
      }
 
650
 
 
651
      if (!(res= open_and_lock_tables(session, lex->query_tables)))
 
652
      {
 
653
        /*
 
654
          Is table which we are changing used somewhere in other parts
 
655
          of query
 
656
        */
 
657
        if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
 
658
        {
 
659
          TableList *duplicate;
 
660
          create_table= lex->unlink_first_table(&link_to_local);
 
661
          if ((duplicate= unique_table(session, create_table, select_tables, 0)))
 
662
          {
 
663
            update_non_unique_table_error(create_table, "CREATE", duplicate);
 
664
            res= 1;
 
665
            goto end_with_restore_list;
 
666
          }
 
667
        }
 
668
 
 
669
        /*
 
670
          select_create is currently not re-execution friendly and
 
671
          needs to be created for every execution of a PS/SP.
 
672
        */
 
673
        if ((result= new select_create(create_table,
 
674
                                       &create_info,
 
675
                                       &alter_info,
 
676
                                       select_lex->item_list,
 
677
                                       lex->duplicates,
 
678
                                       lex->ignore,
 
679
                                       select_tables)))
 
680
        {
 
681
          /*
 
682
            CREATE from SELECT give its Select_Lex for SELECT,
 
683
            and item_list belong to SELECT
 
684
          */
 
685
          res= handle_select(session, lex, result, 0);
 
686
          delete result;
 
687
        }
 
688
      }
 
689
      else if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
 
690
        create_table= lex->unlink_first_table(&link_to_local);
 
691
 
 
692
    }
 
693
    else
 
694
    {
 
695
      /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
 
696
      if (create_info.options & HA_LEX_CREATE_TMP_TABLE)
 
697
        session->options|= OPTION_KEEP_LOG;
 
698
      /* regular create */
 
699
      if (create_info.options & HA_LEX_CREATE_TABLE_LIKE)
 
700
        res= mysql_create_like_table(session, create_table, select_tables,
 
701
                                     &create_info);
 
702
      else
 
703
      {
 
704
        res= mysql_create_table(session, create_table->db,
 
705
                                create_table->table_name, &create_info,
 
706
                                &alter_info, 0, 0);
 
707
      }
 
708
      if (!res)
 
709
        session->my_ok();
 
710
    }
 
711
 
 
712
    /* put tables back for PS rexecuting */
 
713
end_with_restore_list:
 
714
    lex->link_first_table_back(create_table, link_to_local);
 
715
    break;
 
716
  }
 
717
  case SQLCOM_CREATE_INDEX:
 
718
    /* Fall through */
 
719
  case SQLCOM_DROP_INDEX:
 
720
  /*
 
721
    CREATE INDEX and DROP INDEX are implemented by calling ALTER
 
722
    TABLE with proper arguments.
 
723
 
 
724
    In the future ALTER TABLE will notice that the request is to
 
725
    only add indexes and create these one by one for the existing
 
726
    table without having to do a full rebuild.
 
727
  */
 
728
  {
 
729
    /* Prepare stack copies to be re-execution safe */
 
730
    HA_CREATE_INFO create_info;
 
731
    Alter_info alter_info(lex->alter_info, session->mem_root);
 
732
 
 
733
    if (session->is_fatal_error) /* out of memory creating a copy of alter_info */
 
734
      goto error;
 
735
 
 
736
    assert(first_table == all_tables && first_table != 0);
 
737
    if (! session->endActiveTransaction())
 
738
      goto error;
 
739
 
 
740
    memset(&create_info, 0, sizeof(create_info));
 
741
    create_info.db_type= 0;
 
742
    create_info.row_type= ROW_TYPE_NOT_USED;
 
743
    create_info.default_table_charset= session->variables.collation_database;
 
744
 
 
745
    res= mysql_alter_table(session, first_table->db, first_table->table_name,
 
746
                           &create_info, first_table, &alter_info,
 
747
                           0, (order_st*) 0, 0);
 
748
    break;
 
749
  }
 
750
  case SQLCOM_ALTER_TABLE:
 
751
    assert(first_table == all_tables && first_table != 0);
 
752
    {
 
753
      /*
 
754
        Code in mysql_alter_table() may modify its HA_CREATE_INFO argument,
 
755
        so we have to use a copy of this structure to make execution
 
756
        prepared statement- safe. A shallow copy is enough as no memory
 
757
        referenced from this structure will be modified.
 
758
      */
 
759
      HA_CREATE_INFO create_info(lex->create_info);
 
760
      Alter_info alter_info(lex->alter_info, session->mem_root);
 
761
 
 
762
      if (session->is_fatal_error) /* out of memory creating a copy of alter_info */
 
763
      {
 
764
        goto error;
 
765
      }
 
766
 
 
767
      /* Must be set in the parser */
 
768
      assert(select_lex->db);
 
769
 
 
770
      { // Rename of table
 
771
          TableList tmp_table;
 
772
          memset(&tmp_table, 0, sizeof(tmp_table));
 
773
          tmp_table.table_name= lex->name.str;
 
774
          tmp_table.db=select_lex->db;
 
775
      }
 
776
 
 
777
      /* Don't yet allow changing of symlinks with ALTER TABLE */
 
778
      if (create_info.data_file_name)
 
779
        push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, 0,
 
780
                     "DATA DIRECTORY option ignored");
 
781
      if (create_info.index_file_name)
 
782
        push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, 0,
 
783
                     "INDEX DIRECTORY option ignored");
 
784
      create_info.data_file_name= create_info.index_file_name= NULL;
 
785
      /* ALTER TABLE ends previous transaction */
 
786
      if (! session->endActiveTransaction())
 
787
        goto error;
 
788
 
 
789
      if (!session->locked_tables &&
 
790
          !(need_start_waiting= !wait_if_global_read_lock(session, 0, 1)))
 
791
      {
 
792
        res= 1;
 
793
        break;
 
794
      }
 
795
 
 
796
      res= mysql_alter_table(session, select_lex->db, lex->name.str,
 
797
                             &create_info,
 
798
                             first_table,
 
799
                             &alter_info,
 
800
                             select_lex->order_list.elements,
 
801
                             (order_st *) select_lex->order_list.first,
 
802
                             lex->ignore);
 
803
      break;
 
804
    }
 
805
  case SQLCOM_RENAME_TABLE:
 
806
  {
 
807
    assert(first_table == all_tables && first_table != 0);
 
808
    TableList *table;
 
809
    for (table= first_table; table; table= table->next_local->next_local)
 
810
    {
 
811
      TableList old_list, new_list;
 
812
      /*
 
813
        we do not need initialize old_list and new_list because we will
 
814
        come table[0] and table->next[0] there
 
815
      */
 
816
      old_list= table[0];
 
817
      new_list= table->next_local[0];
 
818
    }
 
819
 
 
820
    if (! session->endActiveTransaction() || drizzle_rename_tables(session, first_table, 0))
 
821
    {
 
822
      goto error;
 
823
    }
 
824
    break;
 
825
  }
 
826
  case SQLCOM_SHOW_CREATE:
 
827
    assert(first_table == all_tables && first_table != 0);
 
828
    {
 
829
      res= drizzled_show_create(session, first_table);
 
830
      break;
 
831
    }
 
832
  case SQLCOM_CHECKSUM:
 
833
  {
 
834
    assert(first_table == all_tables && first_table != 0);
 
835
    res = mysql_checksum_table(session, first_table, &lex->check_opt);
 
836
    break;
 
837
  }
 
838
  case SQLCOM_REPAIR:
 
839
  {
 
840
    assert(first_table == all_tables && first_table != 0);
 
841
    res= mysql_repair_table(session, first_table, &lex->check_opt);
 
842
    /* ! we write after unlocking the table */
 
843
    /*
 
844
      Presumably, REPAIR and binlog writing doesn't require synchronization
 
845
    */
 
846
    write_bin_log(session, true, session->query, session->query_length);
 
847
    select_lex->table_list.first= (unsigned char*) first_table;
 
848
    lex->query_tables=all_tables;
 
849
    break;
 
850
  }
 
851
  case SQLCOM_CHECK:
 
852
  {
 
853
    assert(first_table == all_tables && first_table != 0);
 
854
    res = mysql_check_table(session, first_table, &lex->check_opt);
 
855
    select_lex->table_list.first= (unsigned char*) first_table;
 
856
    lex->query_tables=all_tables;
 
857
    break;
 
858
  }
 
859
  case SQLCOM_ANALYZE:
 
860
  {
 
861
    assert(first_table == all_tables && first_table != 0);
 
862
    res= mysql_analyze_table(session, first_table, &lex->check_opt);
 
863
    /* ! we write after unlocking the table */
 
864
    write_bin_log(session, true, session->query, session->query_length);
 
865
    select_lex->table_list.first= (unsigned char*) first_table;
 
866
    lex->query_tables=all_tables;
 
867
    break;
 
868
  }
 
869
 
 
870
  case SQLCOM_OPTIMIZE:
 
871
  {
 
872
    assert(first_table == all_tables && first_table != 0);
 
873
    res= mysql_optimize_table(session, first_table, &lex->check_opt);
 
874
    /* ! we write after unlocking the table */
 
875
    write_bin_log(session, true, session->query, session->query_length);
 
876
    select_lex->table_list.first= (unsigned char*) first_table;
 
877
    lex->query_tables=all_tables;
 
878
    break;
 
879
  }
 
880
  case SQLCOM_UPDATE:
 
881
    assert(first_table == all_tables && first_table != 0);
 
882
    if ((res= update_precheck(session, all_tables)))
 
883
      break;
 
884
    assert(select_lex->offset_limit == 0);
 
885
    unit->set_limit(select_lex);
 
886
    res= mysql_update(session, all_tables,
 
887
                      select_lex->item_list,
 
888
                      lex->value_list,
 
889
                      select_lex->where,
 
890
                      select_lex->order_list.elements,
 
891
                      (order_st *) select_lex->order_list.first,
 
892
                      unit->select_limit_cnt,
 
893
                      lex->duplicates, lex->ignore);
 
894
    break;
 
895
  case SQLCOM_UPDATE_MULTI:
 
896
  {
 
897
    assert(first_table == all_tables && first_table != 0);
 
898
    if ((res= update_precheck(session, all_tables)))
 
899
      break;
 
900
 
 
901
    if ((res= mysql_multi_update_prepare(session)))
 
902
      break;
 
903
 
 
904
    res= mysql_multi_update(session, all_tables,
 
905
                            &select_lex->item_list,
 
906
                            &lex->value_list,
 
907
                            select_lex->where,
 
908
                            select_lex->options,
 
909
                            lex->duplicates, lex->ignore, unit, select_lex);
 
910
    break;
 
911
  }
 
912
  case SQLCOM_REPLACE:
 
913
  case SQLCOM_INSERT:
 
914
  {
 
915
    assert(first_table == all_tables && first_table != 0);
 
916
    if ((res= insert_precheck(session, all_tables)))
 
917
      break;
 
918
 
 
919
    if (!session->locked_tables &&
 
920
        !(need_start_waiting= !wait_if_global_read_lock(session, 0, 1)))
 
921
    {
 
922
      res= 1;
 
923
      break;
 
924
    }
 
925
 
 
926
    res= mysql_insert(session, all_tables, lex->field_list, lex->many_values,
 
927
                      lex->update_list, lex->value_list,
 
928
                      lex->duplicates, lex->ignore);
 
929
 
 
930
    break;
 
931
  }
 
932
  case SQLCOM_REPLACE_SELECT:
 
933
  case SQLCOM_INSERT_SELECT:
 
934
  {
 
935
    select_result *sel_result;
 
936
    assert(first_table == all_tables && first_table != 0);
 
937
    if ((res= insert_precheck(session, all_tables)))
 
938
      break;
 
939
 
 
940
    /* Fix lock for first table */
 
941
    if (first_table->lock_type == TL_WRITE_DELAYED)
 
942
      first_table->lock_type= TL_WRITE;
 
943
 
 
944
    /* Don't unlock tables until command is written to binary log */
 
945
    select_lex->options|= SELECT_NO_UNLOCK;
 
946
 
 
947
    unit->set_limit(select_lex);
 
948
 
 
949
    if (! session->locked_tables &&
 
950
        ! (need_start_waiting= ! wait_if_global_read_lock(session, 0, 1)))
 
951
    {
 
952
      res= 1;
 
953
      break;
 
954
    }
 
955
 
 
956
    if (!(res= open_and_lock_tables(session, all_tables)))
 
957
    {
 
958
      /* Skip first table, which is the table we are inserting in */
 
959
      TableList *second_table= first_table->next_local;
 
960
      select_lex->table_list.first= (unsigned char*) second_table;
 
961
      select_lex->context.table_list=
 
962
        select_lex->context.first_name_resolution_table= second_table;
 
963
      res= mysql_insert_select_prepare(session);
 
964
      if (!res && (sel_result= new select_insert(first_table,
 
965
                                                 first_table->table,
 
966
                                                 &lex->field_list,
 
967
                                                 &lex->update_list,
 
968
                                                 &lex->value_list,
 
969
                                                 lex->duplicates,
 
970
                                                 lex->ignore)))
 
971
      {
 
972
        res= handle_select(session, lex, sel_result, OPTION_SETUP_TABLES_DONE);
 
973
        /*
 
974
          Invalidate the table in the query cache if something changed
 
975
          after unlocking when changes become visible.
 
976
          TODO: this is workaround. right way will be move invalidating in
 
977
          the unlock procedure.
 
978
        */
 
979
        if (first_table->lock_type ==  TL_WRITE_CONCURRENT_INSERT &&
 
980
            session->lock)
 
981
        {
 
982
          /* INSERT ... SELECT should invalidate only the very first table */
 
983
          TableList *save_table= first_table->next_local;
 
984
          first_table->next_local= 0;
 
985
          first_table->next_local= save_table;
 
986
        }
 
987
        delete sel_result;
 
988
      }
 
989
      /* revert changes for SP */
 
990
      select_lex->table_list.first= (unsigned char*) first_table;
 
991
    }
 
992
 
 
993
    break;
 
994
  }
 
995
  case SQLCOM_TRUNCATE:
 
996
    if (! session->endActiveTransaction())
 
997
    {
 
998
      res= -1;
 
999
      break;
 
1000
    }
 
1001
    assert(first_table == all_tables && first_table != 0);
 
1002
    /*
 
1003
      Don't allow this within a transaction because we want to use
 
1004
      re-generate table
 
1005
    */
 
1006
    if (session->locked_tables || session->inTransaction())
 
1007
    {
 
1008
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION, ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
 
1009
      goto error;
 
1010
    }
 
1011
 
 
1012
    res= mysql_truncate(session, first_table, 0);
 
1013
 
 
1014
    break;
 
1015
  case SQLCOM_DELETE:
 
1016
  {
 
1017
    assert(first_table == all_tables && first_table != 0);
 
1018
    assert(select_lex->offset_limit == 0);
 
1019
    unit->set_limit(select_lex);
 
1020
 
 
1021
    if (!session->locked_tables &&
 
1022
        !(need_start_waiting= !wait_if_global_read_lock(session, 0, 1)))
 
1023
    {
 
1024
      res= 1;
 
1025
      break;
 
1026
    }
 
1027
 
 
1028
    res = mysql_delete(session, all_tables, select_lex->where,
 
1029
                       &select_lex->order_list,
 
1030
                       unit->select_limit_cnt, select_lex->options,
 
1031
                       false);
 
1032
    break;
 
1033
  }
 
1034
  case SQLCOM_DELETE_MULTI:
 
1035
  {
 
1036
    assert(first_table == all_tables && first_table != 0);
 
1037
    TableList *aux_tables=
 
1038
      (TableList *)session->lex->auxiliary_table_list.first;
 
1039
    multi_delete *del_result;
 
1040
 
 
1041
    if (!session->locked_tables &&
 
1042
        !(need_start_waiting= !wait_if_global_read_lock(session, 0, 1)))
 
1043
    {
 
1044
      res= 1;
 
1045
      break;
 
1046
    }
 
1047
 
 
1048
    if ((res= multi_delete_precheck(session, all_tables)))
 
1049
      break;
 
1050
 
 
1051
    /* condition will be true on SP re-excuting */
 
1052
    if (select_lex->item_list.elements != 0)
 
1053
      select_lex->item_list.empty();
 
1054
    if (session->add_item_to_list(new Item_null()))
 
1055
      goto error;
 
1056
 
 
1057
    session->set_proc_info("init");
 
1058
    if ((res= open_and_lock_tables(session, all_tables)))
 
1059
      break;
 
1060
 
 
1061
    if ((res= mysql_multi_delete_prepare(session)))
 
1062
      goto error;
 
1063
 
 
1064
    if (!session->is_fatal_error &&
 
1065
        (del_result= new multi_delete(aux_tables, lex->table_count)))
 
1066
    {
 
1067
      res= mysql_select(session, &select_lex->ref_pointer_array,
 
1068
                        select_lex->get_table_list(),
 
1069
                        select_lex->with_wild,
 
1070
                        select_lex->item_list,
 
1071
                        select_lex->where,
 
1072
                        0, (order_st *)NULL, (order_st *)NULL, (Item *)NULL,
 
1073
                        select_lex->options | session->options | SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK | OPTION_SETUP_TABLES_DONE,
 
1074
                        del_result, unit, select_lex);
 
1075
      res|= session->is_error();
 
1076
      if (res)
 
1077
        del_result->abort();
 
1078
      delete del_result;
 
1079
    }
 
1080
    else
 
1081
      res= true;                                // Error
 
1082
    break;
 
1083
  }
 
1084
  case SQLCOM_DROP_TABLE:
 
1085
  {
 
1086
    assert(first_table == all_tables && first_table != 0);
 
1087
    if (!lex->drop_temporary)
 
1088
    {
 
1089
      if (! session->endActiveTransaction())
 
1090
        goto error;
 
1091
    }
 
1092
    else
 
1093
    {
 
1094
      /* So that DROP TEMPORARY TABLE gets to binlog at commit/rollback */
 
1095
      session->options|= OPTION_KEEP_LOG;
 
1096
    }
 
1097
    /* DDL and binlog write order protected by LOCK_open */
 
1098
    res= mysql_rm_table(session, first_table, lex->drop_if_exists, lex->drop_temporary);
 
1099
  }
 
1100
  break;
 
1101
  case SQLCOM_SHOW_PROCESSLIST:
 
1102
    mysqld_list_processes(session, NULL, lex->verbose);
 
1103
    break;
 
1104
  case SQLCOM_SHOW_ENGINE_LOGS:
 
1105
    {
 
1106
      res= ha_show_status(session, lex->create_info.db_type, HA_ENGINE_LOGS);
 
1107
      break;
 
1108
    }
 
1109
  case SQLCOM_CHANGE_DB:
 
1110
  {
 
1111
    LEX_STRING db_str= { (char *) select_lex->db, strlen(select_lex->db) };
 
1112
 
 
1113
    if (!mysql_change_db(session, &db_str, false))
 
1114
      session->my_ok();
 
1115
 
 
1116
    break;
 
1117
  }
 
1118
 
 
1119
  case SQLCOM_LOAD:
 
1120
  {
 
1121
    assert(first_table == all_tables && first_table != 0);
 
1122
    res= mysql_load(session, lex->exchange, first_table, lex->field_list,
 
1123
                    lex->update_list, lex->value_list, lex->duplicates, lex->ignore);
 
1124
    break;
 
1125
  }
 
1126
 
 
1127
  case SQLCOM_SET_OPTION:
 
1128
  {
 
1129
    List<set_var_base> *lex_var_list= &lex->var_list;
 
1130
 
 
1131
    if (lex->autocommit && ! session->endActiveTransaction())
 
1132
      goto error;
 
1133
 
 
1134
    if (open_and_lock_tables(session, all_tables))
 
1135
      goto error;
 
1136
    if (!(res= sql_set_variables(session, lex_var_list)))
 
1137
    {
 
1138
      session->my_ok();
 
1139
    }
 
1140
    else
 
1141
    {
 
1142
      /*
 
1143
        We encountered some sort of error, but no message was sent.
 
1144
        Send something semi-generic here since we don't know which
 
1145
        assignment in the list caused the error.
 
1146
      */
 
1147
      if (!session->is_error())
 
1148
        my_error(ER_WRONG_ARGUMENTS,MYF(0),"SET");
 
1149
      goto error;
 
1150
    }
 
1151
 
 
1152
    break;
 
1153
  }
 
1154
 
 
1155
  case SQLCOM_UNLOCK_TABLES:
 
1156
    /*
 
1157
      It is critical for mysqldump --single-transaction --master-data that
 
1158
      UNLOCK TABLES does not implicitely commit a connection which has only
 
1159
      done FLUSH TABLES WITH READ LOCK + BEGIN. If this assumption becomes
 
1160
      false, mysqldump will not work.
 
1161
    */
 
1162
    unlock_locked_tables(session);
 
1163
    if (session->options & OPTION_TABLE_LOCK)
 
1164
    {
 
1165
      (void) session->endActiveTransaction();
 
1166
      session->options&= ~(OPTION_TABLE_LOCK);
 
1167
    }
 
1168
    if (session->global_read_lock)
 
1169
      unlock_global_read_lock(session);
 
1170
    session->my_ok();
 
1171
    break;
 
1172
  case SQLCOM_LOCK_TABLES:
 
1173
    /*
 
1174
      We try to take transactional locks if
 
1175
      - only transactional locks are requested (lex->lock_transactional) and
 
1176
      - no non-transactional locks exist (!session->locked_tables).
 
1177
    */
 
1178
    if (lex->lock_transactional && !session->locked_tables)
 
1179
    {
 
1180
      int rc;
 
1181
      /*
 
1182
        All requested locks are transactional and no non-transactional
 
1183
        locks exist.
 
1184
      */
 
1185
      if ((rc= try_transactional_lock(session, all_tables)) == -1)
 
1186
        goto error;
 
1187
      if (rc == 0)
 
1188
      {
 
1189
        session->my_ok();
 
1190
        break;
 
1191
      }
 
1192
      /*
 
1193
        Non-transactional locking has been requested or
 
1194
        non-transactional locks exist already or transactional locks are
 
1195
        not supported by all storage engines. Take non-transactional
 
1196
        locks.
 
1197
      */
 
1198
    }
 
1199
    /*
 
1200
      One or more requested locks are non-transactional and/or
 
1201
      non-transactional locks exist or a storage engine does not support
 
1202
      transactional locks. Check if at least one transactional lock is
 
1203
      requested. If yes, warn about the conversion to non-transactional
 
1204
      locks or abort in strict mode.
 
1205
    */
 
1206
    if (check_transactional_lock(session, all_tables))
 
1207
      goto error;
 
1208
    unlock_locked_tables(session);
 
1209
    /* we must end the trasaction first, regardless of anything */
 
1210
    if (! session->endActiveTransaction())
 
1211
      goto error;
 
1212
    session->in_lock_tables=1;
 
1213
    session->options|= OPTION_TABLE_LOCK;
 
1214
 
 
1215
    if (!(res= simple_open_n_lock_tables(session, all_tables)))
 
1216
    {
 
1217
      session->locked_tables=session->lock;
 
1218
      session->lock=0;
 
1219
      (void) set_handler_table_locks(session, all_tables, false);
 
1220
      session->my_ok();
 
1221
    }
 
1222
    else
 
1223
    {
 
1224
      /*
 
1225
        Need to end the current transaction, so the storage engine (InnoDB)
 
1226
        can free its locks if LOCK TABLES locked some tables before finding
 
1227
        that it can't lock a table in its list
 
1228
      */
 
1229
      ha_autocommit_or_rollback(session, 1);
 
1230
      (void) session->endActiveTransaction();
 
1231
      session->options&= ~(OPTION_TABLE_LOCK);
 
1232
    }
 
1233
    session->in_lock_tables=0;
 
1234
    break;
 
1235
  case SQLCOM_CREATE_DB:
 
1236
  {
 
1237
    /*
 
1238
      As mysql_create_db() may modify HA_CREATE_INFO structure passed to
 
1239
      it, we need to use a copy of LEX::create_info to make execution
 
1240
      prepared statement- safe.
 
1241
    */
 
1242
    HA_CREATE_INFO create_info(lex->create_info);
 
1243
    if (! session->endActiveTransaction())
 
1244
    {
 
1245
      res= -1;
 
1246
      break;
 
1247
    }
 
1248
    char *alias;
 
1249
    if (!(alias=session->strmake(lex->name.str, lex->name.length)) ||
 
1250
        check_db_name(&lex->name))
 
1251
    {
 
1252
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name.str);
 
1253
      break;
 
1254
    }
 
1255
    res= mysql_create_db(session,(lower_case_table_names == 2 ? alias :
 
1256
                              lex->name.str), &create_info, 0);
 
1257
    break;
 
1258
  }
 
1259
  case SQLCOM_DROP_DB:
 
1260
  {
 
1261
    if (! session->endActiveTransaction())
 
1262
    {
 
1263
      res= -1;
 
1264
      break;
 
1265
    }
 
1266
    if (check_db_name(&lex->name))
 
1267
    {
 
1268
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name.str);
 
1269
      break;
 
1270
    }
 
1271
    if (session->locked_tables || session->inTransaction())
 
1272
    {
 
1273
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION, ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
 
1274
      goto error;
 
1275
    }
 
1276
    res= mysql_rm_db(session, lex->name.str, lex->drop_if_exists, 0);
 
1277
    break;
 
1278
  }
 
1279
  case SQLCOM_ALTER_DB:
 
1280
  {
 
1281
    LEX_STRING *db= &lex->name;
 
1282
    HA_CREATE_INFO create_info(lex->create_info);
 
1283
    if (check_db_name(db))
 
1284
    {
 
1285
      my_error(ER_WRONG_DB_NAME, MYF(0), db->str);
 
1286
      break;
 
1287
    }
 
1288
    if (session->locked_tables || session->inTransaction())
 
1289
    {
 
1290
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION, ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
 
1291
      goto error;
 
1292
    }
 
1293
    res= mysql_alter_db(session, db->str, &create_info);
 
1294
    break;
 
1295
  }
 
1296
  case SQLCOM_SHOW_CREATE_DB:
 
1297
  {
 
1298
    if (check_db_name(&lex->name))
 
1299
    {
 
1300
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name.str);
 
1301
      break;
 
1302
    }
 
1303
    res= mysqld_show_create_db(session, lex->name.str, &lex->create_info);
 
1304
    break;
 
1305
  }
 
1306
  case SQLCOM_FLUSH:
 
1307
  {
 
1308
    bool write_to_binlog;
 
1309
 
 
1310
    /*
 
1311
      reload_cache() will tell us if we are allowed to write to the
 
1312
      binlog or not.
 
1313
    */
 
1314
    if (!reload_cache(session, lex->type, first_table, &write_to_binlog))
 
1315
    {
 
1316
      /*
 
1317
        We WANT to write and we CAN write.
 
1318
        ! we write after unlocking the table.
 
1319
      */
 
1320
      /*
 
1321
        Presumably, RESET and binlog writing doesn't require synchronization
 
1322
      */
 
1323
      write_bin_log(session, false, session->query, session->query_length);
 
1324
      session->my_ok();
 
1325
    }
 
1326
 
 
1327
    break;
 
1328
  }
 
1329
  case SQLCOM_KILL:
 
1330
  {
 
1331
    Item *it= (Item *)lex->value_list.head();
 
1332
 
 
1333
    if ((!it->fixed && it->fix_fields(lex->session, &it)) || it->check_cols(1))
 
1334
    {
 
1335
      my_message(ER_SET_CONSTANTS_ONLY, ER(ER_SET_CONSTANTS_ONLY),
 
1336
                 MYF(0));
 
1337
      goto error;
 
1338
    }
 
1339
    sql_kill(session, (ulong)it->val_int(), lex->type & ONLY_KILL_QUERY);
 
1340
    break;
 
1341
  }
 
1342
  case SQLCOM_BEGIN:
 
1343
    if (session->transaction.xid_state.xa_state != XA_NOTR)
 
1344
    {
 
1345
      my_error(ER_XAER_RMFAIL, MYF(0),
 
1346
               xa_state_names[session->transaction.xid_state.xa_state]);
 
1347
      break;
 
1348
    }
 
1349
    /*
 
1350
      Breakpoints for backup testing.
 
1351
    */
 
1352
    if (! session->startTransaction())
 
1353
      goto error;
 
1354
    session->my_ok();
 
1355
    break;
 
1356
  case SQLCOM_COMMIT:
 
1357
    if (! session->endTransaction(lex->tx_release ? COMMIT_RELEASE : lex->tx_chain ? COMMIT_AND_CHAIN : COMMIT))
 
1358
      goto error;
 
1359
    session->my_ok();
 
1360
    break;
 
1361
  case SQLCOM_ROLLBACK:
 
1362
    if (! session->endTransaction(lex->tx_release ? ROLLBACK_RELEASE : lex->tx_chain ? ROLLBACK_AND_CHAIN : ROLLBACK))
 
1363
      goto error;
 
1364
    session->my_ok();
 
1365
    break;
 
1366
  case SQLCOM_RELEASE_SAVEPOINT:
 
1367
  {
 
1368
    SAVEPOINT *sv;
 
1369
    for (sv=session->transaction.savepoints; sv; sv=sv->prev)
 
1370
    {
 
1371
      if (my_strnncoll(system_charset_info,
 
1372
                       (unsigned char *)lex->ident.str, lex->ident.length,
 
1373
                       (unsigned char *)sv->name, sv->length) == 0)
 
1374
        break;
 
1375
    }
 
1376
    if (sv)
 
1377
    {
 
1378
      if (ha_release_savepoint(session, sv))
 
1379
        res= true; // cannot happen
 
1380
      else
 
1381
        session->my_ok();
 
1382
      session->transaction.savepoints=sv->prev;
 
1383
    }
 
1384
    else
 
1385
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
 
1386
    break;
 
1387
  }
 
1388
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
 
1389
  {
 
1390
    SAVEPOINT *sv;
 
1391
    for (sv=session->transaction.savepoints; sv; sv=sv->prev)
 
1392
    {
 
1393
      if (my_strnncoll(system_charset_info,
 
1394
                       (unsigned char *)lex->ident.str, lex->ident.length,
 
1395
                       (unsigned char *)sv->name, sv->length) == 0)
 
1396
        break;
 
1397
    }
 
1398
    if (sv)
 
1399
    {
 
1400
      if (ha_rollback_to_savepoint(session, sv))
 
1401
        res= true; // cannot happen
 
1402
      else
 
1403
      {
 
1404
        if ((session->options & OPTION_KEEP_LOG) || session->transaction.all.modified_non_trans_table)
 
1405
          push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
1406
                       ER_WARNING_NOT_COMPLETE_ROLLBACK,
 
1407
                       ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
 
1408
        session->my_ok();
 
1409
      }
 
1410
      session->transaction.savepoints=sv;
 
1411
    }
 
1412
    else
 
1413
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
 
1414
    break;
 
1415
  }
 
1416
  case SQLCOM_SAVEPOINT:
 
1417
    if (!(session->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)))
 
1418
      session->my_ok();
 
1419
    else
 
1420
    {
 
1421
      SAVEPOINT **sv, *newsv;
 
1422
      for (sv=&session->transaction.savepoints; *sv; sv=&(*sv)->prev)
 
1423
      {
 
1424
        if (my_strnncoll(system_charset_info,
 
1425
                         (unsigned char *)lex->ident.str, lex->ident.length,
 
1426
                         (unsigned char *)(*sv)->name, (*sv)->length) == 0)
 
1427
          break;
 
1428
      }
 
1429
      if (*sv) /* old savepoint of the same name exists */
 
1430
      {
 
1431
        newsv=*sv;
 
1432
        ha_release_savepoint(session, *sv); // it cannot fail
 
1433
        *sv=(*sv)->prev;
 
1434
      }
 
1435
      else if ((newsv=(SAVEPOINT *) alloc_root(&session->transaction.mem_root,
 
1436
                                               savepoint_alloc_size)) == 0)
 
1437
      {
 
1438
        my_error(ER_OUT_OF_RESOURCES, MYF(0));
 
1439
        break;
 
1440
      }
 
1441
      newsv->name=strmake_root(&session->transaction.mem_root,
 
1442
                               lex->ident.str, lex->ident.length);
 
1443
      newsv->length=lex->ident.length;
 
1444
      /*
 
1445
        if we'll get an error here, don't add new savepoint to the list.
 
1446
        we'll lose a little bit of memory in transaction mem_root, but it'll
 
1447
        be free'd when transaction ends anyway
 
1448
      */
 
1449
      if (ha_savepoint(session, newsv))
 
1450
        res= true;
 
1451
      else
 
1452
      {
 
1453
        newsv->prev=session->transaction.savepoints;
 
1454
        session->transaction.savepoints=newsv;
 
1455
        session->my_ok();
 
1456
      }
 
1457
    }
 
1458
    break;
 
1459
  default:
 
1460
    assert(0);                             /* Impossible */
 
1461
    session->my_ok();
 
1462
    break;
 
1463
  }
483
1464
  session->set_proc_info("query end");
484
1465
 
485
1466
  /*
488
1469
    wants. We also keep the last value in case of SQLCOM_CALL or
489
1470
    SQLCOM_EXECUTE.
490
1471
  */
491
 
  if (! (sql_command_flags[lex->sql_command].test(CF_BIT_HAS_ROW_COUNT)))
492
 
  {
 
1472
  if (!(sql_command_flags[lex->sql_command].test(CF_BIT_HAS_ROW_COUNT)))
493
1473
    session->row_count_func= -1;
 
1474
 
 
1475
  goto finish;
 
1476
 
 
1477
error:
 
1478
  res= true;
 
1479
 
 
1480
finish:
 
1481
  if (need_start_waiting)
 
1482
  {
 
1483
    /*
 
1484
      Release the protection against the global read lock and wake
 
1485
      everyone, who might want to set a global read lock.
 
1486
    */
 
1487
    start_waiting_global_read_lock(session);
494
1488
  }
495
 
 
496
 
  return (res || session->is_error());
 
1489
  return(res || session->is_error());
497
1490
}
498
1491
 
499
1492
bool execute_sqlcom_select(Session *session, TableList *all_tables)
508
1501
      param->select_limit=
509
1502
        new Item_int((uint64_t) session->variables.select_limit);
510
1503
  }
511
 
  if (not (res= session->openTablesLock(all_tables)))
 
1504
  if (!(res= open_and_lock_tables(session, all_tables)))
512
1505
  {
513
1506
    if (lex->describe)
514
1507
    {
519
1512
        even if the query itself redirects the output.
520
1513
      */
521
1514
      if (!(result= new select_send()))
522
 
        return true;
 
1515
        return true;                               /* purecov: inspected */
523
1516
      session->send_explain_fields(result);
524
 
      optimizer::ExplainPlan planner;
525
 
      res= planner.explainUnion(session, &session->lex->unit, result);
 
1517
      res= mysql_explain_union(session, &session->lex->unit, result);
526
1518
      if (lex->describe & DESCRIBE_EXTENDED)
527
1519
      {
528
1520
        char buff[1024];
542
1534
    else
543
1535
    {
544
1536
      if (!result && !(result= new select_send()))
545
 
        return true;
 
1537
        return true;                               /* purecov: inspected */
546
1538
      res= handle_select(session, lex, result, 0);
547
1539
      if (result != lex->result)
548
1540
        delete result;
621
1613
  if (move_down)
622
1614
  {
623
1615
    Select_Lex_Unit *unit;
 
1616
    lex->subqueries= true;
624
1617
    /* first select_lex of subselect or derived table */
625
1618
    if (!(unit= new (session->mem_root) Select_Lex_Unit()))
626
1619
      return(1);
697
1690
  */
698
1691
  if ((var= get_system_var(session, OPT_SESSION, tmp, null_lex_string)))
699
1692
  {
700
 
    end+= snprintf(buff, sizeof(buff), "@@session.%s", var_name);
 
1693
    end+= sprintf(buff, "@@session.%s", var_name);
701
1694
    var->set_name(buff, end-buff, system_charset_info);
702
1695
    session->add_item_to_list(var);
703
1696
  }
705
1698
}
706
1699
 
707
1700
 
 
1701
void mysql_init_multi_delete(LEX *lex)
 
1702
{
 
1703
  lex->sql_command=  SQLCOM_DELETE_MULTI;
 
1704
  mysql_init_select(lex);
 
1705
  lex->select_lex.select_limit= 0;
 
1706
  lex->unit.select_limit_cnt= HA_POS_ERROR;
 
1707
  lex->select_lex.table_list.save_and_clear(&lex->auxiliary_table_list);
 
1708
  lex->lock_option= TL_READ;
 
1709
  lex->query_tables= 0;
 
1710
  lex->query_tables_last= &lex->query_tables;
 
1711
}
 
1712
 
 
1713
 
708
1714
/**
709
1715
  Parse a query.
710
1716
 
711
1717
  @param       session     Current thread
712
1718
  @param       inBuf   Begining of the query text
713
1719
  @param       length  Length of the query text
 
1720
  @param[out]  found_semicolon For multi queries, position of the character of
 
1721
                               the next query in the query text.
714
1722
*/
715
1723
 
716
 
void mysql_parse(Session *session, const char *inBuf, uint32_t length)
 
1724
void mysql_parse(Session *session, const char *inBuf, uint32_t length,
 
1725
                 const char ** found_semicolon)
717
1726
{
 
1727
  /*
 
1728
    Warning.
 
1729
    The purpose of query_cache_send_result_to_client() is to lookup the
 
1730
    query in the query cache first, to avoid parsing and executing it.
 
1731
    So, the natural implementation would be to:
 
1732
    - first, call query_cache_send_result_to_client,
 
1733
    - second, if caching failed, initialise the lexical and syntactic parser.
 
1734
    The problem is that the query cache depends on a clean initialization
 
1735
    of (among others) lex->safe_to_cache_query and session->server_status,
 
1736
    which are reset respectively in
 
1737
    - lex_start()
 
1738
    - mysql_reset_session_for_next_command()
 
1739
    So, initializing the lexical analyser *before* using the query cache
 
1740
    is required for the cache to work properly.
 
1741
    FIXME: cleanup the dependencies in the code to simplify this.
 
1742
  */
718
1743
  lex_start(session);
719
1744
  session->reset_for_next_command();
720
1745
 
721
 
  LEX *lex= session->lex;
722
 
 
723
 
  Lex_input_stream lip(session, inBuf, length);
724
 
 
725
 
  bool err= parse_sql(session, &lip);
726
 
 
727
 
  if (!err)
728
1746
  {
 
1747
    LEX *lex= session->lex;
 
1748
 
 
1749
    Lex_input_stream lip(session, inBuf, length);
 
1750
 
 
1751
    bool err= parse_sql(session, &lip);
 
1752
    *found_semicolon= lip.found_semicolon;
 
1753
 
 
1754
    if (!err)
729
1755
    {
730
 
      if (! session->is_error())
731
1756
      {
732
 
        DRIZZLE_QUERY_EXEC_START(session->query.c_str(),
733
 
                                 session->thread_id,
734
 
                                 const_cast<const char *>(session->db.empty() ? "" : session->db.c_str()));
735
 
        /* Actually execute the query */
736
 
        mysql_execute_command(session);
737
 
        DRIZZLE_QUERY_EXEC_DONE(0);
 
1757
        if (! session->is_error())
 
1758
        {
 
1759
          /*
 
1760
            Binlog logs a string starting from session->query and having length
 
1761
            session->query_length; so we set session->query_length correctly (to not
 
1762
            log several statements in one event, when we executed only first).
 
1763
            We set it to not see the ';' (otherwise it would get into binlog
 
1764
            and Query_log_event::print() would give ';;' output).
 
1765
            This also helps display only the current query in SHOW
 
1766
            PROCESSLIST.
 
1767
            Note that we don't need LOCK_thread_count to modify query_length.
 
1768
          */
 
1769
          if (*found_semicolon &&
 
1770
              (session->query_length= (ulong)(*found_semicolon - session->query)))
 
1771
            session->query_length--;
 
1772
          /* Actually execute the query */
 
1773
          mysql_execute_command(session);
 
1774
        }
738
1775
      }
739
1776
    }
740
 
  }
741
 
  else
742
 
  {
743
 
    assert(session->is_error());
744
 
  }
745
 
 
746
 
  lex->unit.cleanup();
747
 
  session->set_proc_info("freeing items");
748
 
  session->end_statement();
749
 
  session->cleanup_after_query();
 
1777
    else
 
1778
    {
 
1779
      assert(session->is_error());
 
1780
    }
 
1781
    lex->unit.cleanup();
 
1782
    session->set_proc_info("freeing items");
 
1783
    session->end_statement();
 
1784
    session->cleanup_after_query();
 
1785
  }
750
1786
 
751
1787
  return;
752
1788
}
767
1803
                       Item *default_value, Item *on_update_value,
768
1804
                       LEX_STRING *comment,
769
1805
                       char *change,
770
 
                       List<String> *interval_list, const CHARSET_INFO * const cs)
 
1806
                       List<String> *interval_list, const CHARSET_INFO * const cs,
 
1807
                       virtual_column_info *vcol_info)
771
1808
{
772
 
  register CreateField *new_field;
 
1809
  register Create_field *new_field;
773
1810
  LEX  *lex= session->lex;
774
 
  statement::AlterTable *statement= (statement::AlterTable *)lex->statement;
775
1811
 
776
1812
  if (check_identifier_name(field_name, ER_TOO_LONG_IDENT))
777
 
    return true;
 
1813
    return(1);                          /* purecov: inspected */
778
1814
 
779
1815
  if (type_modifier & PRI_KEY_FLAG)
780
1816
  {
783
1819
    key= new Key(Key::PRIMARY, null_lex_str,
784
1820
                      &default_key_create_info,
785
1821
                      0, lex->col_list);
786
 
    statement->alter_info.key_list.push_back(key);
 
1822
    lex->alter_info.key_list.push_back(key);
787
1823
    lex->col_list.empty();
788
1824
  }
789
1825
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
793
1829
    key= new Key(Key::UNIQUE, null_lex_str,
794
1830
                 &default_key_create_info, 0,
795
1831
                 lex->col_list);
796
 
    statement->alter_info.key_list.push_back(key);
 
1832
    lex->alter_info.key_list.push_back(key);
797
1833
    lex->col_list.empty();
798
1834
  }
799
1835
 
811
1847
         type == DRIZZLE_TYPE_TIMESTAMP))
812
1848
    {
813
1849
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
814
 
      return true;
 
1850
      return(1);
815
1851
    }
816
1852
    else if (default_value->type() == Item::NULL_ITEM)
817
1853
    {
820
1856
          NOT_NULL_FLAG)
821
1857
      {
822
1858
        my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
823
 
        return true;
 
1859
        return(1);
824
1860
      }
825
1861
    }
826
1862
    else if (type_modifier & AUTO_INCREMENT_FLAG)
827
1863
    {
828
1864
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
829
 
      return true;
 
1865
      return(1);
830
1866
    }
831
1867
  }
832
1868
 
833
1869
  if (on_update_value && type != DRIZZLE_TYPE_TIMESTAMP)
834
1870
  {
835
1871
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name->str);
836
 
    return true;
 
1872
    return(1);
837
1873
  }
838
1874
 
839
 
  if (!(new_field= new CreateField()) ||
 
1875
  if (!(new_field= new Create_field()) ||
840
1876
      new_field->init(session, field_name->str, type, length, decimals, type_modifier,
841
1877
                      default_value, on_update_value, comment, change,
842
 
                      interval_list, cs, 0, column_format))
843
 
    return true;
 
1878
                      interval_list, cs, 0, column_format,
 
1879
                      vcol_info))
 
1880
    return(1);
844
1881
 
845
 
  statement->alter_info.create_list.push_back(new_field);
 
1882
  lex->alter_info.create_list.push_back(new_field);
846
1883
  lex->last_field=new_field;
847
 
 
848
 
  return false;
 
1884
  return(0);
849
1885
}
850
1886
 
851
1887
 
857
1893
}
858
1894
 
859
1895
/**
 
1896
  save order by and tables in own lists.
 
1897
*/
 
1898
 
 
1899
bool add_to_list(Session *session, SQL_LIST &list,Item *item,bool asc)
 
1900
{
 
1901
  order_st *order;
 
1902
  if (!(order = (order_st *) session->alloc(sizeof(order_st))))
 
1903
    return(1);
 
1904
  order->item_ptr= item;
 
1905
  order->item= &order->item_ptr;
 
1906
  order->asc = asc;
 
1907
  order->free_me=0;
 
1908
  order->used=0;
 
1909
  order->counter_used= 0;
 
1910
  list.link_in_list((unsigned char*) order,(unsigned char**) &order->next);
 
1911
  return(0);
 
1912
}
 
1913
 
 
1914
 
 
1915
/**
860
1916
  Add a table to list of used tables.
861
1917
 
862
1918
  @param table          Table to add
889
1945
  LEX *lex= session->lex;
890
1946
 
891
1947
  if (!table)
892
 
    return NULL;                                // End of memory
 
1948
    return(0);                          // End of memory
893
1949
  alias_str= alias ? alias->str : table->table.str;
894
1950
  if (!test(table_options & TL_OPTION_ALIAS) &&
895
1951
      check_table_name(table->table.str, table->table.length))
896
1952
  {
897
1953
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
898
 
    return NULL;
 
1954
    return(0);
899
1955
  }
900
1956
 
901
 
  if (table->is_derived_table() == false && table->db.str)
 
1957
  if (table->is_derived_table() == false && table->db.str &&
 
1958
      check_db_name(&table->db))
902
1959
  {
903
 
    my_casedn_str(files_charset_info, table->db.str);
904
 
 
905
 
    SchemaIdentifier schema_identifier(string(table->db.str, table->db.length));
906
 
    if (not check_db_name(schema_identifier))
907
 
    {
908
 
 
909
 
      my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
910
 
      return NULL;
911
 
    }
 
1960
    my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
 
1961
    return(0);
912
1962
  }
913
1963
 
914
1964
  if (!alias)                                   /* Alias is case sensitive */
917
1967
    {
918
1968
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
919
1969
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
920
 
      return NULL;
 
1970
      return(0);
921
1971
    }
922
1972
    if (!(alias_str= (char*) session->memdup(alias_str,table->table.length+1)))
923
 
      return NULL;
 
1973
      return(0);
924
1974
  }
925
1975
  if (!(ptr = (TableList *) session->calloc(sizeof(TableList))))
926
 
    return NULL;
 
1976
    return(0);                          /* purecov: inspected */
927
1977
  if (table->db.str)
928
1978
  {
929
1979
    ptr->is_fqtn= true;
931
1981
    ptr->db_length= table->db.length;
932
1982
  }
933
1983
  else if (lex->copy_db_to(&ptr->db, &ptr->db_length))
934
 
    return NULL;
 
1984
    return(0);
935
1985
  else
936
1986
    ptr->is_fqtn= false;
937
1987
 
938
1988
  ptr->alias= alias_str;
939
1989
  ptr->is_alias= alias ? true : false;
940
 
  if (table->table.length)
 
1990
  if (lower_case_table_names && table->table.length)
941
1991
    table->table.length= my_casedn_str(files_charset_info, table->table.str);
942
1992
  ptr->table_name=table->table.str;
943
1993
  ptr->table_name_length=table->table.length;
944
1994
  ptr->lock_type=   lock_type;
 
1995
  ptr->lock_timeout= -1;      /* default timeout */
 
1996
  ptr->lock_transactional= 1; /* allow transactional locks */
 
1997
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
945
1998
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
946
1999
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
947
2000
  ptr->derived=     table->sel;
 
2001
  if (!ptr->derived && !my_strcasecmp(system_charset_info, ptr->db,
 
2002
                                      INFORMATION_SCHEMA_NAME.c_str()))
 
2003
  {
 
2004
    InfoSchemaTable *schema_table= find_schema_table(session, ptr->table_name);
 
2005
    if (!schema_table ||
 
2006
        (schema_table->hidden &&
 
2007
         ((sql_command_flags[lex->sql_command].test(CF_BIT_STATUS_COMMAND)) == 0 ||
 
2008
          /*
 
2009
            this check is used for show columns|keys from I_S hidden table
 
2010
          */
 
2011
          lex->sql_command == SQLCOM_SHOW_FIELDS ||
 
2012
          lex->sql_command == SQLCOM_SHOW_KEYS)))
 
2013
    {
 
2014
      my_error(ER_UNKNOWN_TABLE, MYF(0),
 
2015
               ptr->table_name, INFORMATION_SCHEMA_NAME.c_str());
 
2016
      return(0);
 
2017
    }
 
2018
    ptr->schema_table_name= ptr->table_name;
 
2019
    ptr->schema_table= schema_table;
 
2020
  }
948
2021
  ptr->select_lex=  lex->current_select;
 
2022
  ptr->cacheable_table= 1;
949
2023
  ptr->index_hints= index_hints_arg;
950
2024
  ptr->option= option ? option->str : 0;
951
2025
  /* check that used name is unique */
957
2031
         tables=tables->next_local)
958
2032
    {
959
2033
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
960
 
          !strcasecmp(ptr->db, tables->db))
 
2034
          !strcmp(ptr->db, tables->db))
961
2035
      {
962
 
        my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str);
963
 
        return NULL;
 
2036
        my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str); /* purecov: tested */
 
2037
        return(0);                              /* purecov: tested */
964
2038
      }
965
2039
    }
966
2040
  }
995
2069
  ptr->next_name_resolution_table= NULL;
996
2070
  /* Link table in global list (all used tables) */
997
2071
  lex->add_to_query_tables(ptr);
998
 
  return ptr;
 
2072
  return(ptr);
999
2073
}
1000
2074
 
1001
2075
 
1025
2099
 
1026
2100
  if (!(ptr= (TableList*) session->calloc(ALIGN_SIZE(sizeof(TableList))+
1027
2101
                                       sizeof(nested_join_st))))
1028
 
    return true;
 
2102
    return(1);
1029
2103
  nested_join= ptr->nested_join=
1030
2104
    ((nested_join_st*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList))));
1031
2105
 
1036
2110
  embedding= ptr;
1037
2111
  join_list= &nested_join->join_list;
1038
2112
  join_list->empty();
1039
 
  return false;
 
2113
  return(0);
1040
2114
}
1041
2115
 
1042
2116
 
1076
2150
  else if (nested_join->join_list.elements == 0)
1077
2151
  {
1078
2152
    join_list->pop();
1079
 
    ptr= NULL;                                     // return value
 
2153
    ptr= 0;                                     // return value
1080
2154
  }
1081
 
  return ptr;
 
2155
  return(ptr);
1082
2156
}
1083
2157
 
1084
2158
 
1103
2177
 
1104
2178
  if (!(ptr= (TableList*) session->calloc(ALIGN_SIZE(sizeof(TableList))+
1105
2179
                                       sizeof(nested_join_st))))
1106
 
    return NULL;
 
2180
    return(0);
1107
2181
  nested_join= ptr->nested_join=
1108
2182
    ((nested_join_st*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList))));
1109
2183
 
1132
2206
  }
1133
2207
  join_list->push_front(ptr);
1134
2208
  nested_join->used_tables= nested_join->not_null_tables= (table_map) 0;
1135
 
  return ptr;
 
2209
  return(ptr);
1136
2210
}
1137
2211
 
1138
2212
 
1155
2229
  join_list->push_front(table);
1156
2230
  table->join_list= join_list;
1157
2231
  table->embedding= embedding;
 
2232
  return;
1158
2233
}
1159
2234
 
1160
2235
 
1198
2273
  join_list->push_front(tab1);
1199
2274
  tab1->outer_join|= JOIN_TYPE_RIGHT;
1200
2275
 
1201
 
  return tab1;
 
2276
  return(tab1);
1202
2277
}
1203
2278
 
1204
2279
/**
1214
2289
 
1215
2290
void Select_Lex::set_lock_for_tables(thr_lock_type lock_type)
1216
2291
{
 
2292
  bool for_update= lock_type >= TL_READ_NO_INSERT;
 
2293
 
1217
2294
  for (TableList *tables= (TableList*) table_list.first;
1218
2295
       tables;
1219
2296
       tables= tables->next_local)
1220
2297
  {
1221
2298
    tables->lock_type= lock_type;
 
2299
    tables->updating=  for_update;
1222
2300
  }
 
2301
  return;
1223
2302
}
1224
2303
 
1225
2304
 
1230
2309
    This object is created for any union construct containing a union
1231
2310
    operation and also for any single select union construct of the form
1232
2311
    @verbatim
1233
 
    (SELECT ... ORDER BY order_list [LIMIT n]) ORDER BY ...
 
2312
    (SELECT ... order_st BY order_list [LIMIT n]) order_st BY ...
1234
2313
    @endvarbatim
1235
2314
    or of the form
1236
2315
    @varbatim
1237
 
    (SELECT ... ORDER BY LIMIT n) ORDER BY ...
 
2316
    (SELECT ... order_st BY LIMIT n) order_st BY ...
1238
2317
    @endvarbatim
1239
2318
 
1240
2319
  @param session_arg               thread handle
1265
2344
  fake_select_lex->select_limit= 0;
1266
2345
 
1267
2346
  fake_select_lex->context.outer_context=first_sl->context.outer_context;
1268
 
  /* allow item list resolving in fake select for ORDER BY */
 
2347
  /* allow item list resolving in fake select for order_st BY */
1269
2348
  fake_select_lex->context.resolve_in_select_list= true;
1270
2349
  fake_select_lex->context.select_lex= fake_select_lex;
1271
2350
 
1273
2352
  {
1274
2353
    /*
1275
2354
      This works only for
1276
 
      (SELECT ... ORDER BY list [LIMIT n]) ORDER BY order_list [LIMIT m],
1277
 
      (SELECT ... LIMIT n) ORDER BY order_list [LIMIT m]
 
2355
      (SELECT ... order_st BY list [LIMIT n]) order_st BY order_list [LIMIT m],
 
2356
      (SELECT ... LIMIT n) order_st BY order_list [LIMIT m]
1278
2357
      just before the parser starts processing order_list
1279
2358
    */
1280
2359
    global_parameters= fake_select_lex;
1397
2476
 
1398
2477
 
1399
2478
/**
 
2479
  Reload/resets privileges and the different caches.
 
2480
 
 
2481
  @param session Thread handler (can be NULL!)
 
2482
  @param options What should be reset/reloaded (tables, privileges, slave...)
 
2483
  @param tables Tables to flush (if any)
 
2484
  @param write_to_binlog True if we can write to the binlog.
 
2485
 
 
2486
  @note Depending on 'options', it may be very bad to write the
 
2487
    query to the binlog (e.g. FLUSH SLAVE); this is a
 
2488
    pointer where reload_cache() will put 0 if
 
2489
    it thinks we really should not write to the binlog.
 
2490
    Otherwise it will put 1.
 
2491
 
 
2492
  @return Error status code
 
2493
    @retval 0 Ok
 
2494
    @retval !=0  Error; session->killed is set or session->is_error() is true
 
2495
*/
 
2496
 
 
2497
bool reload_cache(Session *session, ulong options, TableList *tables, bool *write_to_binlog)
 
2498
{
 
2499
  bool result=0;
 
2500
  select_errors=0;                              /* Write if more errors */
 
2501
  bool tmp_write_to_binlog= 1;
 
2502
 
 
2503
  if (options & REFRESH_LOG)
 
2504
  {
 
2505
    /*
 
2506
      Flush the normal query log, the update log, the binary log,
 
2507
      the slow query log, the relay log (if it exists) and the log
 
2508
      tables.
 
2509
    */
 
2510
 
 
2511
    /*
 
2512
      Writing this command to the binlog may result in infinite loops
 
2513
      when doing mysqlbinlog|mysql, and anyway it does not really make
 
2514
      sense to log it automatically (would cause more trouble to users
 
2515
      than it would help them)
 
2516
    */
 
2517
    tmp_write_to_binlog= 0;
 
2518
 
 
2519
    if (ha_flush_logs(NULL))
 
2520
      result=1;
 
2521
  }
 
2522
  /*
 
2523
    Note that if REFRESH_READ_LOCK bit is set then REFRESH_TABLES is set too
 
2524
    (see sql_yacc.yy)
 
2525
  */
 
2526
  if (options & (REFRESH_TABLES | REFRESH_READ_LOCK))
 
2527
  {
 
2528
    if ((options & REFRESH_READ_LOCK) && session)
 
2529
    {
 
2530
      /*
 
2531
        We must not try to aspire a global read lock if we have a write
 
2532
        locked table. This would lead to a deadlock when trying to
 
2533
        reopen (and re-lock) the table after the flush.
 
2534
      */
 
2535
      if (session->locked_tables)
 
2536
      {
 
2537
        THR_LOCK_DATA **lock_p= session->locked_tables->locks;
 
2538
        THR_LOCK_DATA **end_p= lock_p + session->locked_tables->lock_count;
 
2539
 
 
2540
        for (; lock_p < end_p; lock_p++)
 
2541
        {
 
2542
          if ((*lock_p)->type >= TL_WRITE_ALLOW_WRITE)
 
2543
          {
 
2544
            my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
 
2545
            return 1;
 
2546
          }
 
2547
        }
 
2548
      }
 
2549
      /*
 
2550
        Writing to the binlog could cause deadlocks, as we don't log
 
2551
        UNLOCK TABLES
 
2552
      */
 
2553
      tmp_write_to_binlog= 0;
 
2554
      if (lock_global_read_lock(session))
 
2555
        return 1;                               // Killed
 
2556
      result= close_cached_tables(session, tables, false, (options & REFRESH_FAST) ?
 
2557
                                  false : true, true);
 
2558
      if (make_global_read_lock_block_commit(session)) // Killed
 
2559
      {
 
2560
        /* Don't leave things in a half-locked state */
 
2561
        unlock_global_read_lock(session);
 
2562
        return 1;
 
2563
      }
 
2564
    }
 
2565
    else
 
2566
      result= close_cached_tables(session, tables, false, (options & REFRESH_FAST) ?
 
2567
                                  false : true, false);
 
2568
  }
 
2569
  if (session && (options & REFRESH_STATUS))
 
2570
    session->refresh_status();
 
2571
 *write_to_binlog= tmp_write_to_binlog;
 
2572
 
 
2573
 return result;
 
2574
}
 
2575
 
 
2576
 
 
2577
/**
1400
2578
  kill on thread.
1401
2579
 
1402
2580
  @param session                        Thread class
1410
2588
static unsigned int
1411
2589
kill_one_thread(Session *, ulong id, bool only_kill_query)
1412
2590
{
1413
 
  Session *tmp= NULL;
1414
 
  uint32_t error= ER_NO_SUCH_THREAD;
 
2591
  Session *tmp;
 
2592
  uint32_t error=ER_NO_SUCH_THREAD;
1415
2593
  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
1416
 
  
1417
 
  for (SessionList::iterator it= getSessionList().begin(); it != getSessionList().end(); ++it )
 
2594
  I_List_iterator<Session> it(session_list);
 
2595
  while ((tmp=it++))
1418
2596
  {
1419
 
    if ((*it)->thread_id == id)
 
2597
    if (tmp->thread_id == id)
1420
2598
    {
1421
 
      tmp= *it;
1422
2599
      pthread_mutex_lock(&tmp->LOCK_delete);    // Lock from delete
1423
2600
      break;
1424
2601
    }
1426
2603
  pthread_mutex_unlock(&LOCK_thread_count);
1427
2604
  if (tmp)
1428
2605
  {
1429
 
 
1430
 
    if (tmp->isViewable())
1431
 
    {
1432
 
      tmp->awake(only_kill_query ? Session::KILL_QUERY : Session::KILL_CONNECTION);
1433
 
      error= 0;
1434
 
    }
1435
 
 
 
2606
    tmp->awake(only_kill_query ? Session::KILL_QUERY : Session::KILL_CONNECTION);
 
2607
    error=0;
1436
2608
    pthread_mutex_unlock(&tmp->LOCK_delete);
1437
2609
  }
1438
2610
  return(error);
1459
2631
}
1460
2632
 
1461
2633
 
 
2634
/** If pointer is not a null pointer, append filename to it. */
 
2635
 
 
2636
bool append_file_to_dir(Session *session, const char **filename_ptr,
 
2637
                        const char *table_name)
 
2638
{
 
2639
  char buff[FN_REFLEN],*ptr, *end;
 
2640
  if (!*filename_ptr)
 
2641
    return 0;                                   // nothing to do
 
2642
 
 
2643
  /* Check that the filename is not too long and it's a hard path */
 
2644
  if (strlen(*filename_ptr)+strlen(table_name) >= FN_REFLEN-1 ||
 
2645
      !test_if_hard_path(*filename_ptr))
 
2646
  {
 
2647
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
 
2648
    return 1;
 
2649
  }
 
2650
  /* Fix is using unix filename format on dos */
 
2651
  strcpy(buff,*filename_ptr);
 
2652
  end=convert_dirname(buff, *filename_ptr, NULL);
 
2653
  if (!(ptr= (char*) session->alloc((size_t) (end-buff) + strlen(table_name)+1)))
 
2654
    return 1;                                   // End of memory
 
2655
  *filename_ptr=ptr;
 
2656
  sprintf(ptr,"%s%s",buff,table_name);
 
2657
  return 0;
 
2658
}
 
2659
 
 
2660
 
1462
2661
/**
1463
2662
  Check if the select is a simple select (not an union).
1464
2663
 
1477
2676
    char command[80];
1478
2677
    Lex_input_stream *lip= session->m_lip;
1479
2678
    strncpy(command, lip->yylval->symbol.str,
1480
 
            min(lip->yylval->symbol.length, (uint32_t)(sizeof(command)-1)));
1481
 
    command[min(lip->yylval->symbol.length, (uint32_t)(sizeof(command)-1))]=0;
 
2679
            cmin(lip->yylval->symbol.length, sizeof(command)-1));
 
2680
    command[cmin(lip->yylval->symbol.length, sizeof(command)-1)]=0;
1482
2681
    my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
1483
2682
    return 1;
1484
2683
  }
1556
2755
  return(false);
1557
2756
}
1558
2757
 
 
2758
/**
 
2759
  Multi delete query pre-check.
 
2760
 
 
2761
  @param session                        Thread handler
 
2762
  @param tables         Global/local table list
 
2763
 
 
2764
  @retval
 
2765
    false OK
 
2766
  @retval
 
2767
    true  error
 
2768
*/
 
2769
 
 
2770
bool multi_delete_precheck(Session *session, TableList *)
 
2771
{
 
2772
  Select_Lex *select_lex= &session->lex->select_lex;
 
2773
  TableList **save_query_tables_own_last= session->lex->query_tables_own_last;
 
2774
 
 
2775
  session->lex->query_tables_own_last= 0;
 
2776
  session->lex->query_tables_own_last= save_query_tables_own_last;
 
2777
 
 
2778
  if ((session->options & OPTION_SAFE_UPDATES) && !select_lex->where)
 
2779
  {
 
2780
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
 
2781
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
 
2782
    return(true);
 
2783
  }
 
2784
  return(false);
 
2785
}
 
2786
 
 
2787
 
 
2788
/*
 
2789
  Given a table in the source list, find a correspondent table in the
 
2790
  table references list.
 
2791
 
 
2792
  @param lex Pointer to LEX representing multi-delete.
 
2793
  @param src Source table to match.
 
2794
  @param ref Table references list.
 
2795
 
 
2796
  @remark The source table list (tables listed before the FROM clause
 
2797
  or tables listed in the FROM clause before the USING clause) may
 
2798
  contain table names or aliases that must match unambiguously one,
 
2799
  and only one, table in the target table list (table references list,
 
2800
  after FROM/USING clause).
 
2801
 
 
2802
  @return Matching table, NULL otherwise.
 
2803
*/
 
2804
 
 
2805
static TableList *multi_delete_table_match(LEX *, TableList *tbl,
 
2806
                                           TableList *tables)
 
2807
{
 
2808
  TableList *match= NULL;
 
2809
 
 
2810
  for (TableList *elem= tables; elem; elem= elem->next_local)
 
2811
  {
 
2812
    int cmp;
 
2813
 
 
2814
    if (tbl->is_fqtn && elem->is_alias)
 
2815
      continue; /* no match */
 
2816
    if (tbl->is_fqtn && elem->is_fqtn)
 
2817
      cmp= my_strcasecmp(table_alias_charset, tbl->table_name, elem->table_name) ||
 
2818
           strcmp(tbl->db, elem->db);
 
2819
    else if (elem->is_alias)
 
2820
      cmp= my_strcasecmp(table_alias_charset, tbl->alias, elem->alias);
 
2821
    else
 
2822
      cmp= my_strcasecmp(table_alias_charset, tbl->table_name, elem->table_name) ||
 
2823
           strcmp(tbl->db, elem->db);
 
2824
 
 
2825
    if (cmp)
 
2826
      continue;
 
2827
 
 
2828
    if (match)
 
2829
    {
 
2830
      my_error(ER_NONUNIQ_TABLE, MYF(0), elem->alias);
 
2831
      return(NULL);
 
2832
    }
 
2833
 
 
2834
    match= elem;
 
2835
  }
 
2836
 
 
2837
  if (!match)
 
2838
    my_error(ER_UNKNOWN_TABLE, MYF(0), tbl->table_name, "MULTI DELETE");
 
2839
 
 
2840
  return(match);
 
2841
}
 
2842
 
 
2843
 
 
2844
/**
 
2845
  Link tables in auxilary table list of multi-delete with corresponding
 
2846
  elements in main table list, and set proper locks for them.
 
2847
 
 
2848
  @param lex   pointer to LEX representing multi-delete
 
2849
 
 
2850
  @retval
 
2851
    false   success
 
2852
  @retval
 
2853
    true    error
 
2854
*/
 
2855
 
 
2856
bool multi_delete_set_locks_and_link_aux_tables(LEX *lex)
 
2857
{
 
2858
  TableList *tables= (TableList*)lex->select_lex.table_list.first;
 
2859
  TableList *target_tbl;
 
2860
 
 
2861
  lex->table_count= 0;
 
2862
 
 
2863
  for (target_tbl= (TableList *)lex->auxiliary_table_list.first;
 
2864
       target_tbl; target_tbl= target_tbl->next_local)
 
2865
  {
 
2866
    lex->table_count++;
 
2867
    /* All tables in aux_tables must be found in FROM PART */
 
2868
    TableList *walk= multi_delete_table_match(lex, target_tbl, tables);
 
2869
    if (!walk)
 
2870
      return(true);
 
2871
    if (!walk->derived)
 
2872
    {
 
2873
      target_tbl->table_name= walk->table_name;
 
2874
      target_tbl->table_name_length= walk->table_name_length;
 
2875
    }
 
2876
    walk->updating= target_tbl->updating;
 
2877
    walk->lock_type= target_tbl->lock_type;
 
2878
    target_tbl->correspondent_table= walk;      // Remember corresponding table
 
2879
  }
 
2880
  return(false);
 
2881
}
 
2882
 
1559
2883
 
1560
2884
/**
1561
2885
  simple INSERT query pre-check.
1599
2923
    true   Error
1600
2924
*/
1601
2925
 
1602
 
bool create_table_precheck(TableIdentifier &identifier)
 
2926
bool create_table_precheck(Session *, TableList *,
 
2927
                           TableList *create_table)
1603
2928
{
1604
 
  if (not plugin::StorageEngine::canCreateTable(identifier))
1605
 
  {
1606
 
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0), "", "", identifier.getSchemaName().c_str());
1607
 
    return true;
1608
 
  }
1609
 
 
1610
 
  if (not plugin::StorageEngine::doesSchemaExist(identifier))
1611
 
  {
1612
 
    my_error(ER_BAD_DB_ERROR, MYF(0), identifier.getSchemaName().c_str());
1613
 
    return true;
1614
 
  }
1615
 
 
1616
 
  return false;
 
2929
  bool error= true;                                 // Error message is given
 
2930
 
 
2931
  if (create_table && (strcmp(create_table->db, "information_schema") == 0))
 
2932
  {
 
2933
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0), "", "", INFORMATION_SCHEMA_NAME.c_str());
 
2934
    return(true);
 
2935
  }
 
2936
 
 
2937
  error= false;
 
2938
 
 
2939
  return(error);
1617
2940
}
1618
2941
 
1619
2942
 
1726
3049
}
1727
3050
 
1728
3051
 
 
3052
/*
 
3053
  Check if path does not contain mysql data home directory
 
3054
  SYNOPSIS
 
3055
    test_if_data_home_dir()
 
3056
    dir                     directory
 
3057
    conv_home_dir           converted data home directory
 
3058
    home_dir_len            converted data home directory length
 
3059
 
 
3060
  RETURN VALUES
 
3061
    0   ok
 
3062
    1   error
 
3063
*/
 
3064
 
 
3065
bool test_if_data_home_dir(const char *dir)
 
3066
{
 
3067
  char path[FN_REFLEN], conv_path[FN_REFLEN];
 
3068
  uint32_t dir_len, home_dir_len= strlen(drizzle_unpacked_real_data_home);
 
3069
 
 
3070
  if (!dir)
 
3071
    return(0);
 
3072
 
 
3073
  (void) fn_format(path, dir, "", "",
 
3074
                   (MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));
 
3075
  dir_len= unpack_dirname(conv_path, dir);
 
3076
 
 
3077
  if (home_dir_len < dir_len)
 
3078
  {
 
3079
    if (!my_strnncoll(character_set_filesystem,
 
3080
                      (const unsigned char*) conv_path, home_dir_len,
 
3081
                      (const unsigned char*) drizzle_unpacked_real_data_home,
 
3082
                      home_dir_len))
 
3083
      return(1);
 
3084
  }
 
3085
  return(0);
 
3086
}
 
3087
 
 
3088
 
 
3089
extern int DRIZZLEparse(void *session); // from sql_yacc.cc
 
3090
 
 
3091
 
1729
3092
/**
1730
3093
  This is a wrapper of DRIZZLEparse(). All the code should call parse_sql()
1731
3094
  instead of DRIZZLEparse().
1738
3101
    @retval true on parsing error.
1739
3102
*/
1740
3103
 
1741
 
static bool parse_sql(Session *session, Lex_input_stream *lip)
 
3104
bool parse_sql(Session *session, Lex_input_stream *lip)
1742
3105
{
1743
3106
  assert(session->m_lip == NULL);
1744
3107
 
1745
 
  DRIZZLE_QUERY_PARSE_START(session->query.c_str());
1746
 
 
1747
3108
  /* Set Lex_input_stream. */
1748
3109
 
1749
3110
  session->m_lip= lip;
1760
3121
 
1761
3122
  session->m_lip= NULL;
1762
3123
 
1763
 
  DRIZZLE_QUERY_PARSE_DONE(mysql_parse_status || session->is_fatal_error);
1764
 
 
1765
3124
  /* That's it. */
1766
3125
 
1767
3126
  return mysql_parse_status || session->is_fatal_error;
1770
3129
/**
1771
3130
  @} (end of group Runtime_Environment)
1772
3131
*/
1773
 
 
1774
 
} /* namespace drizzled */