← 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: 2008-08-22 04:35:12 UTC
  • mto: (365.1.2 drizzle)
  • mto: This revision was merged to the branch mainline in revision 368.
  • Revision ID: monty@inaugust.com-20080822043512-3vafw99x3vv97d39
INT32_MAX stuff.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_parse.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
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 */
15
 
 
16
 
#include "config.h"
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
17
15
 
18
16
#define DRIZZLE_LEX 1
19
 
 
20
 
#include "drizzled/item/num.h"
21
 
#include "drizzled/abort_exception.h"
22
 
#include <drizzled/my_hash.h>
23
 
#include <drizzled/error.h>
24
 
#include <drizzled/nested_join.h>
25
 
#include <drizzled/query_id.h>
26
 
#include "drizzled/transaction_services.h"
27
 
#include <drizzled/sql_parse.h>
28
 
#include <drizzled/data_home.h>
29
 
#include <drizzled/sql_base.h>
30
 
#include <drizzled/show.h>
31
 
#include <drizzled/db.h>
32
 
#include <drizzled/function/time/unix_timestamp.h>
33
 
#include <drizzled/function/get_system_var.h>
34
 
#include <drizzled/item/cmpfunc.h>
35
 
#include <drizzled/item/null.h>
36
 
#include <drizzled/session.h>
37
 
#include <drizzled/session/cache.h>
38
 
#include <drizzled/sql_load.h>
39
 
#include <drizzled/lock.h>
40
 
#include <drizzled/select_send.h>
41
 
#include <drizzled/plugin/client.h>
42
 
#include <drizzled/statement.h>
43
 
#include <drizzled/statement/alter_table.h>
44
 
#include "drizzled/probes.h"
45
 
#include "drizzled/global_charset_info.h"
46
 
 
47
 
#include "drizzled/plugin/logging.h"
48
 
#include "drizzled/plugin/query_rewrite.h"
49
 
#include "drizzled/plugin/query_cache.h"
50
 
#include "drizzled/plugin/authorization.h"
51
 
#include "drizzled/optimizer/explain_plan.h"
52
 
#include "drizzled/pthread_globals.h"
53
 
#include "drizzled/plugin/event_observer.h"
54
 
#include "drizzled/visibility.h"
55
 
 
56
 
#include <limits.h>
57
 
 
58
 
#include <bitset>
59
 
#include <algorithm>
60
 
#include <boost/date_time.hpp>
61
 
#include "drizzled/internal/my_sys.h"
62
 
 
63
 
using namespace std;
64
 
 
65
 
extern int DRIZZLEparse(void *session); // from sql_yacc.cc
66
 
 
67
 
namespace drizzled
68
 
{
69
 
 
70
 
/* Prototypes */
71
 
bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
72
 
static bool parse_sql(Session *session, Lex_input_stream *lip);
73
 
void parse(Session *session, const char *inBuf, uint32_t length);
 
17
#include <drizzled/server_includes.h>
 
18
#include "sql_repl.h"
 
19
#include "rpl_filter.h"
 
20
#include "repl_failsafe.h"
 
21
#include <drizzled/drizzled_error_messages.h>
74
22
 
75
23
/**
76
24
  @defgroup Runtime_Environment Runtime Environment
77
25
  @{
78
26
*/
79
27
 
80
 
extern size_t my_thread_stack_size;
81
 
extern const CHARSET_INFO *character_set_filesystem;
82
 
 
83
 
namespace
84
 
{
85
 
 
86
 
static const std::string command_name[COM_END+1]={
87
 
  "Sleep",
88
 
  "Quit",
89
 
  "Init DB",
90
 
  "Query",
91
 
  "Shutdown",
92
 
  "Connect",
93
 
  "Ping",
94
 
  "Error"  // Last command number
 
28
 
 
29
const char *any_db="*any*";     // Special symbol for check_access
 
30
 
 
31
const LEX_STRING command_name[COM_END+1]={
 
32
  { C_STRING_WITH_LEN("Sleep") },
 
33
  { C_STRING_WITH_LEN("Quit") },
 
34
  { C_STRING_WITH_LEN("Init DB") },
 
35
  { C_STRING_WITH_LEN("Query") },
 
36
  { C_STRING_WITH_LEN("Field List") },
 
37
  { C_STRING_WITH_LEN("Create DB") },
 
38
  { C_STRING_WITH_LEN("Drop DB") },
 
39
  { C_STRING_WITH_LEN("Refresh") },
 
40
  { C_STRING_WITH_LEN("Shutdown") },
 
41
  { C_STRING_WITH_LEN("Processlist") },
 
42
  { C_STRING_WITH_LEN("Connect") },
 
43
  { C_STRING_WITH_LEN("Kill") },
 
44
  { C_STRING_WITH_LEN("Ping") },
 
45
  { C_STRING_WITH_LEN("Time") },
 
46
  { C_STRING_WITH_LEN("Change user") },
 
47
  { C_STRING_WITH_LEN("Binlog Dump") },
 
48
  { C_STRING_WITH_LEN("Connect Out") },
 
49
  { C_STRING_WITH_LEN("Register Slave") },
 
50
  { C_STRING_WITH_LEN("Set option") },
 
51
  { C_STRING_WITH_LEN("Daemon") },
 
52
  { C_STRING_WITH_LEN("Error") }  // Last command number
95
53
};
96
54
 
97
 
}
98
 
 
99
55
const char *xa_state_names[]={
100
56
  "NON-EXISTING", "ACTIVE", "IDLE", "PREPARED"
101
57
};
102
58
 
 
59
static void unlock_locked_tables(THD *thd)
 
60
{
 
61
  if (thd->locked_tables)
 
62
  {
 
63
    thd->lock=thd->locked_tables;
 
64
    thd->locked_tables=0;                       // Will be automatically closed
 
65
    close_thread_tables(thd);                   // Free tables
 
66
  }
 
67
}
 
68
 
 
69
 
 
70
bool end_active_trans(THD *thd)
 
71
{
 
72
  int error=0;
 
73
  if (unlikely(thd->in_sub_stmt))
 
74
  {
 
75
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
 
76
    return(1);
 
77
  }
 
78
  if (thd->transaction.xid_state.xa_state != XA_NOTR)
 
79
  {
 
80
    my_error(ER_XAER_RMFAIL, MYF(0),
 
81
             xa_state_names[thd->transaction.xid_state.xa_state]);
 
82
    return(1);
 
83
  }
 
84
  if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
 
85
                      OPTION_TABLE_LOCK))
 
86
  {
 
87
    /* Safety if one did "drop table" on locked tables */
 
88
    if (!thd->locked_tables)
 
89
      thd->options&= ~OPTION_TABLE_LOCK;
 
90
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
 
91
    if (ha_commit(thd))
 
92
      error=1;
 
93
  }
 
94
  thd->options&= ~(OPTION_BEGIN | OPTION_KEEP_LOG);
 
95
  thd->transaction.all.modified_non_trans_table= false;
 
96
  return(error);
 
97
}
 
98
 
 
99
 
 
100
bool begin_trans(THD *thd)
 
101
{
 
102
  int error=0;
 
103
  if (unlikely(thd->in_sub_stmt))
 
104
  {
 
105
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
 
106
    return 1;
 
107
  }
 
108
  if (thd->locked_tables)
 
109
  {
 
110
    thd->lock=thd->locked_tables;
 
111
    thd->locked_tables=0;                       // Will be automatically closed
 
112
    close_thread_tables(thd);                   // Free tables
 
113
  }
 
114
  if (end_active_trans(thd))
 
115
    error= -1;
 
116
  else
 
117
  {
 
118
    LEX *lex= thd->lex;
 
119
    thd->options|= OPTION_BEGIN;
 
120
    thd->server_status|= SERVER_STATUS_IN_TRANS;
 
121
    if (lex->start_transaction_opt & DRIZZLE_START_TRANS_OPT_WITH_CONS_SNAPSHOT)
 
122
      error= ha_start_consistent_snapshot(thd);
 
123
  }
 
124
  return error;
 
125
}
 
126
 
 
127
/**
 
128
  Returns true if all tables should be ignored.
 
129
*/
 
130
inline bool all_tables_not_ok(THD *thd, TableList *tables)
 
131
{
 
132
  return rpl_filter->is_on() && tables &&
 
133
         !rpl_filter->tables_ok(thd->db, tables);
 
134
}
 
135
 
 
136
 
 
137
static bool some_non_temp_table_to_be_updated(THD *thd, TableList *tables)
 
138
{
 
139
  for (TableList *table= tables; table; table= table->next_global)
 
140
  {
 
141
    assert(table->db && table->table_name);
 
142
    if (table->updating &&
 
143
        !find_temporary_table(thd, table->db, table->table_name))
 
144
      return 1;
 
145
  }
 
146
  return 0;
 
147
}
 
148
 
 
149
 
103
150
/**
104
151
  Mark all commands that somehow changes a table.
105
152
 
112
159
     2  - query that returns meaningful ROW_COUNT() -
113
160
          a number of modified rows
114
161
*/
115
 
bitset<CF_BIT_SIZE> sql_command_flags[SQLCOM_END+1];
116
162
 
117
 
const std::string &getCommandName(const enum_server_command& command)
118
 
{
119
 
  return command_name[command];
120
 
}
 
163
uint sql_command_flags[SQLCOM_END+1];
121
164
 
122
165
void init_update_queries(void)
123
166
{
124
 
  uint32_t x;
125
 
 
126
 
  for (x= 0; x <= SQLCOM_END; x++)
127
 
    sql_command_flags[x].reset();
 
167
  memset(&sql_command_flags, 0, sizeof(sql_command_flags));
128
168
 
129
169
  sql_command_flags[SQLCOM_CREATE_TABLE]=   CF_CHANGES_DATA;
130
170
  sql_command_flags[SQLCOM_CREATE_INDEX]=   CF_CHANGES_DATA;
138
178
  sql_command_flags[SQLCOM_DROP_INDEX]=     CF_CHANGES_DATA;
139
179
 
140
180
  sql_command_flags[SQLCOM_UPDATE]=         CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
 
181
  sql_command_flags[SQLCOM_UPDATE_MULTI]=   CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
141
182
  sql_command_flags[SQLCOM_INSERT]=         CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
142
183
  sql_command_flags[SQLCOM_INSERT_SELECT]=  CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
143
184
  sql_command_flags[SQLCOM_DELETE]=         CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
 
185
  sql_command_flags[SQLCOM_DELETE_MULTI]=   CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
144
186
  sql_command_flags[SQLCOM_REPLACE]=        CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
145
187
  sql_command_flags[SQLCOM_REPLACE_SELECT]= CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
146
188
 
 
189
  sql_command_flags[SQLCOM_SHOW_STATUS]=      CF_STATUS_COMMAND;
 
190
  sql_command_flags[SQLCOM_SHOW_DATABASES]=   CF_STATUS_COMMAND;
 
191
  sql_command_flags[SQLCOM_SHOW_OPEN_TABLES]= CF_STATUS_COMMAND;
 
192
  sql_command_flags[SQLCOM_SHOW_FIELDS]=      CF_STATUS_COMMAND;
 
193
  sql_command_flags[SQLCOM_SHOW_KEYS]=        CF_STATUS_COMMAND;
 
194
  sql_command_flags[SQLCOM_SHOW_VARIABLES]=   CF_STATUS_COMMAND;
 
195
  sql_command_flags[SQLCOM_SHOW_CHARSETS]=    CF_STATUS_COMMAND;
 
196
  sql_command_flags[SQLCOM_SHOW_COLLATIONS]=  CF_STATUS_COMMAND;
 
197
  sql_command_flags[SQLCOM_SHOW_BINLOGS]= CF_STATUS_COMMAND;
 
198
  sql_command_flags[SQLCOM_SHOW_SLAVE_HOSTS]= CF_STATUS_COMMAND;
 
199
  sql_command_flags[SQLCOM_SHOW_BINLOG_EVENTS]= CF_STATUS_COMMAND;
147
200
  sql_command_flags[SQLCOM_SHOW_WARNS]= CF_STATUS_COMMAND;
148
201
  sql_command_flags[SQLCOM_SHOW_ERRORS]= CF_STATUS_COMMAND;
 
202
  sql_command_flags[SQLCOM_SHOW_ENGINE_STATUS]= CF_STATUS_COMMAND;
 
203
  sql_command_flags[SQLCOM_SHOW_PROCESSLIST]= CF_STATUS_COMMAND;
149
204
  sql_command_flags[SQLCOM_SHOW_CREATE_DB]=  CF_STATUS_COMMAND;
150
205
  sql_command_flags[SQLCOM_SHOW_CREATE]=  CF_STATUS_COMMAND;
 
206
  sql_command_flags[SQLCOM_SHOW_MASTER_STAT]=  CF_STATUS_COMMAND;
 
207
  sql_command_flags[SQLCOM_SHOW_SLAVE_STAT]=  CF_STATUS_COMMAND;
151
208
 
 
209
   sql_command_flags[SQLCOM_SHOW_TABLES]=       (CF_STATUS_COMMAND |
 
210
                                               CF_SHOW_TABLE_COMMAND);
 
211
  sql_command_flags[SQLCOM_SHOW_TABLE_STATUS]= (CF_STATUS_COMMAND |
 
212
                                                CF_SHOW_TABLE_COMMAND);
152
213
  /*
153
214
    The following admin table operations are allowed
154
215
    on log tables.
155
216
  */
 
217
  sql_command_flags[SQLCOM_REPAIR]=           CF_WRITE_LOGS_COMMAND;
 
218
  sql_command_flags[SQLCOM_OPTIMIZE]=         CF_WRITE_LOGS_COMMAND;
156
219
  sql_command_flags[SQLCOM_ANALYZE]=          CF_WRITE_LOGS_COMMAND;
157
220
}
158
221
 
 
222
 
 
223
bool is_update_query(enum enum_sql_command command)
 
224
{
 
225
  assert(command >= 0 && command <= SQLCOM_END);
 
226
  return (sql_command_flags[command] & CF_CHANGES_DATA) != 0;
 
227
}
 
228
 
 
229
void execute_init_command(THD *thd, sys_var_str *init_command_var,
 
230
                          rw_lock_t *var_mutex)
 
231
{
 
232
  Vio* save_vio;
 
233
  ulong save_client_capabilities;
 
234
 
 
235
  thd_proc_info(thd, "Execution of init_command");
 
236
  /*
 
237
    We need to lock init_command_var because
 
238
    during execution of init_command_var query
 
239
    values of init_command_var can't be changed
 
240
  */
 
241
  rw_rdlock(var_mutex);
 
242
  save_client_capabilities= thd->client_capabilities;
 
243
  thd->client_capabilities|= CLIENT_MULTI_STATEMENTS;
 
244
  /*
 
245
    We don't need return result of execution to client side.
 
246
    To forbid this we should set thd->net.vio to 0.
 
247
  */
 
248
  save_vio= thd->net.vio;
 
249
  thd->net.vio= 0;
 
250
  dispatch_command(COM_QUERY, thd,
 
251
                   init_command_var->value,
 
252
                   init_command_var->value_length);
 
253
  rw_unlock(var_mutex);
 
254
  thd->client_capabilities= save_client_capabilities;
 
255
  thd->net.vio= save_vio;
 
256
}
 
257
 
 
258
/**
 
259
  Ends the current transaction and (maybe) begin the next.
 
260
 
 
261
  @param thd            Current thread
 
262
  @param completion     Completion type
 
263
 
 
264
  @retval
 
265
    0   OK
 
266
*/
 
267
 
 
268
int end_trans(THD *thd, enum enum_mysql_completiontype completion)
 
269
{
 
270
  bool do_release= 0;
 
271
  int res= 0;
 
272
 
 
273
  if (unlikely(thd->in_sub_stmt))
 
274
  {
 
275
    my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
 
276
    return(1);
 
277
  }
 
278
  if (thd->transaction.xid_state.xa_state != XA_NOTR)
 
279
  {
 
280
    my_error(ER_XAER_RMFAIL, MYF(0),
 
281
             xa_state_names[thd->transaction.xid_state.xa_state]);
 
282
    return(1);
 
283
  }
 
284
  switch (completion) {
 
285
  case COMMIT:
 
286
    /*
 
287
     We don't use end_active_trans() here to ensure that this works
 
288
     even if there is a problem with the OPTION_AUTO_COMMIT flag
 
289
     (Which of course should never happen...)
 
290
    */
 
291
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
 
292
    res= ha_commit(thd);
 
293
    thd->options&= ~(OPTION_BEGIN | OPTION_KEEP_LOG);
 
294
    thd->transaction.all.modified_non_trans_table= false;
 
295
    break;
 
296
  case COMMIT_RELEASE:
 
297
    do_release= 1; /* fall through */
 
298
  case COMMIT_AND_CHAIN:
 
299
    res= end_active_trans(thd);
 
300
    if (!res && completion == COMMIT_AND_CHAIN)
 
301
      res= begin_trans(thd);
 
302
    break;
 
303
  case ROLLBACK_RELEASE:
 
304
    do_release= 1; /* fall through */
 
305
  case ROLLBACK:
 
306
  case ROLLBACK_AND_CHAIN:
 
307
  {
 
308
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
 
309
    if (ha_rollback(thd))
 
310
      res= -1;
 
311
    thd->options&= ~(OPTION_BEGIN | OPTION_KEEP_LOG);
 
312
    thd->transaction.all.modified_non_trans_table= false;
 
313
    if (!res && (completion == ROLLBACK_AND_CHAIN))
 
314
      res= begin_trans(thd);
 
315
    break;
 
316
  }
 
317
  default:
 
318
    res= -1;
 
319
    my_error(ER_UNKNOWN_COM_ERROR, MYF(0));
 
320
    return(-1);
 
321
  }
 
322
 
 
323
  if (res < 0)
 
324
    my_error(thd->killed_errno(), MYF(0));
 
325
  else if ((res == 0) && do_release)
 
326
    thd->killed= THD::KILL_CONNECTION;
 
327
 
 
328
  return(res);
 
329
}
 
330
 
 
331
 
 
332
/**
 
333
  Read one command from connection and execute it (query or simple command).
 
334
  This function is called in loop from thread function.
 
335
 
 
336
  For profiling to work, it must never be called recursively.
 
337
 
 
338
  @retval
 
339
    0  success
 
340
  @retval
 
341
    1  request of thread shutdown (see dispatch_command() description)
 
342
*/
 
343
 
 
344
bool do_command(THD *thd)
 
345
{
 
346
  bool return_value;
 
347
  char *packet= 0;
 
348
  ulong packet_length;
 
349
  NET *net= &thd->net;
 
350
  enum enum_server_command command;
 
351
 
 
352
  /*
 
353
    indicator of uninitialized lex => normal flow of errors handling
 
354
    (see my_message_sql)
 
355
  */
 
356
  thd->lex->current_select= 0;
 
357
 
 
358
  /*
 
359
    This thread will do a blocking read from the client which
 
360
    will be interrupted when the next command is received from
 
361
    the client, the connection is closed or "net_wait_timeout"
 
362
    number of seconds has passed
 
363
  */
 
364
  my_net_set_read_timeout(net, thd->variables.net_wait_timeout);
 
365
 
 
366
  /*
 
367
    XXX: this code is here only to clear possible errors of init_connect. 
 
368
    Consider moving to init_connect() instead.
 
369
  */
 
370
  thd->clear_error();                           // Clear error message
 
371
  thd->main_da.reset_diagnostics_area();
 
372
 
 
373
  net_new_transaction(net);
 
374
 
 
375
  packet_length= my_net_read(net);
 
376
  if (packet_length == packet_error)
 
377
  {
 
378
    /* Check if we can continue without closing the connection */
 
379
 
 
380
    /* The error must be set. */
 
381
    assert(thd->is_error());
 
382
    net_end_statement(thd);
 
383
 
 
384
    if (net->error != 3)
 
385
    {
 
386
      return_value= true;                       // We have to close it.
 
387
      goto out;
 
388
    }
 
389
 
 
390
    net->error= 0;
 
391
    return_value= false;
 
392
    goto out;
 
393
  }
 
394
 
 
395
  packet= (char*) net->read_pos;
 
396
  /*
 
397
    'packet_length' contains length of data, as it was stored in packet
 
398
    header. In case of malformed header, my_net_read returns zero.
 
399
    If packet_length is not zero, my_net_read ensures that the returned
 
400
    number of bytes was actually read from network.
 
401
    There is also an extra safety measure in my_net_read:
 
402
    it sets packet[packet_length]= 0, but only for non-zero packets.
 
403
  */
 
404
  if (packet_length == 0)                       /* safety */
 
405
  {
 
406
    /* Initialize with COM_SLEEP packet */
 
407
    packet[0]= (uchar) COM_SLEEP;
 
408
    packet_length= 1;
 
409
  }
 
410
  /* Do not rely on my_net_read, extra safety against programming errors. */
 
411
  packet[packet_length]= '\0';                  /* safety */
 
412
 
 
413
  command= (enum enum_server_command) (uchar) packet[0];
 
414
 
 
415
  if (command >= COM_END)
 
416
    command= COM_END;                           // Wrong command
 
417
 
 
418
  /* Restore read timeout value */
 
419
  my_net_set_read_timeout(net, thd->variables.net_read_timeout);
 
420
 
 
421
  assert(packet_length);
 
422
  return_value= dispatch_command(command, thd, packet+1, (uint) (packet_length-1));
 
423
 
 
424
out:
 
425
  return(return_value);
 
426
}
 
427
 
 
428
/**
 
429
  Determine if an attempt to update a non-temporary table while the
 
430
  read-only option was enabled has been made.
 
431
 
 
432
  This is a helper function to mysql_execute_command.
 
433
 
 
434
  @note SQLCOM_MULTI_UPDATE is an exception and dealt with elsewhere.
 
435
 
 
436
  @see mysql_execute_command
 
437
 
 
438
  @returns Status code
 
439
    @retval true The statement should be denied.
 
440
    @retval false The statement isn't updating any relevant tables.
 
441
*/
 
442
 
 
443
static bool deny_updates_if_read_only_option(THD *thd,
 
444
                                                TableList *all_tables)
 
445
{
 
446
  if (!opt_readonly)
 
447
    return(false);
 
448
 
 
449
  LEX *lex= thd->lex;
 
450
 
 
451
  if (!(sql_command_flags[lex->sql_command] & CF_CHANGES_DATA))
 
452
    return(false);
 
453
 
 
454
  /* Multi update is an exception and is dealt with later. */
 
455
  if (lex->sql_command == SQLCOM_UPDATE_MULTI)
 
456
    return(false);
 
457
 
 
458
  const bool create_temp_tables= 
 
459
    (lex->sql_command == SQLCOM_CREATE_TABLE) &&
 
460
    (lex->create_info.options & HA_LEX_CREATE_TMP_TABLE);
 
461
 
 
462
  const bool drop_temp_tables= 
 
463
    (lex->sql_command == SQLCOM_DROP_TABLE) &&
 
464
    lex->drop_temporary;
 
465
 
 
466
  const bool update_real_tables=
 
467
    some_non_temp_table_to_be_updated(thd, all_tables) &&
 
468
    !(create_temp_tables || drop_temp_tables);
 
469
 
 
470
 
 
471
  const bool create_or_drop_databases=
 
472
    (lex->sql_command == SQLCOM_CREATE_DB) ||
 
473
    (lex->sql_command == SQLCOM_DROP_DB);
 
474
 
 
475
  if (update_real_tables || create_or_drop_databases)
 
476
  {
 
477
      /*
 
478
        An attempt was made to modify one or more non-temporary tables.
 
479
      */
 
480
      return(true);
 
481
  }
 
482
 
 
483
 
 
484
  /* Assuming that only temporary tables are modified. */
 
485
  return(false);
 
486
}
 
487
 
159
488
/**
160
489
  Perform one connection-level (COM_XXXX) command.
161
490
 
162
491
  @param command         type of command to perform
163
 
  @param session             connection handle
 
492
  @param thd             connection handle
164
493
  @param packet          data for the command, packet is always null-terminated
165
494
  @param packet_length   length of packet + 1 (to show that data is
166
495
                         null-terminated) except for COM_SLEEP, where it
167
496
                         can be zero.
168
497
 
169
498
  @todo
170
 
    set session->lex->sql_command to SQLCOM_END here.
 
499
    set thd->lex->sql_command to SQLCOM_END here.
171
500
  @todo
172
501
    The following has to be changed to an 8 byte integer
173
502
 
177
506
    1   request of thread shutdown, i. e. if command is
178
507
        COM_QUIT/COM_SHUTDOWN
179
508
*/
180
 
bool dispatch_command(enum enum_server_command command, Session *session,
181
 
                      char* packet, uint32_t packet_length)
 
509
bool dispatch_command(enum enum_server_command command, THD *thd,
 
510
                      char* packet, uint packet_length)
182
511
{
 
512
  NET *net= &thd->net;
183
513
  bool error= 0;
184
 
  Query_id &query_id= Query_id::get_query_id();
185
 
 
186
 
  DRIZZLE_COMMAND_START(session->thread_id, command);
187
 
 
188
 
  session->command= command;
189
 
  session->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
190
 
  session->set_time();
191
 
  session->setQueryId(query_id.value());
 
514
 
 
515
  thd->command=command;
 
516
  /*
 
517
    Commands which always take a long time are logged into
 
518
    the slow log only if opt_log_slow_admin_statements is set.
 
519
  */
 
520
  thd->enable_slow_log= true;
 
521
  thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
 
522
  thd->set_time();
 
523
  VOID(pthread_mutex_lock(&LOCK_thread_count));
 
524
  thd->query_id= global_query_id;
192
525
 
193
526
  switch( command ) {
194
527
  /* Ignore these statements. */
196
529
    break;
197
530
  /* Increase id and count all other statements. */
198
531
  default:
199
 
    session->status_var.questions++;
200
 
    query_id.next();
201
 
  }
202
 
 
203
 
  /* @todo set session->lex->sql_command to SQLCOM_END here */
204
 
 
205
 
  plugin::Logging::preDo(session);
206
 
  if (unlikely(plugin::EventObserver::beforeStatement(*session)))
207
 
  {
208
 
    // We should do something about an error...
209
 
  }
210
 
 
211
 
  session->server_status&=
 
532
    statistic_increment(thd->status_var.questions, &LOCK_status);
 
533
    next_query_id();
 
534
  }
 
535
 
 
536
  thread_running++;
 
537
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
 
538
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
 
539
 
 
540
  thd->server_status&=
212
541
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
213
542
  switch (command) {
214
543
  case COM_INIT_DB:
215
544
  {
216
 
    if (packet_length == 0)
217
 
    {
218
 
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
219
 
      break;
220
 
    }
221
 
 
222
 
    string tmp(packet, packet_length);
223
 
 
224
 
    identifier::Schema identifier(tmp);
225
 
 
226
 
    if (not change_db(session, identifier))
227
 
    {
228
 
      session->my_ok();
 
545
    LEX_STRING tmp;
 
546
    status_var_increment(thd->status_var.com_stat[SQLCOM_CHANGE_DB]);
 
547
    thd->convert_string(&tmp, system_charset_info,
 
548
                        packet, packet_length, thd->charset());
 
549
    if (!mysql_change_db(thd, &tmp, false))
 
550
    {
 
551
      general_log_write(thd, command, thd->db, thd->db_length);
 
552
      my_ok(thd);
 
553
    }
 
554
    break;
 
555
  }
 
556
  case COM_REGISTER_SLAVE:
 
557
  {
 
558
    if (!register_slave(thd, (uchar*)packet, packet_length))
 
559
      my_ok(thd);
 
560
    break;
 
561
  }
 
562
  case COM_CHANGE_USER:
 
563
  {
 
564
    status_var_increment(thd->status_var.com_other);
 
565
    char *user= (char*) packet, *packet_end= packet + packet_length;
 
566
    /* Safe because there is always a trailing \0 at the end of the packet */
 
567
    char *passwd= strend(user)+1;
 
568
 
 
569
 
 
570
    thd->clear_error();                         // if errors from rollback
 
571
 
 
572
    /*
 
573
      Old clients send null-terminated string ('\0' for empty string) for
 
574
      password.  New clients send the size (1 byte) + string (not null
 
575
      terminated, so also '\0' for empty string).
 
576
 
 
577
      Cast *passwd to an unsigned char, so that it doesn't extend the sign
 
578
      for *passwd > 127 and become 2**32-127 after casting to uint.
 
579
    */
 
580
    char db_buff[NAME_LEN+1];                 // buffer to store db in utf8
 
581
    char *db= passwd;
 
582
    char *save_db;
 
583
    /*
 
584
      If there is no password supplied, the packet must contain '\0',
 
585
      in any type of handshake (4.1 or pre-4.1).
 
586
     */
 
587
    if (passwd >= packet_end)
 
588
    {
 
589
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
 
590
      break;
 
591
    }
 
592
    uint passwd_len= (thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
 
593
                      (uchar)(*passwd++) : strlen(passwd));
 
594
    uint dummy_errors, save_db_length, db_length;
 
595
    int res;
 
596
    Security_context save_security_ctx= *thd->security_ctx;
 
597
    USER_CONN *save_user_connect;
 
598
 
 
599
    db+= passwd_len + 1;
 
600
    /*
 
601
      Database name is always NUL-terminated, so in case of empty database
 
602
      the packet must contain at least the trailing '\0'.
 
603
    */
 
604
    if (db >= packet_end)
 
605
    {
 
606
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
 
607
      break;
 
608
    }
 
609
    db_length= strlen(db);
 
610
 
 
611
    char *ptr= db + db_length + 1;
 
612
    uint cs_number= 0;
 
613
 
 
614
    if (ptr < packet_end)
 
615
    {
 
616
      if (ptr + 2 > packet_end)
 
617
      {
 
618
        my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
 
619
        break;
 
620
      }
 
621
 
 
622
      cs_number= uint2korr(ptr);
 
623
    }
 
624
 
 
625
    /* Convert database name to utf8 */
 
626
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
 
627
                             system_charset_info, db, db_length,
 
628
                             thd->charset(), &dummy_errors)]= 0;
 
629
    db= db_buff;
 
630
 
 
631
    /* Save user and privileges */
 
632
    save_db_length= thd->db_length;
 
633
    save_db= thd->db;
 
634
    save_user_connect= thd->user_connect;
 
635
 
 
636
    if (!(thd->security_ctx->user= my_strdup(user, MYF(0))))
 
637
    {
 
638
      thd->security_ctx->user= save_security_ctx.user;
 
639
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
 
640
      break;
 
641
    }
 
642
 
 
643
    /* Clear variables that are allocated */
 
644
    thd->user_connect= 0;
 
645
    res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, false);
 
646
 
 
647
    if (res)
 
648
    {
 
649
      x_free(thd->security_ctx->user);
 
650
      *thd->security_ctx= save_security_ctx;
 
651
      thd->user_connect= save_user_connect;
 
652
      thd->db= save_db;
 
653
      thd->db_length= save_db_length;
 
654
    }
 
655
    else
 
656
    {
 
657
      x_free(save_db);
 
658
      x_free(save_security_ctx.user);
 
659
 
 
660
      if (cs_number)
 
661
      {
 
662
        thd_init_client_charset(thd, cs_number);
 
663
        thd->update_charset();
 
664
      }
229
665
    }
230
666
    break;
231
667
  }
232
668
  case COM_QUERY:
233
669
  {
234
 
    if (not session->readAndStoreQuery(packet, packet_length))
 
670
    if (alloc_query(thd, packet, packet_length))
235
671
      break;                                    // fatal error is set
236
 
    DRIZZLE_QUERY_START(session->getQueryString()->c_str(),
237
 
                        session->thread_id,
238
 
                        const_cast<const char *>(session->schema()->c_str()));
239
 
 
240
 
    parse(session, session->getQueryString()->c_str(), session->getQueryString()->length());
241
 
 
 
672
    char *packet_end= thd->query + thd->query_length;
 
673
    const char* end_of_stmt= NULL;
 
674
 
 
675
    general_log_write(thd, command, thd->query, thd->query_length);
 
676
 
 
677
    mysql_parse(thd, thd->query, thd->query_length, &end_of_stmt);
 
678
 
 
679
    while (!thd->killed && (end_of_stmt != NULL) && ! thd->is_error())
 
680
    {
 
681
      char *beginning_of_next_stmt= (char*) end_of_stmt;
 
682
 
 
683
      net_end_statement(thd);
 
684
      /*
 
685
        Multiple queries exits, execute them individually
 
686
      */
 
687
      close_thread_tables(thd);
 
688
      ulong length= (ulong)(packet_end - beginning_of_next_stmt);
 
689
 
 
690
      log_slow_statement(thd);
 
691
 
 
692
      /* Remove garbage at start of query */
 
693
      while (length > 0 && my_isspace(thd->charset(), *beginning_of_next_stmt))
 
694
      {
 
695
        beginning_of_next_stmt++;
 
696
        length--;
 
697
      }
 
698
 
 
699
      VOID(pthread_mutex_lock(&LOCK_thread_count));
 
700
      thd->query_length= length;
 
701
      thd->query= beginning_of_next_stmt;
 
702
      /*
 
703
        Count each statement from the client.
 
704
      */
 
705
      statistic_increment(thd->status_var.questions, &LOCK_status);
 
706
      thd->query_id= next_query_id();
 
707
      thd->set_time(); /* Reset the query start time. */
 
708
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
 
709
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
 
710
 
 
711
      mysql_parse(thd, beginning_of_next_stmt, length, &end_of_stmt);
 
712
    }
 
713
    break;
 
714
  }
 
715
  case COM_FIELD_LIST:                          // This isn't actually needed
 
716
  {
 
717
    char *fields, *packet_end= packet + packet_length, *arg_end;
 
718
    /* Locked closure of all tables */
 
719
    TableList table_list;
 
720
    LEX_STRING conv_name;
 
721
 
 
722
    /* used as fields initializator */
 
723
    lex_start(thd);
 
724
 
 
725
    status_var_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS]);
 
726
    memset(&table_list, 0, sizeof(table_list));
 
727
    if (thd->copy_db_to(&table_list.db, &table_list.db_length))
 
728
      break;
 
729
    /*
 
730
      We have name + wildcard in packet, separated by endzero
 
731
    */
 
732
    arg_end= strend(packet);
 
733
    thd->convert_string(&conv_name, system_charset_info,
 
734
                        packet, (uint) (arg_end - packet), thd->charset());
 
735
    table_list.alias= table_list.table_name= conv_name.str;
 
736
    packet= arg_end + 1;
 
737
 
 
738
    if (!my_strcasecmp(system_charset_info, table_list.db,
 
739
                       INFORMATION_SCHEMA_NAME.str))
 
740
    {
 
741
      ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, table_list.alias);
 
742
      if (schema_table)
 
743
        table_list.schema_table= schema_table;
 
744
    }
 
745
 
 
746
    thd->query_length= (uint) (packet_end - packet); // Don't count end \0
 
747
    if (!(thd->query=fields= (char*) thd->memdup(packet,thd->query_length+1)))
 
748
      break;
 
749
    general_log_print(thd, command, "%s %s", table_list.table_name, fields);
 
750
    if (lower_case_table_names)
 
751
      my_casedn_str(files_charset_info, table_list.table_name);
 
752
 
 
753
    /* init structures for VIEW processing */
 
754
    table_list.select_lex= &(thd->lex->select_lex);
 
755
 
 
756
    lex_start(thd);
 
757
    mysql_reset_thd_for_next_command(thd);
 
758
 
 
759
    thd->lex->
 
760
      select_lex.table_list.link_in_list((uchar*) &table_list,
 
761
                                         (uchar**) &table_list.next_local);
 
762
    thd->lex->add_to_query_tables(&table_list);
 
763
 
 
764
    /* switch on VIEW optimisation: do not fill temporary tables */
 
765
    thd->lex->sql_command= SQLCOM_SHOW_FIELDS;
 
766
    mysqld_list_fields(thd,&table_list,fields);
 
767
    thd->lex->unit.cleanup();
 
768
    thd->cleanup_after_query();
242
769
    break;
243
770
  }
244
771
  case COM_QUIT:
245
772
    /* We don't calculate statistics for this command */
246
 
    session->main_da.disable_status();              // Don't send anything back
 
773
    general_log_print(thd, command, NullS);
 
774
    net->error=0;                               // Don't give 'abort' message
 
775
    thd->main_da.disable_status();              // Don't send anything back
247
776
    error=true;                                 // End server
248
777
    break;
 
778
  case COM_BINLOG_DUMP:
 
779
    {
 
780
      ulong pos;
 
781
      ushort flags;
 
782
      uint32_t slave_server_id;
 
783
 
 
784
      status_var_increment(thd->status_var.com_other);
 
785
      thd->enable_slow_log= opt_log_slow_admin_statements;
 
786
      /* TODO: The following has to be changed to an 8 byte integer */
 
787
      pos = uint4korr(packet);
 
788
      flags = uint2korr(packet + 4);
 
789
      thd->server_id=0; /* avoid suicide */
 
790
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
 
791
        kill_zombie_dump_threads(slave_server_id);
 
792
      thd->server_id = slave_server_id;
 
793
 
 
794
      general_log_print(thd, command, "Log: '%s'  Pos: %ld", packet+10,
 
795
                      (long) pos);
 
796
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
 
797
      unregister_slave(thd,1,1);
 
798
      /*  fake COM_QUIT -- if we get here, the thread needs to terminate */
 
799
      error = true;
 
800
      break;
 
801
    }
249
802
  case COM_SHUTDOWN:
250
803
  {
251
 
    session->status_var.com_other++;
252
 
    session->my_eof();
253
 
    session->close_thread_tables();                     // Free before kill
254
 
    kill_drizzle();
 
804
    status_var_increment(thd->status_var.com_other);
 
805
    /*
 
806
      If the client is < 4.1.3, it is going to send us no argument; then
 
807
      packet_length is 0, packet[0] is the end 0 of the packet. Note that
 
808
      SHUTDOWN_DEFAULT is 0. If client is >= 4.1.3, the shutdown level is in
 
809
      packet[0].
 
810
    */
 
811
    enum drizzle_enum_shutdown_level level=
 
812
      (enum drizzle_enum_shutdown_level) (uchar) packet[0];
 
813
    if (level == SHUTDOWN_DEFAULT)
 
814
      level= SHUTDOWN_WAIT_ALL_BUFFERS; // soon default will be configurable
 
815
    else if (level != SHUTDOWN_WAIT_ALL_BUFFERS)
 
816
    {
 
817
      my_error(ER_NOT_SUPPORTED_YET, MYF(0), "this shutdown level");
 
818
      break;
 
819
    }
 
820
    general_log_print(thd, command, NullS);
 
821
    my_eof(thd);
 
822
    close_thread_tables(thd);                   // Free before kill
 
823
    kill_mysql();
255
824
    error=true;
256
825
    break;
257
826
  }
258
827
  case COM_PING:
259
 
    session->status_var.com_other++;
260
 
    session->my_ok();                           // Tell client we are alive
261
 
    break;
 
828
    status_var_increment(thd->status_var.com_other);
 
829
    my_ok(thd);                         // Tell client we are alive
 
830
    break;
 
831
  case COM_PROCESS_INFO:
 
832
    status_var_increment(thd->status_var.com_stat[SQLCOM_SHOW_PROCESSLIST]);
 
833
    general_log_print(thd, command, NullS);
 
834
    mysqld_list_processes(thd, NullS, 0);
 
835
    break;
 
836
  case COM_PROCESS_KILL:
 
837
  {
 
838
    status_var_increment(thd->status_var.com_stat[SQLCOM_KILL]);
 
839
    ulong id=(ulong) uint4korr(packet);
 
840
    sql_kill(thd,id,false);
 
841
    break;
 
842
  }
 
843
  case COM_SET_OPTION:
 
844
  {
 
845
    status_var_increment(thd->status_var.com_stat[SQLCOM_SET_OPTION]);
 
846
    uint opt_command= uint2korr(packet);
 
847
 
 
848
    switch (opt_command) {
 
849
    case (int) DRIZZLE_OPTION_MULTI_STATEMENTS_ON:
 
850
      thd->client_capabilities|= CLIENT_MULTI_STATEMENTS;
 
851
      my_eof(thd);
 
852
      break;
 
853
    case (int) DRIZZLE_OPTION_MULTI_STATEMENTS_OFF:
 
854
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
 
855
      my_eof(thd);
 
856
      break;
 
857
    default:
 
858
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
 
859
      break;
 
860
    }
 
861
    break;
 
862
  }
262
863
  case COM_SLEEP:
263
864
  case COM_CONNECT:                             // Impossible here
 
865
  case COM_TIME:                                // Impossible from client
264
866
  case COM_END:
265
867
  default:
266
868
    my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
268
870
  }
269
871
 
270
872
  /* If commit fails, we should be able to reset the OK status. */
271
 
  session->main_da.can_overwrite_status= true;
272
 
  TransactionServices &transaction_services= TransactionServices::singleton();
273
 
  transaction_services.autocommitOrRollback(*session, session->is_error());
274
 
  session->main_da.can_overwrite_status= false;
 
873
  thd->main_da.can_overwrite_status= true;
 
874
  ha_autocommit_or_rollback(thd, thd->is_error());
 
875
  thd->main_da.can_overwrite_status= false;
275
876
 
276
 
  session->transaction.stmt.reset();
 
877
  thd->transaction.stmt.reset();
277
878
 
278
879
 
279
880
  /* report error issued during command execution */
280
 
  if (session->killed_errno())
281
 
  {
282
 
    if (! session->main_da.is_set())
283
 
      session->send_kill_message();
284
 
  }
285
 
  if (session->getKilled() == Session::KILL_QUERY || session->getKilled() == Session::KILL_BAD_DATA)
286
 
  {
287
 
    session->setKilled(Session::NOT_KILLED);
288
 
    session->setAbort(false);
289
 
  }
290
 
 
291
 
  /* Can not be true, but do not take chances in production. */
292
 
  assert(! session->main_da.is_sent);
293
 
 
294
 
  switch (session->main_da.status())
295
 
  {
296
 
  case Diagnostics_area::DA_ERROR:
297
 
    /* The query failed, send error to log and abort bootstrap. */
298
 
    session->getClient()->sendError(session->main_da.sql_errno(),
299
 
                               session->main_da.message());
300
 
    break;
301
 
 
302
 
  case Diagnostics_area::DA_EOF:
303
 
    session->getClient()->sendEOF();
304
 
    break;
305
 
 
306
 
  case Diagnostics_area::DA_OK:
307
 
    session->getClient()->sendOK();
308
 
    break;
309
 
 
310
 
  case Diagnostics_area::DA_DISABLED:
311
 
    break;
312
 
 
313
 
  case Diagnostics_area::DA_EMPTY:
314
 
  default:
315
 
    session->getClient()->sendOK();
316
 
    break;
317
 
  }
318
 
 
319
 
  session->main_da.is_sent= true;
320
 
 
321
 
  session->set_proc_info("closing tables");
 
881
  if (thd->killed_errno())
 
882
  {
 
883
    if (! thd->main_da.is_set())
 
884
      thd->send_kill_message();
 
885
  }
 
886
  if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
 
887
  {
 
888
    thd->killed= THD::NOT_KILLED;
 
889
    thd->mysys_var->abort= 0;
 
890
  }
 
891
 
 
892
  net_end_statement(thd);
 
893
 
 
894
  thd->proc_info= "closing tables";
322
895
  /* Free tables */
323
 
  session->close_thread_tables();
324
 
 
325
 
  plugin::Logging::postDo(session);
326
 
  if (unlikely(plugin::EventObserver::afterStatement(*session)))
327
 
  {
328
 
    // We should do something about an error...
329
 
  }
330
 
 
331
 
  /* Store temp state for processlist */
332
 
  session->set_proc_info("cleaning up");
333
 
  session->command= COM_SLEEP;
334
 
  session->resetQueryString();
335
 
 
336
 
  session->set_proc_info(NULL);
337
 
  session->mem_root->free_root(MYF(memory::KEEP_PREALLOC));
338
 
 
339
 
  if (DRIZZLE_QUERY_DONE_ENABLED() || DRIZZLE_COMMAND_DONE_ENABLED())
340
 
  {
341
 
    if (command == COM_QUERY)
 
896
  close_thread_tables(thd);
 
897
 
 
898
  log_slow_statement(thd);
 
899
 
 
900
  thd_proc_info(thd, "cleaning up");
 
901
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
 
902
  thd_proc_info(thd, 0);
 
903
  thd->command=COM_SLEEP;
 
904
  thd->query=0;
 
905
  thd->query_length=0;
 
906
  thread_running--;
 
907
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
 
908
  thd->packet.shrink(thd->variables.net_buffer_length); // Reclaim some memory
 
909
  free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
 
910
  return(error);
 
911
}
 
912
 
 
913
 
 
914
void log_slow_statement(THD *thd)
 
915
{
 
916
  /*
 
917
    The following should never be true with our current code base,
 
918
    but better to keep this here so we don't accidently try to log a
 
919
    statement in a trigger or stored function
 
920
  */
 
921
  if (unlikely(thd->in_sub_stmt))
 
922
    return;                           // Don't set time for sub stmt
 
923
 
 
924
  /*
 
925
    Do not log administrative statements unless the appropriate option is
 
926
    set; do not log into slow log if reading from backup.
 
927
  */
 
928
  if (thd->enable_slow_log && !thd->user_time)
 
929
  {
 
930
    thd_proc_info(thd, "logging slow query");
 
931
    uint64_t end_utime_of_query= thd->current_utime();
 
932
 
 
933
    if (((end_utime_of_query - thd->utime_after_lock) >
 
934
         thd->variables.long_query_time ||
 
935
         ((thd->server_status &
 
936
           (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
 
937
          opt_log_queries_not_using_indexes &&
 
938
           !(sql_command_flags[thd->lex->sql_command] & CF_STATUS_COMMAND))) &&
 
939
        thd->examined_row_count >= thd->variables.min_examined_row_limit)
342
940
    {
343
 
      DRIZZLE_QUERY_DONE(session->is_error());
 
941
      thd_proc_info(thd, "logging slow query");
 
942
      thd->status_var.long_query_count++;
 
943
      slow_log_print(thd, thd->query, thd->query_length, end_utime_of_query);
344
944
    }
345
 
    DRIZZLE_COMMAND_DONE(session->is_error());
346
945
  }
347
 
 
348
 
  return error;
 
946
  return;
349
947
}
350
948
 
351
949
 
354
952
 
355
953
    This function is used in the parser to convert a SHOW or DESCRIBE
356
954
    table_name command to a SELECT from INFORMATION_SCHEMA.
357
 
    It prepares a Select_Lex and a TableList object to represent the
 
955
    It prepares a SELECT_LEX and a TableList object to represent the
358
956
    given command as a SELECT parse tree.
359
957
 
360
 
  @param session           thread handle
361
 
  @param lex               current lex
362
 
  @param table_ident       table alias if it's used
363
 
  @param schema_table_name the name of the INFORMATION_SCHEMA table to be
364
 
                           created
 
958
  @param thd              thread handle
 
959
  @param lex              current lex
 
960
  @param table_ident      table alias if it's used
 
961
  @param schema_table_idx the type of the INFORMATION_SCHEMA table to be
 
962
                          created
365
963
 
366
964
  @note
367
965
    Due to the way this function works with memory and LEX it cannot
374
972
    1                 out of memory or SHOW commands are not allowed
375
973
                      in this version of the server.
376
974
*/
377
 
static bool _schema_select(Session *session, Select_Lex *sel,
378
 
                           const string& schema_table_name)
 
975
 
 
976
int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,
 
977
                         enum enum_schema_tables schema_table_idx)
379
978
{
380
 
  LEX_STRING db, table;
381
 
  bitset<NUM_OF_TABLE_OPTIONS> table_options;
382
 
  /*
383
 
     We have to make non const db_name & table_name
384
 
     because of lower_case_table_names
385
 
  */
386
 
  session->make_lex_string(&db, "data_dictionary", sizeof("data_dictionary"), false);
387
 
  session->make_lex_string(&table, schema_table_name, false);
388
 
 
389
 
  if (! sel->add_table_to_list(session, new Table_ident(db, table),
390
 
                               NULL, table_options, TL_READ))
 
979
  SELECT_LEX *schema_select_lex= NULL;
 
980
 
 
981
  switch (schema_table_idx) {
 
982
  case SCH_SCHEMATA:
 
983
    break;
 
984
  case SCH_TABLE_NAMES:
 
985
  case SCH_TABLES:
 
986
    {
 
987
      LEX_STRING db;
 
988
      size_t dummy;
 
989
      if (lex->select_lex.db == NULL &&
 
990
          lex->copy_db_to(&lex->select_lex.db, &dummy))
 
991
      {
 
992
        return(1);
 
993
      }
 
994
      schema_select_lex= new SELECT_LEX();
 
995
      db.str= schema_select_lex->db= lex->select_lex.db;
 
996
      schema_select_lex->table_list.first= NULL;
 
997
      db.length= strlen(db.str);
 
998
 
 
999
      if (check_db_name(&db))
 
1000
      {
 
1001
        my_error(ER_WRONG_DB_NAME, MYF(0), db.str);
 
1002
        return(1);
 
1003
      }
 
1004
      break;
 
1005
    }
 
1006
  case SCH_COLUMNS:
 
1007
  case SCH_STATISTICS:
391
1008
  {
392
 
    return true;
393
 
  }
394
 
  return false;
395
 
}
396
 
 
397
 
int prepare_new_schema_table(Session *session, LEX *lex,
398
 
                             const string& schema_table_name)
399
 
{
400
 
  Select_Lex *schema_select_lex= NULL;
401
 
 
402
 
  Select_Lex *select_lex= lex->current_select;
 
1009
    assert(table_ident);
 
1010
    TableList **query_tables_last= lex->query_tables_last;
 
1011
    schema_select_lex= new SELECT_LEX();
 
1012
    /* 'parent_lex' is used in init_query() so it must be before it. */
 
1013
    schema_select_lex->parent_lex= lex;
 
1014
    schema_select_lex->init_query();
 
1015
    if (!schema_select_lex->add_table_to_list(thd, table_ident, 0, 0, TL_READ))
 
1016
      return(1);
 
1017
    lex->query_tables_last= query_tables_last;
 
1018
    break;
 
1019
  }
 
1020
  case SCH_OPEN_TABLES:
 
1021
  case SCH_VARIABLES:
 
1022
  case SCH_STATUS:
 
1023
  case SCH_CHARSETS:
 
1024
  case SCH_COLLATIONS:
 
1025
  case SCH_COLLATION_CHARACTER_SET_APPLICABILITY:
 
1026
  case SCH_TABLE_CONSTRAINTS:
 
1027
  case SCH_KEY_COLUMN_USAGE:
 
1028
  default:
 
1029
    break;
 
1030
  }
 
1031
  
 
1032
  SELECT_LEX *select_lex= lex->current_select;
403
1033
  assert(select_lex);
404
 
  if (_schema_select(session, select_lex, schema_table_name))
 
1034
  if (make_schema_select(thd, select_lex, schema_table_idx))
405
1035
  {
406
1036
    return(1);
407
1037
  }
408
1038
  TableList *table_list= (TableList*) select_lex->table_list.first;
409
1039
  assert(table_list);
410
1040
  table_list->schema_select_lex= schema_select_lex;
411
 
 
412
 
  return 0;
413
 
}
414
 
 
415
 
/**
416
 
  Execute command saved in session and lex->sql_command.
 
1041
  table_list->schema_table_reformed= 1;
 
1042
  return(0);
 
1043
}
 
1044
 
 
1045
 
 
1046
/**
 
1047
  Read query from packet and store in thd->query.
 
1048
  Used in COM_QUERY and COM_STMT_PREPARE.
 
1049
 
 
1050
    Sets the following THD variables:
 
1051
  - query
 
1052
  - query_length
 
1053
 
 
1054
  @retval
 
1055
    false ok
 
1056
  @retval
 
1057
    true  error;  In this case thd->fatal_error is set
 
1058
*/
 
1059
 
 
1060
bool alloc_query(THD *thd, const char *packet, uint packet_length)
 
1061
{
 
1062
  /* Remove garbage at start and end of query */
 
1063
  while (packet_length > 0 && my_isspace(thd->charset(), packet[0]))
 
1064
  {
 
1065
    packet++;
 
1066
    packet_length--;
 
1067
  }
 
1068
  const char *pos= packet + packet_length;     // Point at end null
 
1069
  while (packet_length > 0 &&
 
1070
         (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
 
1071
  {
 
1072
    pos--;
 
1073
    packet_length--;
 
1074
  }
 
1075
  /* We must allocate some extra memory for query cache */
 
1076
  thd->query_length= 0;                        // Extra safety: Avoid races
 
1077
  if (!(thd->query= (char*) thd->memdup_w_gap((uchar*) (packet),
 
1078
                                              packet_length,
 
1079
                                              thd->db_length+ 1)))
 
1080
    return true;
 
1081
  thd->query[packet_length]=0;
 
1082
  thd->query_length= packet_length;
 
1083
 
 
1084
  /* Reclaim some memory */
 
1085
  thd->packet.shrink(thd->variables.net_buffer_length);
 
1086
  thd->convert_buffer.shrink(thd->variables.net_buffer_length);
 
1087
 
 
1088
  return false;
 
1089
}
 
1090
 
 
1091
static void reset_one_shot_variables(THD *thd) 
 
1092
{
 
1093
  thd->variables.character_set_client=
 
1094
    global_system_variables.character_set_client;
 
1095
  thd->variables.collation_connection=
 
1096
    global_system_variables.collation_connection;
 
1097
  thd->variables.collation_database=
 
1098
    global_system_variables.collation_database;
 
1099
  thd->variables.collation_server=
 
1100
    global_system_variables.collation_server;
 
1101
  thd->update_charset();
 
1102
  thd->variables.time_zone=
 
1103
    global_system_variables.time_zone;
 
1104
  thd->variables.lc_time_names= &my_locale_en_US;
 
1105
  thd->one_shot_set= 0;
 
1106
}
 
1107
 
 
1108
 
 
1109
/**
 
1110
  Execute command saved in thd and lex->sql_command.
417
1111
 
418
1112
    Before every operation that can request a write lock for a table
419
1113
    wait if a global read lock exists. However do not wait if this
425
1119
    global read lock when it succeeds. This needs to be released by
426
1120
    start_waiting_global_read_lock() after the operation.
427
1121
 
428
 
  @param session                       Thread handle
 
1122
  @param thd                       Thread handle
429
1123
 
430
1124
  @todo
431
1125
    - Invalidate the table in the query cache if something changed
442
1136
    true        Error
443
1137
*/
444
1138
 
445
 
static int execute_command(Session *session)
 
1139
int
 
1140
mysql_execute_command(THD *thd)
446
1141
{
447
 
  bool res= false;
448
 
  LEX  *lex= session->lex;
449
 
  /* first Select_Lex (have special meaning for many of non-SELECTcommands) */
450
 
  Select_Lex *select_lex= &lex->select_lex;
 
1142
  int res= false;
 
1143
  bool need_start_waiting= false; // have protection against global read lock
 
1144
  int  up_result= 0;
 
1145
  LEX  *lex= thd->lex;
 
1146
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
 
1147
  SELECT_LEX *select_lex= &lex->select_lex;
 
1148
  /* first table of first SELECT_LEX */
 
1149
  TableList *first_table= (TableList*) select_lex->table_list.first;
451
1150
  /* list of all tables in query */
452
1151
  TableList *all_tables;
 
1152
  /* most outer SELECT_LEX_UNIT of query */
 
1153
  SELECT_LEX_UNIT *unit= &lex->unit;
 
1154
  /* Saved variable value */
453
1155
 
454
1156
  /*
455
 
    In many cases first table of main Select_Lex have special meaning =>
456
 
    check that it is first table in global list and relink it first in
 
1157
    In many cases first table of main SELECT_LEX have special meaning =>
 
1158
    check that it is first table in global list and relink it first in 
457
1159
    queries_tables list if it is necessary (we need such relinking only
458
1160
    for queries with subqueries in select list, in this case tables of
459
1161
    subqueries will go to global list first)
460
1162
 
461
 
    all_tables will differ from first_table only if most upper Select_Lex
 
1163
    all_tables will differ from first_table only if most upper SELECT_LEX
462
1164
    do not contain tables.
463
1165
 
464
1166
    Because of above in place where should be at least one table in most
465
 
    outer Select_Lex we have following check:
 
1167
    outer SELECT_LEX we have following check:
466
1168
    assert(first_table == all_tables);
467
1169
    assert(first_table == all_tables && first_table != 0);
468
1170
  */
481
1183
    variables, but for now this is probably good enough.
482
1184
    Don't reset warnings when executing a stored routine.
483
1185
  */
484
 
  if (all_tables || ! lex->is_single_level_stmt())
485
 
  {
486
 
    drizzle_reset_errors(session, 0);
487
 
  }
488
 
 
489
 
  assert(session->transaction.stmt.hasModifiedNonTransData() == false);
490
 
 
491
 
  if (! (session->server_status & SERVER_STATUS_AUTOCOMMIT)
492
 
      && ! session->inTransaction()
493
 
      && lex->statement->isTransactional())
494
 
  {
495
 
    if (session->startTransaction() == false)
496
 
    {
497
 
      my_error(drizzled::ER_UNKNOWN_ERROR, MYF(0));
498
 
      return true;
499
 
    }
500
 
  }
501
 
 
502
 
  /* now we are ready to execute the statement */
503
 
  res= lex->statement->execute();
504
 
  session->set_proc_info("query end");
 
1186
  if (all_tables || !lex->is_single_level_stmt())
 
1187
    drizzle_reset_errors(thd, 0);
 
1188
 
 
1189
  if (unlikely(thd->slave_thread))
 
1190
  {
 
1191
    /*
 
1192
      Check if statment should be skipped because of slave filtering
 
1193
      rules
 
1194
 
 
1195
      Exceptions are:
 
1196
      - UPDATE MULTI: For this statement, we want to check the filtering
 
1197
        rules later in the code
 
1198
      - SET: we always execute it (Not that many SET commands exists in
 
1199
        the binary log anyway -- only 4.1 masters write SET statements,
 
1200
        in 5.0 there are no SET statements in the binary log)
 
1201
      - DROP TEMPORARY TABLE IF EXISTS: we always execute it (otherwise we
 
1202
        have stale files on slave caused by exclusion of one tmp table).
 
1203
    */
 
1204
    if (!(lex->sql_command == SQLCOM_UPDATE_MULTI) &&
 
1205
        !(lex->sql_command == SQLCOM_SET_OPTION) &&
 
1206
        !(lex->sql_command == SQLCOM_DROP_TABLE &&
 
1207
          lex->drop_temporary && lex->drop_if_exists) &&
 
1208
        all_tables_not_ok(thd, all_tables))
 
1209
    {
 
1210
      /* we warn the slave SQL thread */
 
1211
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
 
1212
      if (thd->one_shot_set)
 
1213
      {
 
1214
        /*
 
1215
          It's ok to check thd->one_shot_set here:
 
1216
 
 
1217
          The charsets in a MySQL 5.0 slave can change by both a binlogged
 
1218
          SET ONE_SHOT statement and the event-internal charset setting, 
 
1219
          and these two ways to change charsets do not seems to work
 
1220
          together.
 
1221
 
 
1222
          At least there seems to be problems in the rli cache for
 
1223
          charsets if we are using ONE_SHOT.  Note that this is normally no
 
1224
          problem because either the >= 5.0 slave reads a 4.1 binlog (with
 
1225
          ONE_SHOT) *or* or 5.0 binlog (without ONE_SHOT) but never both."
 
1226
        */
 
1227
        reset_one_shot_variables(thd);
 
1228
      }
 
1229
      return(0);
 
1230
    }
 
1231
  }
 
1232
  else
 
1233
  {
 
1234
    /*
 
1235
      When option readonly is set deny operations which change non-temporary
 
1236
      tables. Except for the replication thread and the 'super' users.
 
1237
    */
 
1238
    if (deny_updates_if_read_only_option(thd, all_tables))
 
1239
    {
 
1240
      my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
 
1241
      return(-1);
 
1242
    }
 
1243
  } /* endif unlikely slave */
 
1244
  status_var_increment(thd->status_var.com_stat[lex->sql_command]);
 
1245
 
 
1246
  assert(thd->transaction.stmt.modified_non_trans_table == false);
 
1247
  
 
1248
  switch (lex->sql_command) {
 
1249
  case SQLCOM_SHOW_STATUS:
 
1250
  {
 
1251
    system_status_var old_status_var= thd->status_var;
 
1252
    thd->initial_status_var= &old_status_var;
 
1253
    res= execute_sqlcom_select(thd, all_tables);
 
1254
    /* Don't log SHOW STATUS commands to slow query log */
 
1255
    thd->server_status&= ~(SERVER_QUERY_NO_INDEX_USED |
 
1256
                           SERVER_QUERY_NO_GOOD_INDEX_USED);
 
1257
    /*
 
1258
      restore status variables, as we don't want 'show status' to cause
 
1259
      changes
 
1260
    */
 
1261
    pthread_mutex_lock(&LOCK_status);
 
1262
    add_diff_to_status(&global_status_var, &thd->status_var,
 
1263
                       &old_status_var);
 
1264
    thd->status_var= old_status_var;
 
1265
    pthread_mutex_unlock(&LOCK_status);
 
1266
    break;
 
1267
  }
 
1268
  case SQLCOM_SHOW_DATABASES:
 
1269
  case SQLCOM_SHOW_TABLES:
 
1270
  case SQLCOM_SHOW_TABLE_STATUS:
 
1271
  case SQLCOM_SHOW_OPEN_TABLES:
 
1272
  case SQLCOM_SHOW_FIELDS:
 
1273
  case SQLCOM_SHOW_KEYS:
 
1274
  case SQLCOM_SHOW_VARIABLES:
 
1275
  case SQLCOM_SHOW_CHARSETS:
 
1276
  case SQLCOM_SHOW_COLLATIONS:
 
1277
  case SQLCOM_SELECT:
 
1278
  {
 
1279
    thd->status_var.last_query_cost= 0.0;
 
1280
    res= execute_sqlcom_select(thd, all_tables);
 
1281
    break;
 
1282
  }
 
1283
  case SQLCOM_EMPTY_QUERY:
 
1284
    my_ok(thd);
 
1285
    break;
 
1286
 
 
1287
  case SQLCOM_PURGE:
 
1288
  {
 
1289
    res = purge_master_logs(thd, lex->to_log);
 
1290
    break;
 
1291
  }
 
1292
  case SQLCOM_PURGE_BEFORE:
 
1293
  {
 
1294
    Item *it;
 
1295
 
 
1296
    /* PURGE MASTER LOGS BEFORE 'data' */
 
1297
    it= (Item *)lex->value_list.head();
 
1298
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) ||
 
1299
        it->check_cols(1))
 
1300
    {
 
1301
      my_error(ER_WRONG_ARGUMENTS, MYF(0), "PURGE LOGS BEFORE");
 
1302
      goto error;
 
1303
    }
 
1304
    it= new Item_func_unix_timestamp(it);
 
1305
    /*
 
1306
      it is OK only emulate fix_fieds, because we need only
 
1307
      value of constant
 
1308
    */
 
1309
    it->quick_fix_field();
 
1310
    res = purge_master_logs_before_date(thd, (ulong)it->val_int());
 
1311
    break;
 
1312
  }
 
1313
  case SQLCOM_SHOW_WARNS:
 
1314
  {
 
1315
    res= mysqld_show_warnings(thd, (uint32_t)
 
1316
                              ((1L << (uint) DRIZZLE_ERROR::WARN_LEVEL_NOTE) |
 
1317
                               (1L << (uint) DRIZZLE_ERROR::WARN_LEVEL_WARN) |
 
1318
                               (1L << (uint) DRIZZLE_ERROR::WARN_LEVEL_ERROR)
 
1319
                               ));
 
1320
    break;
 
1321
  }
 
1322
  case SQLCOM_SHOW_ERRORS:
 
1323
  {
 
1324
    res= mysqld_show_warnings(thd, (uint32_t)
 
1325
                              (1L << (uint) DRIZZLE_ERROR::WARN_LEVEL_ERROR));
 
1326
    break;
 
1327
  }
 
1328
  case SQLCOM_SHOW_SLAVE_HOSTS:
 
1329
  {
 
1330
    res = show_slave_hosts(thd);
 
1331
    break;
 
1332
  }
 
1333
  case SQLCOM_SHOW_BINLOG_EVENTS:
 
1334
  {
 
1335
    res = mysql_show_binlog_events(thd);
 
1336
    break;
 
1337
  }
 
1338
 
 
1339
  case SQLCOM_ASSIGN_TO_KEYCACHE:
 
1340
  {
 
1341
    assert(first_table == all_tables && first_table != 0);
 
1342
    res= mysql_assign_to_keycache(thd, first_table, &lex->ident);
 
1343
    break;
 
1344
  }
 
1345
  case SQLCOM_CHANGE_MASTER:
 
1346
  {
 
1347
    pthread_mutex_lock(&LOCK_active_mi);
 
1348
    res = change_master(thd,active_mi);
 
1349
    pthread_mutex_unlock(&LOCK_active_mi);
 
1350
    break;
 
1351
  }
 
1352
  case SQLCOM_SHOW_SLAVE_STAT:
 
1353
  {
 
1354
    pthread_mutex_lock(&LOCK_active_mi);
 
1355
    if (active_mi != NULL)
 
1356
    {
 
1357
      res = show_master_info(thd, active_mi);
 
1358
    }
 
1359
    else
 
1360
    {
 
1361
      push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN, 0,
 
1362
                   "the master info structure does not exist");
 
1363
      my_ok(thd);
 
1364
    }
 
1365
    pthread_mutex_unlock(&LOCK_active_mi);
 
1366
    break;
 
1367
  }
 
1368
  case SQLCOM_SHOW_MASTER_STAT:
 
1369
  {
 
1370
    res = show_binlog_info(thd);
 
1371
    break;
 
1372
  }
 
1373
 
 
1374
  case SQLCOM_SHOW_ENGINE_STATUS:
 
1375
    {
 
1376
      res = ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_STATUS);
 
1377
      break;
 
1378
    }
 
1379
  case SQLCOM_CREATE_TABLE:
 
1380
  {
 
1381
    /* If CREATE TABLE of non-temporary table, do implicit commit */
 
1382
    if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE))
 
1383
    {
 
1384
      if (end_active_trans(thd))
 
1385
      {
 
1386
        res= -1;
 
1387
        break;
 
1388
      }
 
1389
    }
 
1390
    assert(first_table == all_tables && first_table != 0);
 
1391
    bool link_to_local;
 
1392
    // Skip first table, which is the table we are creating
 
1393
    TableList *create_table= lex->unlink_first_table(&link_to_local);
 
1394
    TableList *select_tables= lex->query_tables;
 
1395
    /*
 
1396
      Code below (especially in mysql_create_table() and select_create
 
1397
      methods) may modify HA_CREATE_INFO structure in LEX, so we have to
 
1398
      use a copy of this structure to make execution prepared statement-
 
1399
      safe. A shallow copy is enough as this code won't modify any memory
 
1400
      referenced from this structure.
 
1401
    */
 
1402
    HA_CREATE_INFO create_info(lex->create_info);
 
1403
    /*
 
1404
      We need to copy alter_info for the same reasons of re-execution
 
1405
      safety, only in case of Alter_info we have to do (almost) a deep
 
1406
      copy.
 
1407
    */
 
1408
    Alter_info alter_info(lex->alter_info, thd->mem_root);
 
1409
 
 
1410
    if (thd->is_fatal_error)
 
1411
    {
 
1412
      /* If out of memory when creating a copy of alter_info. */
 
1413
      res= 1;
 
1414
      goto end_with_restore_list;
 
1415
    }
 
1416
 
 
1417
    if ((res= create_table_precheck(thd, select_tables, create_table)))
 
1418
      goto end_with_restore_list;
 
1419
 
 
1420
    /* Might have been updated in create_table_precheck */
 
1421
    create_info.alias= create_table->alias;
 
1422
 
 
1423
#ifdef HAVE_READLINK
 
1424
    /* Fix names if symlinked tables */
 
1425
    if (append_file_to_dir(thd, &create_info.data_file_name,
 
1426
                           create_table->table_name) ||
 
1427
        append_file_to_dir(thd, &create_info.index_file_name,
 
1428
                           create_table->table_name))
 
1429
      goto end_with_restore_list;
 
1430
#endif
 
1431
    /*
 
1432
      If we are using SET CHARSET without DEFAULT, add an implicit
 
1433
      DEFAULT to not confuse old users. (This may change).
 
1434
    */
 
1435
    if ((create_info.used_fields &
 
1436
         (HA_CREATE_USED_DEFAULT_CHARSET | HA_CREATE_USED_CHARSET)) ==
 
1437
        HA_CREATE_USED_CHARSET)
 
1438
    {
 
1439
      create_info.used_fields&= ~HA_CREATE_USED_CHARSET;
 
1440
      create_info.used_fields|= HA_CREATE_USED_DEFAULT_CHARSET;
 
1441
      create_info.default_table_charset= create_info.table_charset;
 
1442
      create_info.table_charset= 0;
 
1443
    }
 
1444
    /*
 
1445
      The create-select command will open and read-lock the select table
 
1446
      and then create, open and write-lock the new table. If a global
 
1447
      read lock steps in, we get a deadlock. The write lock waits for
 
1448
      the global read lock, while the global read lock waits for the
 
1449
      select table to be closed. So we wait until the global readlock is
 
1450
      gone before starting both steps. Note that
 
1451
      wait_if_global_read_lock() sets a protection against a new global
 
1452
      read lock when it succeeds. This needs to be released by
 
1453
      start_waiting_global_read_lock(). We protect the normal CREATE
 
1454
      TABLE in the same way. That way we avoid that a new table is
 
1455
      created during a gobal read lock.
 
1456
    */
 
1457
    if (!thd->locked_tables &&
 
1458
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
 
1459
    {
 
1460
      res= 1;
 
1461
      goto end_with_restore_list;
 
1462
    }
 
1463
    if (select_lex->item_list.elements)         // With select
 
1464
    {
 
1465
      select_result *result;
 
1466
 
 
1467
      select_lex->options|= SELECT_NO_UNLOCK;
 
1468
      unit->set_limit(select_lex);
 
1469
 
 
1470
      if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
 
1471
      {
 
1472
        lex->link_first_table_back(create_table, link_to_local);
 
1473
        create_table->create= true;
 
1474
      }
 
1475
 
 
1476
      if (!(res= open_and_lock_tables(thd, lex->query_tables)))
 
1477
      {
 
1478
        /*
 
1479
          Is table which we are changing used somewhere in other parts
 
1480
          of query
 
1481
        */
 
1482
        if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
 
1483
        {
 
1484
          TableList *duplicate;
 
1485
          create_table= lex->unlink_first_table(&link_to_local);
 
1486
          if ((duplicate= unique_table(thd, create_table, select_tables, 0)))
 
1487
          {
 
1488
            update_non_unique_table_error(create_table, "CREATE", duplicate);
 
1489
            res= 1;
 
1490
            goto end_with_restore_list;
 
1491
          }
 
1492
        }
 
1493
 
 
1494
        /*
 
1495
          select_create is currently not re-execution friendly and
 
1496
          needs to be created for every execution of a PS/SP.
 
1497
        */
 
1498
        if ((result= new select_create(create_table,
 
1499
                                       &create_info,
 
1500
                                       &alter_info,
 
1501
                                       select_lex->item_list,
 
1502
                                       lex->duplicates,
 
1503
                                       lex->ignore,
 
1504
                                       select_tables)))
 
1505
        {
 
1506
          /*
 
1507
            CREATE from SELECT give its SELECT_LEX for SELECT,
 
1508
            and item_list belong to SELECT
 
1509
          */
 
1510
          res= handle_select(thd, lex, result, 0);
 
1511
          delete result;
 
1512
        }
 
1513
      }
 
1514
      else if (!(create_info.options & HA_LEX_CREATE_TMP_TABLE))
 
1515
        create_table= lex->unlink_first_table(&link_to_local);
 
1516
 
 
1517
    }
 
1518
    else
 
1519
    {
 
1520
      /* So that CREATE TEMPORARY TABLE gets to binlog at commit/rollback */
 
1521
      if (create_info.options & HA_LEX_CREATE_TMP_TABLE)
 
1522
        thd->options|= OPTION_KEEP_LOG;
 
1523
      /* regular create */
 
1524
      if (create_info.options & HA_LEX_CREATE_TABLE_LIKE)
 
1525
        res= mysql_create_like_table(thd, create_table, select_tables,
 
1526
                                     &create_info);
 
1527
      else
 
1528
      {
 
1529
        res= mysql_create_table(thd, create_table->db,
 
1530
                                create_table->table_name, &create_info,
 
1531
                                &alter_info, 0, 0);
 
1532
      }
 
1533
      if (!res)
 
1534
        my_ok(thd);
 
1535
    }
 
1536
 
 
1537
    /* put tables back for PS rexecuting */
 
1538
end_with_restore_list:
 
1539
    lex->link_first_table_back(create_table, link_to_local);
 
1540
    break;
 
1541
  }
 
1542
  case SQLCOM_CREATE_INDEX:
 
1543
    /* Fall through */
 
1544
  case SQLCOM_DROP_INDEX:
 
1545
  /*
 
1546
    CREATE INDEX and DROP INDEX are implemented by calling ALTER
 
1547
    TABLE with proper arguments.
 
1548
 
 
1549
    In the future ALTER TABLE will notice that the request is to
 
1550
    only add indexes and create these one by one for the existing
 
1551
    table without having to do a full rebuild.
 
1552
  */
 
1553
  {
 
1554
    /* Prepare stack copies to be re-execution safe */
 
1555
    HA_CREATE_INFO create_info;
 
1556
    Alter_info alter_info(lex->alter_info, thd->mem_root);
 
1557
 
 
1558
    if (thd->is_fatal_error) /* out of memory creating a copy of alter_info */
 
1559
      goto error;
 
1560
 
 
1561
    assert(first_table == all_tables && first_table != 0);
 
1562
    if (end_active_trans(thd))
 
1563
      goto error;
 
1564
    /*
 
1565
      Currently CREATE INDEX or DROP INDEX cause a full table rebuild
 
1566
      and thus classify as slow administrative statements just like
 
1567
      ALTER TABLE.
 
1568
    */
 
1569
    thd->enable_slow_log= opt_log_slow_admin_statements;
 
1570
 
 
1571
    memset(&create_info, 0, sizeof(create_info));
 
1572
    create_info.db_type= 0;
 
1573
    create_info.row_type= ROW_TYPE_NOT_USED;
 
1574
    create_info.default_table_charset= thd->variables.collation_database;
 
1575
 
 
1576
    res= mysql_alter_table(thd, first_table->db, first_table->table_name,
 
1577
                           &create_info, first_table, &alter_info,
 
1578
                           0, (order_st*) 0, 0);
 
1579
    break;
 
1580
  }
 
1581
  case SQLCOM_SLAVE_START:
 
1582
  {
 
1583
    pthread_mutex_lock(&LOCK_active_mi);
 
1584
    start_slave(thd,active_mi,1 /* net report*/);
 
1585
    pthread_mutex_unlock(&LOCK_active_mi);
 
1586
    break;
 
1587
  }
 
1588
  case SQLCOM_SLAVE_STOP:
 
1589
  /*
 
1590
    If the client thread has locked tables, a deadlock is possible.
 
1591
    Assume that
 
1592
    - the client thread does LOCK TABLE t READ.
 
1593
    - then the master updates t.
 
1594
    - then the SQL slave thread wants to update t,
 
1595
      so it waits for the client thread because t is locked by it.
 
1596
    - then the client thread does SLAVE STOP.
 
1597
      SLAVE STOP waits for the SQL slave thread to terminate its
 
1598
      update t, which waits for the client thread because t is locked by it.
 
1599
    To prevent that, refuse SLAVE STOP if the
 
1600
    client thread has locked tables
 
1601
  */
 
1602
  if (thd->locked_tables || thd->active_transaction() || thd->global_read_lock)
 
1603
  {
 
1604
    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
 
1605
               ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
 
1606
    goto error;
 
1607
  }
 
1608
  {
 
1609
    pthread_mutex_lock(&LOCK_active_mi);
 
1610
    stop_slave(thd,active_mi,1/* net report*/);
 
1611
    pthread_mutex_unlock(&LOCK_active_mi);
 
1612
    break;
 
1613
  }
 
1614
 
 
1615
  case SQLCOM_ALTER_TABLE:
 
1616
    assert(first_table == all_tables && first_table != 0);
 
1617
    {
 
1618
      /*
 
1619
        Code in mysql_alter_table() may modify its HA_CREATE_INFO argument,
 
1620
        so we have to use a copy of this structure to make execution
 
1621
        prepared statement- safe. A shallow copy is enough as no memory
 
1622
        referenced from this structure will be modified.
 
1623
      */
 
1624
      HA_CREATE_INFO create_info(lex->create_info);
 
1625
      Alter_info alter_info(lex->alter_info, thd->mem_root);
 
1626
 
 
1627
      if (thd->is_fatal_error) /* out of memory creating a copy of alter_info */
 
1628
      {
 
1629
        goto error;
 
1630
      }
 
1631
 
 
1632
      /* Must be set in the parser */
 
1633
      assert(select_lex->db);
 
1634
 
 
1635
      { // Rename of table
 
1636
          TableList tmp_table;
 
1637
          memset(&tmp_table, 0, sizeof(tmp_table));
 
1638
          tmp_table.table_name= lex->name.str;
 
1639
          tmp_table.db=select_lex->db;
 
1640
      }
 
1641
 
 
1642
      /* Don't yet allow changing of symlinks with ALTER TABLE */
 
1643
      if (create_info.data_file_name)
 
1644
        push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN, 0,
 
1645
                     "DATA DIRECTORY option ignored");
 
1646
      if (create_info.index_file_name)
 
1647
        push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN, 0,
 
1648
                     "INDEX DIRECTORY option ignored");
 
1649
      create_info.data_file_name= create_info.index_file_name= NULL;
 
1650
      /* ALTER TABLE ends previous transaction */
 
1651
      if (end_active_trans(thd))
 
1652
        goto error;
 
1653
 
 
1654
      if (!thd->locked_tables &&
 
1655
          !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
 
1656
      {
 
1657
        res= 1;
 
1658
        break;
 
1659
      }
 
1660
 
 
1661
      thd->enable_slow_log= opt_log_slow_admin_statements;
 
1662
      res= mysql_alter_table(thd, select_lex->db, lex->name.str,
 
1663
                             &create_info,
 
1664
                             first_table,
 
1665
                             &alter_info,
 
1666
                             select_lex->order_list.elements,
 
1667
                             (order_st *) select_lex->order_list.first,
 
1668
                             lex->ignore);
 
1669
      break;
 
1670
    }
 
1671
  case SQLCOM_RENAME_TABLE:
 
1672
  {
 
1673
    assert(first_table == all_tables && first_table != 0);
 
1674
    TableList *table;
 
1675
    for (table= first_table; table; table= table->next_local->next_local)
 
1676
    {
 
1677
      TableList old_list, new_list;
 
1678
      /*
 
1679
        we do not need initialize old_list and new_list because we will
 
1680
        come table[0] and table->next[0] there
 
1681
      */
 
1682
      old_list= table[0];
 
1683
      new_list= table->next_local[0];
 
1684
    }
 
1685
 
 
1686
    if (end_active_trans(thd) || mysql_rename_tables(thd, first_table, 0))
 
1687
      {
 
1688
        goto error;
 
1689
      }
 
1690
    break;
 
1691
  }
 
1692
  case SQLCOM_SHOW_BINLOGS:
 
1693
    {
 
1694
      res = show_binlogs(thd);
 
1695
      break;
 
1696
    }
 
1697
  case SQLCOM_SHOW_CREATE:
 
1698
    assert(first_table == all_tables && first_table != 0);
 
1699
    {
 
1700
      res= mysqld_show_create(thd, first_table);
 
1701
      break;
 
1702
    }
 
1703
  case SQLCOM_CHECKSUM:
 
1704
  {
 
1705
    assert(first_table == all_tables && first_table != 0);
 
1706
    res = mysql_checksum_table(thd, first_table, &lex->check_opt);
 
1707
    break;
 
1708
  }
 
1709
  case SQLCOM_REPAIR:
 
1710
  {
 
1711
    assert(first_table == all_tables && first_table != 0);
 
1712
    thd->enable_slow_log= opt_log_slow_admin_statements;
 
1713
    res= mysql_repair_table(thd, first_table, &lex->check_opt);
 
1714
    /* ! we write after unlocking the table */
 
1715
    if (!res && !lex->no_write_to_binlog)
 
1716
    {
 
1717
      /*
 
1718
        Presumably, REPAIR and binlog writing doesn't require synchronization
 
1719
      */
 
1720
      write_bin_log(thd, true, thd->query, thd->query_length);
 
1721
    }
 
1722
    select_lex->table_list.first= (uchar*) first_table;
 
1723
    lex->query_tables=all_tables;
 
1724
    break;
 
1725
  }
 
1726
  case SQLCOM_CHECK:
 
1727
  {
 
1728
    assert(first_table == all_tables && first_table != 0);
 
1729
    thd->enable_slow_log= opt_log_slow_admin_statements;
 
1730
    res = mysql_check_table(thd, first_table, &lex->check_opt);
 
1731
    select_lex->table_list.first= (uchar*) first_table;
 
1732
    lex->query_tables=all_tables;
 
1733
    break;
 
1734
  }
 
1735
  case SQLCOM_ANALYZE:
 
1736
  {
 
1737
    assert(first_table == all_tables && first_table != 0);
 
1738
    thd->enable_slow_log= opt_log_slow_admin_statements;
 
1739
    res= mysql_analyze_table(thd, first_table, &lex->check_opt);
 
1740
    /* ! we write after unlocking the table */
 
1741
    if (!res && !lex->no_write_to_binlog)
 
1742
    {
 
1743
      /*
 
1744
        Presumably, ANALYZE and binlog writing doesn't require synchronization
 
1745
      */
 
1746
      write_bin_log(thd, true, thd->query, thd->query_length);
 
1747
    }
 
1748
    select_lex->table_list.first= (uchar*) first_table;
 
1749
    lex->query_tables=all_tables;
 
1750
    break;
 
1751
  }
 
1752
 
 
1753
  case SQLCOM_OPTIMIZE:
 
1754
  {
 
1755
    assert(first_table == all_tables && first_table != 0);
 
1756
    thd->enable_slow_log= opt_log_slow_admin_statements;
 
1757
    res= mysql_optimize_table(thd, first_table, &lex->check_opt);
 
1758
    /* ! we write after unlocking the table */
 
1759
    if (!res && !lex->no_write_to_binlog)
 
1760
    {
 
1761
      /*
 
1762
        Presumably, OPTIMIZE and binlog writing doesn't require synchronization
 
1763
      */
 
1764
      write_bin_log(thd, true, thd->query, thd->query_length);
 
1765
    }
 
1766
    select_lex->table_list.first= (uchar*) first_table;
 
1767
    lex->query_tables=all_tables;
 
1768
    break;
 
1769
  }
 
1770
  case SQLCOM_UPDATE:
 
1771
    assert(first_table == all_tables && first_table != 0);
 
1772
    if (update_precheck(thd, all_tables))
 
1773
      break;
 
1774
    assert(select_lex->offset_limit == 0);
 
1775
    unit->set_limit(select_lex);
 
1776
    res= (up_result= mysql_update(thd, all_tables,
 
1777
                                  select_lex->item_list,
 
1778
                                  lex->value_list,
 
1779
                                  select_lex->where,
 
1780
                                  select_lex->order_list.elements,
 
1781
                                  (order_st *) select_lex->order_list.first,
 
1782
                                  unit->select_limit_cnt,
 
1783
                                  lex->duplicates, lex->ignore));
 
1784
    /* mysql_update return 2 if we need to switch to multi-update */
 
1785
    if (up_result != 2)
 
1786
      break;
 
1787
    /* Fall through */
 
1788
  case SQLCOM_UPDATE_MULTI:
 
1789
  {
 
1790
    assert(first_table == all_tables && first_table != 0);
 
1791
    /* if we switched from normal update, rights are checked */
 
1792
    if (up_result != 2)
 
1793
    {
 
1794
      if ((res= multi_update_precheck(thd, all_tables)))
 
1795
        break;
 
1796
    }
 
1797
    else
 
1798
      res= 0;
 
1799
 
 
1800
    res= mysql_multi_update_prepare(thd);
 
1801
 
 
1802
    /* Check slave filtering rules */
 
1803
    if (unlikely(thd->slave_thread))
 
1804
    {
 
1805
      if (all_tables_not_ok(thd, all_tables))
 
1806
      {
 
1807
        if (res!= 0)
 
1808
        {
 
1809
          res= 0;             /* don't care of prev failure  */
 
1810
          thd->clear_error(); /* filters are of highest prior */
 
1811
        }
 
1812
        /* we warn the slave SQL thread */
 
1813
        my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
 
1814
        break;
 
1815
      }
 
1816
      if (res)
 
1817
        break;
 
1818
    }
 
1819
    else
 
1820
    {
 
1821
      if (res)
 
1822
        break;
 
1823
      if (opt_readonly &&
 
1824
          some_non_temp_table_to_be_updated(thd, all_tables))
 
1825
      {
 
1826
        my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
 
1827
        break;
 
1828
      }
 
1829
    }  /* unlikely */
 
1830
 
 
1831
    res= mysql_multi_update(thd, all_tables,
 
1832
                            &select_lex->item_list,
 
1833
                            &lex->value_list,
 
1834
                            select_lex->where,
 
1835
                            select_lex->options,
 
1836
                            lex->duplicates, lex->ignore, unit, select_lex);
 
1837
    break;
 
1838
  }
 
1839
  case SQLCOM_REPLACE:
 
1840
  case SQLCOM_INSERT:
 
1841
  {
 
1842
    assert(first_table == all_tables && first_table != 0);
 
1843
    if ((res= insert_precheck(thd, all_tables)))
 
1844
      break;
 
1845
 
 
1846
    if (!thd->locked_tables &&
 
1847
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
 
1848
    {
 
1849
      res= 1;
 
1850
      break;
 
1851
    }
 
1852
 
 
1853
    res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
 
1854
                      lex->update_list, lex->value_list,
 
1855
                      lex->duplicates, lex->ignore);
 
1856
 
 
1857
    break;
 
1858
  }
 
1859
  case SQLCOM_REPLACE_SELECT:
 
1860
  case SQLCOM_INSERT_SELECT:
 
1861
  {
 
1862
    select_result *sel_result;
 
1863
    assert(first_table == all_tables && first_table != 0);
 
1864
    if ((res= insert_precheck(thd, all_tables)))
 
1865
      break;
 
1866
 
 
1867
    /* Fix lock for first table */
 
1868
    if (first_table->lock_type == TL_WRITE_DELAYED)
 
1869
      first_table->lock_type= TL_WRITE;
 
1870
 
 
1871
    /* Don't unlock tables until command is written to binary log */
 
1872
    select_lex->options|= SELECT_NO_UNLOCK;
 
1873
 
 
1874
    unit->set_limit(select_lex);
 
1875
 
 
1876
    if (! thd->locked_tables &&
 
1877
        ! (need_start_waiting= ! wait_if_global_read_lock(thd, 0, 1)))
 
1878
    {
 
1879
      res= 1;
 
1880
      break;
 
1881
    }
 
1882
 
 
1883
    if (!(res= open_and_lock_tables(thd, all_tables)))
 
1884
    {
 
1885
      /* Skip first table, which is the table we are inserting in */
 
1886
      TableList *second_table= first_table->next_local;
 
1887
      select_lex->table_list.first= (uchar*) second_table;
 
1888
      select_lex->context.table_list= 
 
1889
        select_lex->context.first_name_resolution_table= second_table;
 
1890
      res= mysql_insert_select_prepare(thd);
 
1891
      if (!res && (sel_result= new select_insert(first_table,
 
1892
                                                 first_table->table,
 
1893
                                                 &lex->field_list,
 
1894
                                                 &lex->update_list,
 
1895
                                                 &lex->value_list,
 
1896
                                                 lex->duplicates,
 
1897
                                                 lex->ignore)))
 
1898
      {
 
1899
        res= handle_select(thd, lex, sel_result, OPTION_SETUP_TABLES_DONE);
 
1900
        /*
 
1901
          Invalidate the table in the query cache if something changed
 
1902
          after unlocking when changes become visible.
 
1903
          TODO: this is workaround. right way will be move invalidating in
 
1904
          the unlock procedure.
 
1905
        */
 
1906
        if (first_table->lock_type ==  TL_WRITE_CONCURRENT_INSERT &&
 
1907
            thd->lock)
 
1908
        {
 
1909
          /* INSERT ... SELECT should invalidate only the very first table */
 
1910
          TableList *save_table= first_table->next_local;
 
1911
          first_table->next_local= 0;
 
1912
          first_table->next_local= save_table;
 
1913
        }
 
1914
        delete sel_result;
 
1915
      }
 
1916
      /* revert changes for SP */
 
1917
      select_lex->table_list.first= (uchar*) first_table;
 
1918
    }
 
1919
 
 
1920
    break;
 
1921
  }
 
1922
  case SQLCOM_TRUNCATE:
 
1923
    if (end_active_trans(thd))
 
1924
    {
 
1925
      res= -1;
 
1926
      break;
 
1927
    }
 
1928
    assert(first_table == all_tables && first_table != 0);
 
1929
    /*
 
1930
      Don't allow this within a transaction because we want to use
 
1931
      re-generate table
 
1932
    */
 
1933
    if (thd->locked_tables || thd->active_transaction())
 
1934
    {
 
1935
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
 
1936
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
 
1937
      goto error;
 
1938
    }
 
1939
 
 
1940
    res= mysql_truncate(thd, first_table, 0);
 
1941
 
 
1942
    break;
 
1943
  case SQLCOM_DELETE:
 
1944
  {
 
1945
    assert(first_table == all_tables && first_table != 0);
 
1946
    assert(select_lex->offset_limit == 0);
 
1947
    unit->set_limit(select_lex);
 
1948
 
 
1949
    if (!thd->locked_tables &&
 
1950
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
 
1951
    {
 
1952
      res= 1;
 
1953
      break;
 
1954
    }
 
1955
 
 
1956
    res = mysql_delete(thd, all_tables, select_lex->where,
 
1957
                       &select_lex->order_list,
 
1958
                       unit->select_limit_cnt, select_lex->options,
 
1959
                       false);
 
1960
    break;
 
1961
  }
 
1962
  case SQLCOM_DELETE_MULTI:
 
1963
  {
 
1964
    assert(first_table == all_tables && first_table != 0);
 
1965
    TableList *aux_tables=
 
1966
      (TableList *)thd->lex->auxiliary_table_list.first;
 
1967
    multi_delete *del_result;
 
1968
 
 
1969
    if (!thd->locked_tables &&
 
1970
        !(need_start_waiting= !wait_if_global_read_lock(thd, 0, 1)))
 
1971
    {
 
1972
      res= 1;
 
1973
      break;
 
1974
    }
 
1975
 
 
1976
    if ((res= multi_delete_precheck(thd, all_tables)))
 
1977
      break;
 
1978
 
 
1979
    /* condition will be true on SP re-excuting */
 
1980
    if (select_lex->item_list.elements != 0)
 
1981
      select_lex->item_list.empty();
 
1982
    if (add_item_to_list(thd, new Item_null()))
 
1983
      goto error;
 
1984
 
 
1985
    thd_proc_info(thd, "init");
 
1986
    if ((res= open_and_lock_tables(thd, all_tables)))
 
1987
      break;
 
1988
 
 
1989
    if ((res= mysql_multi_delete_prepare(thd)))
 
1990
      goto error;
 
1991
 
 
1992
    if (!thd->is_fatal_error &&
 
1993
        (del_result= new multi_delete(aux_tables, lex->table_count)))
 
1994
    {
 
1995
      res= mysql_select(thd, &select_lex->ref_pointer_array,
 
1996
                        select_lex->get_table_list(),
 
1997
                        select_lex->with_wild,
 
1998
                        select_lex->item_list,
 
1999
                        select_lex->where,
 
2000
                        0, (order_st *)NULL, (order_st *)NULL, (Item *)NULL,
 
2001
                        (order_st *)NULL,
 
2002
                        select_lex->options | thd->options |
 
2003
                        SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
 
2004
                        OPTION_SETUP_TABLES_DONE,
 
2005
                        del_result, unit, select_lex);
 
2006
      res|= thd->is_error();
 
2007
      if (res)
 
2008
        del_result->abort();
 
2009
      delete del_result;
 
2010
    }
 
2011
    else
 
2012
      res= true;                                // Error
 
2013
    break;
 
2014
  }
 
2015
  case SQLCOM_DROP_TABLE:
 
2016
  {
 
2017
    assert(first_table == all_tables && first_table != 0);
 
2018
    if (!lex->drop_temporary)
 
2019
    {
 
2020
      if (end_active_trans(thd))
 
2021
        goto error;
 
2022
    }
 
2023
    else
 
2024
    {
 
2025
      /*
 
2026
        If this is a slave thread, we may sometimes execute some 
 
2027
        DROP / * 40005 TEMPORARY * / TABLE
 
2028
        that come from parts of binlogs (likely if we use RESET SLAVE or CHANGE
 
2029
        MASTER TO), while the temporary table has already been dropped.
 
2030
        To not generate such irrelevant "table does not exist errors",
 
2031
        we silently add IF EXISTS if TEMPORARY was used.
 
2032
      */
 
2033
      if (thd->slave_thread)
 
2034
        lex->drop_if_exists= 1;
 
2035
 
 
2036
      /* So that DROP TEMPORARY TABLE gets to binlog at commit/rollback */
 
2037
      thd->options|= OPTION_KEEP_LOG;
 
2038
    }
 
2039
    /* DDL and binlog write order protected by LOCK_open */
 
2040
    res= mysql_rm_table(thd, first_table, lex->drop_if_exists, lex->drop_temporary);
 
2041
  }
 
2042
  break;
 
2043
  case SQLCOM_SHOW_PROCESSLIST:
 
2044
    mysqld_list_processes(thd, NullS, lex->verbose);
 
2045
    break;
 
2046
  case SQLCOM_SHOW_ENGINE_LOGS:
 
2047
    {
 
2048
      res= ha_show_status(thd, lex->create_info.db_type, HA_ENGINE_LOGS);
 
2049
      break;
 
2050
    }
 
2051
  case SQLCOM_CHANGE_DB:
 
2052
  {
 
2053
    LEX_STRING db_str= { (char *) select_lex->db, strlen(select_lex->db) };
 
2054
 
 
2055
    if (!mysql_change_db(thd, &db_str, false))
 
2056
      my_ok(thd);
 
2057
 
 
2058
    break;
 
2059
  }
 
2060
 
 
2061
  case SQLCOM_LOAD:
 
2062
  {
 
2063
    assert(first_table == all_tables && first_table != 0);
 
2064
    if (lex->local_file)
 
2065
    {
 
2066
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
 
2067
          !opt_local_infile)
 
2068
      {
 
2069
        my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND), MYF(0));
 
2070
        goto error;
 
2071
      }
 
2072
    }
 
2073
 
 
2074
    res= mysql_load(thd, lex->exchange, first_table, lex->field_list,
 
2075
                    lex->update_list, lex->value_list, lex->duplicates,
 
2076
                    lex->ignore, (bool) lex->local_file);
 
2077
    break;
 
2078
  }
 
2079
 
 
2080
  case SQLCOM_SET_OPTION:
 
2081
  {
 
2082
    List<set_var_base> *lex_var_list= &lex->var_list;
 
2083
 
 
2084
    if (lex->autocommit && end_active_trans(thd))
 
2085
      goto error;
 
2086
 
 
2087
    if (open_and_lock_tables(thd, all_tables))
 
2088
      goto error;
 
2089
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
 
2090
    {
 
2091
      my_error(ER_RESERVED_SYNTAX, MYF(0), "SET ONE_SHOT");
 
2092
      goto error;
 
2093
    }
 
2094
    if (!(res= sql_set_variables(thd, lex_var_list)))
 
2095
    {
 
2096
      /*
 
2097
        If the previous command was a SET ONE_SHOT, we don't want to forget
 
2098
        about the ONE_SHOT property of that SET. So we use a |= instead of = .
 
2099
      */
 
2100
      thd->one_shot_set|= lex->one_shot_set;
 
2101
      my_ok(thd);
 
2102
    }
 
2103
    else
 
2104
    {
 
2105
      /*
 
2106
        We encountered some sort of error, but no message was sent.
 
2107
        Send something semi-generic here since we don't know which
 
2108
        assignment in the list caused the error.
 
2109
      */
 
2110
      if (!thd->is_error())
 
2111
        my_error(ER_WRONG_ARGUMENTS,MYF(0),"SET");
 
2112
      goto error;
 
2113
    }
 
2114
 
 
2115
    break;
 
2116
  }
 
2117
 
 
2118
  case SQLCOM_UNLOCK_TABLES:
 
2119
    /*
 
2120
      It is critical for mysqldump --single-transaction --master-data that
 
2121
      UNLOCK TABLES does not implicitely commit a connection which has only
 
2122
      done FLUSH TABLES WITH READ LOCK + BEGIN. If this assumption becomes
 
2123
      false, mysqldump will not work.
 
2124
    */
 
2125
    unlock_locked_tables(thd);
 
2126
    if (thd->options & OPTION_TABLE_LOCK)
 
2127
    {
 
2128
      end_active_trans(thd);
 
2129
      thd->options&= ~(OPTION_TABLE_LOCK);
 
2130
    }
 
2131
    if (thd->global_read_lock)
 
2132
      unlock_global_read_lock(thd);
 
2133
    my_ok(thd);
 
2134
    break;
 
2135
  case SQLCOM_LOCK_TABLES:
 
2136
    /*
 
2137
      We try to take transactional locks if
 
2138
      - only transactional locks are requested (lex->lock_transactional) and
 
2139
      - no non-transactional locks exist (!thd->locked_tables).
 
2140
    */
 
2141
    if (lex->lock_transactional && !thd->locked_tables)
 
2142
    {
 
2143
      int rc;
 
2144
      /*
 
2145
        All requested locks are transactional and no non-transactional
 
2146
        locks exist.
 
2147
      */
 
2148
      if ((rc= try_transactional_lock(thd, all_tables)) == -1)
 
2149
        goto error;
 
2150
      if (rc == 0)
 
2151
      {
 
2152
        my_ok(thd);
 
2153
        break;
 
2154
      }
 
2155
      /*
 
2156
        Non-transactional locking has been requested or
 
2157
        non-transactional locks exist already or transactional locks are
 
2158
        not supported by all storage engines. Take non-transactional
 
2159
        locks.
 
2160
      */
 
2161
    }
 
2162
    /*
 
2163
      One or more requested locks are non-transactional and/or
 
2164
      non-transactional locks exist or a storage engine does not support
 
2165
      transactional locks. Check if at least one transactional lock is
 
2166
      requested. If yes, warn about the conversion to non-transactional
 
2167
      locks or abort in strict mode.
 
2168
    */
 
2169
    if (check_transactional_lock(thd, all_tables))
 
2170
      goto error;
 
2171
    unlock_locked_tables(thd);
 
2172
    /* we must end the trasaction first, regardless of anything */
 
2173
    if (end_active_trans(thd))
 
2174
      goto error;
 
2175
    thd->in_lock_tables=1;
 
2176
    thd->options|= OPTION_TABLE_LOCK;
 
2177
 
 
2178
    if (!(res= simple_open_n_lock_tables(thd, all_tables)))
 
2179
    {
 
2180
      thd->locked_tables=thd->lock;
 
2181
      thd->lock=0;
 
2182
      (void) set_handler_table_locks(thd, all_tables, false);
 
2183
      my_ok(thd);
 
2184
    }
 
2185
    else
 
2186
    {
 
2187
      /* 
 
2188
        Need to end the current transaction, so the storage engine (InnoDB)
 
2189
        can free its locks if LOCK TABLES locked some tables before finding
 
2190
        that it can't lock a table in its list
 
2191
      */
 
2192
      ha_autocommit_or_rollback(thd, 1);
 
2193
      end_active_trans(thd);
 
2194
      thd->options&= ~(OPTION_TABLE_LOCK);
 
2195
    }
 
2196
    thd->in_lock_tables=0;
 
2197
    break;
 
2198
  case SQLCOM_CREATE_DB:
 
2199
  {
 
2200
    /*
 
2201
      As mysql_create_db() may modify HA_CREATE_INFO structure passed to
 
2202
      it, we need to use a copy of LEX::create_info to make execution
 
2203
      prepared statement- safe.
 
2204
    */
 
2205
    HA_CREATE_INFO create_info(lex->create_info);
 
2206
    if (end_active_trans(thd))
 
2207
    {
 
2208
      res= -1;
 
2209
      break;
 
2210
    }
 
2211
    char *alias;
 
2212
    if (!(alias=thd->strmake(lex->name.str, lex->name.length)) ||
 
2213
        check_db_name(&lex->name))
 
2214
    {
 
2215
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name.str);
 
2216
      break;
 
2217
    }
 
2218
    /*
 
2219
      If in a slave thread :
 
2220
      CREATE DATABASE DB was certainly not preceded by USE DB.
 
2221
      For that reason, db_ok() in sql/slave.cc did not check the
 
2222
      do_db/ignore_db. And as this query involves no tables, tables_ok()
 
2223
      above was not called. So we have to check rules again here.
 
2224
    */
 
2225
    if (thd->slave_thread && 
 
2226
        (!rpl_filter->db_ok(lex->name.str) ||
 
2227
         !rpl_filter->db_ok_with_wild_table(lex->name.str)))
 
2228
    {
 
2229
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
 
2230
      break;
 
2231
    }
 
2232
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias :
 
2233
                              lex->name.str), &create_info, 0);
 
2234
    break;
 
2235
  }
 
2236
  case SQLCOM_DROP_DB:
 
2237
  {
 
2238
    if (end_active_trans(thd))
 
2239
    {
 
2240
      res= -1;
 
2241
      break;
 
2242
    }
 
2243
    if (check_db_name(&lex->name))
 
2244
    {
 
2245
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name.str);
 
2246
      break;
 
2247
    }
 
2248
    /*
 
2249
      If in a slave thread :
 
2250
      DROP DATABASE DB may not be preceded by USE DB.
 
2251
      For that reason, maybe db_ok() in sql/slave.cc did not check the 
 
2252
      do_db/ignore_db. And as this query involves no tables, tables_ok()
 
2253
      above was not called. So we have to check rules again here.
 
2254
    */
 
2255
    if (thd->slave_thread && 
 
2256
        (!rpl_filter->db_ok(lex->name.str) ||
 
2257
         !rpl_filter->db_ok_with_wild_table(lex->name.str)))
 
2258
    {
 
2259
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
 
2260
      break;
 
2261
    }
 
2262
    if (thd->locked_tables || thd->active_transaction())
 
2263
    {
 
2264
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
 
2265
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
 
2266
      goto error;
 
2267
    }
 
2268
    res= mysql_rm_db(thd, lex->name.str, lex->drop_if_exists, 0);
 
2269
    break;
 
2270
  }
 
2271
  case SQLCOM_ALTER_DB:
 
2272
  {
 
2273
    LEX_STRING *db= &lex->name;
 
2274
    HA_CREATE_INFO create_info(lex->create_info);
 
2275
    if (check_db_name(db))
 
2276
    {
 
2277
      my_error(ER_WRONG_DB_NAME, MYF(0), db->str);
 
2278
      break;
 
2279
    }
 
2280
    /*
 
2281
      If in a slave thread :
 
2282
      ALTER DATABASE DB may not be preceded by USE DB.
 
2283
      For that reason, maybe db_ok() in sql/slave.cc did not check the
 
2284
      do_db/ignore_db. And as this query involves no tables, tables_ok()
 
2285
      above was not called. So we have to check rules again here.
 
2286
    */
 
2287
    if (thd->slave_thread &&
 
2288
        (!rpl_filter->db_ok(db->str) ||
 
2289
         !rpl_filter->db_ok_with_wild_table(db->str)))
 
2290
    {
 
2291
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
 
2292
      break;
 
2293
    }
 
2294
    if (thd->locked_tables || thd->active_transaction())
 
2295
    {
 
2296
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
 
2297
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
 
2298
      goto error;
 
2299
    }
 
2300
    res= mysql_alter_db(thd, db->str, &create_info);
 
2301
    break;
 
2302
  }
 
2303
  case SQLCOM_SHOW_CREATE_DB:
 
2304
  {
 
2305
    if (check_db_name(&lex->name))
 
2306
    {
 
2307
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name.str);
 
2308
      break;
 
2309
    }
 
2310
    res= mysqld_show_create_db(thd, lex->name.str, &lex->create_info);
 
2311
    break;
 
2312
  }
 
2313
  case SQLCOM_RESET:
 
2314
    /*
 
2315
      RESET commands are never written to the binary log, so we have to
 
2316
      initialize this variable because RESET shares the same code as FLUSH
 
2317
    */
 
2318
    lex->no_write_to_binlog= 1;
 
2319
  case SQLCOM_FLUSH:
 
2320
  {
 
2321
    bool write_to_binlog;
 
2322
 
 
2323
    /*
 
2324
      reload_cache() will tell us if we are allowed to write to the
 
2325
      binlog or not.
 
2326
    */
 
2327
    if (!reload_cache(thd, lex->type, first_table, &write_to_binlog))
 
2328
    {
 
2329
      /*
 
2330
        We WANT to write and we CAN write.
 
2331
        ! we write after unlocking the table.
 
2332
      */
 
2333
      /*
 
2334
        Presumably, RESET and binlog writing doesn't require synchronization
 
2335
      */
 
2336
      if (!lex->no_write_to_binlog && write_to_binlog)
 
2337
      {
 
2338
        write_bin_log(thd, false, thd->query, thd->query_length);
 
2339
      }
 
2340
      my_ok(thd);
 
2341
    } 
 
2342
    
 
2343
    break;
 
2344
  }
 
2345
  case SQLCOM_KILL:
 
2346
  {
 
2347
    Item *it= (Item *)lex->value_list.head();
 
2348
 
 
2349
    if (lex->table_or_sp_used())
 
2350
    {
 
2351
      my_error(ER_NOT_SUPPORTED_YET, MYF(0), "Usage of subqueries or stored "
 
2352
               "function calls as part of this statement");
 
2353
      break;
 
2354
    }
 
2355
 
 
2356
    if ((!it->fixed && it->fix_fields(lex->thd, &it)) || it->check_cols(1))
 
2357
    {
 
2358
      my_message(ER_SET_CONSTANTS_ONLY, ER(ER_SET_CONSTANTS_ONLY),
 
2359
                 MYF(0));
 
2360
      goto error;
 
2361
    }
 
2362
    sql_kill(thd, (ulong)it->val_int(), lex->type & ONLY_KILL_QUERY);
 
2363
    break;
 
2364
  }
 
2365
  case SQLCOM_BEGIN:
 
2366
    if (thd->transaction.xid_state.xa_state != XA_NOTR)
 
2367
    {
 
2368
      my_error(ER_XAER_RMFAIL, MYF(0),
 
2369
               xa_state_names[thd->transaction.xid_state.xa_state]);
 
2370
      break;
 
2371
    }
 
2372
    /*
 
2373
      Breakpoints for backup testing.
 
2374
    */
 
2375
    if (begin_trans(thd))
 
2376
      goto error;
 
2377
    my_ok(thd);
 
2378
    break;
 
2379
  case SQLCOM_COMMIT:
 
2380
    if (end_trans(thd, lex->tx_release ? COMMIT_RELEASE :
 
2381
                              lex->tx_chain ? COMMIT_AND_CHAIN : COMMIT))
 
2382
      goto error;
 
2383
    my_ok(thd);
 
2384
    break;
 
2385
  case SQLCOM_ROLLBACK:
 
2386
    if (end_trans(thd, lex->tx_release ? ROLLBACK_RELEASE :
 
2387
                              lex->tx_chain ? ROLLBACK_AND_CHAIN : ROLLBACK))
 
2388
      goto error;
 
2389
    my_ok(thd);
 
2390
    break;
 
2391
  case SQLCOM_RELEASE_SAVEPOINT:
 
2392
  {
 
2393
    SAVEPOINT *sv;
 
2394
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
 
2395
    {
 
2396
      if (my_strnncoll(system_charset_info,
 
2397
                       (uchar *)lex->ident.str, lex->ident.length,
 
2398
                       (uchar *)sv->name, sv->length) == 0)
 
2399
        break;
 
2400
    }
 
2401
    if (sv)
 
2402
    {
 
2403
      if (ha_release_savepoint(thd, sv))
 
2404
        res= true; // cannot happen
 
2405
      else
 
2406
        my_ok(thd);
 
2407
      thd->transaction.savepoints=sv->prev;
 
2408
    }
 
2409
    else
 
2410
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
 
2411
    break;
 
2412
  }
 
2413
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
 
2414
  {
 
2415
    SAVEPOINT *sv;
 
2416
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
 
2417
    {
 
2418
      if (my_strnncoll(system_charset_info,
 
2419
                       (uchar *)lex->ident.str, lex->ident.length,
 
2420
                       (uchar *)sv->name, sv->length) == 0)
 
2421
        break;
 
2422
    }
 
2423
    if (sv)
 
2424
    {
 
2425
      if (ha_rollback_to_savepoint(thd, sv))
 
2426
        res= true; // cannot happen
 
2427
      else
 
2428
      {
 
2429
        if (((thd->options & OPTION_KEEP_LOG) || 
 
2430
             thd->transaction.all.modified_non_trans_table) &&
 
2431
            !thd->slave_thread)
 
2432
          push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
2433
                       ER_WARNING_NOT_COMPLETE_ROLLBACK,
 
2434
                       ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
 
2435
        my_ok(thd);
 
2436
      }
 
2437
      thd->transaction.savepoints=sv;
 
2438
    }
 
2439
    else
 
2440
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
 
2441
    break;
 
2442
  }
 
2443
  case SQLCOM_SAVEPOINT:
 
2444
    if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN) ||
 
2445
          thd->in_sub_stmt) || !opt_using_transactions)
 
2446
      my_ok(thd);
 
2447
    else
 
2448
    {
 
2449
      SAVEPOINT **sv, *newsv;
 
2450
      for (sv=&thd->transaction.savepoints; *sv; sv=&(*sv)->prev)
 
2451
      {
 
2452
        if (my_strnncoll(system_charset_info,
 
2453
                         (uchar *)lex->ident.str, lex->ident.length,
 
2454
                         (uchar *)(*sv)->name, (*sv)->length) == 0)
 
2455
          break;
 
2456
      }
 
2457
      if (*sv) /* old savepoint of the same name exists */
 
2458
      {
 
2459
        newsv=*sv;
 
2460
        ha_release_savepoint(thd, *sv); // it cannot fail
 
2461
        *sv=(*sv)->prev;
 
2462
      }
 
2463
      else if ((newsv=(SAVEPOINT *) alloc_root(&thd->transaction.mem_root,
 
2464
                                               savepoint_alloc_size)) == 0)
 
2465
      {
 
2466
        my_error(ER_OUT_OF_RESOURCES, MYF(0));
 
2467
        break;
 
2468
      }
 
2469
      newsv->name=strmake_root(&thd->transaction.mem_root,
 
2470
                               lex->ident.str, lex->ident.length);
 
2471
      newsv->length=lex->ident.length;
 
2472
      /*
 
2473
        if we'll get an error here, don't add new savepoint to the list.
 
2474
        we'll lose a little bit of memory in transaction mem_root, but it'll
 
2475
        be free'd when transaction ends anyway
 
2476
      */
 
2477
      if (ha_savepoint(thd, newsv))
 
2478
        res= true;
 
2479
      else
 
2480
      {
 
2481
        newsv->prev=thd->transaction.savepoints;
 
2482
        thd->transaction.savepoints=newsv;
 
2483
        my_ok(thd);
 
2484
      }
 
2485
    }
 
2486
    break;
 
2487
  case SQLCOM_BINLOG_BASE64_EVENT:
 
2488
  {
 
2489
    mysql_client_binlog_statement(thd);
 
2490
    break;
 
2491
  }
 
2492
  default:
 
2493
    assert(0);                             /* Impossible */
 
2494
    my_ok(thd);
 
2495
    break;
 
2496
  }
 
2497
  thd_proc_info(thd, "query end");
 
2498
 
 
2499
  /*
 
2500
    Binlog-related cleanup:
 
2501
    Reset system variables temporarily modified by SET ONE SHOT.
 
2502
 
 
2503
    Exception: If this is a SET, do nothing. This is to allow
 
2504
    mysqlbinlog to print many SET commands (in this case we want the
 
2505
    charset temp setting to live until the real query). This is also
 
2506
    needed so that SET CHARACTER_SET_CLIENT... does not cancel itself
 
2507
    immediately.
 
2508
  */
 
2509
  if (thd->one_shot_set && lex->sql_command != SQLCOM_SET_OPTION)
 
2510
    reset_one_shot_variables(thd);
 
2511
 
505
2512
  /*
506
2513
    The return value for ROW_COUNT() is "implementation dependent" if the
507
2514
    statement is not DELETE, INSERT or UPDATE, but -1 is what JDBC and ODBC
508
2515
    wants. We also keep the last value in case of SQLCOM_CALL or
509
2516
    SQLCOM_EXECUTE.
510
2517
  */
511
 
  if (! (sql_command_flags[lex->sql_command].test(CF_BIT_HAS_ROW_COUNT)))
 
2518
  if (!(sql_command_flags[lex->sql_command] & CF_HAS_ROW_COUNT))
 
2519
    thd->row_count_func= -1;
 
2520
 
 
2521
  goto finish;
 
2522
 
 
2523
error:
 
2524
  res= true;
 
2525
 
 
2526
finish:
 
2527
  if (need_start_waiting)
512
2528
  {
513
 
    session->row_count_func= -1;
 
2529
    /*
 
2530
      Release the protection against the global read lock and wake
 
2531
      everyone, who might want to set a global read lock.
 
2532
    */
 
2533
    start_waiting_global_read_lock(thd);
514
2534
  }
515
 
 
516
 
  return (res || session->is_error());
 
2535
  return(res || thd->is_error());
517
2536
}
518
 
bool execute_sqlcom_select(Session *session, TableList *all_tables)
 
2537
 
 
2538
bool execute_sqlcom_select(THD *thd, TableList *all_tables)
519
2539
{
520
 
  LEX   *lex= session->lex;
 
2540
  LEX   *lex= thd->lex;
521
2541
  select_result *result=lex->result;
522
 
  bool res= false;
 
2542
  bool res;
523
2543
  /* assign global limit variable if limit is not given */
524
2544
  {
525
 
    Select_Lex *param= lex->unit.global_parameters;
 
2545
    SELECT_LEX *param= lex->unit.global_parameters;
526
2546
    if (!param->explicit_limit)
527
2547
      param->select_limit=
528
 
        new Item_int((uint64_t) session->variables.select_limit);
529
 
  }
530
 
 
531
 
  if (all_tables
532
 
      && ! (session->server_status & SERVER_STATUS_AUTOCOMMIT)
533
 
      && ! session->inTransaction()
534
 
      && ! lex->statement->isShow())
535
 
  {
536
 
    if (session->startTransaction() == false)
537
 
    {
538
 
      my_error(drizzled::ER_UNKNOWN_ERROR, MYF(0));
539
 
      return true;
540
 
    }
541
 
  }
542
 
 
543
 
  if (not (res= session->openTablesLock(all_tables)))
 
2548
        new Item_int((uint64_t) thd->variables.select_limit);
 
2549
  }
 
2550
  if (!(res= open_and_lock_tables(thd, all_tables)))
544
2551
  {
545
2552
    if (lex->describe)
546
2553
    {
551
2558
        even if the query itself redirects the output.
552
2559
      */
553
2560
      if (!(result= new select_send()))
554
 
        return true;
555
 
      session->send_explain_fields(result);
556
 
      optimizer::ExplainPlan planner;
557
 
      res= planner.explainUnion(session, &session->lex->unit, result);
 
2561
        return 1;                               /* purecov: inspected */
 
2562
      thd->send_explain_fields(result);
 
2563
      res= mysql_explain_union(thd, &thd->lex->unit, result);
558
2564
      if (lex->describe & DESCRIBE_EXTENDED)
559
2565
      {
560
2566
        char buff[1024];
561
2567
        String str(buff,(uint32_t) sizeof(buff), system_charset_info);
562
2568
        str.length(0);
563
 
        session->lex->unit.print(&str, QT_ORDINARY);
 
2569
        thd->lex->unit.print(&str, QT_ORDINARY);
564
2570
        str.append('\0');
565
 
        push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
2571
        push_warning(thd, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
566
2572
                     ER_YES, str.ptr());
567
2573
      }
568
2574
      if (res)
574
2580
    else
575
2581
    {
576
2582
      if (!result && !(result= new select_send()))
577
 
        return true;
578
 
 
579
 
      /* Init the Query Cache plugin */
580
 
      plugin::QueryCache::prepareResultset(session); 
581
 
      res= handle_select(session, lex, result, 0);
582
 
      /* Send the Resultset to the cache */
583
 
      plugin::QueryCache::setResultset(session); 
584
 
 
 
2583
        return 1;                               /* purecov: inspected */
 
2584
      res= handle_select(thd, lex, result, 0);
585
2585
      if (result != lex->result)
586
2586
        delete result;
587
2587
    }
589
2589
  return res;
590
2590
}
591
2591
 
 
2592
/****************************************************************************
 
2593
        Check stack size; Send error if there isn't enough stack to continue
 
2594
****************************************************************************/
 
2595
#if STACK_DIRECTION < 0
 
2596
#define used_stack(A,B) (long) (A - B)
 
2597
#else
 
2598
#define used_stack(A,B) (long) (B - A)
 
2599
#endif
 
2600
 
 
2601
/**
 
2602
  @note
 
2603
  Note: The 'buf' parameter is necessary, even if it is unused here.
 
2604
  - fix_fields functions has a "dummy" buffer large enough for the
 
2605
    corresponding exec. (Thus we only have to check in fix_fields.)
 
2606
  - Passing to check_stack_overrun() prevents the compiler from removing it.
 
2607
*/
 
2608
bool check_stack_overrun(THD *thd, long margin,
 
2609
                         uchar *buf __attribute__((unused)))
 
2610
{
 
2611
  long stack_used;
 
2612
  assert(thd == current_thd);
 
2613
  if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
 
2614
      (long) (my_thread_stack_size - margin))
 
2615
  {
 
2616
    sprintf(errbuff[0],ER(ER_STACK_OVERRUN_NEED_MORE),
 
2617
            stack_used,my_thread_stack_size,margin);
 
2618
    my_message(ER_STACK_OVERRUN_NEED_MORE,errbuff[0],MYF(ME_FATALERROR));
 
2619
    return 1;
 
2620
  }
 
2621
  return 0;
 
2622
}
592
2623
 
593
2624
#define MY_YACC_INIT 1000                       // Start with big alloc
594
2625
#define MY_YACC_MAX  32000                      // Because of 'short'
595
2626
 
596
2627
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
597
2628
{
598
 
  LEX   *lex= current_session->lex;
 
2629
  LEX   *lex= current_thd->lex;
599
2630
  ulong old_info=0;
600
 
  if ((uint32_t) *yystacksize >= MY_YACC_MAX)
 
2631
  if ((uint) *yystacksize >= MY_YACC_MAX)
601
2632
    return 1;
602
2633
  if (!lex->yacc_yyvs)
603
2634
    old_info= *yystacksize;
604
2635
  *yystacksize= set_zone((*yystacksize)*2,MY_YACC_INIT,MY_YACC_MAX);
605
 
  unsigned char *tmpptr= NULL;
606
 
  if (!(tmpptr= (unsigned char *)realloc(lex->yacc_yyvs,
607
 
                                         *yystacksize* sizeof(**yyvs))))
608
 
      return 1;
609
 
  lex->yacc_yyvs= tmpptr;
610
 
  tmpptr= NULL;
611
 
  if (!(tmpptr= (unsigned char*)realloc(lex->yacc_yyss,
612
 
                                        *yystacksize* sizeof(**yyss))))
613
 
      return 1;
614
 
  lex->yacc_yyss= tmpptr;
 
2636
  if (!(lex->yacc_yyvs= (uchar*)
 
2637
        my_realloc(lex->yacc_yyvs,
 
2638
                   *yystacksize*sizeof(**yyvs),
 
2639
                   MYF(MY_ALLOW_ZERO_PTR | MY_FREE_ON_ERROR))) ||
 
2640
      !(lex->yacc_yyss= (uchar*)
 
2641
        my_realloc(lex->yacc_yyss,
 
2642
                   *yystacksize*sizeof(**yyss),
 
2643
                   MYF(MY_ALLOW_ZERO_PTR | MY_FREE_ON_ERROR))))
 
2644
    return 1;
615
2645
  if (old_info)
616
2646
  {                                             // Copy old info from stack
617
2647
    memcpy(lex->yacc_yyss, *yyss, old_info*sizeof(**yyss));
623
2653
}
624
2654
 
625
2655
 
 
2656
/**
 
2657
 Reset THD part responsible for command processing state.
 
2658
 
 
2659
   This needs to be called before execution of every statement
 
2660
   (prepared or conventional).
 
2661
   It is not called by substatements of routines.
 
2662
 
 
2663
  @todo
 
2664
   Make it a method of THD and align its name with the rest of
 
2665
   reset/end/start/init methods.
 
2666
  @todo
 
2667
   Call it after we use THD for queries, not before.
 
2668
*/
 
2669
 
 
2670
void mysql_reset_thd_for_next_command(THD *thd)
 
2671
{
 
2672
  assert(! thd->in_sub_stmt);
 
2673
  thd->free_list= 0;
 
2674
  thd->select_number= 1;
 
2675
  /*
 
2676
    Those two lines below are theoretically unneeded as
 
2677
    THD::cleanup_after_query() should take care of this already.
 
2678
  */
 
2679
  thd->auto_inc_intervals_in_cur_stmt_for_binlog.empty();
 
2680
  thd->stmt_depends_on_first_successful_insert_id_in_prev_stmt= 0;
 
2681
 
 
2682
  thd->query_start_used= 0;
 
2683
  thd->is_fatal_error= thd->time_zone_used= 0;
 
2684
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
 
2685
                          SERVER_QUERY_NO_INDEX_USED |
 
2686
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
 
2687
  /*
 
2688
    If in autocommit mode and not in a transaction, reset
 
2689
    OPTION_STATUS_NO_TRANS_UPDATE | OPTION_KEEP_LOG to not get warnings
 
2690
    in ha_rollback_trans() about some tables couldn't be rolled back.
 
2691
  */
 
2692
  if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)))
 
2693
  {
 
2694
    thd->options&= ~OPTION_KEEP_LOG;
 
2695
    thd->transaction.all.modified_non_trans_table= false;
 
2696
  }
 
2697
  assert(thd->security_ctx== &thd->main_security_ctx);
 
2698
  thd->thread_specific_used= false;
 
2699
 
 
2700
  if (opt_bin_log)
 
2701
  {
 
2702
    reset_dynamic(&thd->user_var_events);
 
2703
    thd->user_var_events_alloc= thd->mem_root;
 
2704
  }
 
2705
  thd->clear_error();
 
2706
  thd->main_da.reset_diagnostics_area();
 
2707
  thd->total_warn_count=0;                      // Warnings for this query
 
2708
  thd->rand_used= 0;
 
2709
  thd->sent_row_count= thd->examined_row_count= 0;
 
2710
 
 
2711
  /*
 
2712
    Because we come here only for start of top-statements, binlog format is
 
2713
    constant inside a complex statement (using stored functions) etc.
 
2714
  */
 
2715
  thd->reset_current_stmt_binlog_row_based();
 
2716
 
 
2717
  return;
 
2718
}
 
2719
 
 
2720
 
626
2721
void
627
 
init_select(LEX *lex)
 
2722
mysql_init_select(LEX *lex)
628
2723
{
629
 
  Select_Lex *select_lex= lex->current_select;
 
2724
  SELECT_LEX *select_lex= lex->current_select;
630
2725
  select_lex->init_select();
631
2726
  lex->wild= 0;
632
2727
  if (select_lex == &lex->select_lex)
638
2733
 
639
2734
 
640
2735
bool
641
 
new_select(LEX *lex, bool move_down)
 
2736
mysql_new_select(LEX *lex, bool move_down)
642
2737
{
643
 
  Select_Lex *select_lex;
644
 
  Session *session= lex->session;
645
 
 
646
 
  if (!(select_lex= new (session->mem_root) Select_Lex()))
647
 
    return true;
648
 
 
649
 
  select_lex->select_number= ++session->select_number;
 
2738
  SELECT_LEX *select_lex;
 
2739
  THD *thd= lex->thd;
 
2740
 
 
2741
  if (!(select_lex= new (thd->mem_root) SELECT_LEX()))
 
2742
    return(1);
 
2743
  select_lex->select_number= ++thd->select_number;
650
2744
  select_lex->parent_lex= lex; /* Used in init_query. */
651
2745
  select_lex->init_query();
652
2746
  select_lex->init_select();
653
2747
  lex->nest_level++;
654
 
 
655
2748
  if (lex->nest_level > (int) MAX_SELECT_NESTING)
656
2749
  {
657
2750
    my_error(ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT,MYF(0),MAX_SELECT_NESTING);
658
2751
    return(1);
659
2752
  }
660
 
 
661
2753
  select_lex->nest_level= lex->nest_level;
662
2754
  if (move_down)
663
2755
  {
664
 
    Select_Lex_Unit *unit;
 
2756
    SELECT_LEX_UNIT *unit;
 
2757
    lex->subqueries= true;
665
2758
    /* first select_lex of subselect or derived table */
666
 
    if (!(unit= new (session->mem_root) Select_Lex_Unit()))
 
2759
    if (!(unit= new (thd->mem_root) SELECT_LEX_UNIT()))
667
2760
      return(1);
668
2761
 
669
2762
    unit->init_query();
670
2763
    unit->init_select();
671
 
    unit->session= session;
 
2764
    unit->thd= thd;
672
2765
    unit->include_down(lex->current_select);
673
2766
    unit->link_next= 0;
674
2767
    unit->link_prev= 0;
685
2778
    if (lex->current_select->order_list.first && !lex->current_select->braces)
686
2779
    {
687
2780
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "order_st BY");
688
 
      return true;
 
2781
      return(1);
689
2782
    }
690
 
 
691
2783
    select_lex->include_neighbour(lex->current_select);
692
 
    Select_Lex_Unit *unit= select_lex->master_unit();
693
 
 
694
 
    if (not unit->fake_select_lex && unit->add_fake_select_lex(lex->session))
695
 
      return true;
696
 
 
697
 
    select_lex->context.outer_context=
 
2784
    SELECT_LEX_UNIT *unit= select_lex->master_unit();                              
 
2785
    if (!unit->fake_select_lex && unit->add_fake_select_lex(lex->thd))
 
2786
      return(1);
 
2787
    select_lex->context.outer_context= 
698
2788
                unit->first_select()->context.outer_context;
699
2789
  }
700
2790
 
701
2791
  select_lex->master_unit()->global_parameters= select_lex;
702
 
  select_lex->include_global((Select_Lex_Node**)&lex->all_selects_list);
 
2792
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
703
2793
  lex->current_select= select_lex;
704
2794
  /*
705
2795
    in subquery is SELECT query and we allow resolution of names in SELECT
706
2796
    list
707
2797
  */
708
2798
  select_lex->context.resolve_in_select_list= true;
709
 
 
710
 
  return false;
 
2799
  return(0);
711
2800
}
712
2801
 
713
2802
/**
720
2809
  @param var_name               Variable name
721
2810
*/
722
2811
 
723
 
void create_select_for_variable(Session *session, const char *var_name)
 
2812
void create_select_for_variable(const char *var_name)
724
2813
{
 
2814
  THD *thd;
725
2815
  LEX *lex;
726
2816
  LEX_STRING tmp, null_lex_string;
727
2817
  Item *var;
728
 
  char buff[MAX_SYS_VAR_LENGTH*2+4+8];
729
 
  char *end= buff;
 
2818
  char buff[MAX_SYS_VAR_LENGTH*2+4+8], *end;
730
2819
 
731
 
  lex= session->lex;
732
 
  init_select(lex);
 
2820
  thd= current_thd;
 
2821
  lex= thd->lex;
 
2822
  mysql_init_select(lex);
733
2823
  lex->sql_command= SQLCOM_SELECT;
734
2824
  tmp.str= (char*) var_name;
735
2825
  tmp.length=strlen(var_name);
738
2828
    We set the name of Item to @@session.var_name because that then is used
739
2829
    as the column name in the output.
740
2830
  */
741
 
  if ((var= get_system_var(session, OPT_SESSION, tmp, null_lex_string)))
 
2831
  if ((var= get_system_var(thd, OPT_SESSION, tmp, null_lex_string)))
742
2832
  {
743
 
    end+= snprintf(buff, sizeof(buff), "@@session.%s", var_name);
 
2833
    end= strxmov(buff, "@@session.", var_name, NullS);
744
2834
    var->set_name(buff, end-buff, system_charset_info);
745
 
    session->add_item_to_list(var);
 
2835
    add_item_to_list(thd, var);
746
2836
  }
747
 
}
748
 
 
 
2837
  return;
 
2838
}
 
2839
 
 
2840
 
 
2841
void mysql_init_multi_delete(LEX *lex)
 
2842
{
 
2843
  lex->sql_command=  SQLCOM_DELETE_MULTI;
 
2844
  mysql_init_select(lex);
 
2845
  lex->select_lex.select_limit= 0;
 
2846
  lex->unit.select_limit_cnt= HA_POS_ERROR;
 
2847
  lex->select_lex.table_list.save_and_clear(&lex->auxiliary_table_list);
 
2848
  lex->lock_option= using_update_log ? TL_READ_NO_INSERT : TL_READ;
 
2849
  lex->query_tables= 0;
 
2850
  lex->query_tables_last= &lex->query_tables;
 
2851
}
 
2852
 
 
2853
 
 
2854
/*
 
2855
  When you modify mysql_parse(), you may need to mofify
 
2856
  mysql_test_parse_for_slave() in this same file.
 
2857
*/
749
2858
 
750
2859
/**
751
2860
  Parse a query.
752
2861
 
753
 
  @param       session     Current thread
 
2862
  @param       thd     Current thread
754
2863
  @param       inBuf   Begining of the query text
755
2864
  @param       length  Length of the query text
 
2865
  @param[out]  found_semicolon For multi queries, position of the character of
 
2866
                               the next query in the query text.
756
2867
*/
757
2868
 
758
 
void parse(Session *session, const char *inBuf, uint32_t length)
 
2869
void mysql_parse(THD *thd, const char *inBuf, uint length,
 
2870
                 const char ** found_semicolon)
759
2871
{
760
 
  session->lex->start(session);
761
 
 
762
 
  session->reset_for_next_command();
763
 
  /* Check if the Query is Cached if and return true if yes
764
 
   * TODO the plugin has to make sure that the query is cacheble
765
 
   * by setting the query_safe_cache param to TRUE
766
 
   */
767
 
  bool res= true;
768
 
  if (plugin::QueryCache::isCached(session))
769
 
  {
770
 
    res= plugin::QueryCache::sendCachedResultset(session);
771
 
  }
772
 
  if (not res)
773
 
  {
774
 
    return;
775
 
  }
776
 
  LEX *lex= session->lex;
777
 
  Lex_input_stream lip(session, inBuf, length);
778
 
  bool err= parse_sql(session, &lip);
779
 
  if (!err)
780
 
  {
 
2872
  /*
 
2873
    Warning.
 
2874
    The purpose of query_cache_send_result_to_client() is to lookup the
 
2875
    query in the query cache first, to avoid parsing and executing it.
 
2876
    So, the natural implementation would be to:
 
2877
    - first, call query_cache_send_result_to_client,
 
2878
    - second, if caching failed, initialise the lexical and syntactic parser.
 
2879
    The problem is that the query cache depends on a clean initialization
 
2880
    of (among others) lex->safe_to_cache_query and thd->server_status,
 
2881
    which are reset respectively in
 
2882
    - lex_start()
 
2883
    - mysql_reset_thd_for_next_command()
 
2884
    So, initializing the lexical analyser *before* using the query cache
 
2885
    is required for the cache to work properly.
 
2886
    FIXME: cleanup the dependencies in the code to simplify this.
 
2887
  */
 
2888
  lex_start(thd);
 
2889
  mysql_reset_thd_for_next_command(thd);
 
2890
 
 
2891
  {
 
2892
    LEX *lex= thd->lex;
 
2893
 
 
2894
    Lex_input_stream lip(thd, inBuf, length);
 
2895
 
 
2896
    bool err= parse_sql(thd, &lip);
 
2897
    *found_semicolon= lip.found_semicolon;
 
2898
 
 
2899
    if (!err)
781
2900
    {
782
 
      if (not session->is_error())
783
2901
      {
784
 
        DRIZZLE_QUERY_EXEC_START(session->getQueryString()->c_str(),
785
 
                                 session->thread_id,
786
 
                                 const_cast<const char *>(session->schema()->c_str()));
787
 
        // Implement Views here --Brian
788
 
        /* Actually execute the query */
789
 
        try 
790
 
        {
791
 
          execute_command(session);
792
 
        }
793
 
        catch (...)
794
 
        {
795
 
          // Just try to catch any random failures that could have come
796
 
          // during execution.
797
 
          DRIZZLE_ABORT;
798
 
        }
799
 
        DRIZZLE_QUERY_EXEC_DONE(0);
 
2902
        if (! thd->is_error())
 
2903
        {
 
2904
          /*
 
2905
            Binlog logs a string starting from thd->query and having length
 
2906
            thd->query_length; so we set thd->query_length correctly (to not
 
2907
            log several statements in one event, when we executed only first).
 
2908
            We set it to not see the ';' (otherwise it would get into binlog
 
2909
            and Query_log_event::print() would give ';;' output).
 
2910
            This also helps display only the current query in SHOW
 
2911
            PROCESSLIST.
 
2912
            Note that we don't need LOCK_thread_count to modify query_length.
 
2913
          */
 
2914
          if (*found_semicolon &&
 
2915
              (thd->query_length= (ulong)(*found_semicolon - thd->query)))
 
2916
            thd->query_length--;
 
2917
          /* Actually execute the query */
 
2918
          mysql_execute_command(thd);
 
2919
        }
800
2920
      }
801
2921
    }
802
 
  }
803
 
  else
804
 
  {
805
 
    assert(session->is_error());
806
 
  }
807
 
  lex->unit.cleanup();
808
 
  session->set_proc_info("freeing items");
809
 
  session->end_statement();
810
 
  session->cleanup_after_query();
811
 
  session->set_end_timer();
 
2922
    else
 
2923
    {
 
2924
      assert(thd->is_error());
 
2925
    }
 
2926
    lex->unit.cleanup();
 
2927
    thd_proc_info(thd, "freeing items");
 
2928
    thd->end_statement();
 
2929
    thd->cleanup_after_query();
 
2930
    assert(thd->change_list.is_empty());
 
2931
  }
 
2932
 
 
2933
  return;
 
2934
}
 
2935
 
 
2936
 
 
2937
/*
 
2938
  Usable by the replication SQL thread only: just parse a query to know if it
 
2939
  can be ignored because of replicate-*-table rules.
 
2940
 
 
2941
  @retval
 
2942
    0   cannot be ignored
 
2943
  @retval
 
2944
    1   can be ignored
 
2945
*/
 
2946
 
 
2947
bool mysql_test_parse_for_slave(THD *thd, char *inBuf, uint length)
 
2948
{
 
2949
  LEX *lex= thd->lex;
 
2950
  bool error= 0;
 
2951
 
 
2952
  Lex_input_stream lip(thd, inBuf, length);
 
2953
  lex_start(thd);
 
2954
  mysql_reset_thd_for_next_command(thd);
 
2955
 
 
2956
  if (!parse_sql(thd, &lip) &&
 
2957
      all_tables_not_ok(thd,(TableList*) lex->select_lex.table_list.first))
 
2958
    error= 1;                  /* Ignore question */
 
2959
  thd->end_statement();
 
2960
  thd->cleanup_after_query();
 
2961
  return(error);
812
2962
}
813
2963
 
814
2964
 
820
2970
    Return 0 if ok
821
2971
*/
822
2972
 
823
 
bool add_field_to_list(Session *session, LEX_STRING *field_name, enum_field_types type,
 
2973
bool add_field_to_list(THD *thd, LEX_STRING *field_name, enum_field_types type,
824
2974
                       char *length, char *decimals,
825
 
                       uint32_t type_modifier,
 
2975
                       uint type_modifier,
826
2976
                       enum column_format_type column_format,
827
2977
                       Item *default_value, Item *on_update_value,
828
2978
                       LEX_STRING *comment,
829
2979
                       char *change,
830
2980
                       List<String> *interval_list, const CHARSET_INFO * const cs)
831
2981
{
832
 
  register CreateField *new_field;
833
 
  LEX  *lex= session->lex;
834
 
  statement::AlterTable *statement= (statement::AlterTable *)lex->statement;
 
2982
  register Create_field *new_field;
 
2983
  LEX  *lex= thd->lex;
835
2984
 
836
2985
  if (check_identifier_name(field_name, ER_TOO_LONG_IDENT))
837
 
    return true;
 
2986
    return(1);                          /* purecov: inspected */
838
2987
 
839
2988
  if (type_modifier & PRI_KEY_FLAG)
840
2989
  {
843
2992
    key= new Key(Key::PRIMARY, null_lex_str,
844
2993
                      &default_key_create_info,
845
2994
                      0, lex->col_list);
846
 
    statement->alter_info.key_list.push_back(key);
 
2995
    lex->alter_info.key_list.push_back(key);
847
2996
    lex->col_list.empty();
848
2997
  }
849
2998
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
853
3002
    key= new Key(Key::UNIQUE, null_lex_str,
854
3003
                 &default_key_create_info, 0,
855
3004
                 lex->col_list);
856
 
    statement->alter_info.key_list.push_back(key);
 
3005
    lex->alter_info.key_list.push_back(key);
857
3006
    lex->col_list.empty();
858
3007
  }
859
3008
 
860
3009
  if (default_value)
861
3010
  {
862
 
    /*
 
3011
    /* 
863
3012
      Default value should be literal => basic constants =>
864
3013
      no need fix_fields()
865
 
 
866
 
      We allow only one function as part of default value -
 
3014
      
 
3015
      We allow only one function as part of default value - 
867
3016
      NOW() as default for TIMESTAMP type.
868
3017
    */
869
 
    if (default_value->type() == Item::FUNC_ITEM &&
 
3018
    if (default_value->type() == Item::FUNC_ITEM && 
870
3019
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
871
 
         (type == DRIZZLE_TYPE_TIMESTAMP or type == DRIZZLE_TYPE_MICROTIME)))
 
3020
         type == DRIZZLE_TYPE_TIMESTAMP))
872
3021
    {
873
3022
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
874
 
      return true;
 
3023
      return(1);
875
3024
    }
876
3025
    else if (default_value->type() == Item::NULL_ITEM)
877
3026
    {
878
3027
      default_value= 0;
879
 
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) == NOT_NULL_FLAG)
 
3028
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
 
3029
          NOT_NULL_FLAG)
880
3030
      {
881
3031
        my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
882
 
        return true;
 
3032
        return(1);
883
3033
      }
884
3034
    }
885
3035
    else if (type_modifier & AUTO_INCREMENT_FLAG)
886
3036
    {
887
3037
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
888
 
      return true;
 
3038
      return(1);
889
3039
    }
890
3040
  }
891
3041
 
892
 
  if (on_update_value && (type != DRIZZLE_TYPE_TIMESTAMP and type != DRIZZLE_TYPE_MICROTIME))
 
3042
  if (on_update_value && type != DRIZZLE_TYPE_TIMESTAMP)
893
3043
  {
894
3044
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name->str);
895
 
    return true;
 
3045
    return(1);
896
3046
  }
897
3047
 
898
 
  if (!(new_field= new CreateField()) ||
899
 
      new_field->init(session, field_name->str, type, length, decimals, type_modifier,
 
3048
  if (!(new_field= new Create_field()) ||
 
3049
      new_field->init(thd, field_name->str, type, length, decimals, type_modifier,
900
3050
                      default_value, on_update_value, comment, change,
901
3051
                      interval_list, cs, 0, column_format))
902
 
    return true;
 
3052
    return(1);
903
3053
 
904
 
  statement->alter_info.create_list.push_back(new_field);
 
3054
  lex->alter_info.create_list.push_back(new_field);
905
3055
  lex->last_field=new_field;
906
 
 
907
 
  return false;
 
3056
  return(0);
 
3057
}
 
3058
 
 
3059
 
 
3060
/** Store position for column in ALTER TABLE .. ADD column. */
 
3061
 
 
3062
void store_position_for_column(const char *name)
 
3063
{
 
3064
  current_thd->lex->last_field->after=my_const_cast(char*) (name);
 
3065
}
 
3066
 
 
3067
bool
 
3068
add_proc_to_list(THD* thd, Item *item)
 
3069
{
 
3070
  order_st *order;
 
3071
  Item  **item_ptr;
 
3072
 
 
3073
  if (!(order = (order_st *) thd->alloc(sizeof(order_st)+sizeof(Item*))))
 
3074
    return 1;
 
3075
  item_ptr = (Item**) (order+1);
 
3076
  *item_ptr= item;
 
3077
  order->item=item_ptr;
 
3078
  order->free_me=0;
 
3079
  thd->lex->proc_list.link_in_list((uchar*) order,(uchar**) &order->next);
 
3080
  return 0;
 
3081
}
 
3082
 
 
3083
 
 
3084
/**
 
3085
  save order by and tables in own lists.
 
3086
*/
 
3087
 
 
3088
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
 
3089
{
 
3090
  order_st *order;
 
3091
  if (!(order = (order_st *) thd->alloc(sizeof(order_st))))
 
3092
    return(1);
 
3093
  order->item_ptr= item;
 
3094
  order->item= &order->item_ptr;
 
3095
  order->asc = asc;
 
3096
  order->free_me=0;
 
3097
  order->used=0;
 
3098
  order->counter_used= 0;
 
3099
  list.link_in_list((uchar*) order,(uchar**) &order->next);
 
3100
  return(0);
908
3101
}
909
3102
 
910
3103
 
927
3120
    \#  Pointer to TableList element added to the total table list
928
3121
*/
929
3122
 
930
 
TableList *Select_Lex::add_table_to_list(Session *session,
931
 
                                         Table_ident *table,
932
 
                                         LEX_STRING *alias,
933
 
                                         const bitset<NUM_OF_TABLE_OPTIONS>& table_options,
934
 
                                         thr_lock_type lock_type,
935
 
                                         List<Index_hint> *index_hints_arg,
936
 
                                         LEX_STRING *option)
 
3123
TableList *st_select_lex::add_table_to_list(THD *thd,
 
3124
                                             Table_ident *table,
 
3125
                                             LEX_STRING *alias,
 
3126
                                             uint32_t table_options,
 
3127
                                             thr_lock_type lock_type,
 
3128
                                             List<Index_hint> *index_hints_arg,
 
3129
                                             LEX_STRING *option)
937
3130
{
938
 
  TableList *ptr;
 
3131
  register TableList *ptr;
939
3132
  TableList *previous_table_ref; /* The table preceding the current one. */
940
3133
  char *alias_str;
941
 
  LEX *lex= session->lex;
 
3134
  LEX *lex= thd->lex;
942
3135
 
943
3136
  if (!table)
944
 
    return NULL;                                // End of memory
 
3137
    return(0);                          // End of memory
945
3138
  alias_str= alias ? alias->str : table->table.str;
946
 
  if (! table_options.test(TL_OPTION_ALIAS) &&
 
3139
  if (!test(table_options & TL_OPTION_ALIAS) && 
947
3140
      check_table_name(table->table.str, table->table.length))
948
3141
  {
949
3142
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
950
 
    return NULL;
 
3143
    return(0);
951
3144
  }
952
3145
 
953
 
  if (table->is_derived_table() == false && table->db.str)
 
3146
  if (table->is_derived_table() == false && table->db.str &&
 
3147
      check_db_name(&table->db))
954
3148
  {
955
 
    my_casedn_str(files_charset_info, table->db.str);
956
 
 
957
 
    identifier::Schema schema_identifier(string(table->db.str));
958
 
    if (not check_db_name(session, schema_identifier))
959
 
    {
960
 
 
961
 
      my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
962
 
      return NULL;
963
 
    }
 
3149
    my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
 
3150
    return(0);
964
3151
  }
965
3152
 
966
3153
  if (!alias)                                   /* Alias is case sensitive */
969
3156
    {
970
3157
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
971
3158
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
972
 
      return NULL;
 
3159
      return(0);
973
3160
    }
974
 
    if (!(alias_str= (char*) session->getMemRoot()->duplicate(alias_str,table->table.length+1)))
975
 
      return NULL;
 
3161
    if (!(alias_str= (char*) thd->memdup(alias_str,table->table.length+1)))
 
3162
      return(0);
976
3163
  }
977
 
  if (!(ptr = (TableList *) session->calloc(sizeof(TableList))))
978
 
    return NULL;
979
 
 
 
3164
  if (!(ptr = (TableList *) thd->calloc(sizeof(TableList))))
 
3165
    return(0);                          /* purecov: inspected */
980
3166
  if (table->db.str)
981
3167
  {
982
 
    ptr->setIsFqtn(true);
983
 
    ptr->setSchemaName(table->db.str);
 
3168
    ptr->is_fqtn= true;
 
3169
    ptr->db= table->db.str;
984
3170
    ptr->db_length= table->db.length;
985
3171
  }
986
 
  else if (lex->copy_db_to(ptr->getSchemaNamePtr(), &ptr->db_length))
987
 
    return NULL;
 
3172
  else if (lex->copy_db_to(&ptr->db, &ptr->db_length))
 
3173
    return(0);
988
3174
  else
989
 
    ptr->setIsFqtn(false);
 
3175
    ptr->is_fqtn= false;
990
3176
 
991
3177
  ptr->alias= alias_str;
992
 
  ptr->setIsAlias(alias ? true : false);
993
 
  ptr->setTableName(table->table.str);
 
3178
  ptr->is_alias= alias ? true : false;
 
3179
  if (lower_case_table_names && table->table.length)
 
3180
    table->table.length= my_casedn_str(files_charset_info, table->table.str);
 
3181
  ptr->table_name=table->table.str;
994
3182
  ptr->table_name_length=table->table.length;
995
3183
  ptr->lock_type=   lock_type;
996
 
  ptr->force_index= table_options.test(TL_OPTION_FORCE_INDEX);
997
 
  ptr->ignore_leaves= table_options.test(TL_OPTION_IGNORE_LEAVES);
 
3184
  ptr->lock_timeout= -1;      /* default timeout */
 
3185
  ptr->lock_transactional= 1; /* allow transactional locks */
 
3186
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
 
3187
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
 
3188
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
998
3189
  ptr->derived=     table->sel;
 
3190
  if (!ptr->derived && !my_strcasecmp(system_charset_info, ptr->db,
 
3191
                                      INFORMATION_SCHEMA_NAME.str))
 
3192
  {
 
3193
    ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->table_name);
 
3194
    if (!schema_table ||
 
3195
        (schema_table->hidden && 
 
3196
         ((sql_command_flags[lex->sql_command] & CF_STATUS_COMMAND) == 0 || 
 
3197
          /*
 
3198
            this check is used for show columns|keys from I_S hidden table
 
3199
          */
 
3200
          lex->sql_command == SQLCOM_SHOW_FIELDS ||
 
3201
          lex->sql_command == SQLCOM_SHOW_KEYS)))
 
3202
    {
 
3203
      my_error(ER_UNKNOWN_TABLE, MYF(0),
 
3204
               ptr->table_name, INFORMATION_SCHEMA_NAME.str);
 
3205
      return(0);
 
3206
    }
 
3207
    ptr->schema_table_name= ptr->table_name;
 
3208
    ptr->schema_table= schema_table;
 
3209
  }
999
3210
  ptr->select_lex=  lex->current_select;
 
3211
  ptr->cacheable_table= 1;
1000
3212
  ptr->index_hints= index_hints_arg;
1001
3213
  ptr->option= option ? option->str : 0;
1002
3214
  /* check that used name is unique */
1007
3219
         tables ;
1008
3220
         tables=tables->next_local)
1009
3221
    {
1010
 
      if (not my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
1011
 
          not my_strcasecmp(system_charset_info, ptr->getSchemaName(), tables->getSchemaName()))
 
3222
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
 
3223
          !strcmp(ptr->db, tables->db))
1012
3224
      {
1013
 
        my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str);
1014
 
        return NULL;
 
3225
        my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str); /* purecov: tested */
 
3226
        return(0);                              /* purecov: tested */
1015
3227
      }
1016
3228
    }
1017
3229
  }
1042
3254
    previous table reference to 'ptr'. Here we also add one element to the
1043
3255
    list 'table_list'.
1044
3256
  */
1045
 
  table_list.link_in_list((unsigned char*) ptr, (unsigned char**) &ptr->next_local);
 
3257
  table_list.link_in_list((uchar*) ptr, (uchar**) &ptr->next_local);
1046
3258
  ptr->next_name_resolution_table= NULL;
1047
3259
  /* Link table in global list (all used tables) */
1048
3260
  lex->add_to_query_tables(ptr);
1049
 
  return ptr;
 
3261
  return(ptr);
1050
3262
}
1051
3263
 
1052
3264
 
1056
3268
    The function initializes a structure of the TableList type
1057
3269
    for a nested join. It sets up its nested join list as empty.
1058
3270
    The created structure is added to the front of the current
1059
 
    join list in the Select_Lex object. Then the function
 
3271
    join list in the st_select_lex object. Then the function
1060
3272
    changes the current nest level for joins to refer to the newly
1061
3273
    created empty list after having saved the info on the old level
1062
3274
    in the initialized structure.
1063
3275
 
1064
 
  @param session         current thread
 
3276
  @param thd         current thread
1065
3277
 
1066
3278
  @retval
1067
3279
    0   if success
1069
3281
    1   otherwise
1070
3282
*/
1071
3283
 
1072
 
bool Select_Lex::init_nested_join(Session *session)
 
3284
bool st_select_lex::init_nested_join(THD *thd)
1073
3285
{
1074
3286
  TableList *ptr;
1075
 
  NestedJoin *nested_join;
1076
 
 
1077
 
  if (!(ptr= (TableList*) session->calloc(ALIGN_SIZE(sizeof(TableList))+
1078
 
                                       sizeof(NestedJoin))))
1079
 
    return true;
1080
 
  ptr->setNestedJoin(((NestedJoin*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList)))));
1081
 
  nested_join= ptr->getNestedJoin();
 
3287
  nested_join_st *nested_join;
 
3288
 
 
3289
  if (!(ptr= (TableList*) thd->calloc(ALIGN_SIZE(sizeof(TableList))+
 
3290
                                       sizeof(nested_join_st))))
 
3291
    return(1);
 
3292
  nested_join= ptr->nested_join=
 
3293
    ((nested_join_st*) ((uchar*) ptr + ALIGN_SIZE(sizeof(TableList))));
 
3294
 
1082
3295
  join_list->push_front(ptr);
1083
 
  ptr->setEmbedding(embedding);
1084
 
  ptr->setJoinList(join_list);
 
3296
  ptr->embedding= embedding;
 
3297
  ptr->join_list= join_list;
1085
3298
  ptr->alias= (char*) "(nested_join)";
1086
3299
  embedding= ptr;
1087
3300
  join_list= &nested_join->join_list;
1088
3301
  join_list->empty();
1089
 
  return false;
 
3302
  return(0);
1090
3303
}
1091
3304
 
1092
3305
 
1097
3310
    If the current level contains only one member, the function
1098
3311
    moves it one level up, eliminating the nest.
1099
3312
 
1100
 
  @param session         current thread
 
3313
  @param thd         current thread
1101
3314
 
1102
3315
  @return
1103
3316
    - Pointer to TableList element added to the total table list, if success
1104
3317
    - 0, otherwise
1105
3318
*/
1106
3319
 
1107
 
TableList *Select_Lex::end_nested_join(Session *)
 
3320
TableList *st_select_lex::end_nested_join(THD *thd __attribute__((unused)))
1108
3321
{
1109
3322
  TableList *ptr;
1110
 
  NestedJoin *nested_join;
 
3323
  nested_join_st *nested_join;
1111
3324
 
1112
3325
  assert(embedding);
1113
3326
  ptr= embedding;
1114
 
  join_list= ptr->getJoinList();
1115
 
  embedding= ptr->getEmbedding();
1116
 
  nested_join= ptr->getNestedJoin();
 
3327
  join_list= ptr->join_list;
 
3328
  embedding= ptr->embedding;
 
3329
  nested_join= ptr->nested_join;
1117
3330
  if (nested_join->join_list.elements == 1)
1118
3331
  {
1119
3332
    TableList *embedded= nested_join->join_list.head();
1120
3333
    join_list->pop();
1121
 
    embedded->setJoinList(join_list);
1122
 
    embedded->setEmbedding(embedding);
 
3334
    embedded->join_list= join_list;
 
3335
    embedded->embedding= embedding;
1123
3336
    join_list->push_front(embedded);
1124
3337
    ptr= embedded;
1125
3338
  }
1126
3339
  else if (nested_join->join_list.elements == 0)
1127
3340
  {
1128
3341
    join_list->pop();
1129
 
    ptr= NULL;                                     // return value
 
3342
    ptr= 0;                                     // return value
1130
3343
  }
1131
 
  return ptr;
 
3344
  return(ptr);
1132
3345
}
1133
3346
 
1134
3347
 
1137
3350
 
1138
3351
    The function nest last join operation as if it was enclosed in braces.
1139
3352
 
1140
 
  @param session         current thread
 
3353
  @param thd         current thread
1141
3354
 
1142
3355
  @retval
1143
3356
    0  Error
1145
3358
    \#  Pointer to TableList element created for the new nested join
1146
3359
*/
1147
3360
 
1148
 
TableList *Select_Lex::nest_last_join(Session *session)
 
3361
TableList *st_select_lex::nest_last_join(THD *thd)
1149
3362
{
1150
3363
  TableList *ptr;
1151
 
  NestedJoin *nested_join;
 
3364
  nested_join_st *nested_join;
1152
3365
  List<TableList> *embedded_list;
1153
3366
 
1154
 
  if (!(ptr= (TableList*) session->calloc(ALIGN_SIZE(sizeof(TableList))+
1155
 
                                          sizeof(NestedJoin))))
1156
 
    return NULL;
1157
 
  ptr->setNestedJoin(((NestedJoin*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList)))));
1158
 
  nested_join= ptr->getNestedJoin();
1159
 
  ptr->setEmbedding(embedding);
1160
 
  ptr->setJoinList(join_list);
 
3367
  if (!(ptr= (TableList*) thd->calloc(ALIGN_SIZE(sizeof(TableList))+
 
3368
                                       sizeof(nested_join_st))))
 
3369
    return(0);
 
3370
  nested_join= ptr->nested_join=
 
3371
    ((nested_join_st*) ((uchar*) ptr + ALIGN_SIZE(sizeof(TableList))));
 
3372
 
 
3373
  ptr->embedding= embedding;
 
3374
  ptr->join_list= join_list;
1161
3375
  ptr->alias= (char*) "(nest_last_join)";
1162
3376
  embedded_list= &nested_join->join_list;
1163
3377
  embedded_list->empty();
1164
3378
 
1165
 
  for (uint32_t i=0; i < 2; i++)
 
3379
  for (uint i=0; i < 2; i++)
1166
3380
  {
1167
3381
    TableList *table= join_list->pop();
1168
 
    table->setJoinList(embedded_list);
1169
 
    table->setEmbedding(ptr);
 
3382
    table->join_list= embedded_list;
 
3383
    table->embedding= ptr;
1170
3384
    embedded_list->push_back(table);
1171
3385
    if (table->natural_join)
1172
3386
    {
1181
3395
  }
1182
3396
  join_list->push_front(ptr);
1183
3397
  nested_join->used_tables= nested_join->not_null_tables= (table_map) 0;
1184
 
  return ptr;
 
3398
  return(ptr);
1185
3399
}
1186
3400
 
1187
3401
 
1189
3403
  Add a table to the current join list.
1190
3404
 
1191
3405
    The function puts a table in front of the current join list
1192
 
    of Select_Lex object.
 
3406
    of st_select_lex object.
1193
3407
    Thus, joined tables are put into this list in the reverse order
1194
3408
    (the most outer join operation follows first).
1195
3409
 
1199
3413
    None
1200
3414
*/
1201
3415
 
1202
 
void Select_Lex::add_joined_table(TableList *table)
 
3416
void st_select_lex::add_joined_table(TableList *table)
1203
3417
{
1204
3418
  join_list->push_front(table);
1205
 
  table->setJoinList(join_list);
1206
 
  table->setEmbedding(embedding);
 
3419
  table->join_list= join_list;
 
3420
  table->embedding= embedding;
 
3421
  return;
1207
3422
}
1208
3423
 
1209
3424
 
1231
3446
      SELECT * FROM t3 LEFT JOIN (t1 LEFT JOIN t2 ON on_expr2) ON on_expr1
1232
3447
   @endverbatim
1233
3448
 
1234
 
  @param session         current thread
 
3449
  @param thd         current thread
1235
3450
 
1236
3451
  @return
1237
3452
    - Pointer to the table representing the inner table, if success
1238
3453
    - 0, otherwise
1239
3454
*/
1240
3455
 
1241
 
TableList *Select_Lex::convert_right_join()
 
3456
TableList *st_select_lex::convert_right_join()
1242
3457
{
1243
3458
  TableList *tab2= join_list->pop();
1244
3459
  TableList *tab1= join_list->pop();
1247
3462
  join_list->push_front(tab1);
1248
3463
  tab1->outer_join|= JOIN_TYPE_RIGHT;
1249
3464
 
1250
 
  return tab1;
 
3465
  return(tab1);
1251
3466
}
1252
3467
 
1253
3468
/**
1261
3476
    query
1262
3477
*/
1263
3478
 
1264
 
void Select_Lex::set_lock_for_tables(thr_lock_type lock_type)
 
3479
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
1265
3480
{
 
3481
  bool for_update= lock_type >= TL_READ_NO_INSERT;
 
3482
 
1266
3483
  for (TableList *tables= (TableList*) table_list.first;
1267
3484
       tables;
1268
3485
       tables= tables->next_local)
1269
3486
  {
1270
3487
    tables->lock_type= lock_type;
 
3488
    tables->updating=  for_update;
1271
3489
  }
 
3490
  return;
1272
3491
}
1273
3492
 
1274
3493
 
1275
3494
/**
1276
 
  Create a fake Select_Lex for a unit.
 
3495
  Create a fake SELECT_LEX for a unit.
1277
3496
 
1278
 
    The method create a fake Select_Lex object for a unit.
 
3497
    The method create a fake SELECT_LEX object for a unit.
1279
3498
    This object is created for any union construct containing a union
1280
3499
    operation and also for any single select union construct of the form
1281
3500
    @verbatim
1282
 
    (SELECT ... ORDER BY order_list [LIMIT n]) ORDER BY ...
 
3501
    (SELECT ... order_st BY order_list [LIMIT n]) order_st BY ... 
1283
3502
    @endvarbatim
1284
3503
    or of the form
1285
3504
    @varbatim
1286
 
    (SELECT ... ORDER BY LIMIT n) ORDER BY ...
 
3505
    (SELECT ... order_st BY LIMIT n) order_st BY ...
1287
3506
    @endvarbatim
1288
 
 
1289
 
  @param session_arg               thread handle
 
3507
  
 
3508
  @param thd_arg                   thread handle
1290
3509
 
1291
3510
  @note
1292
3511
    The object is used to retrieve rows from the temporary table
1298
3517
    0     on success
1299
3518
*/
1300
3519
 
1301
 
bool Select_Lex_Unit::add_fake_select_lex(Session *session_arg)
 
3520
bool st_select_lex_unit::add_fake_select_lex(THD *thd_arg)
1302
3521
{
1303
 
  Select_Lex *first_sl= first_select();
 
3522
  SELECT_LEX *first_sl= first_select();
1304
3523
  assert(!fake_select_lex);
1305
3524
 
1306
 
  if (!(fake_select_lex= new (session_arg->mem_root) Select_Lex()))
 
3525
  if (!(fake_select_lex= new (thd_arg->mem_root) SELECT_LEX()))
1307
3526
      return(1);
1308
 
  fake_select_lex->include_standalone(this,
1309
 
                                      (Select_Lex_Node**)&fake_select_lex);
 
3527
  fake_select_lex->include_standalone(this, 
 
3528
                                      (SELECT_LEX_NODE**)&fake_select_lex);
1310
3529
  fake_select_lex->select_number= INT_MAX;
1311
 
  fake_select_lex->parent_lex= session_arg->lex; /* Used in init_query. */
 
3530
  fake_select_lex->parent_lex= thd_arg->lex; /* Used in init_query. */
1312
3531
  fake_select_lex->make_empty_select();
1313
3532
  fake_select_lex->linkage= GLOBAL_OPTIONS_TYPE;
1314
3533
  fake_select_lex->select_limit= 0;
1315
3534
 
1316
3535
  fake_select_lex->context.outer_context=first_sl->context.outer_context;
1317
 
  /* allow item list resolving in fake select for ORDER BY */
 
3536
  /* allow item list resolving in fake select for order_st BY */
1318
3537
  fake_select_lex->context.resolve_in_select_list= true;
1319
3538
  fake_select_lex->context.select_lex= fake_select_lex;
1320
3539
 
1321
3540
  if (!is_union())
1322
3541
  {
1323
 
    /*
1324
 
      This works only for
1325
 
      (SELECT ... ORDER BY list [LIMIT n]) ORDER BY order_list [LIMIT m],
1326
 
      (SELECT ... LIMIT n) ORDER BY order_list [LIMIT m]
 
3542
    /* 
 
3543
      This works only for 
 
3544
      (SELECT ... order_st BY list [LIMIT n]) order_st BY order_list [LIMIT m],
 
3545
      (SELECT ... LIMIT n) order_st BY order_list [LIMIT m]
1327
3546
      just before the parser starts processing order_list
1328
 
    */
 
3547
    */ 
1329
3548
    global_parameters= fake_select_lex;
1330
3549
    fake_select_lex->no_table_names_allowed= 1;
1331
 
    session_arg->lex->current_select= fake_select_lex;
 
3550
    thd_arg->lex->current_select= fake_select_lex;
1332
3551
  }
1333
 
  session_arg->lex->pop_context();
 
3552
  thd_arg->lex->pop_context();
1334
3553
  return(0);
1335
3554
}
1336
3555
 
1344
3563
    to be used for name resolution, and push the newly created
1345
3564
    context to the stack of contexts of the query.
1346
3565
 
1347
 
  @param session       pointer to current thread
 
3566
  @param thd       pointer to current thread
1348
3567
  @param left_op   left  operand of the JOIN
1349
3568
  @param right_op  rigth operand of the JOIN
1350
3569
 
1355
3574
*/
1356
3575
 
1357
3576
bool
1358
 
push_new_name_resolution_context(Session *session,
 
3577
push_new_name_resolution_context(THD *thd,
1359
3578
                                 TableList *left_op, TableList *right_op)
1360
3579
{
1361
3580
  Name_resolution_context *on_context;
1362
 
  if (!(on_context= new (session->mem_root) Name_resolution_context))
 
3581
  if (!(on_context= new (thd->mem_root) Name_resolution_context))
1363
3582
    return true;
1364
3583
  on_context->init();
1365
3584
  on_context->first_name_resolution_table=
1366
3585
    left_op->first_leaf_for_name_resolution();
1367
3586
  on_context->last_name_resolution_table=
1368
3587
    right_op->last_leaf_for_name_resolution();
1369
 
  return session->lex->push_context(on_context);
 
3588
  return thd->lex->push_context(on_context);
1370
3589
}
1371
3590
 
1372
3591
 
1438
3657
*/
1439
3658
 
1440
3659
void add_join_natural(TableList *a, TableList *b, List<String> *using_fields,
1441
 
                      Select_Lex *lex)
 
3660
                      SELECT_LEX *lex)
1442
3661
{
1443
3662
  b->natural_join= a;
1444
3663
  lex->prev_join_using= using_fields;
1446
3665
 
1447
3666
 
1448
3667
/**
 
3668
  Reload/resets privileges and the different caches.
 
3669
 
 
3670
  @param thd Thread handler (can be NULL!)
 
3671
  @param options What should be reset/reloaded (tables, privileges, slave...)
 
3672
  @param tables Tables to flush (if any)
 
3673
  @param write_to_binlog True if we can write to the binlog.
 
3674
               
 
3675
  @note Depending on 'options', it may be very bad to write the
 
3676
    query to the binlog (e.g. FLUSH SLAVE); this is a
 
3677
    pointer where reload_cache() will put 0 if
 
3678
    it thinks we really should not write to the binlog.
 
3679
    Otherwise it will put 1.
 
3680
 
 
3681
  @return Error status code
 
3682
    @retval 0 Ok
 
3683
    @retval !=0  Error; thd->killed is set or thd->is_error() is true
 
3684
*/
 
3685
 
 
3686
bool reload_cache(THD *thd, ulong options, TableList *tables,
 
3687
                          bool *write_to_binlog)
 
3688
{
 
3689
  bool result=0;
 
3690
  select_errors=0;                              /* Write if more errors */
 
3691
  bool tmp_write_to_binlog= 1;
 
3692
 
 
3693
  assert(!thd || !thd->in_sub_stmt);
 
3694
 
 
3695
  if (options & REFRESH_LOG)
 
3696
  {
 
3697
    /*
 
3698
      Flush the normal query log, the update log, the binary log,
 
3699
      the slow query log, the relay log (if it exists) and the log
 
3700
      tables.
 
3701
    */
 
3702
 
 
3703
    /*
 
3704
      Writing this command to the binlog may result in infinite loops
 
3705
      when doing mysqlbinlog|mysql, and anyway it does not really make
 
3706
      sense to log it automatically (would cause more trouble to users
 
3707
      than it would help them)
 
3708
    */
 
3709
    tmp_write_to_binlog= 0;
 
3710
    if( mysql_bin_log.is_open() )
 
3711
    {
 
3712
      mysql_bin_log.rotate_and_purge(RP_FORCE_ROTATE);
 
3713
    }
 
3714
    pthread_mutex_lock(&LOCK_active_mi);
 
3715
    rotate_relay_log(active_mi);
 
3716
    pthread_mutex_unlock(&LOCK_active_mi);
 
3717
 
 
3718
    /* flush slow and general logs */
 
3719
    logger.flush_logs(thd);
 
3720
 
 
3721
    if (ha_flush_logs(NULL))
 
3722
      result=1;
 
3723
    if (flush_error_log())
 
3724
      result=1;
 
3725
  }
 
3726
  /*
 
3727
    Note that if REFRESH_READ_LOCK bit is set then REFRESH_TABLES is set too
 
3728
    (see sql_yacc.yy)
 
3729
  */
 
3730
  if (options & (REFRESH_TABLES | REFRESH_READ_LOCK)) 
 
3731
  {
 
3732
    if ((options & REFRESH_READ_LOCK) && thd)
 
3733
    {
 
3734
      /*
 
3735
        We must not try to aspire a global read lock if we have a write
 
3736
        locked table. This would lead to a deadlock when trying to
 
3737
        reopen (and re-lock) the table after the flush.
 
3738
      */
 
3739
      if (thd->locked_tables)
 
3740
      {
 
3741
        THR_LOCK_DATA **lock_p= thd->locked_tables->locks;
 
3742
        THR_LOCK_DATA **end_p= lock_p + thd->locked_tables->lock_count;
 
3743
 
 
3744
        for (; lock_p < end_p; lock_p++)
 
3745
        {
 
3746
          if ((*lock_p)->type >= TL_WRITE_ALLOW_WRITE)
 
3747
          {
 
3748
            my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
 
3749
            return 1;
 
3750
          }
 
3751
        }
 
3752
      }
 
3753
      /*
 
3754
        Writing to the binlog could cause deadlocks, as we don't log
 
3755
        UNLOCK TABLES
 
3756
      */
 
3757
      tmp_write_to_binlog= 0;
 
3758
      if (lock_global_read_lock(thd))
 
3759
        return 1;                               // Killed
 
3760
      result= close_cached_tables(thd, tables, false, (options & REFRESH_FAST) ?
 
3761
                                  false : true, true);
 
3762
      if (make_global_read_lock_block_commit(thd)) // Killed
 
3763
      {
 
3764
        /* Don't leave things in a half-locked state */
 
3765
        unlock_global_read_lock(thd);
 
3766
        return 1;
 
3767
      }
 
3768
    }
 
3769
    else
 
3770
      result= close_cached_tables(thd, tables, false, (options & REFRESH_FAST) ?
 
3771
                                  false : true, false);
 
3772
    my_dbopt_cleanup();
 
3773
  }
 
3774
  if (thd && (options & REFRESH_STATUS))
 
3775
    refresh_status(thd);
 
3776
  if (options & REFRESH_THREADS)
 
3777
    flush_thread_cache();
 
3778
  if (options & REFRESH_MASTER)
 
3779
  {
 
3780
    assert(thd);
 
3781
    tmp_write_to_binlog= 0;
 
3782
    if (reset_master(thd))
 
3783
    {
 
3784
      result=1;
 
3785
    }
 
3786
  }
 
3787
 if (options & REFRESH_SLAVE)
 
3788
 {
 
3789
   tmp_write_to_binlog= 0;
 
3790
   pthread_mutex_lock(&LOCK_active_mi);
 
3791
   if (reset_slave(thd, active_mi))
 
3792
     result=1;
 
3793
   pthread_mutex_unlock(&LOCK_active_mi);
 
3794
 }
 
3795
 *write_to_binlog= tmp_write_to_binlog;
 
3796
 return result;
 
3797
}
 
3798
 
 
3799
 
 
3800
/**
 
3801
  kill on thread.
 
3802
 
 
3803
  @param thd                    Thread class
 
3804
  @param id                     Thread id
 
3805
  @param only_kill_query        Should it kill the query or the connection
 
3806
 
 
3807
  @note
 
3808
    This is written such that we have a short lock on LOCK_thread_count
 
3809
*/
 
3810
 
 
3811
static unsigned int
 
3812
kill_one_thread(THD *thd __attribute__((unused)),
 
3813
                ulong id, bool only_kill_query)
 
3814
{
 
3815
  THD *tmp;
 
3816
  uint error=ER_NO_SUCH_THREAD;
 
3817
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
 
3818
  I_List_iterator<THD> it(threads);
 
3819
  while ((tmp=it++))
 
3820
  {
 
3821
    if (tmp->command == COM_DAEMON)
 
3822
      continue;
 
3823
    if (tmp->thread_id == id)
 
3824
    {
 
3825
      pthread_mutex_lock(&tmp->LOCK_delete);    // Lock from delete
 
3826
      break;
 
3827
    }
 
3828
  }
 
3829
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
 
3830
  if (tmp)
 
3831
  {
 
3832
    tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
 
3833
    error=0;
 
3834
    pthread_mutex_unlock(&tmp->LOCK_delete);
 
3835
  }
 
3836
  return(error);
 
3837
}
 
3838
 
 
3839
 
 
3840
/*
 
3841
  kills a thread and sends response
 
3842
 
 
3843
  SYNOPSIS
 
3844
    sql_kill()
 
3845
    thd                 Thread class
 
3846
    id                  Thread id
 
3847
    only_kill_query     Should it kill the query or the connection
 
3848
*/
 
3849
 
 
3850
void sql_kill(THD *thd, ulong id, bool only_kill_query)
 
3851
{
 
3852
  uint error;
 
3853
  if (!(error= kill_one_thread(thd, id, only_kill_query)))
 
3854
    my_ok(thd);
 
3855
  else
 
3856
    my_error(error, MYF(0), id);
 
3857
}
 
3858
 
 
3859
 
 
3860
/** If pointer is not a null pointer, append filename to it. */
 
3861
 
 
3862
bool append_file_to_dir(THD *thd, const char **filename_ptr,
 
3863
                        const char *table_name)
 
3864
{
 
3865
  char buff[FN_REFLEN],*ptr, *end;
 
3866
  if (!*filename_ptr)
 
3867
    return 0;                                   // nothing to do
 
3868
 
 
3869
  /* Check that the filename is not too long and it's a hard path */
 
3870
  if (strlen(*filename_ptr)+strlen(table_name) >= FN_REFLEN-1 ||
 
3871
      !test_if_hard_path(*filename_ptr))
 
3872
  {
 
3873
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
 
3874
    return 1;
 
3875
  }
 
3876
  /* Fix is using unix filename format on dos */
 
3877
  stpcpy(buff,*filename_ptr);
 
3878
  end=convert_dirname(buff, *filename_ptr, NullS);
 
3879
  if (!(ptr= (char*) thd->alloc((size_t) (end-buff) + strlen(table_name)+1)))
 
3880
    return 1;                                   // End of memory
 
3881
  *filename_ptr=ptr;
 
3882
  strxmov(ptr,buff,table_name,NullS);
 
3883
  return 0;
 
3884
}
 
3885
 
 
3886
 
 
3887
/**
1449
3888
  Check if the select is a simple select (not an union).
1450
3889
 
1451
3890
  @retval
1454
3893
    1   error   ; In this case the error messege is sent to the client
1455
3894
*/
1456
3895
 
1457
 
bool check_simple_select(Session::pointer session)
 
3896
bool check_simple_select()
1458
3897
{
1459
 
  LEX *lex= session->lex;
 
3898
  THD *thd= current_thd;
 
3899
  LEX *lex= thd->lex;
1460
3900
  if (lex->current_select != &lex->select_lex)
1461
3901
  {
1462
3902
    char command[80];
1463
 
    Lex_input_stream *lip= session->m_lip;
1464
 
    strncpy(command, lip->yylval->symbol.str,
1465
 
            min(lip->yylval->symbol.length, (uint32_t)(sizeof(command)-1)));
1466
 
    command[min(lip->yylval->symbol.length, (uint32_t)(sizeof(command)-1))]=0;
 
3903
    Lex_input_stream *lip= thd->m_lip;
 
3904
    strmake(command, lip->yylval->symbol.str,
 
3905
            min((ulong)lip->yylval->symbol.length, sizeof(command)-1));
1467
3906
    my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
1468
3907
    return 1;
1469
3908
  }
1471
3910
}
1472
3911
 
1473
3912
 
 
3913
Comp_creator *comp_eq_creator(bool invert)
 
3914
{
 
3915
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
 
3916
}
 
3917
 
 
3918
 
 
3919
Comp_creator *comp_ge_creator(bool invert)
 
3920
{
 
3921
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
 
3922
}
 
3923
 
 
3924
 
 
3925
Comp_creator *comp_gt_creator(bool invert)
 
3926
{
 
3927
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
 
3928
}
 
3929
 
 
3930
 
 
3931
Comp_creator *comp_le_creator(bool invert)
 
3932
{
 
3933
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
 
3934
}
 
3935
 
 
3936
 
 
3937
Comp_creator *comp_lt_creator(bool invert)
 
3938
{
 
3939
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
 
3940
}
 
3941
 
 
3942
 
 
3943
Comp_creator *comp_ne_creator(bool invert)
 
3944
{
 
3945
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
 
3946
}
 
3947
 
 
3948
 
1474
3949
/**
1475
3950
  Construct ALL/ANY/SOME subquery Item.
1476
3951
 
1483
3958
    constructed Item (or 0 if out of memory)
1484
3959
*/
1485
3960
Item * all_any_subquery_creator(Item *left_expr,
1486
 
                                chooser_compare_func_creator cmp,
1487
 
                                bool all,
1488
 
                                Select_Lex *select_lex)
 
3961
                                chooser_compare_func_creator cmp,
 
3962
                                bool all,
 
3963
                                SELECT_LEX *select_lex)
1489
3964
{
1490
3965
  if ((cmp == &comp_eq_creator) && !all)       //  = ANY <=> IN
1491
3966
    return new Item_in_subselect(left_expr, select_lex);
1503
3978
 
1504
3979
 
1505
3980
/**
1506
 
  Update query pre-check.
 
3981
  Multi update query pre-check.
1507
3982
 
1508
 
  @param session                Thread handler
 
3983
  @param thd            Thread handler
1509
3984
  @param tables Global/local table list (have to be the same)
1510
3985
 
1511
3986
  @retval
1514
3989
    true  Error
1515
3990
*/
1516
3991
 
1517
 
bool update_precheck(Session *session, TableList *)
 
3992
bool multi_update_precheck(THD *thd,
 
3993
                           TableList *tables __attribute__((unused)))
1518
3994
{
1519
3995
  const char *msg= 0;
1520
 
  LEX *lex= session->lex;
1521
 
  Select_Lex *select_lex= &lex->select_lex;
 
3996
  LEX *lex= thd->lex;
 
3997
  SELECT_LEX *select_lex= &lex->select_lex;
1522
3998
 
1523
 
  if (session->lex->select_lex.item_list.elements != session->lex->value_list.elements)
 
3999
  if (select_lex->item_list.elements != lex->value_list.elements)
1524
4000
  {
1525
4001
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
1526
4002
    return(true);
1527
4003
  }
1528
4004
 
1529
 
  if (session->lex->select_lex.table_list.elements > 1)
1530
 
  {
1531
 
    if (select_lex->order_list.elements)
1532
 
      msg= "ORDER BY";
1533
 
    else if (select_lex->select_limit)
1534
 
      msg= "LIMIT";
1535
 
    if (msg)
 
4005
  if (select_lex->order_list.elements)
 
4006
    msg= "ORDER BY";
 
4007
  else if (select_lex->select_limit)
 
4008
    msg= "LIMIT";
 
4009
  if (msg)
 
4010
  {
 
4011
    my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
 
4012
    return(true);
 
4013
  }
 
4014
  return(false);
 
4015
}
 
4016
 
 
4017
/**
 
4018
  Multi delete query pre-check.
 
4019
 
 
4020
  @param thd                    Thread handler
 
4021
  @param tables         Global/local table list
 
4022
 
 
4023
  @retval
 
4024
    false OK
 
4025
  @retval
 
4026
    true  error
 
4027
*/
 
4028
 
 
4029
bool multi_delete_precheck(THD *thd,
 
4030
                           TableList *tables __attribute__((unused)))
 
4031
{
 
4032
  SELECT_LEX *select_lex= &thd->lex->select_lex;
 
4033
  TableList **save_query_tables_own_last= thd->lex->query_tables_own_last;
 
4034
 
 
4035
  thd->lex->query_tables_own_last= 0;
 
4036
  thd->lex->query_tables_own_last= save_query_tables_own_last;
 
4037
 
 
4038
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
 
4039
  {
 
4040
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
 
4041
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
 
4042
    return(true);
 
4043
  }
 
4044
  return(false);
 
4045
}
 
4046
 
 
4047
 
 
4048
/*
 
4049
  Given a table in the source list, find a correspondent table in the
 
4050
  table references list.
 
4051
 
 
4052
  @param lex Pointer to LEX representing multi-delete.
 
4053
  @param src Source table to match.
 
4054
  @param ref Table references list.
 
4055
 
 
4056
  @remark The source table list (tables listed before the FROM clause
 
4057
  or tables listed in the FROM clause before the USING clause) may
 
4058
  contain table names or aliases that must match unambiguously one,
 
4059
  and only one, table in the target table list (table references list,
 
4060
  after FROM/USING clause).
 
4061
 
 
4062
  @return Matching table, NULL otherwise.
 
4063
*/
 
4064
 
 
4065
static TableList *multi_delete_table_match(LEX *lex __attribute__((unused)),
 
4066
                                            TableList *tbl,
 
4067
                                            TableList *tables)
 
4068
{
 
4069
  TableList *match= NULL;
 
4070
 
 
4071
  for (TableList *elem= tables; elem; elem= elem->next_local)
 
4072
  {
 
4073
    int cmp;
 
4074
 
 
4075
    if (tbl->is_fqtn && elem->is_alias)
 
4076
      continue; /* no match */
 
4077
    if (tbl->is_fqtn && elem->is_fqtn)
 
4078
      cmp= my_strcasecmp(table_alias_charset, tbl->table_name, elem->table_name) ||
 
4079
           strcmp(tbl->db, elem->db);
 
4080
    else if (elem->is_alias)
 
4081
      cmp= my_strcasecmp(table_alias_charset, tbl->alias, elem->alias);
 
4082
    else
 
4083
      cmp= my_strcasecmp(table_alias_charset, tbl->table_name, elem->table_name) ||
 
4084
           strcmp(tbl->db, elem->db);
 
4085
 
 
4086
    if (cmp)
 
4087
      continue;
 
4088
 
 
4089
    if (match)
1536
4090
    {
1537
 
      my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
 
4091
      my_error(ER_NONUNIQ_TABLE, MYF(0), elem->alias);
 
4092
      return(NULL);
 
4093
    }
 
4094
 
 
4095
    match= elem;
 
4096
  }
 
4097
 
 
4098
  if (!match)
 
4099
    my_error(ER_UNKNOWN_TABLE, MYF(0), tbl->table_name, "MULTI DELETE");
 
4100
 
 
4101
  return(match);
 
4102
}
 
4103
 
 
4104
 
 
4105
/**
 
4106
  Link tables in auxilary table list of multi-delete with corresponding
 
4107
  elements in main table list, and set proper locks for them.
 
4108
 
 
4109
  @param lex   pointer to LEX representing multi-delete
 
4110
 
 
4111
  @retval
 
4112
    false   success
 
4113
  @retval
 
4114
    true    error
 
4115
*/
 
4116
 
 
4117
bool multi_delete_set_locks_and_link_aux_tables(LEX *lex)
 
4118
{
 
4119
  TableList *tables= (TableList*)lex->select_lex.table_list.first;
 
4120
  TableList *target_tbl;
 
4121
 
 
4122
  lex->table_count= 0;
 
4123
 
 
4124
  for (target_tbl= (TableList *)lex->auxiliary_table_list.first;
 
4125
       target_tbl; target_tbl= target_tbl->next_local)
 
4126
  {
 
4127
    lex->table_count++;
 
4128
    /* All tables in aux_tables must be found in FROM PART */
 
4129
    TableList *walk= multi_delete_table_match(lex, target_tbl, tables);
 
4130
    if (!walk)
1538
4131
      return(true);
 
4132
    if (!walk->derived)
 
4133
    {
 
4134
      target_tbl->table_name= walk->table_name;
 
4135
      target_tbl->table_name_length= walk->table_name_length;
1539
4136
    }
 
4137
    walk->updating= target_tbl->updating;
 
4138
    walk->lock_type= target_tbl->lock_type;
 
4139
    target_tbl->correspondent_table= walk;      // Remember corresponding table
 
4140
  }
 
4141
  return(false);
 
4142
}
 
4143
 
 
4144
 
 
4145
/**
 
4146
  simple UPDATE query pre-check.
 
4147
 
 
4148
  @param thd            Thread handler
 
4149
  @param tables Global table list
 
4150
 
 
4151
  @retval
 
4152
    false OK
 
4153
  @retval
 
4154
    true  Error
 
4155
*/
 
4156
 
 
4157
bool update_precheck(THD *thd, TableList *tables __attribute__((unused)))
 
4158
{
 
4159
  if (thd->lex->select_lex.item_list.elements != thd->lex->value_list.elements)
 
4160
  {
 
4161
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
 
4162
    return(true);
1540
4163
  }
1541
4164
  return(false);
1542
4165
}
1545
4168
/**
1546
4169
  simple INSERT query pre-check.
1547
4170
 
1548
 
  @param session                Thread handler
 
4171
  @param thd            Thread handler
1549
4172
  @param tables Global table list
1550
4173
 
1551
4174
  @retval
1554
4177
    true   error
1555
4178
*/
1556
4179
 
1557
 
bool insert_precheck(Session *session, TableList *)
 
4180
bool insert_precheck(THD *thd, TableList *tables __attribute__((unused)))
1558
4181
{
1559
 
  LEX *lex= session->lex;
 
4182
  LEX *lex= thd->lex;
1560
4183
 
1561
4184
  /*
1562
4185
    Check that we have modify privileges for the first table and
1572
4195
 
1573
4196
 
1574
4197
/**
 
4198
  CREATE TABLE query pre-check.
 
4199
 
 
4200
  @param thd                    Thread handler
 
4201
  @param tables         Global table list
 
4202
  @param create_table           Table which will be created
 
4203
 
 
4204
  @retval
 
4205
    false   OK
 
4206
  @retval
 
4207
    true   Error
 
4208
*/
 
4209
 
 
4210
bool create_table_precheck(THD *thd,
 
4211
                           TableList *tables __attribute__((unused)),
 
4212
                           TableList *create_table)
 
4213
{
 
4214
  LEX *lex= thd->lex;
 
4215
  SELECT_LEX *select_lex= &lex->select_lex;
 
4216
  bool error= true;                                 // Error message is given
 
4217
 
 
4218
  if (create_table && (strcmp(create_table->db, "information_schema") == 0))
 
4219
  {
 
4220
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0), "", "", INFORMATION_SCHEMA_NAME.str);
 
4221
    return(true);
 
4222
  }
 
4223
 
 
4224
  if (select_lex->item_list.elements)
 
4225
  {
 
4226
    /* Check permissions for used tables in CREATE TABLE ... SELECT */
 
4227
 
 
4228
#ifdef NOT_NECESSARY_TO_CHECK_CREATE_TABLE_EXIST_WHEN_PREPARING_STATEMENT
 
4229
    /* This code throws an ill error for CREATE TABLE t1 SELECT * FROM t1 */
 
4230
    /*
 
4231
      Only do the check for PS, because we on execute we have to check that
 
4232
      against the opened tables to ensure we don't use a table that is part
 
4233
      of the view (which can only be done after the table has been opened).
 
4234
    */
 
4235
    if (thd->stmt_arena->is_stmt_prepare_or_first_sp_execute())
 
4236
    {
 
4237
      /*
 
4238
        For temporary tables we don't have to check if the created table exists
 
4239
      */
 
4240
      if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) &&
 
4241
          find_table_in_global_list(tables, create_table->db,
 
4242
                                    create_table->table_name))
 
4243
      {
 
4244
        error= false;
 
4245
        goto err;
 
4246
      }
 
4247
    }
 
4248
#endif
 
4249
  }
 
4250
  error= false;
 
4251
 
 
4252
  return(error);
 
4253
}
 
4254
 
 
4255
 
 
4256
/**
1575
4257
  negate given expression.
1576
4258
 
1577
 
  @param session  thread handler
 
4259
  @param thd  thread handler
1578
4260
  @param expr expression for negation
1579
4261
 
1580
4262
  @return
1581
4263
    negated expression
1582
4264
*/
1583
4265
 
1584
 
Item *negate_expression(Session *session, Item *expr)
 
4266
Item *negate_expression(THD *thd, Item *expr)
1585
4267
{
1586
4268
  Item *negated;
1587
4269
  if (expr->type() == Item::FUNC_ITEM &&
1589
4271
  {
1590
4272
    /* it is NOT(NOT( ... )) */
1591
4273
    Item *arg= ((Item_func *) expr)->arguments()[0];
1592
 
    enum_parsing_place place= session->lex->current_select->parsing_place;
 
4274
    enum_parsing_place place= thd->lex->current_select->parsing_place;
1593
4275
    if (arg->is_bool_func() || place == IN_WHERE || place == IN_HAVING)
1594
4276
      return arg;
1595
4277
    /*
1599
4281
    return new Item_func_ne(arg, new Item_int((char*) "0", 0, 1));
1600
4282
  }
1601
4283
 
1602
 
  if ((negated= expr->neg_transformer(session)) != 0)
 
4284
  if ((negated= expr->neg_transformer(thd)) != 0)
1603
4285
    return negated;
1604
4286
  return new Item_func_not(expr);
1605
4287
}
1606
4288
 
1607
4289
 
 
4290
/**
 
4291
  Check that byte length of a string does not exceed some limit.
 
4292
 
 
4293
  @param str         string to be checked
 
4294
  @param err_msg     error message to be displayed if the string is too long
 
4295
  @param max_length  max length
 
4296
 
 
4297
  @retval
 
4298
    false   the passed string is not longer than max_length
 
4299
  @retval
 
4300
    true    the passed string is longer than max_length
 
4301
 
 
4302
  NOTE
 
4303
    The function is not used in existing code but can be useful later?
 
4304
*/
 
4305
 
 
4306
bool check_string_byte_length(LEX_STRING *str, const char *err_msg,
 
4307
                              uint max_byte_length)
 
4308
{
 
4309
  if (str->length <= max_byte_length)
 
4310
    return false;
 
4311
 
 
4312
  my_error(ER_WRONG_STRING_LENGTH, MYF(0), str->str, err_msg, max_byte_length);
 
4313
 
 
4314
  return true;
 
4315
}
 
4316
 
 
4317
 
1608
4318
/*
1609
4319
  Check that char length of a string does not exceed some limit.
1610
4320
 
1622
4332
 
1623
4333
 
1624
4334
bool check_string_char_length(LEX_STRING *str, const char *err_msg,
1625
 
                              uint32_t max_char_length, const CHARSET_INFO * const cs,
 
4335
                              uint max_char_length, const CHARSET_INFO * const cs,
1626
4336
                              bool no_error)
1627
4337
{
1628
4338
  int well_formed_error;
1629
 
  uint32_t res= cs->cset->well_formed_len(cs, str->str, str->str + str->length,
 
4339
  uint res= cs->cset->well_formed_len(cs, str->str, str->str + str->length,
1630
4340
                                      max_char_length, &well_formed_error);
1631
4341
 
1632
4342
  if (!well_formed_error &&  str->length == res)
1638
4348
}
1639
4349
 
1640
4350
 
1641
 
bool check_identifier_name(LEX_STRING *str, error_t err_code,
1642
 
                           uint32_t max_char_length,
1643
 
                           const char *param_for_err_msg)
 
4351
bool check_identifier_name(LEX_STRING *str, uint max_char_length,
 
4352
                           uint err_code, const char *param_for_err_msg)
1644
4353
{
 
4354
#ifdef HAVE_CHARSET_utf8mb3
1645
4355
  /*
1646
4356
    We don't support non-BMP characters in identifiers at the moment,
1647
4357
    so they should be prohibited until such support is done.
1648
4358
    This is why we use the 3-byte utf8 to check well-formedness here.
1649
4359
  */
1650
 
  const CHARSET_INFO * const cs= &my_charset_utf8mb4_general_ci;
1651
 
 
 
4360
  const CHARSET_INFO * const cs= &my_charset_utf8mb3_general_ci;
 
4361
#else
 
4362
  const CHARSET_INFO * const cs= system_charset_info;
 
4363
#endif
1652
4364
  int well_formed_error;
1653
 
  uint32_t res= cs->cset->well_formed_len(cs, str->str, str->str + str->length,
 
4365
  uint res= cs->cset->well_formed_len(cs, str->str, str->str + str->length,
1654
4366
                                      max_char_length, &well_formed_error);
1655
4367
 
1656
4368
  if (well_formed_error)
1658
4370
    my_error(ER_INVALID_CHARACTER_STRING, MYF(0), "identifier", str->str);
1659
4371
    return true;
1660
4372
  }
1661
 
 
 
4373
  
1662
4374
  if (str->length == res)
1663
4375
    return false;
1664
4376
 
1665
4377
  switch (err_code)
1666
4378
  {
1667
 
  case EE_OK:
 
4379
  case 0:
1668
4380
    break;
1669
4381
  case ER_WRONG_STRING_LENGTH:
1670
4382
    my_error(err_code, MYF(0), str->str, param_for_err_msg, max_char_length);
1676
4388
    assert(0);
1677
4389
    break;
1678
4390
  }
1679
 
 
1680
4391
  return true;
1681
4392
}
1682
4393
 
1683
4394
 
 
4395
/*
 
4396
  Check if path does not contain mysql data home directory
 
4397
  SYNOPSIS
 
4398
    test_if_data_home_dir()
 
4399
    dir                     directory
 
4400
    conv_home_dir           converted data home directory
 
4401
    home_dir_len            converted data home directory length
 
4402
 
 
4403
  RETURN VALUES
 
4404
    0   ok
 
4405
    1   error  
 
4406
*/
 
4407
 
 
4408
bool test_if_data_home_dir(const char *dir)
 
4409
{
 
4410
  char path[FN_REFLEN], conv_path[FN_REFLEN];
 
4411
  uint dir_len, home_dir_len= strlen(mysql_unpacked_real_data_home);
 
4412
 
 
4413
  if (!dir)
 
4414
    return(0);
 
4415
 
 
4416
  (void) fn_format(path, dir, "", "",
 
4417
                   (MY_RETURN_REAL_PATH|MY_RESOLVE_SYMLINKS));
 
4418
  dir_len= unpack_dirname(conv_path, dir);
 
4419
 
 
4420
  if (home_dir_len < dir_len)
 
4421
  {
 
4422
    if (!my_strnncoll(character_set_filesystem,
 
4423
                      (const uchar*) conv_path, home_dir_len,
 
4424
                      (const uchar*) mysql_unpacked_real_data_home,
 
4425
                      home_dir_len))
 
4426
      return(1);
 
4427
  }
 
4428
  return(0);
 
4429
}
 
4430
 
 
4431
 
 
4432
extern int MYSQLparse(void *thd); // from sql_yacc.cc
 
4433
 
 
4434
 
1684
4435
/**
1685
 
  This is a wrapper of DRIZZLEparse(). All the code should call parse_sql()
1686
 
  instead of DRIZZLEparse().
 
4436
  This is a wrapper of MYSQLparse(). All the code should call parse_sql()
 
4437
  instead of MYSQLparse().
1687
4438
 
1688
 
  @param session Thread context.
 
4439
  @param thd Thread context.
1689
4440
  @param lip Lexer context.
1690
4441
 
1691
4442
  @return Error status.
1693
4444
    @retval true on parsing error.
1694
4445
*/
1695
4446
 
1696
 
static bool parse_sql(Session *session, Lex_input_stream *lip)
 
4447
bool parse_sql(THD *thd, Lex_input_stream *lip)
1697
4448
{
1698
 
  assert(session->m_lip == NULL);
1699
 
 
1700
 
  DRIZZLE_QUERY_PARSE_START(session->getQueryString()->c_str());
 
4449
  assert(thd->m_lip == NULL);
1701
4450
 
1702
4451
  /* Set Lex_input_stream. */
1703
4452
 
1704
 
  session->m_lip= lip;
 
4453
  thd->m_lip= lip;
1705
4454
 
1706
4455
  /* Parse the query. */
1707
4456
 
1708
 
  bool parse_status= DRIZZLEparse(session) != 0;
1709
 
 
1710
 
  /* Check that if DRIZZLEparse() failed, session->is_error() is set. */
1711
 
 
1712
 
  assert(!parse_status || session->is_error());
 
4457
  bool mysql_parse_status= MYSQLparse(thd) != 0;
 
4458
 
 
4459
  /* Check that if MYSQLparse() failed, thd->is_error() is set. */
 
4460
 
 
4461
  assert(!mysql_parse_status || thd->is_error());
1713
4462
 
1714
4463
  /* Reset Lex_input_stream. */
1715
4464
 
1716
 
  session->m_lip= NULL;
1717
 
 
1718
 
  DRIZZLE_QUERY_PARSE_DONE(parse_status || session->is_fatal_error);
 
4465
  thd->m_lip= NULL;
1719
4466
 
1720
4467
  /* That's it. */
1721
4468
 
1722
 
  return parse_status || session->is_fatal_error;
 
4469
  return mysql_parse_status || thd->is_fatal_error;
1723
4470
}
1724
4471
 
1725
4472
/**
1726
4473
  @} (end of group Runtime_Environment)
1727
4474
*/
1728
 
 
1729
 
} /* namespace drizzled */