sql_parse.cc 198 KB
Newer Older
1
/* Copyright (C) 2000-2003 MySQL AB
2

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
7

unknown's avatar
unknown committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
12

unknown's avatar
unknown committed
13 14 15 16 17
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

#include "mysql_priv.h"
18
#include "sql_repl.h"
19
#include "repl_failsafe.h"
unknown's avatar
unknown committed
20 21 22 23
#include <m_ctype.h>
#include <myisam.h>
#include <my_dir.h>

unknown's avatar
unknown committed
24
#ifdef HAVE_INNOBASE_DB
25
#include "ha_innodb.h"
unknown's avatar
unknown committed
26 27
#endif

28
#include "sp_head.h"
29
#include "sp.h"
30

unknown's avatar
unknown committed
31 32 33 34 35 36 37 38 39 40 41
#ifdef HAVE_OPENSSL
/*
  Without SSL the handshake consists of one packet. This packet
  has both client capabilites and scrambled password.
  With SSL the handshake might consist of two packets. If the first
  packet (client capabilities) has CLIENT_SSL flag set, we have to
  switch to SSL and read the second packet. The scrambled password
  is in the second packet and client_capabilites field will be ignored.
  Maybe it is better to accept flags other than CLIENT_SSL from the
  second packet?
*/
unknown's avatar
unknown committed
42 43 44
#define SSL_HANDSHAKE_SIZE      2
#define NORMAL_HANDSHAKE_SIZE   6
#define MIN_HANDSHAKE_SIZE      2
unknown's avatar
unknown committed
45
#else
unknown's avatar
unknown committed
46
#define MIN_HANDSHAKE_SIZE      6
unknown's avatar
unknown committed
47
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
48

49 50 51 52 53 54
/* Used in error handling only */
#define SP_TYPE_STRING(LP) \
  ((LP)->sphead->m_type == TYPE_ENUM_FUNCTION ? "FUNCTION" : "PROCEDURE")
#define SP_COM_STRING(LP) \
  ((LP)->sql_command == SQLCOM_CREATE_SPFUNCTION || \
   (LP)->sql_command == SQLCOM_ALTER_FUNCTION || \
55
   (LP)->sql_command == SQLCOM_SHOW_CREATE_FUNC || \
56 57 58
   (LP)->sql_command == SQLCOM_DROP_FUNCTION ? \
   "FUNCTION" : "PROCEDURE")

59 60 61
#ifdef SOLARIS
extern "C" int gethostname(char *name, int namelen);
#endif
unknown's avatar
unknown committed
62

63
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc);
unknown's avatar
unknown committed
64
#ifndef NO_EMBEDDED_ACCESS_CHECKS
65
static int check_for_max_user_connections(THD *thd, USER_CONN *uc);
unknown's avatar
unknown committed
66
#endif
67
static void decrease_user_connections(USER_CONN *uc);
unknown's avatar
unknown committed
68
static bool check_db_used(THD *thd,TABLE_LIST *tables);
unknown's avatar
unknown committed
69
static bool check_multi_update_lock(THD *thd);
unknown's avatar
unknown committed
70 71
static void remove_escape(char *name);
static void refresh_status(void);
unknown's avatar
unknown committed
72 73
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name);
74
static void log_slow_query(THD *thd);
unknown's avatar
unknown committed
75

76
const char *any_db="*any*";	// Special symbol for check_access
unknown's avatar
unknown committed
77 78 79 80

const char *command_name[]={
  "Sleep", "Quit", "Init DB", "Query", "Field List", "Create DB",
  "Drop DB", "Refresh", "Shutdown", "Statistics", "Processlist",
81
  "Connect","Kill","Debug","Ping","Time","Delayed insert","Change user",
unknown's avatar
unknown committed
82
  "Binlog Dump","Table Dump",  "Connect Out", "Register Slave",
83
  "Prepare", "Execute", "Long Data", "Close stmt",
84
  "Reset stmt", "Set option", "Fetch",
85
  "Error"					// Last command number
unknown's avatar
unknown committed
86 87
};

unknown's avatar
unknown committed
88 89 90 91
const char *xa_state_names[]={
  "NON-EXISTING", "ACTIVE", "IDLE", "PREPARED"
};

92
static char empty_c_string[1]= {0};		// Used for not defined 'db'
unknown's avatar
unknown committed
93 94 95 96

#ifdef __WIN__
static void  test_signal(int sig_ptr)
{
unknown's avatar
unknown committed
97
#if !defined( DBUG_OFF)
unknown's avatar
unknown committed
98 99
  MessageBox(NULL,"Test signal","DBUG",MB_OK);
#endif
unknown's avatar
unknown committed
100
#if defined(OS2)
101 102
  fprintf(stderr, "Test signal %d\n", sig_ptr);
  fflush(stderr);
unknown's avatar
unknown committed
103
#endif
unknown's avatar
unknown committed
104 105 106 107
}
static void init_signals(void)
{
  int signals[7] = {SIGINT,SIGILL,SIGFPE,SIGSEGV,SIGTERM,SIGBREAK,SIGABRT } ;
108
  for (int i=0 ; i < 7 ; i++)
unknown's avatar
unknown committed
109 110 111 112
    signal( signals[i], test_signal) ;
}
#endif

unknown's avatar
unknown committed
113 114 115 116 117
static void unlock_locked_tables(THD *thd)
{
  if (thd->locked_tables)
  {
    thd->lock=thd->locked_tables;
118
    thd->locked_tables=0;			// Will be automatically closed
unknown's avatar
unknown committed
119 120 121 122
    close_thread_tables(thd);			// Free tables
  }
}

123

unknown's avatar
unknown committed
124
static bool end_active_trans(THD *thd)
125
{
unknown's avatar
unknown committed
126
  int error=0;
127
  DBUG_ENTER("end_active_trans");
unknown's avatar
unknown committed
128
  if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
unknown's avatar
unknown committed
129
		      OPTION_TABLE_LOCK))
130
  {
131 132 133 134
    DBUG_PRINT("info",("options: 0x%lx", (ulong) thd->options));
    /* Safety if one did "drop table" on locked tables */
    if (!thd->locked_tables)
      thd->options&= ~OPTION_TABLE_LOCK;
135
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
136
    if (ha_commit(thd))
unknown's avatar
unknown committed
137
      error=1;
138
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
139
  }
140
  DBUG_RETURN(error);
141 142
}

unknown's avatar
unknown committed
143 144 145 146 147 148 149 150 151 152 153 154 155
static bool begin_trans(THD *thd)
{
  int error=0;
  if (thd->locked_tables)
  {
    thd->lock=thd->locked_tables;
    thd->locked_tables=0;			// Will be automatically closed
    close_thread_tables(thd);			// Free tables
  }
  if (end_active_trans(thd))
    error= -1;
  else
  {
156
    LEX *lex= thd->lex;
unknown's avatar
unknown committed
157 158 159 160
    thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
		   OPTION_BEGIN);
    thd->server_status|= SERVER_STATUS_IN_TRANS;
    if (lex->start_transaction_opt & MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT)
unknown's avatar
unknown committed
161
      error= ha_start_consistent_snapshot(thd);
unknown's avatar
unknown committed
162 163 164
  }
  return error;
}
165

unknown's avatar
unknown committed
166
#ifdef HAVE_REPLICATION
167 168 169
inline bool all_tables_not_ok(THD *thd, TABLE_LIST *tables)
{
  return (table_rules_on && tables && !tables_ok(thd,tables) &&
unknown's avatar
unknown committed
170
          ((thd->lex->sql_command != SQLCOM_DELETE_MULTI) ||
unknown's avatar
unknown committed
171 172
           !tables_ok(thd,
		      (TABLE_LIST *)thd->lex->auxilliary_table_list.first)));
173
}
unknown's avatar
unknown committed
174
#endif
175 176


177 178
static HASH hash_user_connections;

unknown's avatar
unknown committed
179 180
static int get_or_create_user_conn(THD *thd, const char *user,
				   const char *host,
unknown's avatar
unknown committed
181
				   USER_RESOURCES *mqh)
182 183
{
  int return_val=0;
unknown's avatar
unknown committed
184
  uint temp_len, user_len;
185 186 187 188 189 190
  char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];
  struct  user_conn *uc;

  DBUG_ASSERT(user != 0);
  DBUG_ASSERT(host != 0);

191 192
  user_len=strlen(user);
  temp_len= (strmov(strmov(temp_user, user)+1, host) - temp_user)+1;
193
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
194 195
  if (!(uc = (struct  user_conn *) hash_search(&hash_user_connections,
					       (byte*) temp_user, temp_len)))
196
  {
unknown's avatar
unknown committed
197 198 199
    /* First connection for user; Create a user connection object */
    if (!(uc= ((struct user_conn*)
	       my_malloc(sizeof(struct user_conn) + temp_len+1,
unknown's avatar
unknown committed
200 201
			 MYF(MY_WME)))))
    {
202
      net_send_error(thd, 0, NullS);		// Out of memory
203 204
      return_val=1;
      goto end;
unknown's avatar
unknown committed
205
    }
206 207
    uc->user=(char*) (uc+1);
    memcpy(uc->user,temp_user,temp_len+1);
208
    uc->host= uc->user + user_len +  1;
209
    uc->len = temp_len;
210
    uc->connections= uc->questions= uc->updates= uc->conn_per_hour= 0;
211
    uc->user_resources=*mqh;
212
    uc->intime=thd->thr_create_time;
unknown's avatar
SCRUM  
unknown committed
213
    if (my_hash_insert(&hash_user_connections, (byte*) uc))
214 215
    {
      my_free((char*) uc,0);
216
      net_send_error(thd, 0, NullS);		// Out of memory
217 218 219 220 221
      return_val=1;
      goto end;
    }
  }
  thd->user_connect=uc;
222
  uc->connections++;
223 224 225
end:
  (void) pthread_mutex_unlock(&LOCK_user_conn);
  return return_val;
unknown's avatar
unknown committed
226

227
}
228 229 230


/*
231
    Check if user exist and password supplied is correct. 
232 233
  SYNOPSIS
    check_user()
234 235 236 237
    thd          thread handle, thd->{host,user,ip} are used
    command      originator of the check: now check_user is called
                 during connect and change user procedures; used for 
                 logging.
238
    passwd       scrambled password received from client
239 240 241 242
    passwd_len   length of scrambled password
    db           database name to connect to, may be NULL
    check_count  dont know exactly

243
    Note, that host, user and passwd may point to communication buffer.
244
    Current implementation does not depend on that, but future changes
245 246 247
    should be done with this in mind; 'thd' is INOUT, all other params
    are 'IN'.

248 249 250
  RETURN VALUE
    0  OK; thd->user, thd->master_access, thd->priv_user, thd->db and
       thd->db_access are updated; OK is sent to client;
unknown's avatar
unknown committed
251 252
   -1  access denied or handshake error; error is sent to client;
   >0  error, not sent to client
unknown's avatar
unknown committed
253 254
*/

unknown's avatar
unknown committed
255 256 257
int check_user(THD *thd, enum enum_server_command command, 
	       const char *passwd, uint passwd_len, const char *db,
	       bool check_count)
unknown's avatar
unknown committed
258
{
259
  DBUG_ENTER("check_user");
unknown's avatar
unknown committed
260
  
unknown's avatar
unknown committed
261 262
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  thd->master_access= GLOBAL_ACLS;			// Full rights
263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
  /* Change database if necessary: OK or FAIL is sent in mysql_change_db */
  if (db && db[0])
  {
    thd->db= 0;
    thd->db_length= 0;
    if (mysql_change_db(thd, db))
    {
      if (thd->user_connect)
	decrease_user_connections(thd->user_connect);
      DBUG_RETURN(-1);
    }
  }
  else
    send_ok(thd);
  DBUG_RETURN(0);
unknown's avatar
unknown committed
278 279
#else

280 281 282 283 284
  my_bool opt_secure_auth_local;
  pthread_mutex_lock(&LOCK_global_system_variables);
  opt_secure_auth_local= opt_secure_auth;
  pthread_mutex_unlock(&LOCK_global_system_variables);
  
285
  /*
286 287
    If the server is running in secure auth mode, short scrambles are 
    forbidden.
288
  */
289
  if (opt_secure_auth_local && passwd_len == SCRAMBLE_LENGTH_323)
unknown's avatar
unknown committed
290
  {
291
    net_printf_error(thd, ER_NOT_SUPPORTED_AUTH_MODE);
292 293
    mysql_log.write(thd, COM_CONNECT, ER(ER_NOT_SUPPORTED_AUTH_MODE));
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
294
  }
unknown's avatar
unknown committed
295 296 297 298
  if (passwd_len != 0 &&
      passwd_len != SCRAMBLE_LENGTH &&
      passwd_len != SCRAMBLE_LENGTH_323)
    DBUG_RETURN(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
299

300
  /*
301
    Clear thd->db as it points to something, that will be freed when 
302
    connection is closed. We don't want to accidentally free a wrong pointer
303 304
    if connect failed. Also in case of 'CHANGE USER' failure, current
    database will be switched to 'no database selected'.
305
  */
306 307
  thd->db= 0;
  thd->db_length= 0;
unknown's avatar
unknown committed
308
  
309
  USER_RESOURCES ur;
310
  int res= acl_getroot(thd, &ur, passwd, passwd_len);
unknown's avatar
unknown committed
311
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
312
  if (res == -1)
unknown's avatar
unknown committed
313
  {
unknown's avatar
unknown committed
314 315 316 317 318 319
    /*
      This happens when client (new) sends password scrambled with
      scramble(), but database holds old value (scrambled with
      scramble_323()). Here we please client to send scrambled_password
      in old format.
    */
320
    NET *net= &thd->net;
321
    if (opt_secure_auth_local)
322
    {
323 324
      net_printf_error(thd, ER_SERVER_IS_IN_SECURE_AUTH_MODE,
                       thd->user, thd->host_or_ip);
325 326 327 328
      mysql_log.write(thd, COM_CONNECT, ER(ER_SERVER_IS_IN_SECURE_AUTH_MODE),
                      thd->user, thd->host_or_ip);
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
329
    /* We have to read very specific packet size */
330
    if (send_old_password_request(thd) ||
unknown's avatar
unknown committed
331 332
        my_net_read(net) != SCRAMBLE_LENGTH_323 + 1)
    {                                               
unknown's avatar
unknown committed
333 334 335 336 337
      inc_host_errors(&thd->remote.sin_addr);
      DBUG_RETURN(ER_HANDSHAKE_ERROR);
    }
    /* Final attempt to check the user based on reply */
    /* So as passwd is short, errcode is always >= 0 */
338
    res= acl_getroot(thd, &ur, (char *) net->read_pos, SCRAMBLE_LENGTH_323);
unknown's avatar
unknown committed
339
  }
unknown's avatar
unknown committed
340
#endif /*EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
341 342
  /* here res is always >= 0 */
  if (res == 0)
unknown's avatar
unknown committed
343
  {
344
    if (!(thd->master_access & NO_ACCESS)) // authentication is OK 
345
    {
unknown's avatar
unknown committed
346 347 348 349 350 351 352 353 354 355
      DBUG_PRINT("info",
                 ("Capabilities: %d  packet_length: %ld  Host: '%s'  "
                  "Login user: '%s' Priv_user: '%s'  Using password: %s "
                  "Access: %u  db: '%s'",
                  thd->client_capabilities, thd->max_client_packet_length,
                  thd->host_or_ip, thd->user, thd->priv_user,
                  passwd_len ? "yes": "no",
                  thd->master_access, thd->db ? thd->db : "*none*"));

      if (check_count)
356
      {
unknown's avatar
unknown committed
357
        VOID(pthread_mutex_lock(&LOCK_thread_count));
unknown's avatar
unknown committed
358
        bool count_ok= thread_count <= max_connections + delayed_insert_threads
359
                       || (thd->master_access & SUPER_ACL);
unknown's avatar
unknown committed
360 361
        VOID(pthread_mutex_unlock(&LOCK_thread_count));
        if (!count_ok)
unknown's avatar
unknown committed
362
        {                                         // too many connections
363
          net_send_error(thd, ER_CON_COUNT_ERROR);
unknown's avatar
unknown committed
364 365
          DBUG_RETURN(-1);
        }
366
      }
unknown's avatar
unknown committed
367

unknown's avatar
unknown committed
368 369 370 371 372 373 374 375
      /* Why logging is performed before all checks've passed? */
      mysql_log.write(thd,command,
                      (thd->priv_user == thd->user ?
                       (char*) "%s@%s on %s" :
                       (char*) "%s@%s as anonymous on %s"),
                      thd->user, thd->host_or_ip,
                      db ? db : (char*) "");

376
      /*
377 378 379
        This is the default access rights for the current database.  It's
        set to 0 here because we don't have an active database yet (and we
        may not have an active database to set.
380
      */
unknown's avatar
unknown committed
381 382 383
      thd->db_access=0;

      /* Don't allow user to connect if he has done too many queries */
384
      if ((ur.questions || ur.updates || ur.conn_per_hour || ur.user_conn ||
unknown's avatar
unknown committed
385
	   max_user_connections) &&
386 387 388 389
	  get_or_create_user_conn(thd,
            opt_old_style_user_limits ? thd->user : thd->priv_user,
            opt_old_style_user_limits ? thd->host_or_ip : thd->priv_host,
            &ur))
unknown's avatar
unknown committed
390 391
	DBUG_RETURN(-1);
      if (thd->user_connect &&
392 393
	  (thd->user_connect->user_resources.conn_per_hour ||
	   thd->user_connect->user_resources.user_conn ||
unknown's avatar
unknown committed
394 395 396
	   max_user_connections) &&
	  check_for_max_user_connections(thd, thd->user_connect))
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
397 398 399

      /* Change database if necessary: OK or FAIL is sent in mysql_change_db */
      if (db && db[0])
400
      {
unknown's avatar
unknown committed
401 402 403 404 405 406
        if (mysql_change_db(thd, db))
        {
          if (thd->user_connect)
            decrease_user_connections(thd->user_connect);
          DBUG_RETURN(-1);
        }
407 408
      }
      else
unknown's avatar
unknown committed
409
	send_ok(thd);
unknown's avatar
unknown committed
410 411 412
      thd->password= test(passwd_len);          // remember for error messages 
      /* Ready to handle queries */
      DBUG_RETURN(0);
unknown's avatar
unknown committed
413 414
    }
  }
unknown's avatar
unknown committed
415
  else if (res == 2) // client gave short hash, server has long hash
unknown's avatar
unknown committed
416
  {
417
    net_printf_error(thd, ER_NOT_SUPPORTED_AUTH_MODE);
unknown's avatar
unknown committed
418 419
    mysql_log.write(thd,COM_CONNECT,ER(ER_NOT_SUPPORTED_AUTH_MODE));
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
420
  }
421 422 423 424
  net_printf_error(thd, ER_ACCESS_DENIED_ERROR,
                   thd->user,
                   thd->host_or_ip,
                   passwd_len ? ER(ER_YES) : ER(ER_NO));
unknown's avatar
unknown committed
425 426 427 428 429
  mysql_log.write(thd, COM_CONNECT, ER(ER_ACCESS_DENIED_ERROR),
                  thd->user,
                  thd->host_or_ip,
                  passwd_len ? ER(ER_YES) : ER(ER_NO));
  DBUG_RETURN(-1);
unknown's avatar
unknown committed
430
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
431 432
}

unknown's avatar
unknown committed
433
/*
unknown's avatar
unknown committed
434 435
  Check for maximum allowable user connections, if the mysqld server is
  started with corresponding variable that is greater then 0.
unknown's avatar
unknown committed
436 437
*/

438 439
extern "C" byte *get_key_conn(user_conn *buff, uint *length,
			      my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
440 441 442 443 444
{
  *length=buff->len;
  return (byte*) buff->user;
}

445
extern "C" void free_user(struct user_conn *uc)
unknown's avatar
unknown committed
446 447 448 449
{
  my_free((char*) uc,MYF(0));
}

unknown's avatar
unknown committed
450
void init_max_user_conn(void)
unknown's avatar
unknown committed
451
{
unknown's avatar
unknown committed
452 453
  (void) hash_init(&hash_user_connections,system_charset_info,max_connections,
		   0,0,
454
		   (hash_get_key) get_key_conn, (hash_free_key) free_user,
455
		   0);
unknown's avatar
unknown committed
456 457 458
}


unknown's avatar
unknown committed
459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
/*
  check if user has already too many connections
  
  SYNOPSIS
  check_for_max_user_connections()
  thd			Thread handle
  uc			User connect object

  NOTES
    If check fails, we decrease user connection count, which means one
    shouldn't call decrease_user_connections() after this function.

  RETURN
    0	ok
    1	error
*/

unknown's avatar
unknown committed
476 477
#ifndef NO_EMBEDDED_ACCESS_CHECKS

478
static int check_for_max_user_connections(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
479
{
480
  int error=0;
481
  DBUG_ENTER("check_for_max_user_connections");
unknown's avatar
unknown committed
482

483
  (void) pthread_mutex_lock(&LOCK_user_conn);
484
  if (max_user_connections && !uc->user_resources.user_conn &&
unknown's avatar
unknown committed
485
      max_user_connections < (uint) uc->connections)
unknown's avatar
unknown committed
486
  {
487
    net_printf_error(thd, ER_TOO_MANY_USER_CONNECTIONS, uc->user);
488 489
    error=1;
    goto end;
unknown's avatar
unknown committed
490
  }
491
  time_out_user_resource_limits(thd, uc);
492 493 494 495 496 497 498 499 500 501 502
  if (uc->user_resources.user_conn &&
      uc->user_resources.user_conn < uc->connections)
  {
    net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user,
                     "max_user_connections",
                     (long) uc->user_resources.user_conn);
    error= 1;
    goto end;
  }
  if (uc->user_resources.conn_per_hour &&
      uc->user_resources.conn_per_hour <= uc->conn_per_hour)
503
  {
504 505
    net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user,
                     "max_connections",
506
                     (long) uc->user_resources.conn_per_hour);
507 508 509
    error=1;
    goto end;
  }
510
  uc->conn_per_hour++;
unknown's avatar
unknown committed
511 512

  end:
513 514
  if (error)
    uc->connections--; // no need for decrease_user_connections() here
515
  (void) pthread_mutex_unlock(&LOCK_user_conn);
516
  DBUG_RETURN(error);
unknown's avatar
unknown committed
517
}
unknown's avatar
unknown committed
518
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
519

unknown's avatar
unknown committed
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537
/*
  Decrease user connection count

  SYNOPSIS
    decrease_user_connections()
    uc			User connection object

  NOTES
    If there is a n user connection object for a connection
    (which only happens if 'max_user_connections' is defined or
    if someone has created a resource grant for a user), then
    the connection count is always incremented on connect.

    The user connect object is not freed if some users has
    'max connections per hour' defined as we need to be able to hold
    count over the lifetime of the connection.
*/

538
static void decrease_user_connections(USER_CONN *uc)
unknown's avatar
unknown committed
539
{
540
  DBUG_ENTER("decrease_user_connections");
541 542 543
  (void) pthread_mutex_lock(&LOCK_user_conn);
  DBUG_ASSERT(uc->connections);
  if (!--uc->connections && !mqh_used)
unknown's avatar
unknown committed
544 545
  {
    /* Last connection for user; Delete it */
unknown's avatar
unknown committed
546
    (void) hash_delete(&hash_user_connections,(byte*) uc);
unknown's avatar
unknown committed
547
  }
548
  (void) pthread_mutex_unlock(&LOCK_user_conn);
549
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
550 551
}

552

unknown's avatar
unknown committed
553 554 555 556 557
void free_max_user_conn(void)
{
  hash_free(&hash_user_connections);
}

unknown's avatar
unknown committed
558

559 560 561
/*
  Mark all commands that somehow changes a table
  This is used to check number of updates / hour
unknown's avatar
unknown committed
562 563 564

  sql_command is actually set to SQLCOM_END sometimes
  so we need the +1 to include it in the array.
unknown's avatar
unknown committed
565 566 567 568 569 570

  numbers are:
     0  - read-only query
  != 0  - query that may change a table
     2  - query that returns meaningful ROW_COUNT() -
          a number of modified rows
571 572
*/

unknown's avatar
unknown committed
573
char  uc_update_queries[SQLCOM_END+1];
574 575 576

void init_update_queries(void)
{
unknown's avatar
unknown committed
577 578
  bzero((gptr) &uc_update_queries, sizeof(uc_update_queries));

579 580 581
  uc_update_queries[SQLCOM_CREATE_TABLE]=1;
  uc_update_queries[SQLCOM_CREATE_INDEX]=1;
  uc_update_queries[SQLCOM_ALTER_TABLE]=1;
582 583 584 585 586 587
  uc_update_queries[SQLCOM_UPDATE]=2;
  uc_update_queries[SQLCOM_UPDATE_MULTI]=2;
  uc_update_queries[SQLCOM_INSERT]=2;
  uc_update_queries[SQLCOM_INSERT_SELECT]=2;
  uc_update_queries[SQLCOM_DELETE]=2;
  uc_update_queries[SQLCOM_DELETE_MULTI]=2;
588 589 590 591 592
  uc_update_queries[SQLCOM_TRUNCATE]=1;
  uc_update_queries[SQLCOM_DROP_TABLE]=1;
  uc_update_queries[SQLCOM_LOAD]=1;
  uc_update_queries[SQLCOM_CREATE_DB]=1;
  uc_update_queries[SQLCOM_DROP_DB]=1;
593 594
  uc_update_queries[SQLCOM_REPLACE]=2;
  uc_update_queries[SQLCOM_REPLACE_SELECT]=2;
595 596 597 598
  uc_update_queries[SQLCOM_RENAME_TABLE]=1;
  uc_update_queries[SQLCOM_BACKUP_TABLE]=1;
  uc_update_queries[SQLCOM_RESTORE_TABLE]=1;
  uc_update_queries[SQLCOM_DROP_INDEX]=1;
unknown's avatar
VIEW  
unknown committed
599 600
  uc_update_queries[SQLCOM_CREATE_VIEW]=1;
  uc_update_queries[SQLCOM_DROP_VIEW]=1;
601 602
}

unknown's avatar
unknown committed
603 604
bool is_update_query(enum enum_sql_command command)
{
unknown's avatar
unknown committed
605
  DBUG_ASSERT(command >= 0 && command <= SQLCOM_END);
unknown's avatar
unknown committed
606 607
  return uc_update_queries[command];
}
608

unknown's avatar
unknown committed
609
/*
610 611
  Reset per-hour user resource limits when it has been more than
  an hour since they were last checked
unknown's avatar
unknown committed
612

613 614 615 616
  SYNOPSIS:
    time_out_user_resource_limits()
    thd			Thread handler
    uc			User connection details
unknown's avatar
unknown committed
617

618 619 620 621
  NOTE:
    This assumes that the LOCK_user_conn mutex has been acquired, so it is
    safe to test and modify members of the USER_CONN structure.
*/
622

623
static void time_out_user_resource_limits(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
624
{
unknown's avatar
unknown committed
625
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
626
  DBUG_ENTER("time_out_user_resource_limits");
unknown's avatar
unknown committed
627

unknown's avatar
unknown committed
628
  /* If more than a hour since last check, reset resource checking */
629 630 631 632 633 634 635
  if (check_time  - uc->intime >= 3600)
  {
    uc->questions=1;
    uc->updates=0;
    uc->conn_per_hour=0;
    uc->intime=check_time;
  }
636 637 638 639 640 641 642 643 644 645 646 647

  DBUG_VOID_RETURN;
}


/*
  Check if maximum queries per hour limit has been reached
  returns 0 if OK.
*/

static bool check_mqh(THD *thd, uint check_command)
{
648 649
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  bool error= 0;
650 651 652 653 654 655 656 657 658
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
  USER_CONN *uc=thd->user_connect;
  DBUG_ENTER("check_mqh");
  DBUG_ASSERT(uc != 0);

  (void) pthread_mutex_lock(&LOCK_user_conn);

  time_out_user_resource_limits(thd, uc);

unknown's avatar
unknown committed
659
  /* Check that we have not done too many questions / hour */
660 661 662
  if (uc->user_resources.questions &&
      uc->questions++ >= uc->user_resources.questions)
  {
663 664
    net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user, "max_questions",
                     (long) uc->user_resources.questions);
665 666 667
    error=1;
    goto end;
  }
668
  if (check_command < (uint) SQLCOM_END)
unknown's avatar
unknown committed
669
  {
unknown's avatar
unknown committed
670 671 672 673
    /* Check that we have not done too many updates / hour */
    if (uc->user_resources.updates && uc_update_queries[check_command] &&
	uc->updates++ >= uc->user_resources.updates)
    {
674 675
      net_printf_error(thd, ER_USER_LIMIT_REACHED, uc->user, "max_updates",
                       (long) uc->user_resources.updates);
unknown's avatar
unknown committed
676 677 678
      error=1;
      goto end;
    }
unknown's avatar
unknown committed
679 680
  }
end:
681
  (void) pthread_mutex_unlock(&LOCK_user_conn);
682
  DBUG_RETURN(error);
683 684
#else
  return (0);
unknown's avatar
unknown committed
685
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
686 687
}

unknown's avatar
unknown committed
688

unknown's avatar
unknown committed
689
static void reset_mqh(LEX_USER *lu, bool get_them= 0)
690
{
unknown's avatar
unknown committed
691
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
692
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
693
  if (lu)  // for GRANT
694
  {
695
    USER_CONN *uc;
696
    uint temp_len=lu->user.length+lu->host.length+2;
697 698
    char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];

unknown's avatar
unknown committed
699 700
    memcpy(temp_user,lu->user.str,lu->user.length);
    memcpy(temp_user+lu->user.length+1,lu->host.str,lu->host.length);
701
    temp_user[lu->user.length]='\0'; temp_user[temp_len-1]=0;
unknown's avatar
unknown committed
702
    if ((uc = (struct  user_conn *) hash_search(&hash_user_connections,
703
						(byte*) temp_user, temp_len)))
704 705
    {
      uc->questions=0;
706
      get_mqh(temp_user,&temp_user[lu->user.length+1],uc);
707 708
      uc->updates=0;
      uc->conn_per_hour=0;
709 710
    }
  }
unknown's avatar
unknown committed
711
  else
712
  {
unknown's avatar
unknown committed
713
    /* for FLUSH PRIVILEGES and FLUSH USER_RESOURCES */
unknown's avatar
unknown committed
714
    for (uint idx=0;idx < hash_user_connections.records; idx++)
715
    {
unknown's avatar
unknown committed
716 717
      USER_CONN *uc=(struct user_conn *) hash_element(&hash_user_connections,
						      idx);
718 719 720 721 722
      if (get_them)
	get_mqh(uc->user,uc->host,uc);
      uc->questions=0;
      uc->updates=0;
      uc->conn_per_hour=0;
723 724
    }
  }
unknown's avatar
unknown committed
725
  (void) pthread_mutex_unlock(&LOCK_user_conn);
unknown's avatar
unknown committed
726
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
727
}
unknown's avatar
unknown committed
728

unknown's avatar
unknown committed
729
/*
730
    Perform handshake, authorize client and update thd ACL variables.
731
  SYNOPSIS
732
    check_connection()
733
    thd  thread handle
734 735

  RETURN
736
     0  success, OK is sent to user, thd is updated.
737 738
    -1  error, which is sent to user
   > 0  error code (not sent to user)
unknown's avatar
unknown committed
739 740
*/

unknown's avatar
unknown committed
741 742
#ifndef EMBEDDED_LIBRARY
static int check_connection(THD *thd)
unknown's avatar
unknown committed
743
{
744
  uint connect_errors= 0;
unknown's avatar
unknown committed
745
  NET *net= &thd->net;
unknown's avatar
unknown committed
746 747
  ulong pkt_len= 0;
  char *end;
748

749 750 751
  DBUG_PRINT("info",
             ("New connection received on %s", vio_description(net->vio)));

unknown's avatar
unknown committed
752 753
  if (!thd->host)                           // If TCP/IP connection
  {
754
    char ip[30];
755

756
    if (vio_peer_addr(net->vio, ip, &thd->peer_port))
unknown's avatar
unknown committed
757
      return (ER_BAD_HOST_ERROR);
758
    if (!(thd->ip= my_strdup(ip,MYF(0))))
unknown's avatar
unknown committed
759
      return (ER_OUT_OF_RESOURCES);
760
    thd->host_or_ip= thd->ip;
unknown's avatar
unknown committed
761
    vio_in_addr(net->vio,&thd->remote.sin_addr);
unknown's avatar
unknown committed
762 763 764
#if !defined(HAVE_SYS_UN_H) || defined(HAVE_mit_thread)
    /* Fast local hostname resolve for Win32 */
    if (!strcmp(thd->ip,"127.0.0.1"))
unknown's avatar
unknown committed
765
    {
unknown's avatar
unknown committed
766 767
      thd->host= (char*) my_localhost;
      thd->host_or_ip= my_localhost;
unknown's avatar
unknown committed
768
    }
unknown's avatar
unknown committed
769 770 771
    else
#endif
    {
772 773 774 775 776 777
      if (!(specialflag & SPECIAL_NO_RESOLVE))
      {
	vio_in_addr(net->vio,&thd->remote.sin_addr);
	thd->host=ip_to_hostname(&thd->remote.sin_addr,&connect_errors);
	/* Cut very long hostnames to avoid possible overflows */
	if (thd->host)
unknown's avatar
unknown committed
778
	{
779
	  thd->host[min(strlen(thd->host), HOSTNAME_LENGTH)]= 0;
unknown's avatar
unknown committed
780 781
	  thd->host_or_ip= thd->host;
	}
782 783 784
	if (connect_errors > max_connect_errors)
	  return(ER_HOST_IS_BLOCKED);
      }
unknown's avatar
unknown committed
785
    }
unknown's avatar
unknown committed
786 787 788
    DBUG_PRINT("info",("Host: %s  ip: %s",
		       thd->host ? thd->host : "unknown host",
		       thd->ip ? thd->ip : "unknown ip"));
unknown's avatar
unknown committed
789 790 791
    if (acl_check_host(thd->host,thd->ip))
      return(ER_HOST_NOT_PRIVILEGED);
  }
792
  else /* Hostname given means that the connection was on a socket */
unknown's avatar
unknown committed
793
  {
unknown's avatar
unknown committed
794
    DBUG_PRINT("info",("Host: %s",thd->host));
795 796
    thd->host_or_ip= thd->host;
    thd->ip= 0;
797 798
    /* Reset sin_addr */
    bzero((char*) &thd->remote, sizeof(thd->remote));
unknown's avatar
unknown committed
799 800 801
  }
  vio_keepalive(net->vio, TRUE);
  {
unknown's avatar
unknown committed
802
    /* buff[] needs to big enough to hold the server_version variable */
803
    char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH + 64];
804 805
    ulong client_flags = (CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB |
			  CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION);
unknown's avatar
unknown committed
806

807 808 809 810 811
    if (opt_using_transactions)
      client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS
    client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */
unknown's avatar
unknown committed
812 813
#ifdef HAVE_OPENSSL
    if (ssl_acceptor_fd)
814
      client_flags |= CLIENT_SSL;       /* Wow, SSL is available! */
unknown's avatar
unknown committed
815
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
816

817 818 819 820 821 822 823 824 825 826 827
    end= strnmov(buff, server_version, SERVER_VERSION_LENGTH) + 1;
    int4store((uchar*) end, thd->thread_id);
    end+= 4;
    /*
      So as check_connection is the only entry point to authorization
      procedure, scramble is set here. This gives us new scramble for
      each handshake.
    */
    create_random_string(thd->scramble, SCRAMBLE_LENGTH, &thd->rand);
    /*
      Old clients does not understand long scrambles, but can ignore packet
unknown's avatar
unknown committed
828
      tail: that's why first part of the scramble is placed here, and second
829 830
      part at the end of packet.
    */
831
    end= strmake(end, thd->scramble, SCRAMBLE_LENGTH_323) + 1;
832 833 834
   
    int2store(end, client_flags);
    /* write server characteristics: up to 16 bytes allowed */
835
    end[2]=(char) default_charset_info->number;
836 837 838 839 840 841 842 843 844
    int2store(end+3, thd->server_status);
    bzero(end+5, 13);
    end+= 18;
    /* write scramble tail */
    end= strmake(end, thd->scramble + SCRAMBLE_LENGTH_323, 
                 SCRAMBLE_LENGTH - SCRAMBLE_LENGTH_323) + 1;

    /* At this point we write connection message and read reply */
    if (net_write_command(net, (uchar) protocol_version, "", 0, buff,
unknown's avatar
unknown committed
845
			  (uint) (end-buff)) ||
846
	(pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
847 848 849 850 851 852 853 854 855 856 857
	pkt_len < MIN_HANDSHAKE_SIZE)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
  }
#ifdef _CUSTOMCONFIG_
#include "_cust_sql_parse.h"
#endif
  if (connect_errors)
    reset_host_errors(&thd->remote.sin_addr);
unknown's avatar
unknown committed
858
  if (thd->packet.alloc(thd->variables.net_buffer_length))
unknown's avatar
unknown committed
859 860 861
    return(ER_OUT_OF_RESOURCES);

  thd->client_capabilities=uint2korr(net->read_pos);
862 863 864 865
  if (thd->client_capabilities & CLIENT_PROTOCOL_41)
  {
    thd->client_capabilities|= ((ulong) uint2korr(net->read_pos+2)) << 16;
    thd->max_client_packet_length= uint4korr(net->read_pos+4);
unknown's avatar
unknown committed
866 867 868 869 870 871 872
    DBUG_PRINT("info", ("client_character_set: %d", (uint) net->read_pos[8]));
    /*
      Use server character set and collation if
      - client has not specified a character set
      - client character set is the same as the servers
      - client character set doesn't exists in server
    */
873
    if (!(thd->variables.character_set_client=
unknown's avatar
unknown committed
874 875 876 877
	  get_charset((uint) net->read_pos[8], MYF(0))) ||
	!my_strcasecmp(&my_charset_latin1,
		       global_system_variables.character_set_client->name,
		       thd->variables.character_set_client->name))
878
    {
879 880
      thd->variables.character_set_client=
	global_system_variables.character_set_client;
881 882
      thd->variables.collation_connection=
	global_system_variables.collation_connection;
883 884
      thd->variables.character_set_results=
	global_system_variables.character_set_results;
885 886 887
    }
    else
    {
888
      thd->variables.character_set_results=
889 890 891
      thd->variables.collation_connection= 
	thd->variables.character_set_client;
    }
unknown's avatar
unknown committed
892
    thd->update_charset();
893
    end= (char*) net->read_pos+32;
894 895 896 897 898 899 900
  }
  else
  {
    thd->max_client_packet_length= uint3korr(net->read_pos+2);
    end= (char*) net->read_pos+5;
  }

901
  if (thd->client_capabilities & CLIENT_IGNORE_SPACE)
902
    thd->variables.sql_mode|= MODE_IGNORE_SPACE;
unknown's avatar
unknown committed
903
#ifdef HAVE_OPENSSL
unknown's avatar
unknown committed
904
  DBUG_PRINT("info", ("client capabilities: %d", thd->client_capabilities));
unknown's avatar
unknown committed
905 906 907
  if (thd->client_capabilities & CLIENT_SSL)
  {
    /* Do the SSL layering. */
908 909 910 911 912
    if (!ssl_acceptor_fd)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
unknown's avatar
unknown committed
913
    DBUG_PRINT("info", ("IO layer change in progress..."));
unknown's avatar
unknown committed
914 915 916 917 918
    if (sslaccept(ssl_acceptor_fd, net->vio, thd->variables.net_wait_timeout))
    {
      DBUG_PRINT("error", ("Failed to read user information (pkt_len= %lu)",
			   pkt_len));
      inc_host_errors(&thd->remote.sin_addr);
unknown's avatar
unknown committed
919
      return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
920
    }
unknown's avatar
unknown committed
921
    DBUG_PRINT("info", ("Reading user information over SSL layer"));
922
    if ((pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
923 924
	pkt_len < NORMAL_HANDSHAKE_SIZE)
    {
unknown's avatar
unknown committed
925 926
      DBUG_PRINT("error", ("Failed to read user information (pkt_len= %lu)",
			   pkt_len));
unknown's avatar
unknown committed
927 928 929 930
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
  }
931 932 933
#endif

  if (end >= (char*) net->read_pos+ pkt_len +2)
unknown's avatar
unknown committed
934
  {
935 936
    inc_host_errors(&thd->remote.sin_addr);
    return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
937 938 939
  }

  if (thd->client_capabilities & CLIENT_INTERACTIVE)
940
    thd->variables.net_wait_timeout= thd->variables.net_interactive_timeout;
941
  if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
942 943
      opt_using_transactions)
    net->return_status= &thd->server_status;
unknown's avatar
unknown committed
944
  net->read_timeout=(uint) thd->variables.net_read_timeout;
unknown's avatar
unknown committed
945

946 947
  char *user= end;
  char *passwd= strend(user)+1;
unknown's avatar
unknown committed
948
  char *db= passwd;
949
  char db_buff[NAME_LEN+1];                     // buffer to store db in utf8
unknown's avatar
unknown committed
950
  char user_buff[USERNAME_LENGTH+1];		// buffer to store user in utf8
951 952 953
  uint dummy_errors;

  /*
unknown's avatar
unknown committed
954 955 956 957
    Old clients send null-terminated string as password; new clients send
    the size (1 byte) + string (not null-terminated). Hence in case of empty
    password both send '\0'.
  */
958
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
unknown's avatar
unknown committed
959 960 961
    *passwd++ : strlen(passwd);
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
unknown's avatar
unknown committed
962

unknown's avatar
unknown committed
963 964
  /* Since 4.1 all database names are stored in utf8 */
  if (db)
unknown's avatar
unknown committed
965
  {
966 967 968
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info,
                             db, strlen(db),
969
                             thd->charset(), &dummy_errors)]= 0;
970
    db= db_buff;
unknown's avatar
unknown committed
971
  }
unknown's avatar
unknown committed
972

973 974 975 976
  user_buff[copy_and_convert(user_buff, sizeof(user_buff)-1,
                             system_charset_info, user, strlen(user),
                             thd->charset(), &dummy_errors)]= '\0';
  user= user_buff;
unknown's avatar
unknown committed
977

978 979
  if (thd->user)
    x_free(thd->user);
980 981
  if (!(thd->user= my_strdup(user, MYF(0))))
    return (ER_OUT_OF_RESOURCES);
unknown's avatar
unknown committed
982
  return check_user(thd, COM_CONNECT, passwd, passwd_len, db, TRUE);
unknown's avatar
unknown committed
983 984
}

985

986 987
void execute_init_command(THD *thd, sys_var_str *init_command_var,
			  rw_lock_t *var_mutex)
unknown's avatar
unknown committed
988 989 990 991
{
  Vio* save_vio;
  ulong save_client_capabilities;

992 993 994 995 996 997 998 999 1000
  thd->proc_info= "Execution of init_command";
  /*
    We need to lock init_command_var because
    during execution of init_command_var query
    values of init_command_var can't be changed
  */
  rw_rdlock(var_mutex);
  thd->query= init_command_var->value;
  thd->query_length= init_command_var->value_length;
unknown's avatar
unknown committed
1001 1002
  save_client_capabilities= thd->client_capabilities;
  thd->client_capabilities|= CLIENT_MULTI_QUERIES;
1003 1004 1005 1006
  /*
    We don't need return result of execution to client side.
    To forbid this we should set thd->net.vio to 0.
  */
unknown's avatar
unknown committed
1007 1008
  save_vio= thd->net.vio;
  thd->net.vio= 0;
1009
  thd->net.no_send_error= 0;
unknown's avatar
unknown committed
1010
  dispatch_command(COM_QUERY, thd, thd->query, thd->query_length+1);
1011
  rw_unlock(var_mutex);
unknown's avatar
unknown committed
1012 1013 1014 1015 1016
  thd->client_capabilities= save_client_capabilities;
  thd->net.vio= save_vio;
}


unknown's avatar
unknown committed
1017 1018 1019 1020
pthread_handler_decl(handle_one_connection,arg)
{
  THD *thd=(THD*) arg;
  uint launch_time  =
unknown's avatar
unknown committed
1021
    (uint) ((thd->thr_create_time = time(NULL)) - thd->connect_time);
unknown's avatar
unknown committed
1022 1023 1024 1025 1026
  if (launch_time >= slow_launch_time)
    statistic_increment(slow_launch_threads,&LOCK_status );

  pthread_detach_this_thread();

1027
#if !defined( __WIN__) && !defined(OS2)	// Win32 calls this in pthread_create
unknown's avatar
unknown committed
1028
  /* The following calls needs to be done before we call DBUG_ macros */
1029
  if (!(test_flags & TEST_NO_THREADS) & my_thread_init())
unknown's avatar
unknown committed
1030
  {
1031
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
1032
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
1033 1034 1035 1036 1037
    end_thread(thd,0);
    return 0;
  }
#endif

1038 1039 1040 1041 1042 1043 1044
  /*
    handle_one_connection() is the only way a thread would start
    and would always be on top of the stack, therefore, the thread
    stack always starts at the address of the first local variable
    of handle_one_connection, which is thd. We need to know the
    start of the stack so that we could check for stack overruns.
  */
unknown's avatar
unknown committed
1045 1046
  DBUG_PRINT("info", ("handle_one_connection called by thread %d\n",
		      thd->thread_id));
unknown's avatar
unknown committed
1047
  /* now that we've called my_thread_init(), it is safe to call DBUG_* */
unknown's avatar
unknown committed
1048

unknown's avatar
unknown committed
1049
#if defined(__WIN__)
unknown's avatar
unknown committed
1050
  init_signals();				// IRENA; testing ?
unknown's avatar
unknown committed
1051
#elif !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1052 1053 1054 1055 1056 1057
  sigset_t set;
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
#endif
  if (thd->store_globals())
  {
1058
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
1059
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
1060 1061 1062 1063 1064 1065 1066 1067 1068
    end_thread(thd,0);
    return 0;
  }

  do
  {
    int error;
    NET *net= &thd->net;
    thd->thread_stack= (char*) &thd;
1069
    net->no_send_error= 0;
unknown's avatar
unknown committed
1070

1071
    if ((error=check_connection(thd)))
unknown's avatar
unknown committed
1072 1073
    {						// Wrong permissions
      if (error > 0)
1074
	net_printf_error(thd, error, thd->host_or_ip);
unknown's avatar
unknown committed
1075 1076
#ifdef __NT__
      if (vio_type(net->vio) == VIO_TYPE_NAMEDPIPE)
1077
	my_sleep(1000);				/* must wait after eof() */
unknown's avatar
unknown committed
1078
#endif
1079
      statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
1080 1081
      goto end_thread;
    }
unknown's avatar
unknown committed
1082 1083 1084
#ifdef __NETWARE__
    netware_reg_user(thd->ip, thd->user, "MySQL");
#endif
1085
    if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1086 1087 1088 1089
      thd->options |= OPTION_BIG_SELECTS;
    if (thd->client_capabilities & CLIENT_COMPRESS)
      net->compress=1;				// Use compression

unknown's avatar
unknown committed
1090
    thd->version= refresh_version;
1091
    thd->proc_info= 0;
1092
    thd->command= COM_SLEEP;
1093 1094
    thd->set_time();
    thd->init_for_queries();
unknown's avatar
unknown committed
1095

unknown's avatar
unknown committed
1096
    if (sys_init_connect.value_length && !(thd->master_access & SUPER_ACL))
unknown's avatar
unknown committed
1097
    {
1098 1099
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
unknown's avatar
unknown committed
1100
	thd->killed= THD::KILL_CONNECTION;
unknown's avatar
unknown committed
1101 1102 1103
    }

    thd->proc_info=0;
unknown's avatar
unknown committed
1104
    thd->set_time();
1105
    thd->init_for_queries();
1106 1107
    while (!net->error && net->vio != 0 &&
           !(thd->killed == THD::KILL_CONNECTION))
unknown's avatar
unknown committed
1108
    {
1109
      net->no_send_error= 0;
unknown's avatar
unknown committed
1110 1111 1112
      if (do_command(thd))
	break;
    }
1113 1114
    if (thd->user_connect)
      decrease_user_connections(thd->user_connect);
unknown's avatar
unknown committed
1115
    if (net->error && net->vio != 0 && net->report_error)
unknown's avatar
unknown committed
1116
    {
1117
      if (!thd->killed && thd->variables.log_warnings > 1)
unknown's avatar
unknown committed
1118
	sql_print_warning(ER(ER_NEW_ABORTING_CONNECTION),
unknown's avatar
unknown committed
1119 1120 1121 1122 1123
                          thd->thread_id,(thd->db ? thd->db : "unconnected"),
                          thd->user ? thd->user : "unauthenticated",
                          thd->host_or_ip,
                          (net->last_errno ? ER(net->last_errno) :
                           ER(ER_UNKNOWN_ERROR)));
1124
      net_send_error(thd, net->last_errno, NullS);
unknown's avatar
unknown committed
1125
      statistic_increment(aborted_threads,&LOCK_status);
unknown's avatar
unknown committed
1126
    }
1127 1128 1129 1130
    else if (thd->killed)
    {
      statistic_increment(aborted_threads,&LOCK_status);
    }
1131
    
unknown's avatar
unknown committed
1132
end_thread:
1133
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
    end_thread(thd,1);
    /*
      If end_thread returns, we are either running with --one-thread
      or this thread has been schedule to handle the next query
    */
    thd= current_thd;
  } while (!(test_flags & TEST_NO_THREADS));
  /* The following is only executed if we are not using --one-thread */
  return(0);					/* purecov: deadcode */
}

unknown's avatar
unknown committed
1145 1146
#endif /* EMBEDDED_LIBRARY */

1147 1148 1149 1150
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
unknown's avatar
unknown committed
1151

1152
extern "C" pthread_handler_decl(handle_bootstrap,arg)
unknown's avatar
unknown committed
1153
{
1154 1155 1156
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
unknown's avatar
unknown committed
1157

1158
  /* The following must be called before DBUG_ENTER */
1159
  if (my_thread_init() || thd->store_globals())
unknown's avatar
unknown committed
1160
  {
unknown's avatar
unknown committed
1161
#ifndef EMBEDDED_LIBRARY
1162
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
1163
#endif
1164
    thd->fatal_error();
1165
    goto end;
unknown's avatar
unknown committed
1166
  }
1167 1168
  DBUG_ENTER("handle_bootstrap");

unknown's avatar
unknown committed
1169
#ifndef EMBEDDED_LIBRARY
1170 1171
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1172
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1173
  sigset_t set;
1174 1175
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
unknown's avatar
unknown committed
1176
#endif
unknown's avatar
unknown committed
1177
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
1178

1179
  if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1180 1181 1182 1183
    thd->options |= OPTION_BIG_SELECTS;

  thd->proc_info=0;
  thd->version=refresh_version;
1184
  thd->priv_user=thd->user=(char*) my_strdup("boot", MYF(MY_WME));
unknown's avatar
unknown committed
1185

1186
  buff= (char*) thd->net.buff;
1187
  thd->init_for_queries();
unknown's avatar
unknown committed
1188 1189
  while (fgets(buff, thd->net.max_packet, file))
  {
unknown's avatar
unknown committed
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
   ulong length= (ulong) strlen(buff);
   while (buff[length-1] != '\n' && !feof(file))
   {
     /*
       We got only a part of the current string. Will try to increase
       net buffer then read the rest of the current string.
     */
     if (net_realloc(&(thd->net), 2 * thd->net.max_packet))
     {
       net_send_error(thd, ER_NET_PACKET_TOO_LARGE, NullS);
       thd->fatal_error();
       break;
     }
     buff= (char*) thd->net.buff;
     fgets(buff + length, thd->net.max_packet - length, file);
     length+= (ulong) strlen(buff + length);
   }
   if (thd->is_fatal_error)
     break;

unknown's avatar
unknown committed
1210
    while (length && (my_isspace(thd->charset(), buff[length-1]) ||
1211
           buff[length-1] == ';'))
unknown's avatar
unknown committed
1212 1213
      length--;
    buff[length]=0;
1214
    thd->query_length=length;
unknown's avatar
unknown committed
1215 1216
    thd->query= thd->memdup_w_gap(buff, length+1, thd->db_length+1);
    thd->query[length] = '\0';
1217 1218 1219 1220
    /*
      We don't need to obtain LOCK_thread_count here because in bootstrap
      mode we have only one thread.
    */
1221
    thd->query_id=next_query_id();
unknown's avatar
unknown committed
1222 1223
    mysql_parse(thd,thd->query,length);
    close_thread_tables(thd);			// Free tables
1224
    if (thd->is_fatal_error)
1225
      break;
unknown's avatar
unknown committed
1226
    free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
1227
#ifdef USING_TRANSACTIONS
1228
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
1229
#endif
unknown's avatar
unknown committed
1230
  }
1231 1232 1233

  /* thd->fatal_error should be set in case something went wrong */
end:
1234 1235 1236 1237 1238 1239
  bootstrap_error= thd->is_fatal_error;

  net_end(&thd->net);
  thd->cleanup();
  delete thd;

unknown's avatar
unknown committed
1240
#ifndef EMBEDDED_LIBRARY
1241 1242 1243
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1244
  (void) pthread_cond_broadcast(&COND_thread_count);
1245 1246
  my_thread_end();
  pthread_exit(0);
unknown's avatar
unknown committed
1247
#endif
1248
  DBUG_RETURN(0);
unknown's avatar
unknown committed
1249 1250
}

1251
    /* This works because items are allocated with sql_alloc() */
unknown's avatar
unknown committed
1252

1253
void free_items(Item *item)
unknown's avatar
unknown committed
1254
{
unknown's avatar
unknown committed
1255
  Item *next;
unknown's avatar
unknown committed
1256
  DBUG_ENTER("free_items");
unknown's avatar
unknown committed
1257 1258 1259
  for (; item ; item=next)
  {
    next=item->next;
1260
    item->delete_self();
unknown's avatar
unknown committed
1261
  }
unknown's avatar
unknown committed
1262
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1263 1264
}

1265 1266 1267 1268 1269 1270 1271 1272
    /* This works because items are allocated with sql_alloc() */

void cleanup_items(Item *item)
{
  for (; item ; item=item->next)
    item->cleanup();
}

unknown's avatar
unknown committed
1273 1274 1275 1276 1277 1278 1279
int mysql_table_dump(THD* thd, char* db, char* tbl_name, int fd)
{
  TABLE* table;
  TABLE_LIST* table_list;
  int error = 0;
  DBUG_ENTER("mysql_table_dump");
  db = (db && db[0]) ? db : thd->db;
1280
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
1281
    DBUG_RETURN(1); // out of memory
unknown's avatar
VIEW  
unknown committed
1282
  table_list->db= db;
1283
  table_list->table_name= table_list->alias= tbl_name;
unknown's avatar
VIEW  
unknown committed
1284 1285
  table_list->lock_type= TL_READ_NO_INSERT;
  table_list->prev_global= &table_list;	// can be removed after merge with 4.1
unknown's avatar
unknown committed
1286

1287 1288
  if (!db || check_db_name(db))
  {
1289
    my_error(ER_WRONG_DB_NAME ,MYF(0), db ? db : "NULL");
1290 1291
    goto err;
  }
1292
  if (lower_case_table_names)
1293
    my_casedn_str(files_charset_info, tbl_name);
1294
  remove_escape(table_list->table_name);
1295 1296 1297 1298

  if (!(table=open_ltable(thd, table_list, TL_READ_NO_INSERT)))
    DBUG_RETURN(1);

unknown's avatar
unknown committed
1299
  if (check_one_table_access(thd, SELECT_ACL, table_list))
unknown's avatar
unknown committed
1300 1301
    goto err;
  thd->free_list = 0;
unknown's avatar
unknown committed
1302
  thd->query_length=(uint) strlen(tbl_name);
unknown's avatar
unknown committed
1303
  thd->query = tbl_name;
unknown's avatar
unknown committed
1304
  if ((error = mysqld_dump_create_info(thd, table_list, -1)))
1305
  {
1306
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1307 1308
    goto err;
  }
unknown's avatar
unknown committed
1309
  net_flush(&thd->net);
1310
  if ((error= table->file->dump(thd,fd)))
1311
    my_error(ER_GET_ERRNO, MYF(0), error);
unknown's avatar
unknown committed
1312

unknown's avatar
unknown committed
1313
err:
unknown's avatar
unknown committed
1314
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1315 1316
}

unknown's avatar
unknown committed
1317 1318 1319 1320
/*
  Ends the current transaction and (maybe) begin the next

  SYNOPSIS
1321
    end_trans()
unknown's avatar
unknown committed
1322 1323 1324 1325 1326 1327 1328
      thd            Current thread
      completion     Completion type

  RETURN
    0 - OK
*/

1329
int end_trans(THD *thd, enum enum_mysql_completiontype completion)
unknown's avatar
unknown committed
1330 1331 1332
{
  bool do_release= 0;
  int res= 0;
1333
  DBUG_ENTER("end_trans");
unknown's avatar
unknown committed
1334 1335 1336 1337 1338 1339 1340 1341 1342

  switch (completion) {
  case COMMIT:
    /*
     We don't use end_active_trans() here to ensure that this works
     even if there is a problem with the OPTION_AUTO_COMMIT flag
     (Which of course should never happen...)
    */
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
1343
    res= ha_commit(thd);
1344
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
1345 1346
    break;
  case COMMIT_RELEASE:
unknown's avatar
unknown committed
1347
    do_release= 1; /* fall through */
unknown's avatar
unknown committed
1348 1349 1350 1351 1352 1353
  case COMMIT_AND_CHAIN:
    res= end_active_trans(thd);
    if (!res && completion == COMMIT_AND_CHAIN)
      res= begin_trans(thd);
    break;
  case ROLLBACK_RELEASE:
unknown's avatar
unknown committed
1354
    do_release= 1; /* fall through */
unknown's avatar
unknown committed
1355 1356 1357 1358
  case ROLLBACK:
  case ROLLBACK_AND_CHAIN:
  {
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
unknown's avatar
unknown committed
1359
    if (ha_rollback(thd))
unknown's avatar
unknown committed
1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370
      res= -1;
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    if (!res && (completion == ROLLBACK_AND_CHAIN))
      res= begin_trans(thd);
    break;
  }
  default:
    res= -1;
    my_error(ER_UNKNOWN_COM_ERROR, MYF(0));
    DBUG_RETURN(-1);
  }
unknown's avatar
unknown committed
1371

unknown's avatar
unknown committed
1372 1373 1374
  if (res < 0)
    my_error(thd->killed_errno(), MYF(0));
  else if ((res == 0) && do_release)
unknown's avatar
unknown committed
1375 1376
    thd->killed= THD::KILL_CONNECTION;

unknown's avatar
unknown committed
1377 1378
  DBUG_RETURN(res);
}
unknown's avatar
unknown committed
1379

1380
#ifndef EMBEDDED_LIBRARY
1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391

/*
  Read one command from socket and execute it (query or simple command).
  This function is called in loop from thread function.
  SYNOPSIS
    do_command()
  RETURN VALUE
    0  success
    1  request of thread shutdown (see dispatch_command() description)
*/

unknown's avatar
unknown committed
1392 1393 1394
bool do_command(THD *thd)
{
  char *packet;
unknown's avatar
unknown committed
1395 1396
  uint old_timeout;
  ulong packet_length;
unknown's avatar
unknown committed
1397 1398 1399 1400 1401
  NET *net;
  enum enum_server_command command;
  DBUG_ENTER("do_command");

  net= &thd->net;
unknown's avatar
unknown committed
1402 1403 1404 1405
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1406
  thd->lex->current_select= 0;
unknown's avatar
unknown committed
1407 1408

  packet=0;
unknown's avatar
unknown committed
1409
  old_timeout=net->read_timeout;
unknown's avatar
unknown committed
1410
  /* Wait max for 8 hours */
unknown's avatar
unknown committed
1411
  net->read_timeout=(uint) thd->variables.net_wait_timeout;
unknown's avatar
unknown committed
1412
  thd->clear_error();				// Clear error message
unknown's avatar
unknown committed
1413 1414 1415 1416

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1417 1418 1419 1420 1421
    DBUG_PRINT("info",("Got error %d reading command from socket %s",
		       net->error,
		       vio_description(net->vio)));
    /* Check if we can continue without closing the connection */
    if (net->error != 3)
1422 1423
    {
      statistic_increment(aborted_threads,&LOCK_status);
1424
      DBUG_RETURN(TRUE);			// We have to close it.
1425
    }
1426
    net_send_error(thd, net->last_errno, NullS);
1427
    net->error= 0;
1428
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
1429 1430 1431
  }
  else
  {
unknown's avatar
unknown committed
1432
    if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
unknown's avatar
SCRUM  
unknown committed
1433
      thd->killed= THD::NOT_KILLED;
unknown's avatar
SCRUM  
unknown committed
1434

unknown's avatar
unknown committed
1435 1436
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1437 1438
    if (command >= COM_END)
      command= COM_END;				// Wrong command
unknown's avatar
unknown committed
1439 1440 1441
    DBUG_PRINT("info",("Command on %s = %d (%s)",
		       vio_description(net->vio), command,
		       command_name[command]));
unknown's avatar
unknown committed
1442
  }
unknown's avatar
unknown committed
1443
  net->read_timeout=old_timeout;		// restore it
1444 1445 1446 1447 1448 1449 1450 1451 1452
  /*
    packet_length contains length of data, as it was stored in packet
    header. In case of malformed header, packet_length can be zero.
    If packet_length is not zero, my_net_read ensures that this number
    of bytes was actually read from network. Additionally my_net_read
    sets packet[packet_length]= 0 (thus if packet_length == 0,
    command == packet[0] == COM_SLEEP).
    In dispatch_command packet[packet_length] points beyond the end of packet.
  */
unknown's avatar
unknown committed
1453
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1454
}
1455
#endif  /* EMBEDDED_LIBRARY */
1456

1457

1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472
/*
   Perform one connection-level (COM_XXXX) command.
  SYNOPSIS
    dispatch_command()
    thd             connection handle
    command         type of command to perform 
    packet          data for the command, packet is always null-terminated
    packet_length   length of packet + 1 (to show that data is
                    null-terminated) except for COM_SLEEP, where it
                    can be zero.
  RETURN VALUE
    0   ok
    1   request of thread shutdown, i. e. if command is
        COM_QUIT/COM_SHUTDOWN
*/
1473

1474 1475 1476 1477
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1478
  bool error= 0;
1479 1480 1481
  DBUG_ENTER("dispatch_command");

  thd->command=command;
unknown's avatar
unknown committed
1482 1483 1484 1485
  /*
    Commands which will always take a long time should be marked with
    this so that they will not get logged to the slow query log
  */
1486
  thd->slow_command=FALSE;
1487
  thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
unknown's avatar
unknown committed
1488
  thd->set_time();
unknown's avatar
unknown committed
1489 1490 1491
  VOID(pthread_mutex_lock(&LOCK_thread_count));
  thd->query_id=query_id;
  if (command != COM_STATISTICS && command != COM_PING)
1492
    next_query_id();
unknown's avatar
unknown committed
1493
  thread_running++;
1494
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
unknown's avatar
unknown committed
1495
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1496

1497 1498
  thd->server_status&=
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
1499
  switch (command) {
unknown's avatar
unknown committed
1500
  case COM_INIT_DB:
unknown's avatar
unknown committed
1501 1502
  {
    LEX_STRING tmp;
1503 1504
    statistic_increment(thd->status_var.com_stat[SQLCOM_CHANGE_DB],
			&LOCK_status);
unknown's avatar
unknown committed
1505 1506 1507 1508 1509 1510
    thd->convert_string(&tmp, system_charset_info,
			packet, strlen(packet), thd->charset());
    if (!mysql_change_db(thd, tmp.str))
      mysql_log.write(thd,command,"%s",thd->db);
    break;
  }
unknown's avatar
unknown committed
1511
#ifdef HAVE_REPLICATION
1512 1513
  case COM_REGISTER_SLAVE:
  {
1514
    if (!register_slave(thd, (uchar*)packet, packet_length))
1515
      send_ok(thd);
1516 1517
    break;
  }
1518
#endif
unknown's avatar
unknown committed
1519
  case COM_TABLE_DUMP:
1520 1521 1522 1523 1524
  {
    char *db, *tbl_name;
    uint db_len= *(uchar*) packet;
    uint tbl_len= *(uchar*) (packet + db_len + 1);

1525
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1526
    thd->slow_command= TRUE;
1527 1528 1529
    db= thd->alloc(db_len + tbl_len + 2);
    tbl_name= strmake(db, packet + 1, db_len)+1;
    strmake(tbl_name, packet + db_len + 2, tbl_len);
unknown's avatar
unknown committed
1530
    mysql_table_dump(thd, db, tbl_name, -1);
1531 1532
    break;
  }
unknown's avatar
unknown committed
1533 1534
  case COM_CHANGE_USER:
  {
unknown's avatar
unknown committed
1535
    thd->change_user();
1536
    thd->clear_error();                         // if errors from rollback
unknown's avatar
unknown committed
1537

1538
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1539
    char *user= (char*) packet;
unknown's avatar
unknown committed
1540
    char *passwd= strend(user)+1;
unknown's avatar
unknown committed
1541 1542 1543 1544 1545
    /* 
      Old clients send null-terminated string ('\0' for empty string) for
      password.  New clients send the size (1 byte) + string (not null
      terminated, so also '\0' for empty string).
    */
1546
    char db_buff[NAME_LEN+1];                 // buffer to store db in utf8 
unknown's avatar
unknown committed
1547 1548 1549 1550
    char *db= passwd;
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ? 
      *passwd++ : strlen(passwd);
    db+= passwd_len + 1;
1551
#ifndef EMBEDDED_LIBRARY
1552
    /* Small check for incoming packet */
unknown's avatar
unknown committed
1553
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1554
    {
unknown's avatar
unknown committed
1555
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1556 1557
      break;
    }
1558
#endif
1559
    /* Convert database name to utf8 */
1560
    uint dummy_errors;
1561 1562
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
1563
                             thd->charset(), &dummy_errors)]= 0;
1564
    db= db_buff;
unknown's avatar
unknown committed
1565

1566 1567 1568 1569 1570 1571 1572
    /* Save user and privileges */
    uint save_master_access= thd->master_access;
    uint save_db_access= thd->db_access;
    uint save_db_length= thd->db_length;
    char *save_user= thd->user;
    char *save_priv_user= thd->priv_user;
    char *save_db= thd->db;
unknown's avatar
unknown committed
1573
    USER_CONN *save_user_connect= thd->user_connect;
unknown's avatar
unknown committed
1574 1575
    
    if (!(thd->user= my_strdup(user, MYF(0))))
1576 1577
    {
      thd->user= save_user;
unknown's avatar
unknown committed
1578
      my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
1579 1580
      break;
    }
unknown's avatar
unknown committed
1581

unknown's avatar
unknown committed
1582 1583
    /* Clear variables that are allocated */
    thd->user_connect= 0;
unknown's avatar
unknown committed
1584
    int res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, FALSE);
unknown's avatar
unknown committed
1585

1586 1587
    if (res)
    {
1588
      /* authentication failure, we shall restore old user */
1589
      if (res > 0)
unknown's avatar
unknown committed
1590
        my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1591 1592 1593
      x_free(thd->user);
      thd->user= save_user;
      thd->priv_user= save_priv_user;
unknown's avatar
unknown committed
1594
      thd->user_connect= save_user_connect;
1595 1596 1597 1598 1599 1600 1601 1602
      thd->master_access= save_master_access;
      thd->db_access= save_db_access;
      thd->db= save_db;
      thd->db_length= save_db_length;
    }
    else
    {
      /* we've authenticated new user */
unknown's avatar
unknown committed
1603 1604
      if (save_user_connect)
	decrease_user_connections(save_user_connect);
1605 1606 1607
      x_free((gptr) save_db);
      x_free((gptr) save_user);
    }
unknown's avatar
unknown committed
1608 1609
    break;
  }
unknown's avatar
unknown committed
1610 1611
  case COM_EXECUTE:
  {
1612
    mysql_stmt_execute(thd, packet, packet_length);
unknown's avatar
unknown committed
1613 1614
    break;
  }
1615 1616 1617 1618 1619
  case COM_FETCH:
  {
    mysql_stmt_fetch(thd, packet, packet_length);
    break;
  }
unknown's avatar
unknown committed
1620 1621
  case COM_LONG_DATA:
  {
1622
    mysql_stmt_get_longdata(thd, packet, packet_length);
unknown's avatar
unknown committed
1623 1624 1625 1626
    break;
  }
  case COM_PREPARE:
  {
unknown's avatar
unknown committed
1627
    mysql_stmt_prepare(thd, packet, packet_length, 0);
unknown's avatar
unknown committed
1628 1629
    break;
  }
unknown's avatar
unknown committed
1630 1631 1632 1633 1634
  case COM_CLOSE_STMT:
  {
    mysql_stmt_free(thd, packet);
    break;
  }
1635 1636 1637 1638 1639
  case COM_RESET_STMT:
  {
    mysql_stmt_reset(thd, packet);
    break;
  }
unknown's avatar
unknown committed
1640 1641
  case COM_QUERY:
  {
1642 1643
    if (alloc_query(thd, packet, packet_length))
      break;					// fatal error is set
1644
    char *packet_end= thd->query + thd->query_length;
1645
    mysql_log.write(thd,command,"%s",thd->query);
1646
    DBUG_PRINT("query",("%-.4096s",thd->query));
1647
    mysql_parse(thd,thd->query, thd->query_length);
1648

1649
    while (!thd->killed && thd->lex->found_semicolon && !thd->net.report_error)
1650
    {
1651
      char *packet= thd->lex->found_semicolon;
1652
      /*
1653
        Multiple queries exits, execute them individually
1654
	in embedded server - just store them to be executed later 
1655
      */
1656
#ifndef EMBEDDED_LIBRARY
1657 1658
      if (thd->lock || thd->open_tables || thd->derived_tables ||
          thd->prelocked_mode)
1659
        close_thread_tables(thd);
1660
#endif
1661
      ulong length= (ulong)(packet_end-packet);
1662

1663 1664
      log_slow_query(thd);

1665
      /* Remove garbage at start of query */
unknown's avatar
unknown committed
1666
      while (my_isspace(thd->charset(), *packet) && length > 0)
1667 1668 1669 1670
      {
        packet++;
        length--;
      }
unknown's avatar
unknown committed
1671
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1672
      thd->query_length= length;
1673
      thd->query= packet;
1674
      thd->query_id= next_query_id();
1675
      thd->set_time(); /* Reset the query start time. */
1676
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1677
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1678
#ifndef EMBEDDED_LIBRARY
1679
      mysql_parse(thd, packet, length);
1680
#else
unknown's avatar
unknown committed
1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
      /*
	'packet' can point inside the query_rest's buffer
	so we have to do memmove here
       */
      if (thd->query_rest.length() > length)
      {
	memmove(thd->query_rest.c_ptr(), packet, length);
	thd->query_rest.length(length);
      }
      else
1691
	thd->query_rest.copy(packet, length, thd->query_rest.charset());
1692 1693 1694

      thd->server_status&= ~ (SERVER_QUERY_NO_INDEX_USED |
                              SERVER_QUERY_NO_GOOD_INDEX_USED);
1695 1696
      break;
#endif /*EMBEDDED_LIBRARY*/
1697 1698
    }

unknown's avatar
unknown committed
1699 1700 1701 1702 1703
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1704
  case COM_FIELD_LIST:				// This isn't actually needed
unknown's avatar
unknown committed
1705
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
1706 1707
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
unknown's avatar
unknown committed
1708 1709 1710
    break;
#else
  {
1711
    char *fields, *pend;
1712 1713
    /* Locked closure of all tables */
    TABLE_LIST *locked_tables= NULL;
unknown's avatar
unknown committed
1714
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1715
    LEX_STRING conv_name;
1716
    /* Saved variable value */
1717 1718
    my_bool old_innodb_table_locks= 
              IF_INNOBASE_DB(thd->variables.innodb_table_locks, FALSE);
1719

unknown's avatar
unknown committed
1720

1721 1722
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
			&LOCK_status);
unknown's avatar
unknown committed
1723 1724 1725
    bzero((char*) &table_list,sizeof(table_list));
    if (!(table_list.db=thd->db))
    {
unknown's avatar
unknown committed
1726
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
unknown's avatar
unknown committed
1727 1728
      break;
    }
1729
    pend= strend(packet);
unknown's avatar
unknown committed
1730 1731
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
1732
    table_list.alias= table_list.table_name= conv_name.str;
1733
    packet= pend+1;
1734 1735 1736 1737 1738 1739 1740 1741 1742

    if (!my_strcasecmp(system_charset_info, table_list.db,
                       information_schema_name.str))
    {
      ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, table_list.alias);
      if (schema_table)
        table_list.schema_table= schema_table;
    }

1743
    thd->query_length= strlen(packet);       // for simplicity: don't optimize
unknown's avatar
unknown committed
1744 1745
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1746
    mysql_log.write(thd,command,"%s %s",table_list.table_name, fields);
1747
    if (lower_case_table_names)
1748 1749
      my_casedn_str(files_charset_info, table_list.table_name);
    remove_escape(table_list.table_name);	// This can't have wildcards
unknown's avatar
unknown committed
1750

unknown's avatar
unknown committed
1751 1752
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
		     0, 0))
unknown's avatar
unknown committed
1753
      break;
unknown's avatar
unknown committed
1754 1755
    if (grant_option &&
	check_grant(thd, SELECT_ACL, &table_list, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
1756
      break;
1757 1758 1759 1760 1761 1762
    /* init structures for VIEW processing */
    table_list.select_lex= &(thd->lex->select_lex);
    mysql_init_query(thd, (uchar*)"", 0);
    thd->lex->
      select_lex.table_list.link_in_list((byte*) &table_list,
                                         (byte**) &table_list.next_local);
1763
    thd->lex->query_tables= &table_list;
1764

1765 1766
    /* switch on VIEW optimisation: do not fill temporary tables */
    thd->lex->sql_command= SQLCOM_SHOW_FIELDS;
unknown's avatar
unknown committed
1767
    mysqld_list_fields(thd,&table_list,fields);
1768
    thd->lex->unit.cleanup();
1769
    thd->cleanup_after_query();
unknown's avatar
unknown committed
1770 1771 1772 1773
    break;
  }
#endif
  case COM_QUIT:
1774
    /* We don't calculate statistics for this command */
1775
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1776 1777 1778 1779
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

unknown's avatar
unknown committed
1780
  case COM_CREATE_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1781
    {
unknown's avatar
unknown committed
1782
      char *db=thd->strdup(packet), *alias;
1783
      HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
1784

1785 1786
      statistic_increment(thd->status_var.com_stat[SQLCOM_CREATE_DB],
			  &LOCK_status);
1787
      // null test to handle EOM
unknown's avatar
unknown committed
1788
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1789
      {
1790
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1791 1792
	break;
      }
unknown's avatar
unknown committed
1793
      if (check_access(thd,CREATE_ACL,db,0,1,0))
unknown's avatar
unknown committed
1794
	break;
1795
      mysql_log.write(thd,command,packet);
1796
      bzero(&create_info, sizeof(create_info));
1797 1798
      mysql_create_db(thd, (lower_case_table_names == 2 ? alias : db),
                      &create_info, 0);
unknown's avatar
unknown committed
1799 1800
      break;
    }
unknown's avatar
unknown committed
1801
  case COM_DROP_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1802
    {
1803 1804
      statistic_increment(thd->status_var.com_stat[SQLCOM_DROP_DB],
			  &LOCK_status);
1805
      char *db=thd->strdup(packet);
unknown's avatar
unknown committed
1806
      /*  null test to handle EOM */
1807
      if (!db || check_db_name(db))
1808
      {
1809
	my_error(ER_WRONG_DB_NAME, MYF(0), db ? db : "NULL");
1810 1811
	break;
      }
unknown's avatar
unknown committed
1812
      if (check_access(thd,DROP_ACL,db,0,1,0))
1813
	break;
unknown's avatar
unknown committed
1814 1815
      if (thd->locked_tables || thd->active_transaction())
      {
unknown's avatar
unknown committed
1816 1817
	my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                   ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
unknown's avatar
unknown committed
1818
	break;
unknown's avatar
unknown committed
1819
      }
1820
      mysql_log.write(thd,command,db);
1821
      mysql_rm_db(thd, db, 0, 0);
unknown's avatar
unknown committed
1822 1823
      break;
    }
1824
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1825 1826
  case COM_BINLOG_DUMP:
    {
unknown's avatar
unknown committed
1827 1828 1829 1830
      ulong pos;
      ushort flags;
      uint32 slave_server_id;

1831
      statistic_increment(thd->status_var.com_other,&LOCK_status);
1832
      thd->slow_command = TRUE;
unknown's avatar
unknown committed
1833
      if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1834
	break;
unknown's avatar
unknown committed
1835

1836
      /* TODO: The following has to be changed to an 8 byte integer */
1837 1838
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
unknown's avatar
unknown committed
1839
      thd->server_id=0; /* avoid suicide */
unknown's avatar
unknown committed
1840
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
unknown's avatar
unknown committed
1841
	kill_zombie_dump_threads(slave_server_id);
1842
      thd->server_id = slave_server_id;
unknown's avatar
unknown committed
1843 1844 1845

      mysql_log.write(thd, command, "Log: '%s'  Pos: %ld", packet+10,
                      (long) pos);
1846
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
unknown's avatar
unknown committed
1847
      unregister_slave(thd,1,1);
unknown's avatar
unknown committed
1848
      /*  fake COM_QUIT -- if we get here, the thread needs to terminate */
1849 1850
      error = TRUE;
      net->error = 0;
unknown's avatar
unknown committed
1851 1852
      break;
    }
1853
#endif
unknown's avatar
unknown committed
1854 1855
  case COM_REFRESH:
    {
1856 1857
      statistic_increment(thd->status_var.com_stat[SQLCOM_FLUSH],
			  &LOCK_status);
unknown's avatar
unknown committed
1858
      ulong options= (ulong) (uchar) packet[0];
unknown's avatar
unknown committed
1859
      if (check_global_access(thd,RELOAD_ACL))
unknown's avatar
unknown committed
1860
	break;
1861
      mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1862
      if (!reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, NULL))
1863
        send_ok(thd);
unknown's avatar
unknown committed
1864 1865
      break;
    }
1866
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1867
  case COM_SHUTDOWN:
1868
  {
1869
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
1870
    if (check_global_access(thd,SHUTDOWN_ACL))
unknown's avatar
unknown committed
1871
      break; /* purecov: inspected */
1872
    /*
1873 1874 1875 1876
      If the client is < 4.1.3, it is going to send us no argument; then
      packet_length is 1, packet[0] is the end 0 of the packet. Note that
      SHUTDOWN_DEFAULT is 0. If client is >= 4.1.3, the shutdown level is in
      packet[0].
1877
    */
1878 1879
    enum mysql_enum_shutdown_level level=
      (enum mysql_enum_shutdown_level) (uchar) packet[0];
1880
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1881 1882 1883 1884 1885 1886 1887
    if (level == SHUTDOWN_DEFAULT)
      level= SHUTDOWN_WAIT_ALL_BUFFERS; // soon default will be configurable
    else if (level != SHUTDOWN_WAIT_ALL_BUFFERS)
    {
      my_error(ER_NOT_SUPPORTED_YET, MYF(0), "this shutdown level");
      break;
    }
1888
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1889
    mysql_log.write(thd,command,NullS);
1890
    send_eof(thd);
unknown's avatar
unknown committed
1891 1892 1893
#ifdef __WIN__
    sleep(1);					// must wait after eof()
#endif
unknown's avatar
unknown committed
1894
#ifndef OS2
1895
    send_eof(thd);				// This is for 'quit request'
unknown's avatar
unknown committed
1896
#endif
1897
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1898 1899 1900 1901
    close_thread_tables(thd);			// Free before kill
    kill_mysql();
    error=TRUE;
    break;
1902
  }
1903
#endif
unknown's avatar
unknown committed
1904 1905
  case COM_STATISTICS:
  {
1906
    mysql_log.write(thd,command,NullS);
1907 1908
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_STATUS],
			&LOCK_status);
unknown's avatar
unknown committed
1909
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1910
    char buff[200];
unknown's avatar
unknown committed
1911 1912 1913
#else
    char *buff= thd->net.last_error;
#endif
1914
    ulong uptime = (ulong) (thd->start_time - start_time);
unknown's avatar
unknown committed
1915
    sprintf((char*) buff,
1916
	    "Uptime: %lu  Threads: %d  Questions: %lu  Slow queries: %lu  Opens: %lu  Flush tables: %lu  Open tables: %u  Queries per second avg: %.3f",
unknown's avatar
unknown committed
1917
	    uptime,
1918 1919 1920
	    (int) thread_count, (ulong) thd->query_id,
            (ulong) thd->status_var.long_query_count,
	    thd->status_var.opened_tables, refresh_version, cached_tables(),
1921 1922
	    (uptime ? (ulonglong2double(thd->query_id) / (double) uptime) :
	     (double) 0));
unknown's avatar
unknown committed
1923
#ifdef SAFEMALLOC
1924
    if (sf_malloc_cur_memory)				// Using SAFEMALLOC
unknown's avatar
unknown committed
1925
      sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
1926 1927
	      (sf_malloc_cur_memory+1023L)/1024L,
	      (sf_malloc_max_memory+1023L)/1024L);
unknown's avatar
unknown committed
1928 1929
#endif
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1930
    VOID(my_net_write(net, buff,(uint) strlen(buff)));
unknown's avatar
unknown committed
1931
    VOID(net_flush(net));
unknown's avatar
unknown committed
1932
#endif
unknown's avatar
unknown committed
1933 1934 1935
    break;
  }
  case COM_PING:
1936
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1937
    send_ok(thd);				// Tell client we are alive
unknown's avatar
unknown committed
1938 1939
    break;
  case COM_PROCESS_INFO:
1940 1941
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_PROCESSLIST],
			&LOCK_status);
unknown's avatar
unknown committed
1942
    if (!thd->priv_user[0] && check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
1943
      break;
1944
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1945 1946
    mysqld_list_processes(thd,
			  thd->master_access & PROCESS_ACL ? 
unknown's avatar
unknown committed
1947
			  NullS : thd->priv_user, 0);
unknown's avatar
unknown committed
1948 1949 1950
    break;
  case COM_PROCESS_KILL:
  {
1951
    statistic_increment(thd->status_var.com_stat[SQLCOM_KILL], &LOCK_status);
1952
    ulong id=(ulong) uint4korr(packet);
unknown's avatar
SCRUM  
unknown committed
1953
    kill_one_thread(thd,id,false);
unknown's avatar
unknown committed
1954 1955
    break;
  }
1956 1957
  case COM_SET_OPTION:
  {
1958 1959
    statistic_increment(thd->status_var.com_stat[SQLCOM_SET_OPTION],
			&LOCK_status);
1960 1961 1962 1963
    enum_mysql_set_option command= (enum_mysql_set_option) uint2korr(packet);
    switch (command) {
    case MYSQL_OPTION_MULTI_STATEMENTS_ON:
      thd->client_capabilities|= CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
1964
      send_eof(thd);
1965 1966 1967
      break;
    case MYSQL_OPTION_MULTI_STATEMENTS_OFF:
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
1968
      send_eof(thd);
1969 1970
      break;
    default:
unknown's avatar
unknown committed
1971
      my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
1972 1973 1974 1975
      break;
    }
    break;
  }
unknown's avatar
unknown committed
1976
  case COM_DEBUG:
1977
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
1978
    if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
1979
      break;					/* purecov: inspected */
1980
    mysql_print_status();
1981
    mysql_log.write(thd,command,NullS);
1982
    send_eof(thd);
unknown's avatar
unknown committed
1983 1984 1985 1986 1987
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
1988
  case COM_END:
unknown's avatar
unknown committed
1989
  default:
unknown's avatar
unknown committed
1990
    my_message(ER_UNKNOWN_COM_ERROR, ER(ER_UNKNOWN_COM_ERROR), MYF(0));
unknown's avatar
unknown committed
1991 1992
    break;
  }
1993 1994
  if (thd->lock || thd->open_tables || thd->derived_tables ||
      thd->prelocked_mode)
unknown's avatar
unknown committed
1995 1996 1997 1998
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }
1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
  /*
    assume handlers auto-commit (if some doesn't - transaction handling
    in MySQL should be redesigned to support it; it's a big change,
    and it's not worth it - better to commit explicitly only writing
    transactions, read-only ones should better take care of themselves.
    saves some work in 2pc too)
    see also sql_base.cc - close_thread_tables()
  */
  bzero(&thd->transaction.stmt, sizeof(thd->transaction.stmt));
  if (!thd->active_transaction())
    thd->transaction.xid.null();
unknown's avatar
unknown committed
2010

unknown's avatar
unknown committed
2011 2012 2013
  /* report error issued during command execution */
  if (thd->killed_errno() && !thd->net.report_error)
    thd->send_kill_message();
unknown's avatar
unknown committed
2014
  if (thd->net.report_error)
2015
    net_send_error(thd);
unknown's avatar
unknown committed
2016

2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034
  log_slow_query(thd);

  thd->proc_info="cleaning up";
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
  thd->proc_info=0;
  thd->command=COM_SLEEP;
  thd->query=0;
  thd->query_length=0;
  thread_running--;
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
  thd->packet.shrink(thd->variables.net_buffer_length);	// Reclaim some memory
  free_root(thd->mem_root,MYF(MY_KEEP_PREALLOC));
  DBUG_RETURN(error);
}


static void log_slow_query(THD *thd)
{
unknown's avatar
unknown committed
2035
  time_t start_of_query=thd->start_time;
2036
  thd->end_time();				// Set start time
2037

2038
  /* If not reading from backup and if the query took too long */
2039
  if (!thd->slow_command && !thd->user_time) // do not log 'slow_command' queries
unknown's avatar
unknown committed
2040
  {
2041 2042
    thd->proc_info="logging slow query";

2043 2044
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
2045 2046
	((thd->server_status &
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
2047
	 (specialflag & SPECIAL_LOG_QUERIES_NOT_USING_INDEXES)))
2048
    {
2049
      thd->status_var.long_query_count++;
2050 2051
      mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
    }
unknown's avatar
unknown committed
2052 2053 2054
  }
}

2055

2056 2057 2058 2059 2060
int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,
                         enum enum_schema_tables schema_table_idx)
{
  DBUG_ENTER("prepare_schema_table");
  SELECT_LEX *sel= 0;
2061
  switch (schema_table_idx) {
2062 2063
  case SCH_SCHEMATA:
#if defined(DONT_ALLOW_SHOW_COMMANDS)
unknown's avatar
unknown committed
2064 2065
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0));   /* purecov: inspected */
2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076
    DBUG_RETURN(1);
#else
    if ((specialflag & SPECIAL_SKIP_SHOW_DB) &&
	check_global_access(thd, SHOW_DB_ACL))
      DBUG_RETURN(1);
    break;
#endif
  case SCH_TABLE_NAMES:
  case SCH_TABLES:
  case SCH_VIEWS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2077 2078
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2079 2080 2081 2082 2083 2084
    DBUG_RETURN(1);
#else
    {
      char *db= lex->select_lex.db ? lex->select_lex.db : thd->db;
      if (!db)
      {
unknown's avatar
unknown committed
2085 2086
	my_message(ER_NO_DB_ERROR,
                   ER(ER_NO_DB_ERROR), MYF(0)); /* purecov: inspected */
2087 2088 2089 2090 2091
        DBUG_RETURN(1);				/* purecov: inspected */
      }
      remove_escape(db);				// Fix escaped '_'
      if (check_db_name(db))
      {
unknown's avatar
unknown committed
2092
        my_error(ER_WRONG_DB_NAME, MYF(0), db);
2093 2094 2095 2096 2097 2098
        DBUG_RETURN(1);
      }
      if (check_access(thd,SELECT_ACL,db,&thd->col_access,0,0))
        DBUG_RETURN(1);			        /* purecov: inspected */
      if (!thd->col_access && check_grant_db(thd,db))
      {
unknown's avatar
unknown committed
2099 2100
	my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
                 thd->priv_user, thd->priv_host, db);
2101 2102
	DBUG_RETURN(1);
      }
2103 2104 2105 2106 2107
      /*
        We need to do a copy to make this prepared statement safe if this
        was thd->db
      */
      lex->select_lex.db= thd->strdup(db);
2108 2109 2110 2111 2112 2113
      break;
    }
#endif
  case SCH_COLUMNS:
  case SCH_STATISTICS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2114 2115
    my_message(ER_NOT_ALLOWED_COMMAND,
               ER(ER_NOT_ALLOWED_COMMAND), MYF(0)); /* purecov: inspected */
2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
    DBUG_RETURN(1);
#else
    if (table_ident)
    {
      TABLE_LIST **query_tables_last= lex->query_tables_last;
      sel= new SELECT_LEX();
      sel->init_query();
      if(!sel->add_table_to_list(thd, table_ident, 0, 0, TL_READ, 
                                 (List<String> *) 0, (List<String> *) 0))
        DBUG_RETURN(1);
      lex->query_tables_last= query_tables_last;
      TABLE_LIST *table_list= (TABLE_LIST*) sel->table_list.first;
      char *db= table_list->db;
      remove_escape(db);			// Fix escaped '_'
2130
      remove_escape(table_list->table_name);
2131 2132 2133 2134 2135 2136 2137 2138 2139
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
                       &table_list->grant.privilege, 0, 0))
        DBUG_RETURN(1);				/* purecov: inspected */
      if (grant_option && check_grant(thd, SELECT_ACL, table_list, 2,
                                      UINT_MAX, 0))
        DBUG_RETURN(1);
      break;
    }
#endif
2140 2141 2142
  case SCH_OPEN_TABLES:
  case SCH_VARIABLES:
  case SCH_STATUS:
2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163
  case SCH_PROCEDURES:
  case SCH_CHARSETS:
  case SCH_COLLATIONS:
  case SCH_COLLATION_CHARACTER_SET_APPLICABILITY:
  case SCH_USER_PRIVILEGES:
  case SCH_SCHEMA_PRIVILEGES:
  case SCH_TABLE_PRIVILEGES:
  case SCH_COLUMN_PRIVILEGES:
  case SCH_TABLE_CONSTRAINTS:
  case SCH_KEY_COLUMN_USAGE:
  default:
    break;
  }
  
  SELECT_LEX *select_lex= lex->current_select;
  if (make_schema_select(thd, select_lex, schema_table_idx))
  {
    DBUG_RETURN(1);
  }
  TABLE_LIST *table_list= (TABLE_LIST*) select_lex->table_list.first;
  table_list->schema_select_lex= sel;
2164
  table_list->schema_table_reformed= 1;
2165 2166 2167 2168
  DBUG_RETURN(0);
}


2169 2170 2171 2172 2173 2174 2175 2176 2177 2178
/*
  Read query from packet and store in thd->query
  Used in COM_QUERY and COM_PREPARE

  DESCRIPTION
    Sets the following THD variables:
      query
      query_length

  RETURN VALUES
unknown's avatar
unknown committed
2179 2180
    FALSE ok
    TRUE  error;  In this case thd->fatal_error is set
2181 2182 2183 2184 2185
*/

bool alloc_query(THD *thd, char *packet, ulong packet_length)
{
  packet_length--;				// Remove end null
2186
  /* Remove garbage at start and end of query */
unknown's avatar
unknown committed
2187
  while (my_isspace(thd->charset(),packet[0]) && packet_length > 0)
2188 2189 2190 2191 2192
  {
    packet++;
    packet_length--;
  }
  char *pos=packet+packet_length;		// Point at end null
unknown's avatar
unknown committed
2193
  while (packet_length > 0 &&
unknown's avatar
unknown committed
2194
	 (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
2195 2196 2197 2198 2199
  {
    pos--;
    packet_length--;
  }
  /* We must allocate some extra memory for query cache */
unknown's avatar
unknown committed
2200
  thd->query_length= 0;                        // Extra safety: Avoid races
2201 2202
  if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
					      packet_length,
2203 2204
					      thd->db_length+ 1 +
					      QUERY_CACHE_FLAGS_SIZE)))
unknown's avatar
unknown committed
2205
    return TRUE;
2206 2207
  thd->query[packet_length]=0;
  thd->query_length= packet_length;
2208 2209 2210 2211

  /* Reclaim some memory */
  thd->packet.shrink(thd->variables.net_buffer_length);
  thd->convert_buffer.shrink(thd->variables.net_buffer_length);
2212 2213 2214

  if (!(specialflag & SPECIAL_NO_PRIOR))
    my_pthread_setprio(pthread_self(),QUERY_PRIOR);
unknown's avatar
unknown committed
2215
  return FALSE;
2216 2217
}

unknown's avatar
unknown committed
2218 2219 2220 2221 2222
/****************************************************************************
** mysql_execute_command
** Execute command saved in thd and current_lex->sql_command
****************************************************************************/

unknown's avatar
unknown committed
2223
bool
2224
mysql_execute_command(THD *thd)
unknown's avatar
unknown committed
2225
{
unknown's avatar
unknown committed
2226
  bool	res= FALSE;
unknown's avatar
unknown committed
2227
  int result= 0;
unknown's avatar
unknown committed
2228
  LEX	*lex= thd->lex;
unknown's avatar
unknown committed
2229
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
unknown's avatar
unknown committed
2230
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
unknown committed
2231 2232
  bool slave_fake_lock= 0;
  MYSQL_LOCK *fake_prev_lock= 0;
unknown's avatar
VIEW  
unknown committed
2233
  /* first table of first SELECT_LEX */
unknown's avatar
unknown committed
2234
  TABLE_LIST *first_table= (TABLE_LIST*) select_lex->table_list.first;
unknown's avatar
VIEW  
unknown committed
2235 2236 2237
  /* list of all tables in query */
  TABLE_LIST *all_tables;
  /* most outer SELECT_LEX_UNIT of query */
2238
  SELECT_LEX_UNIT *unit= &lex->unit;
2239
  /* Saved variable value */
unknown's avatar
unknown committed
2240
  DBUG_ENTER("mysql_execute_command");
2241
  thd->net.no_send_error= 0;
unknown's avatar
unknown committed
2242

unknown's avatar
VIEW  
unknown committed
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258
  /*
    In many cases first table of main SELECT_LEX have special meaning =>
    check that it is first table in global list and relink it first in 
    queries_tables list if it is necessary (we need such relinking only
    for queries with subqueries in select list, in this case tables of
    subqueries will go to global list first)

    all_tables will differ from first_table only if most upper SELECT_LEX
    do not contain tables.

    Because of above in place where should be at least one table in most
    outer SELECT_LEX we have following check:
    DBUG_ASSERT(first_table == all_tables);
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
  */
  lex->first_lists_tables_same();
2259
  /* should be assigned after making first tables same */
unknown's avatar
VIEW  
unknown committed
2260 2261
  all_tables= lex->query_tables;

2262 2263 2264 2265 2266 2267
  /*
    Reset warning count for each query that uses tables
    A better approach would be to reset this for any commands
    that is not a SHOW command or a select that only access local
    variables, but for now this is probably good enough.
  */
2268 2269
  if (all_tables || &lex->select_lex != lex->all_selects_list ||
      lex->spfuns.records || lex->spprocs.records)
unknown's avatar
unknown committed
2270
    mysql_reset_errors(thd, 0);
2271

unknown's avatar
SCRUM  
unknown committed
2272
#ifdef HAVE_REPLICATION
2273 2274
  if (thd->slave_thread)
  {
unknown's avatar
unknown committed
2275
    if (lex->sql_command == SQLCOM_UPDATE_MULTI)
unknown's avatar
unknown committed
2276 2277 2278
    {
      DBUG_PRINT("info",("need faked locked tables"));
      
unknown's avatar
unknown committed
2279
      if (check_multi_update_lock(thd))
unknown's avatar
unknown committed
2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290
        goto error;

      /* Fix for replication, the tables are opened and locked,
         now we pretend that we have performed a LOCK TABLES action */
	 
      fake_prev_lock= thd->locked_tables;
      if (thd->lock)
        thd->locked_tables= thd->lock;
      thd->lock= 0;
      slave_fake_lock= 1;
    }
unknown's avatar
unknown committed
2291
    /*
unknown's avatar
merge  
unknown committed
2292
      Skip if we are in the slave thread, some table rules have been
2293 2294 2295 2296
      given and the table list says the query should not be replicated.
      Exception is DROP TEMPORARY TABLE IF EXISTS: we always execute it
      (otherwise we have stale files on slave caused by exclusion of one tmp
      table).
unknown's avatar
merge  
unknown committed
2297
    */
2298 2299
    if (!(lex->sql_command == SQLCOM_DROP_TABLE &&
          lex->drop_temporary && lex->drop_if_exists) &&
unknown's avatar
Merge  
unknown committed
2300
        all_tables_not_ok(thd, all_tables))
unknown's avatar
unknown committed
2301 2302
    {
      /* we warn the slave SQL thread */
unknown's avatar
unknown committed
2303
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
2304
      DBUG_RETURN(0);
unknown's avatar
unknown committed
2305
    }
unknown's avatar
merge  
unknown committed
2306 2307
#ifndef TO_BE_DELETED
    /*
2308 2309 2310
      This is a workaround to deal with the shortcoming in 3.23.44-3.23.46
      masters in RELEASE_LOCK() logging. We re-write SELECT RELEASE_LOCK()
      as DO RELEASE_LOCK()
unknown's avatar
merge  
unknown committed
2311
    */
2312 2313 2314
    if (lex->sql_command == SQLCOM_SELECT)
    {
      lex->sql_command = SQLCOM_DO;
unknown's avatar
unknown committed
2315
      lex->insert_list = &select_lex->item_list;
2316
    }
unknown's avatar
merge  
unknown committed
2317
#endif
2318
  }
unknown's avatar
unknown committed
2319
#endif /* !HAVE_REPLICATION */
2320

2321 2322 2323 2324 2325
  /*
    When option readonly is set deny operations which change tables.
    Except for the replication thread and the 'super' users.
  */
  if (opt_readonly &&
unknown's avatar
unknown committed
2326
      !(thd->slave_thread || (thd->master_access & SUPER_ACL)) &&
unknown's avatar
unknown committed
2327
      uc_update_queries[lex->sql_command])
2328
  {
unknown's avatar
unknown committed
2329
    my_error(ER_OPTION_PREVENTS_STATEMENT, MYF(0), "--read-only");
unknown's avatar
unknown committed
2330
    DBUG_RETURN(-1);
2331
  }
2332

2333 2334
  statistic_increment(thd->status_var.com_stat[lex->sql_command],
		      &LOCK_status);
unknown's avatar
unknown committed
2335 2336 2337
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2338 2339 2340 2341 2342 2343 2344
    /* assign global limit variable if limit is not given */
    {
      SELECT_LEX *param= lex->unit.global_parameters;
      if (!param->explicit_limit)
	param->select_limit= thd->variables.select_limit;
    }

2345
    select_result *result=lex->result;
unknown's avatar
VIEW  
unknown committed
2346
    if (all_tables)
unknown's avatar
unknown committed
2347
    {
unknown's avatar
VIEW  
unknown committed
2348 2349 2350 2351
      res= check_table_access(thd,
			      lex->exchange ? SELECT_ACL | FILE_ACL :
			      SELECT_ACL,
			      all_tables, 0);
unknown's avatar
unknown committed
2352 2353
    }
    else
unknown's avatar
VIEW  
unknown committed
2354 2355 2356
      res= check_access(thd,
			lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
			any_db, 0, 0, 0);
unknown's avatar
unknown committed
2357
    if (res)
unknown's avatar
unknown committed
2358
      goto error;
unknown's avatar
unknown committed
2359

unknown's avatar
VIEW  
unknown committed
2360
    if (!(res= open_and_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
2361
    {
unknown's avatar
unknown committed
2362
      if (lex->describe)
unknown's avatar
unknown committed
2363
      {
2364
	if (!(result= new select_send()))
2365
	  goto error;
2366 2367
	else
	  thd->send_explain_fields(result);
unknown's avatar
unknown committed
2368
	res= mysql_explain_union(thd, &thd->lex->unit, result);
unknown's avatar
unknown committed
2369 2370 2371 2372 2373
	if (lex->describe & DESCRIBE_EXTENDED)
	{
	  char buff[1024];
	  String str(buff,(uint32) sizeof(buff), system_charset_info);
	  str.length(0);
unknown's avatar
unknown committed
2374
	  thd->lex->unit.print(&str);
unknown's avatar
unknown committed
2375 2376 2377 2378
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
2379
	result->send_eof();
2380
        delete result;
unknown's avatar
unknown committed
2381 2382 2383
      }
      else
      {
2384
	if (!result && !(result= new select_send()))
unknown's avatar
unknown committed
2385
          goto error;
unknown's avatar
VIEW  
unknown committed
2386
	query_cache_store_query(thd, all_tables);
2387
	res= handle_select(thd, lex, result, 0);
2388 2389
        if (result != lex->result)
          delete result;
unknown's avatar
unknown committed
2390
      }
unknown's avatar
unknown committed
2391
    }
unknown's avatar
unknown committed
2392 2393
    break;
  }
unknown's avatar
unknown committed
2394
  case SQLCOM_PREPARE:
2395
  {
2396 2397 2398 2399
    char *query_str;
    uint query_len;
    if (lex->prepared_stmt_code_is_varref)
    {
2400
      /* This is PREPARE stmt FROM @var. */
2401 2402 2403 2404
      String str;
      CHARSET_INFO *to_cs= thd->variables.collation_connection;
      bool need_conversion;
      user_var_entry *entry;
2405
      String *pstr= &str;
2406
      uint32 unused;
2407
      /*
2408 2409 2410
        Convert @var contents to string in connection character set. Although
        it is known that int/real/NULL value cannot be a valid query we still
        convert it for error messages to uniform.
2411
      */
2412 2413
      if ((entry=
             (user_var_entry*)hash_search(&thd->user_vars,
2414 2415 2416 2417
                                          (byte*)lex->prepared_stmt_code.str,
                                          lex->prepared_stmt_code.length))
          && entry->value)
      {
2418 2419
        my_bool is_var_null;
        pstr= entry->val_str(&is_var_null, &str, NOT_FIXED_DEC);
2420 2421 2422 2423
        /*
          NULL value of variable checked early as entry->value so here
          we can't get NULL in normal conditions
        */
2424 2425
        DBUG_ASSERT(!is_var_null);
        if (!pstr)
unknown's avatar
unknown committed
2426
          goto error;
2427 2428
      }
      else
2429 2430 2431 2432 2433
      {
        /*
          variable absent or equal to NULL, so we need to set variable to
          something reasonable to get readable error message during parsing
        */
2434
        str.set("NULL", 4, &my_charset_latin1);
2435 2436
      }

2437
      need_conversion=
2438 2439
        String::needs_conversion(pstr->length(), pstr->charset(),
                                 to_cs, &unused);
2440

2441 2442
      query_len= need_conversion? (pstr->length() * to_cs->mbmaxlen) :
                                  pstr->length();
unknown's avatar
unknown committed
2443
      if (!(query_str= alloc_root(thd->mem_root, query_len+1)))
unknown's avatar
unknown committed
2444
        goto error;
unknown's avatar
merge  
unknown committed
2445
 
2446
      if (need_conversion)
2447 2448 2449 2450 2451 2452
      {
        uint dummy_errors;
        query_len= copy_and_convert(query_str, query_len, to_cs,
                                    pstr->ptr(), pstr->length(),
                                    pstr->charset(), &dummy_errors);
      }
2453
      else
2454
        memcpy(query_str, pstr->ptr(), pstr->length());
2455
      query_str[query_len]= 0;
2456 2457 2458
    }
    else
    {
2459 2460
      query_str= lex->prepared_stmt_code.str;
      query_len= lex->prepared_stmt_code.length;
2461
      DBUG_PRINT("info", ("PREPARE: %.*s FROM '%.*s' \n",
2462 2463
                          lex->prepared_stmt_name.length,
                          lex->prepared_stmt_name.str,
2464
                          query_len, query_str));
2465
    }
unknown's avatar
unknown committed
2466
    thd->command= COM_PREPARE;
unknown's avatar
unknown committed
2467 2468
    if (!(res= mysql_stmt_prepare(thd, query_str, query_len + 1,
                                  &lex->prepared_stmt_name)))
unknown's avatar
unknown committed
2469 2470 2471 2472 2473
      send_ok(thd, 0L, 0L, "Statement prepared");
    break;
  }
  case SQLCOM_EXECUTE:
  {
2474
    DBUG_PRINT("info", ("EXECUTE: %.*s\n",
2475 2476 2477
                        lex->prepared_stmt_name.length,
                        lex->prepared_stmt_name.str));
    mysql_sql_stmt_execute(thd, &lex->prepared_stmt_name);
unknown's avatar
unknown committed
2478 2479 2480 2481 2482
    lex->prepared_stmt_params.empty();
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2483 2484 2485 2486 2487
    Statement* stmt;
    DBUG_PRINT("info", ("DEALLOCATE PREPARE: %.*s\n", 
                        lex->prepared_stmt_name.length,
                        lex->prepared_stmt_name.str));
    if ((stmt= thd->stmt_map.find_by_name(&lex->prepared_stmt_name)))
unknown's avatar
unknown committed
2488
    {
2489 2490
      thd->stmt_map.erase(stmt);
      send_ok(thd);
unknown's avatar
unknown committed
2491
    }
2492
    else
2493 2494
    {
      my_error(ER_UNKNOWN_STMT_HANDLER, MYF(0),
2495 2496
               lex->prepared_stmt_name.length,
               lex->prepared_stmt_name.str,
2497
               "DEALLOCATE PREPARE");
unknown's avatar
unknown committed
2498
      goto error;
2499
    }
unknown's avatar
unknown committed
2500 2501
    break;
  }
unknown's avatar
unknown committed
2502
  case SQLCOM_DO:
2503 2504
    if (check_table_access(thd, SELECT_ACL, all_tables, 0) ||
        open_and_lock_tables(thd, all_tables))
unknown's avatar
unknown committed
2505
      goto error;
unknown's avatar
unknown committed
2506 2507

    res= mysql_do(thd, *lex->insert_list);
unknown's avatar
unknown committed
2508 2509
    break;

2510
  case SQLCOM_EMPTY_QUERY:
2511
    send_ok(thd);
2512 2513
    break;

unknown's avatar
unknown committed
2514 2515 2516 2517
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2518
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2519
  case SQLCOM_PURGE:
2520
  {
unknown's avatar
unknown committed
2521
    if (check_global_access(thd, SUPER_ACL))
2522
      goto error;
unknown's avatar
unknown committed
2523
    /* PURGE MASTER LOGS TO 'file' */
2524 2525 2526
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2527 2528
  case SQLCOM_PURGE_BEFORE:
  {
2529 2530
    Item *it;

2531 2532
    if (check_global_access(thd, SUPER_ACL))
      goto error;
unknown's avatar
unknown committed
2533
    /* PURGE MASTER LOGS BEFORE 'data' */
2534
    it= (Item *)lex->value_list.head();
unknown's avatar
unknown committed
2535 2536
    if ((!it->fixed &&it->fix_fields(lex->thd, 0, &it)) ||
        it->check_cols(1))
2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547
    {
      my_error(ER_WRONG_ARGUMENTS, MYF(0), "PURGE LOGS BEFORE");
      goto error;
    }
    it= new Item_func_unix_timestamp(it);
    /*
      it is OK only emulate fix_fieds, because we need only
      value of constant
    */
    it->quick_fix_field();
    res = purge_master_logs_before_date(thd, (ulong)it->val_int());
2548 2549
    break;
  }
2550
#endif
unknown's avatar
unknown committed
2551 2552
  case SQLCOM_SHOW_WARNS:
  {
2553 2554
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2555 2556 2557
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
unknown's avatar
unknown committed
2558 2559 2560 2561
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2562 2563
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
unknown's avatar
unknown committed
2564 2565
    break;
  }
unknown's avatar
unknown committed
2566 2567
  case SQLCOM_SHOW_NEW_MASTER:
  {
unknown's avatar
unknown committed
2568
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2569
      goto error;
2570
    /* This query don't work now. See comment in repl_failsafe.cc */
unknown's avatar
unknown committed
2571
#ifndef WORKING_NEW_MASTER
unknown's avatar
unknown committed
2572 2573
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "SHOW NEW MASTER");
    goto error;
unknown's avatar
unknown committed
2574
#else
unknown's avatar
unknown committed
2575 2576
    res = show_new_master(thd);
    break;
unknown's avatar
unknown committed
2577
#endif
unknown's avatar
unknown committed
2578
  }
2579

unknown's avatar
unknown committed
2580
#ifdef HAVE_REPLICATION
2581 2582
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
unknown's avatar
unknown committed
2583
    if (check_global_access(thd, REPL_SLAVE_ACL))
2584 2585 2586 2587
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
unknown's avatar
unknown committed
2588 2589
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
unknown's avatar
unknown committed
2590
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2591
      goto error;
2592
    res = mysql_show_binlog_events(thd);
unknown's avatar
unknown committed
2593 2594
    break;
  }
2595 2596
#endif

unknown's avatar
unknown committed
2597
  case SQLCOM_BACKUP_TABLE:
2598
  {
unknown's avatar
VIEW  
unknown committed
2599 2600 2601
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL, all_tables, 0) ||
unknown's avatar
unknown committed
2602
	check_global_access(thd, FILE_ACL))
2603
      goto error; /* purecov: inspected */
2604
    thd->slow_command=TRUE;
unknown's avatar
VIEW  
unknown committed
2605
    res = mysql_backup_table(thd, first_table);
unknown's avatar
unknown committed
2606

2607 2608
    break;
  }
unknown's avatar
unknown committed
2609
  case SQLCOM_RESTORE_TABLE:
2610
  {
unknown's avatar
VIEW  
unknown committed
2611 2612 2613
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, INSERT_ACL, all_tables, 0) ||
unknown's avatar
unknown committed
2614
	check_global_access(thd, FILE_ACL))
2615
      goto error; /* purecov: inspected */
2616
    thd->slow_command=TRUE;
unknown's avatar
VIEW  
unknown committed
2617
    res = mysql_restore_table(thd, first_table);
2618 2619
    break;
  }
unknown's avatar
unknown committed
2620 2621
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
unknown's avatar
VIEW  
unknown committed
2622 2623 2624 2625
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
        check_access(thd, INDEX_ACL, first_table->db,
                     &first_table->grant.privilege, 0, 0))
unknown's avatar
unknown committed
2626
      goto error;
2627
    res= mysql_assign_to_keycache(thd, first_table, &lex->ident);
unknown's avatar
unknown committed
2628 2629
    break;
  }
unknown's avatar
unknown committed
2630 2631
  case SQLCOM_PRELOAD_KEYS:
  {
unknown's avatar
VIEW  
unknown committed
2632 2633 2634 2635
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_access(thd, INDEX_ACL, first_table->db,
                     &first_table->grant.privilege, 0, 0))
2636
      goto error;
unknown's avatar
VIEW  
unknown committed
2637
    res = mysql_preload_keys(thd, first_table);
unknown's avatar
unknown committed
2638 2639
    break;
  }
unknown's avatar
unknown committed
2640
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2641
  case SQLCOM_CHANGE_MASTER:
2642
  {
unknown's avatar
unknown committed
2643
    if (check_global_access(thd, SUPER_ACL))
2644
      goto error;
2645
    pthread_mutex_lock(&LOCK_active_mi);
2646
    res = change_master(thd,active_mi);
2647
    pthread_mutex_unlock(&LOCK_active_mi);
2648 2649
    break;
  }
unknown's avatar
unknown committed
2650
  case SQLCOM_SHOW_SLAVE_STAT:
2651
  {
2652 2653
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2654
      goto error;
2655
    pthread_mutex_lock(&LOCK_active_mi);
2656
    res = show_master_info(thd,active_mi);
2657
    pthread_mutex_unlock(&LOCK_active_mi);
2658 2659
    break;
  }
unknown's avatar
unknown committed
2660
  case SQLCOM_SHOW_MASTER_STAT:
2661
  {
2662 2663
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2664 2665 2666 2667
      goto error;
    res = show_binlog_info(thd);
    break;
  }
unknown's avatar
unknown committed
2668

2669
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
unknown's avatar
unknown committed
2670
    if (check_global_access(thd, SUPER_ACL))
2671
      goto error;
2672
    if (end_active_trans(thd))
unknown's avatar
unknown committed
2673
      goto error;
2674 2675
    else
      res = load_master_data(thd);
2676
    break;
unknown's avatar
unknown committed
2677
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
2678 2679 2680
#ifdef HAVE_INNOBASE_DB
  case SQLCOM_SHOW_INNODB_STATUS:
    {
2681
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2682 2683 2684 2685
	goto error;
      res = innodb_show_status(thd);
      break;
    }
unknown's avatar
unknown committed
2686 2687 2688
  case SQLCOM_SHOW_MUTEX_STATUS:
    {
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2689
        goto error;
unknown's avatar
unknown committed
2690 2691 2692
      res = innodb_mutex_show_status(thd);
      break;
    }
unknown's avatar
unknown committed
2693
#endif
unknown's avatar
unknown committed
2694
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2695
  case SQLCOM_LOAD_MASTER_TABLE:
2696
  {
unknown's avatar
VIEW  
unknown committed
2697 2698 2699 2700 2701
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (!first_table->db)
      first_table->db= thd->db;
    if (check_access(thd, CREATE_ACL, first_table->db,
		     &first_table->grant.privilege, 0, 0))
unknown's avatar
unknown committed
2702 2703 2704 2705
      goto error;				/* purecov: inspected */
    if (grant_option)
    {
      /* Check that the first table has CREATE privilege */
unknown's avatar
VIEW  
unknown committed
2706
      if (check_grant(thd, CREATE_ACL, all_tables, 0, 1, 0))
2707
	goto error;
unknown's avatar
unknown committed
2708
    }
2709
    if (strlen(first_table->table_name) > NAME_LEN)
unknown's avatar
unknown committed
2710
    {
2711
      my_error(ER_WRONG_TABLE_NAME, MYF(0), first_table->table_name);
unknown's avatar
unknown committed
2712 2713
      break;
    }
2714
    pthread_mutex_lock(&LOCK_active_mi);
2715 2716 2717 2718
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
2719
    if (!fetch_master_table(thd, first_table->db, first_table->table_name,
2720
			    active_mi, 0, 0))
2721
    {
2722
      send_ok(thd);
2723
    }
2724
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2725
    break;
2726
  }
unknown's avatar
unknown committed
2727
#endif /* HAVE_REPLICATION */
2728

unknown's avatar
unknown committed
2729
  case SQLCOM_CREATE_TABLE:
unknown's avatar
unknown committed
2730
  {
unknown's avatar
VIEW  
unknown committed
2731 2732 2733 2734 2735
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    bool link_to_local;
    // Skip first table, which is the table we are creating
    TABLE_LIST *create_table= lex->unlink_first_table(&link_to_local);
    TABLE_LIST *select_tables= lex->query_tables;
unknown's avatar
unknown committed
2736

unknown's avatar
VIEW  
unknown committed
2737
    if ((res= create_table_precheck(thd, select_tables, create_table)))
2738
      goto unsent_create_error;
unknown's avatar
unknown committed
2739

2740 2741 2742
#ifndef HAVE_READLINK
    lex->create_info.data_file_name=lex->create_info.index_file_name=0;
#else
2743
    /* Fix names if symlinked tables */
unknown's avatar
unknown committed
2744
    if (append_file_to_dir(thd, &lex->create_info.data_file_name,
2745
			   create_table->table_name) ||
unknown's avatar
VIEW  
unknown committed
2746
	append_file_to_dir(thd, &lex->create_info.index_file_name,
2747
			   create_table->table_name))
2748
      goto unsent_create_error;
2749
#endif
2750
    /*
2751
      If we are using SET CHARSET without DEFAULT, add an implicit
2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762
      DEFAULT to not confuse old users. (This may change).
    */
    if ((lex->create_info.used_fields & 
	 (HA_CREATE_USED_DEFAULT_CHARSET | HA_CREATE_USED_CHARSET)) ==
	HA_CREATE_USED_CHARSET)
    {
      lex->create_info.used_fields&= ~HA_CREATE_USED_CHARSET;
      lex->create_info.used_fields|= HA_CREATE_USED_DEFAULT_CHARSET;
      lex->create_info.default_table_charset= lex->create_info.table_charset;
      lex->create_info.table_charset= 0;
    }
2763
    if (select_lex->item_list.elements)		// With select
unknown's avatar
unknown committed
2764 2765
    {
      select_result *result;
2766

2767
      select_lex->options|= SELECT_NO_UNLOCK;
unknown's avatar
unknown committed
2768
      unit->set_limit(select_lex, select_lex);
2769

unknown's avatar
VIEW  
unknown committed
2770
      if (!(res= open_and_lock_tables(thd, select_tables)))
2771
      {
2772 2773 2774 2775 2776 2777 2778
        /*
          Is table which we are changing used somewhere in other parts
          of query
        */
        if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) &&
            unique_table(create_table, select_tables))
        {
2779
          my_error(ER_UPDATE_TABLE_USED, MYF(0), create_table->table_name);
2780
          goto unsent_create_error;
2781
        }
unknown's avatar
unknown committed
2782 2783 2784 2785 2786 2787 2788 2789 2790 2791
        /* If we create merge table, we have to test tables in merge, too */
        if (lex->create_info.used_fields & HA_CREATE_USED_UNION)
        {
          TABLE_LIST *tab;
          for (tab= (TABLE_LIST*) lex->create_info.merge_list.first;
               tab;
               tab= tab->next_local)
          {
            if (unique_table(tab, select_tables))
            {
2792
              my_error(ER_UPDATE_TABLE_USED, MYF(0), tab->table_name);
2793
              goto unsent_create_error;
unknown's avatar
unknown committed
2794 2795 2796
            }
          }
        }
2797

unknown's avatar
VIEW  
unknown committed
2798 2799 2800 2801 2802
        if ((result= new select_create(create_table,
				       &lex->create_info,
				       lex->create_list,
				       lex->key_list,
				       select_lex->item_list,
2803 2804
				       lex->duplicates,
				       lex->ignore)))
2805 2806 2807 2808 2809 2810
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
          select_lex->resolve_mode= SELECT_LEX::SELECT_MODE;
2811
          res= handle_select(thd, lex, result, 0);
2812
          select_lex->resolve_mode= SELECT_LEX::NOMATTER_MODE;
2813
          delete result;
2814
        }
unknown's avatar
unknown committed
2815
	/* reset for PS */
2816 2817
	lex->create_list.empty();
	lex->key_list.empty();
2818 2819
      }
    }
unknown's avatar
unknown committed
2820
    else
unknown's avatar
unknown committed
2821
    {
unknown's avatar
unknown committed
2822
      /* regular create */
unknown's avatar
unknown committed
2823
      if (lex->name)
unknown's avatar
unknown committed
2824
        res= mysql_create_like_table(thd, create_table, &lex->create_info, 
unknown's avatar
unknown committed
2825 2826
                                     (Table_ident *)lex->name); 
      else
2827
      {
unknown's avatar
VIEW  
unknown committed
2828
        res= mysql_create_table(thd, create_table->db,
2829
				create_table->table_name, &lex->create_info,
unknown's avatar
VIEW  
unknown committed
2830
				lex->create_list,
unknown's avatar
unknown committed
2831
				lex->key_list, 0, 0);
2832
      }
unknown's avatar
unknown committed
2833
      if (!res)
2834
	send_ok(thd);
unknown's avatar
unknown committed
2835
    }
unknown's avatar
VIEW  
unknown committed
2836
    lex->link_first_table_back(create_table, link_to_local);
2837 2838
    break;

unknown's avatar
unknown committed
2839
    /* put tables back for PS rexecuting */
2840
unsent_create_error:
unknown's avatar
VIEW  
unknown committed
2841
    lex->link_first_table_back(create_table, link_to_local);
unknown's avatar
unknown committed
2842
    goto error;
unknown's avatar
unknown committed
2843
  }
unknown's avatar
unknown committed
2844
  case SQLCOM_CREATE_INDEX:
unknown's avatar
VIEW  
unknown committed
2845 2846
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, INDEX_ACL, all_tables))
unknown's avatar
unknown committed
2847
      goto error; /* purecov: inspected */
2848
    thd->slow_command=TRUE;
2849
    if (end_active_trans(thd))
unknown's avatar
unknown committed
2850
      goto error;
2851
    else
unknown's avatar
VIEW  
unknown committed
2852
      res = mysql_create_index(thd, first_table, lex->key_list);
unknown's avatar
unknown committed
2853 2854
    break;

unknown's avatar
unknown committed
2855
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2856
  case SQLCOM_SLAVE_START:
2857
  {
2858
    pthread_mutex_lock(&LOCK_active_mi);
2859
    start_slave(thd,active_mi,1 /* net report*/);
2860
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2861
    break;
2862
  }
unknown's avatar
unknown committed
2863
  case SQLCOM_SLAVE_STOP:
2864 2865 2866 2867 2868 2869
  /*
    If the client thread has locked tables, a deadlock is possible.
    Assume that
    - the client thread does LOCK TABLE t READ.
    - then the master updates t.
    - then the SQL slave thread wants to update t,
2870
      so it waits for the client thread because t is locked by it.
2871
    - then the client thread does SLAVE STOP.
2872 2873
      SLAVE STOP waits for the SQL slave thread to terminate its
      update t, which waits for the client thread because t is locked by it.
2874 2875 2876 2877 2878
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
  if (thd->locked_tables || thd->active_transaction())
  {
unknown's avatar
unknown committed
2879 2880
    my_message(ER_LOCK_OR_ACTIVE_TRANSACTION, ER(ER_LOCK_OR_ACTIVE_TRANSACTION),
               MYF(0));
2881
    goto error;
2882
  }
2883
  {
2884
    pthread_mutex_lock(&LOCK_active_mi);
2885
    stop_slave(thd,active_mi,1/* net report*/);
2886
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2887
    break;
2888
  }
unknown's avatar
unknown committed
2889
#endif /* HAVE_REPLICATION */
2890

unknown's avatar
unknown committed
2891
  case SQLCOM_ALTER_TABLE:
unknown's avatar
VIEW  
unknown committed
2892
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
2893
#if defined(DONT_ALLOW_SHOW_COMMANDS)
unknown's avatar
unknown committed
2894 2895
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
2896
    goto error;
unknown's avatar
unknown committed
2897 2898
#else
    {
unknown's avatar
unknown committed
2899
      ulong priv=0;
unknown's avatar
unknown committed
2900
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
unknown's avatar
unknown committed
2901
      {
2902
	my_error(ER_WRONG_TABLE_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
2903
        goto error;
unknown's avatar
unknown committed
2904
      }
2905
      if (!select_lex->db)
unknown's avatar
VIEW  
unknown committed
2906 2907 2908
	select_lex->db= first_table->db;
      if (check_access(thd, ALTER_ACL, first_table->db,
		       &first_table->grant.privilege, 0, 0) ||
unknown's avatar
unknown committed
2909
	  check_access(thd,INSERT_ACL | CREATE_ACL,select_lex->db,&priv,0,0)||
unknown's avatar
VIEW  
unknown committed
2910
	  check_merge_table_access(thd, first_table->db,
2911 2912 2913
				   (TABLE_LIST *)
				   lex->create_info.merge_list.first))
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
2914 2915
      if (grant_option)
      {
unknown's avatar
VIEW  
unknown committed
2916
	if (check_grant(thd, ALTER_ACL, all_tables, 0, UINT_MAX, 0))
unknown's avatar
unknown committed
2917 2918 2919 2920 2921
	  goto error;
	if (lex->name && !test_all_bits(priv,INSERT_ACL | CREATE_ACL))
	{					// Rename of table
	  TABLE_LIST tmp_table;
	  bzero((char*) &tmp_table,sizeof(tmp_table));
2922
	  tmp_table.table_name=lex->name;
2923
	  tmp_table.db=select_lex->db;
unknown's avatar
unknown committed
2924
	  tmp_table.grant.privilege=priv;
unknown's avatar
unknown committed
2925 2926
	  if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, 0,
			  UINT_MAX, 0))
unknown's avatar
unknown committed
2927 2928 2929
	    goto error;
	}
      }
2930 2931
      /* Don't yet allow changing of symlinks with ALTER TABLE */
      lex->create_info.data_file_name=lex->create_info.index_file_name=0;
unknown's avatar
unknown committed
2932
      /* ALTER TABLE ends previous transaction */
2933
      if (end_active_trans(thd))
unknown's avatar
unknown committed
2934
	goto error;
unknown's avatar
unknown committed
2935
      else
unknown's avatar
unknown committed
2936
      {
2937
        thd->slow_command=TRUE;
2938
	res= mysql_alter_table(thd, select_lex->db, lex->name,
unknown's avatar
unknown committed
2939
			       &lex->create_info,
unknown's avatar
VIEW  
unknown committed
2940
			       first_table, lex->create_list,
2941
			       lex->key_list,
2942
			       select_lex->order_list.elements,
2943
                               (ORDER *) select_lex->order_list.first,
unknown's avatar
unknown committed
2944 2945
			       lex->duplicates, lex->ignore, &lex->alter_info,
                               1);
unknown's avatar
unknown committed
2946
      }
unknown's avatar
unknown committed
2947 2948
      break;
    }
unknown's avatar
unknown committed
2949
#endif /*DONT_ALLOW_SHOW_COMMANDS*/
unknown's avatar
unknown committed
2950
  case SQLCOM_RENAME_TABLE:
unknown's avatar
unknown committed
2951
  {
unknown's avatar
VIEW  
unknown committed
2952
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
2953
    TABLE_LIST *table;
unknown's avatar
VIEW  
unknown committed
2954
    if (check_db_used(thd, all_tables))
unknown's avatar
unknown committed
2955
      goto error;
unknown's avatar
VIEW  
unknown committed
2956
    for (table= first_table; table; table= table->next_local->next_local)
unknown's avatar
unknown committed
2957
    {
unknown's avatar
unknown committed
2958
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
unknown's avatar
unknown committed
2959
		       &table->grant.privilege,0,0) ||
unknown's avatar
VIEW  
unknown committed
2960 2961
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next_local->db,
		       &table->next_local->grant.privilege, 0, 0))
unknown's avatar
unknown committed
2962 2963 2964
	goto error;
      if (grant_option)
      {
unknown's avatar
VIEW  
unknown committed
2965
	TABLE_LIST old_list, new_list;
unknown's avatar
unknown committed
2966 2967 2968 2969
	/*
	  we do not need initialize old_list and new_list because we will
	  come table[0] and table->next[0] there
	*/
unknown's avatar
VIEW  
unknown committed
2970 2971 2972 2973
	old_list= table[0];
	new_list= table->next_local[0];
	if (check_grant(thd, ALTER_ACL, &old_list, 0, 1, 0) ||
	    (!test_all_bits(table->next_local->grant.privilege,
2974
			    INSERT_ACL | CREATE_ACL) &&
unknown's avatar
VIEW  
unknown committed
2975
	     check_grant(thd, INSERT_ACL | CREATE_ACL, &new_list, 0, 1, 0)))
unknown's avatar
unknown committed
2976 2977 2978
	  goto error;
      }
    }
unknown's avatar
VIEW  
unknown committed
2979
    query_cache_invalidate3(thd, first_table, 0);
unknown's avatar
unknown committed
2980 2981
    if (end_active_trans(thd) || mysql_rename_tables(thd, first_table))
      goto error;
unknown's avatar
unknown committed
2982
    break;
unknown's avatar
unknown committed
2983
  }
2984
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2985 2986
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
2987 2988
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
2989
    goto error;
unknown's avatar
unknown committed
2990 2991
#else
    {
unknown's avatar
unknown committed
2992
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2993 2994 2995 2996
	goto error;
      res = show_binlogs(thd);
      break;
    }
unknown's avatar
unknown committed
2997
#endif
2998
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
2999
  case SQLCOM_SHOW_CREATE:
unknown's avatar
VIEW  
unknown committed
3000
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3001
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3002 3003
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0)); /* purecov: inspected */
3004
    goto error;
unknown's avatar
unknown committed
3005
#else
unknown's avatar
unknown committed
3006
    {
unknown's avatar
VIEW  
unknown committed
3007 3008 3009
      if (check_db_used(thd, all_tables) ||
	  check_access(thd, SELECT_ACL | EXTRA_ACL, first_table->db,
		       &first_table->grant.privilege, 0, 0))
unknown's avatar
unknown committed
3010
	goto error;
unknown's avatar
unknown committed
3011
      if (grant_option && check_grant(thd, SELECT_ACL, all_tables, 2, UINT_MAX, 0))
3012
	goto error;
unknown's avatar
unknown committed
3013
      res= mysqld_show_create(thd, first_table);
unknown's avatar
unknown committed
3014 3015
      break;
    }
unknown's avatar
unknown committed
3016
#endif
3017 3018
  case SQLCOM_CHECKSUM:
  {
unknown's avatar
VIEW  
unknown committed
3019 3020 3021
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL | EXTRA_ACL, all_tables, 0))
3022
      goto error; /* purecov: inspected */
unknown's avatar
VIEW  
unknown committed
3023
    res = mysql_checksum_table(thd, first_table, &lex->check_opt);
3024 3025
    break;
  }
unknown's avatar
unknown committed
3026
  case SQLCOM_REPAIR:
3027
  {
unknown's avatar
VIEW  
unknown committed
3028 3029 3030
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL | INSERT_ACL, all_tables, 0))
3031
      goto error; /* purecov: inspected */
3032
    thd->slow_command=TRUE;
unknown's avatar
VIEW  
unknown committed
3033
    res= mysql_repair_table(thd, first_table, &lex->check_opt);
3034 3035 3036 3037 3038
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3039
	thd->clear_error(); // No binlog error generated
3040
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3041 3042 3043
        mysql_bin_log.write(&qinfo);
      }
    }
3044 3045
    break;
  }
unknown's avatar
unknown committed
3046
  case SQLCOM_CHECK:
3047
  {
unknown's avatar
VIEW  
unknown committed
3048 3049 3050
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL | EXTRA_ACL , all_tables, 0))
3051
      goto error; /* purecov: inspected */
3052
    thd->slow_command=TRUE;
unknown's avatar
VIEW  
unknown committed
3053
    res = mysql_check_table(thd, first_table, &lex->check_opt);
3054 3055
    break;
  }
unknown's avatar
unknown committed
3056 3057
  case SQLCOM_ANALYZE:
  {
unknown's avatar
VIEW  
unknown committed
3058 3059 3060
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL | INSERT_ACL, all_tables, 0))
unknown's avatar
unknown committed
3061
      goto error; /* purecov: inspected */
3062
    thd->slow_command=TRUE;
unknown's avatar
VIEW  
unknown committed
3063
    res = mysql_analyze_table(thd, first_table, &lex->check_opt);
3064 3065 3066 3067 3068
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3069
	thd->clear_error(); // No binlog error generated
3070
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3071 3072 3073
        mysql_bin_log.write(&qinfo);
      }
    }
unknown's avatar
unknown committed
3074
    break;
unknown's avatar
unknown committed
3075
  }
3076

unknown's avatar
unknown committed
3077 3078
  case SQLCOM_OPTIMIZE:
  {
unknown's avatar
VIEW  
unknown committed
3079 3080 3081
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL | INSERT_ACL, all_tables, 0))
unknown's avatar
unknown committed
3082
      goto error; /* purecov: inspected */
3083
    thd->slow_command=TRUE;
3084
    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
unknown's avatar
VIEW  
unknown committed
3085 3086
      mysql_recreate_table(thd, first_table, 1) :
      mysql_optimize_table(thd, first_table, &lex->check_opt);
3087 3088 3089 3090 3091
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3092
	thd->clear_error(); // No binlog error generated
3093
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3094 3095 3096
        mysql_bin_log.write(&qinfo);
      }
    }
unknown's avatar
unknown committed
3097 3098 3099
    break;
  }
  case SQLCOM_UPDATE:
unknown's avatar
VIEW  
unknown committed
3100 3101
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (update_precheck(thd, all_tables))
unknown's avatar
unknown committed
3102
      break;
unknown's avatar
unknown committed
3103 3104 3105 3106 3107 3108 3109
    res= (result= mysql_update(thd, all_tables,
                               select_lex->item_list,
                               lex->value_list,
                               select_lex->where,
                               select_lex->order_list.elements,
                               (ORDER *) select_lex->order_list.first,
                               select_lex->select_limit,
3110
                               lex->duplicates, lex->ignore));
3111
    /* mysql_update return 2 if we need to switch to multi-update */
unknown's avatar
unknown committed
3112
    if (result != 2)
3113
      break;
3114
  case SQLCOM_UPDATE_MULTI:
3115
    {
unknown's avatar
unknown committed
3116
      DBUG_ASSERT(first_table == all_tables && first_table != 0);
3117
      /* if we switched from normal update, rights are checked */
unknown's avatar
unknown committed
3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130
      if (result != 2)
      {
        if ((res= multi_update_precheck(thd, all_tables)))
          break;
      }
      else
        res= 0;

      res= mysql_multi_update(thd, all_tables,
                              &select_lex->item_list,
                              &lex->value_list,
                              select_lex->where,
                              select_lex->options,
3131
                              lex->duplicates, lex->ignore, unit, select_lex);
unknown's avatar
unknown committed
3132
    break;
unknown's avatar
unknown committed
3133
  }
unknown's avatar
unknown committed
3134
  case SQLCOM_REPLACE:
3135 3136
  case SQLCOM_INSERT:
  {
unknown's avatar
VIEW  
unknown committed
3137
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3138
    if ((res= insert_precheck(thd, all_tables)))
unknown's avatar
unknown committed
3139
      break;
unknown's avatar
VIEW  
unknown committed
3140
    res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
unknown's avatar
unknown committed
3141
		      lex->update_list, lex->value_list,
3142
                      lex->duplicates, lex->ignore);
unknown's avatar
VIEW  
unknown committed
3143 3144
    if (first_table->view && !first_table->contain_auto_increment)
      thd->last_insert_id= 0; // do not show last insert ID if VIEW have not it
unknown's avatar
unknown committed
3145
    break;
3146
  }
unknown's avatar
unknown committed
3147 3148 3149
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
unknown's avatar
VIEW  
unknown committed
3150
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3151
    if ((res= insert_precheck(thd, all_tables)))
3152
      break;
unknown's avatar
unknown committed
3153

3154
    /* Fix lock for first table */
unknown's avatar
VIEW  
unknown committed
3155 3156
    if (first_table->lock_type == TL_WRITE_DELAYED)
      first_table->lock_type= TL_WRITE;
3157

3158 3159
    /* Don't unlock tables until command is written to binary log */
    select_lex->options|= SELECT_NO_UNLOCK;
unknown's avatar
unknown committed
3160 3161

    select_result *result;
unknown's avatar
unknown committed
3162
    unit->set_limit(select_lex, select_lex);
unknown's avatar
unknown committed
3163

unknown's avatar
VIEW  
unknown committed
3164
    if (!(res= open_and_lock_tables(thd, all_tables)))
3165
    {
3166 3167
      /* Skip first table, which is the table we are inserting in */
      lex->select_lex.table_list.first= (byte*)first_table->next_local;
3168

3169 3170 3171
      res= mysql_insert_select_prepare(thd);
      if (!res && (result= new select_insert(first_table, first_table->table,
                                             &lex->field_list,
unknown's avatar
unknown committed
3172
                                             &lex->update_list, &lex->value_list,
3173
                                             lex->duplicates, lex->ignore)))
3174
      {
3175 3176 3177 3178 3179
        /*
          insert/replace from SELECT give its SELECT_LEX for SELECT,
          and item_list belong to SELECT
        */
	lex->select_lex.resolve_mode= SELECT_LEX::SELECT_MODE;
3180
	res= handle_select(thd, lex, result, OPTION_SETUP_TABLES_DONE);
3181
	lex->select_lex.resolve_mode= SELECT_LEX::INSERT_MODE;
3182 3183
        delete result;
      }
3184 3185
      /* revert changes for SP */
      lex->select_lex.table_list.first= (byte*) first_table;
3186
    }
unknown's avatar
VIEW  
unknown committed
3187 3188 3189 3190

    if (first_table->view && !first_table->contain_auto_increment)
      thd->last_insert_id= 0; // do not show last insert ID if VIEW have not it

unknown's avatar
unknown committed
3191 3192
    break;
  }
3193
  case SQLCOM_TRUNCATE:
unknown's avatar
VIEW  
unknown committed
3194 3195
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, DELETE_ACL, all_tables))
unknown's avatar
unknown committed
3196
      goto error;
3197 3198 3199 3200
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
3201
    if ((thd->locked_tables && !lex->sphead) || thd->active_transaction())
3202
    {
unknown's avatar
unknown committed
3203 3204
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3205 3206
      goto error;
    }
unknown's avatar
VIEW  
unknown committed
3207

unknown's avatar
unknown committed
3208
    res= mysql_truncate(thd, first_table, 0);
3209
    break;
unknown's avatar
unknown committed
3210
  case SQLCOM_DELETE:
unknown's avatar
unknown committed
3211
  {
unknown's avatar
VIEW  
unknown committed
3212 3213
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if ((res= delete_precheck(thd, all_tables)))
unknown's avatar
unknown committed
3214
      break;
unknown's avatar
VIEW  
unknown committed
3215
    res = mysql_delete(thd, all_tables, select_lex->where,
3216
                       &select_lex->order_list,
unknown's avatar
unknown committed
3217
                       select_lex->select_limit, select_lex->options);
unknown's avatar
unknown committed
3218 3219
    break;
  }
3220
  case SQLCOM_DELETE_MULTI:
unknown's avatar
unknown committed
3221
  {
unknown's avatar
VIEW  
unknown committed
3222
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3223 3224
    TABLE_LIST *aux_tables=
      (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
unknown's avatar
unknown committed
3225
    uint table_count;
unknown's avatar
unknown committed
3226
    multi_delete *result;
unknown's avatar
unknown committed
3227

unknown's avatar
VIEW  
unknown committed
3228
    if ((res= multi_delete_precheck(thd, all_tables, &table_count)))
3229
      break;
unknown's avatar
unknown committed
3230

unknown's avatar
unknown committed
3231
    /* condition will be TRUE on SP re-excuting */
3232 3233
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
unknown's avatar
unknown committed
3234
    if (add_item_to_list(thd, new Item_null()))
unknown's avatar
unknown committed
3235
      goto error;
3236

unknown's avatar
unknown committed
3237
    thd->proc_info="init";
unknown's avatar
VIEW  
unknown committed
3238 3239 3240 3241
    if ((res= open_and_lock_tables(thd, all_tables)))
      break;

    if ((res= mysql_multi_delete_prepare(thd)))
unknown's avatar
unknown committed
3242
      goto error;
3243

3244 3245
    if (!thd->is_fatal_error && (result= new multi_delete(thd,aux_tables,
							  table_count)))
unknown's avatar
unknown committed
3246
    {
3247 3248 3249
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
3250
			select_lex->item_list,
unknown's avatar
unknown committed
3251
			select_lex->where,
3252
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
unknown's avatar
unknown committed
3253 3254
			(ORDER *)NULL,
			select_lex->options | thd->options |
3255 3256
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK |
                        OPTION_SETUP_TABLES_DONE,
3257
			result, unit, select_lex);
3258
      delete result;
unknown's avatar
unknown committed
3259 3260
    }
    else
3261
      res= TRUE;                                // Error
unknown's avatar
unknown committed
3262 3263
    break;
  }
unknown's avatar
unknown committed
3264
  case SQLCOM_DROP_TABLE:
unknown's avatar
unknown committed
3265
  {
unknown's avatar
VIEW  
unknown committed
3266
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3267 3268
    if (!lex->drop_temporary)
    {
unknown's avatar
VIEW  
unknown committed
3269
      if (check_table_access(thd, DROP_ACL, all_tables, 0))
3270 3271
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
unknown's avatar
unknown committed
3272
        goto error;
3273
    }
unknown's avatar
unknown committed
3274
    else
unknown's avatar
unknown committed
3275 3276 3277 3278 3279 3280
    {
      /*
	If this is a slave thread, we may sometimes execute some 
	DROP / * 40005 TEMPORARY * / TABLE
	that come from parts of binlogs (likely if we use RESET SLAVE or CHANGE
	MASTER TO), while the temporary table has already been dropped.
unknown's avatar
unknown committed
3281 3282
	To not generate such irrelevant "table does not exist errors",
	we silently add IF EXISTS if TEMPORARY was used.
unknown's avatar
unknown committed
3283 3284 3285 3286
      */
      if (thd->slave_thread)
	lex->drop_if_exists= 1;
    }
unknown's avatar
VIEW  
unknown committed
3287 3288
    res= mysql_rm_table(thd, first_table, lex->drop_if_exists,
			lex->drop_temporary);
unknown's avatar
unknown committed
3289 3290
  }
  break;
unknown's avatar
unknown committed
3291
  case SQLCOM_DROP_INDEX:
unknown's avatar
VIEW  
unknown committed
3292 3293
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, INDEX_ACL, all_tables))
unknown's avatar
unknown committed
3294
      goto error;				/* purecov: inspected */
3295
    if (end_active_trans(thd))
unknown's avatar
unknown committed
3296
      goto error;
3297
    else
unknown's avatar
VIEW  
unknown committed
3298
      res = mysql_drop_index(thd, first_table, &lex->alter_info);
unknown's avatar
unknown committed
3299 3300
    break;
  case SQLCOM_SHOW_PROCESSLIST:
unknown's avatar
unknown committed
3301
    if (!thd->priv_user[0] && check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
3302
      break;
unknown's avatar
unknown committed
3303 3304
    mysqld_list_processes(thd,
			  thd->master_access & PROCESS_ACL ? NullS :
unknown's avatar
unknown committed
3305
			  thd->priv_user,lex->verbose);
unknown's avatar
unknown committed
3306
    break;
unknown's avatar
unknown committed
3307 3308
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
unknown's avatar
unknown committed
3309 3310 3311 3312 3313 3314 3315
    break;
  case SQLCOM_SHOW_PRIVILEGES:
    res= mysqld_show_privileges(thd);
    break;
  case SQLCOM_SHOW_COLUMN_TYPES:
    res= mysqld_show_column_types(thd);
    break;
unknown's avatar
unknown committed
3316 3317
  case SQLCOM_SHOW_LOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
unknown's avatar
unknown committed
3318 3319
    my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND),
               MYF(0));	/* purecov: inspected */
3320
    goto error;
unknown's avatar
unknown committed
3321 3322
#else
    {
unknown's avatar
unknown committed
3323
      if (grant_option && check_access(thd, FILE_ACL, any_db,0,0,0))
unknown's avatar
unknown committed
3324 3325 3326 3327
	goto error;
      res= mysqld_show_logs(thd);
      break;
    }
unknown's avatar
unknown committed
3328 3329
#endif
  case SQLCOM_CHANGE_DB:
3330
    mysql_change_db(thd,select_lex->db);
unknown's avatar
unknown committed
3331
    break;
3332

unknown's avatar
unknown committed
3333 3334
  case SQLCOM_LOAD:
  {
unknown's avatar
VIEW  
unknown committed
3335
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3336
    uint privilege= (lex->duplicates == DUP_REPLACE ?
unknown's avatar
unknown committed
3337 3338
		     INSERT_ACL | DELETE_ACL : INSERT_ACL) |
                    (lex->local_file ? 0 : FILE_ACL);
3339

unknown's avatar
unknown committed
3340
    if (lex->local_file)
unknown's avatar
unknown committed
3341
    {
3342
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
unknown's avatar
unknown committed
3343
	  ! opt_local_infile)
3344
      {
unknown's avatar
unknown committed
3345
	my_message(ER_NOT_ALLOWED_COMMAND, ER(ER_NOT_ALLOWED_COMMAND), MYF(0));
3346 3347
	goto error;
      }
unknown's avatar
unknown committed
3348
    }
unknown's avatar
unknown committed
3349 3350 3351 3352

    if (check_one_table_access(thd, privilege, all_tables))
      goto error;

unknown's avatar
VIEW  
unknown committed
3353
    res= mysql_load(thd, lex->exchange, first_table, lex->field_list,
unknown's avatar
unknown committed
3354
                    lex->update_list, lex->value_list, lex->duplicates,
3355
                    lex->ignore, (bool) lex->local_file);
unknown's avatar
unknown committed
3356 3357
    break;
  }
3358

unknown's avatar
unknown committed
3359
  case SQLCOM_SET_OPTION:
3360 3361
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
3362
    if ((check_table_access(thd, SELECT_ACL, all_tables, 0) ||
unknown's avatar
unknown committed
3363 3364
	 open_and_lock_tables(thd, all_tables)))
      goto error;
3365 3366
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
    {
unknown's avatar
unknown committed
3367 3368
      my_error(ER_RESERVED_SYNTAX, MYF(0), "SET ONE_SHOT");
      goto error;
3369 3370 3371 3372 3373 3374 3375 3376
    }
    if (!(res= sql_set_variables(thd, lex_var_list)))
    {
      /*
        If the previous command was a SET ONE_SHOT, we don't want to forget
        about the ONE_SHOT property of that SET. So we use a |= instead of = .
      */
      thd->one_shot_set|= lex->one_shot_set;
3377
      send_ok(thd);
3378
    }
unknown's avatar
unknown committed
3379
    break;
3380
  }
unknown's avatar
unknown committed
3381

unknown's avatar
unknown committed
3382
  case SQLCOM_UNLOCK_TABLES:
3383 3384 3385 3386 3387 3388
    /*
      It is critical for mysqldump --single-transaction --master-data that
      UNLOCK TABLES does not implicitely commit a connection which has only
      done FLUSH TABLES WITH READ LOCK + BEGIN. If this assumption becomes
      false, mysqldump will not work.
    */
unknown's avatar
unknown committed
3389
    unlock_locked_tables(thd);
unknown's avatar
unknown committed
3390 3391
    if (thd->options & OPTION_TABLE_LOCK)
    {
unknown's avatar
unknown committed
3392
      end_active_trans(thd);
unknown's avatar
unknown committed
3393
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3394 3395
    }
    if (thd->global_read_lock)
3396
      unlock_global_read_lock(thd);
3397
    send_ok(thd);
unknown's avatar
unknown committed
3398 3399
    break;
  case SQLCOM_LOCK_TABLES:
unknown's avatar
unknown committed
3400
    unlock_locked_tables(thd);
unknown's avatar
VIEW  
unknown committed
3401
    if (check_db_used(thd, all_tables) || end_active_trans(thd))
unknown's avatar
unknown committed
3402
      goto error;
unknown's avatar
VIEW  
unknown committed
3403
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, all_tables, 0))
3404
      goto error;
unknown's avatar
unknown committed
3405
    thd->in_lock_tables=1;
unknown's avatar
unknown committed
3406
    thd->options|= OPTION_TABLE_LOCK;
unknown's avatar
VIEW  
unknown committed
3407

3408
    if (!(res= simple_open_n_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
3409
    {
3410 3411
#ifdef HAVE_QUERY_CACHE
      if (thd->variables.query_cache_wlock_invalidate)
unknown's avatar
VIEW  
unknown committed
3412
	query_cache.invalidate_locked_for_write(first_table);
3413
#endif /*HAVE_QUERY_CACHE*/
unknown's avatar
unknown committed
3414 3415
      thd->locked_tables=thd->lock;
      thd->lock=0;
3416
      send_ok(thd);
unknown's avatar
unknown committed
3417
    }
unknown's avatar
unknown committed
3418 3419
    else
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3420 3421 3422
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3423
  {
unknown's avatar
unknown committed
3424
    char *alias;
unknown's avatar
unknown committed
3425
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3426
    {
3427
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3428 3429
      break;
    }
3430 3431 3432
    /*
      If in a slave thread :
      CREATE DATABASE DB was certainly not preceded by USE DB.
3433
      For that reason, db_ok() in sql/slave.cc did not check the
3434 3435 3436
      do_db/ignore_db. And as this query involves no tables, tables_ok()
      above was not called. So we have to check rules again here.
    */
3437
#ifdef HAVE_REPLICATION
3438
    if (thd->slave_thread &&
3439 3440
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3441
    {
unknown's avatar
unknown committed
3442
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3443
      break;
unknown's avatar
unknown committed
3444
    }
3445
#endif
unknown's avatar
unknown committed
3446
    if (check_access(thd,CREATE_ACL,lex->name,0,1,0))
3447
      break;
unknown's avatar
unknown committed
3448
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : lex->name),
unknown's avatar
unknown committed
3449
			 &lex->create_info, 0);
3450 3451
    break;
  }
unknown's avatar
unknown committed
3452
  case SQLCOM_DROP_DB:
3453
  {
3454
    if (check_db_name(lex->name))
unknown's avatar
unknown committed
3455
    {
3456
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3457 3458
      break;
    }
3459 3460 3461 3462 3463 3464 3465
    /*
      If in a slave thread :
      DROP DATABASE DB may not be preceded by USE DB.
      For that reason, maybe db_ok() in sql/slave.cc did not check the 
      do_db/ignore_db. And as this query involves no tables, tables_ok()
      above was not called. So we have to check rules again here.
    */
3466
#ifdef HAVE_REPLICATION
3467 3468 3469
    if (thd->slave_thread && 
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
unknown's avatar
unknown committed
3470
    {
unknown's avatar
unknown committed
3471
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
3472
      break;
unknown's avatar
unknown committed
3473
    }
3474
#endif
unknown's avatar
unknown committed
3475
    if (check_access(thd,DROP_ACL,lex->name,0,1,0))
3476
      break;
3477 3478
    if (thd->locked_tables || thd->active_transaction())
    {
unknown's avatar
unknown committed
3479 3480
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3481 3482
      goto error;
    }
3483
    res= mysql_rm_db(thd, lex->name, lex->drop_if_exists, 0);
3484 3485
    break;
  }
3486 3487
  case SQLCOM_ALTER_DB:
  {
3488 3489
    char *db= lex->name ? lex->name : thd->db;
    if (!db)
3490
    {
unknown's avatar
unknown committed
3491 3492
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
      break;
3493 3494
    }
    if (!strip_sp(db) || check_db_name(db))
3495
    {
3496
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
3497 3498
      break;
    }
unknown's avatar
unknown committed
3499 3500 3501
    /*
      If in a slave thread :
      ALTER DATABASE DB may not be preceded by USE DB.
3502
      For that reason, maybe db_ok() in sql/slave.cc did not check the
unknown's avatar
unknown committed
3503 3504 3505 3506
      do_db/ignore_db. And as this query involves no tables, tables_ok()
      above was not called. So we have to check rules again here.
    */
#ifdef HAVE_REPLICATION
3507
    if (thd->slave_thread &&
3508 3509
	(!db_ok(db, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(db)))
unknown's avatar
unknown committed
3510
    {
unknown's avatar
unknown committed
3511
      my_message(ER_SLAVE_IGNORED_TABLE, ER(ER_SLAVE_IGNORED_TABLE), MYF(0));
unknown's avatar
unknown committed
3512 3513 3514
      break;
    }
#endif
3515
    if (check_access(thd, ALTER_ACL, db, 0, 1, 0))
3516 3517 3518
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
unknown's avatar
unknown committed
3519 3520
      my_message(ER_LOCK_OR_ACTIVE_TRANSACTION,
                 ER(ER_LOCK_OR_ACTIVE_TRANSACTION), MYF(0));
3521 3522
      goto error;
    }
3523
    res= mysql_alter_db(thd, db, &lex->create_info);
3524 3525
    break;
  }
unknown's avatar
unknown committed
3526 3527 3528 3529
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3530
      my_error(ER_WRONG_DB_NAME, MYF(0), lex->name);
unknown's avatar
unknown committed
3531 3532
      break;
    }
unknown's avatar
unknown committed
3533
    if (check_access(thd,SELECT_ACL,lex->name,0,1,0))
unknown's avatar
unknown committed
3534
      break;
unknown's avatar
unknown committed
3535
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
unknown's avatar
unknown committed
3536 3537
    break;
  }
unknown's avatar
unknown committed
3538
  case SQLCOM_CREATE_FUNCTION:                  // UDF function
unknown's avatar
unknown committed
3539 3540 3541
  {
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0))
      break;
unknown's avatar
unknown committed
3542
#ifdef HAVE_DLOPEN
3543
    if (sp_find_function(thd, lex->spname))
unknown's avatar
unknown committed
3544
    {
3545
      my_error(ER_UDF_EXISTS, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
3546 3547
      goto error;
    }
3548
    if (!(res = mysql_create_function(thd, &lex->udf)))
unknown's avatar
unknown committed
3549
      send_ok(thd);
unknown's avatar
unknown committed
3550
#else
unknown's avatar
unknown committed
3551
    res= TRUE;
unknown's avatar
unknown committed
3552 3553
#endif
    break;
unknown's avatar
unknown committed
3554
  }
unknown's avatar
unknown committed
3555
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3556 3557
  case SQLCOM_CREATE_USER:
  {
3558 3559
    if (check_access(thd, INSERT_ACL, "mysql", 0, 1, 1) &&
        check_global_access(thd,CREATE_USER_ACL))
3560 3561 3562 3563 3564
      break;
    if (!(res= mysql_create_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3565
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3566 3567 3568 3569 3570 3571
        mysql_bin_log.write(&qinfo);
      }
      send_ok(thd);
    }
    break;
  }
3572 3573
  case SQLCOM_DROP_USER:
  {
3574 3575
    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 1) &&
        check_global_access(thd,CREATE_USER_ACL))
3576 3577 3578 3579 3580
      break;
    if (!(res= mysql_drop_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3581
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3582 3583 3584 3585 3586 3587 3588 3589
        mysql_bin_log.write(&qinfo);
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_RENAME_USER:
  {
3590 3591
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1) &&
        check_global_access(thd,CREATE_USER_ACL))
3592 3593 3594 3595 3596
      break;
    if (!(res= mysql_rename_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
3597
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3598
        mysql_bin_log.write(&qinfo);
3599 3600 3601 3602 3603 3604 3605
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
3606 3607
    if (check_access(thd, UPDATE_ACL, "mysql", 0, 1, 1) &&
        check_global_access(thd,CREATE_USER_ACL))
3608 3609 3610 3611 3612
      break;
    if (!(res = mysql_revoke_all(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
3613
	Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3614 3615 3616 3617 3618 3619
	mysql_bin_log.write(&qinfo);
      }
      send_ok(thd);
    }
    break;
  }
3620 3621 3622 3623
  case SQLCOM_REVOKE:
  case SQLCOM_GRANT:
  {
    if (check_access(thd, lex->grant | lex->grant_tot_col | GRANT_ACL,
unknown's avatar
unknown committed
3624
		     first_table ?  first_table->db : select_lex->db,
unknown's avatar
VIEW  
unknown committed
3625 3626
		     first_table ? &first_table->grant.privilege : 0,
		     first_table ? 0 : 1, 0))
3627 3628
      goto error;

unknown's avatar
unknown committed
3629 3630 3631
    if (thd->user)				// If not replication
    {
      LEX_USER *user;
3632 3633
      uint counter;

unknown's avatar
unknown committed
3634
      List_iterator <LEX_USER> user_list(lex->users_list);
3635
      while ((user= user_list++))
unknown's avatar
unknown committed
3636
      {
3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657
        if (specialflag & SPECIAL_NO_RESOLVE &&
            hostname_requires_resolving(user->host.str))
          push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                              ER_WARN_HOSTNAME_WONT_WORK,
                              ER(ER_WARN_HOSTNAME_WONT_WORK),
                              user->host.str);
        // Are we trying to change a password of another user
        DBUG_ASSERT(user->host.str != 0);
        if (strcmp(thd->user, user->user.str) ||
            my_strcasecmp(system_charset_info,
                          user->host.str, thd->host_or_ip))
        {
          // TODO: use check_change_password()
          if (check_acl_user(user, &counter) && user->password.str &&
              check_access(thd, UPDATE_ACL,"mysql",0,1,1))
          {
            my_message(ER_PASSWORD_NOT_ALLOWED,
                       ER(ER_PASSWORD_NOT_ALLOWED), MYF(0));
            goto error;
          }
        }
unknown's avatar
SCRUM  
unknown committed
3658 3659
      }
    }
unknown's avatar
VIEW  
unknown committed
3660
    if (first_table)
3661
    {
3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685
      if (!lex->columns.elements && 
          sp_exists_routine(thd, all_tables, 1, 1))
      {
        uint grants= lex->all_privileges 
		   ? (PROC_ACLS & ~GRANT_ACL) | (lex->grant & GRANT_ACL)
		   : lex->grant;
        if (grant_option && 
	    check_grant_procedure(thd, grants | GRANT_ACL, all_tables, 0))
	  goto error;
        res= mysql_procedure_grant(thd, all_tables, lex->users_list,
				   grants, lex->sql_command == SQLCOM_REVOKE,0);
      }
      else
      {
	if (grant_option && check_grant(thd,
					(lex->grant | lex->grant_tot_col |
					 GRANT_ACL),
					all_tables, 0, UINT_MAX, 0))
	  goto error;
        res= mysql_table_grant(thd, all_tables, lex->users_list,
			       lex->columns, lex->grant,
			       lex->sql_command == SQLCOM_REVOKE);
      }
      if (!res && mysql_bin_log.is_open())
3686
      {
unknown's avatar
unknown committed
3687
        thd->clear_error();
unknown's avatar
unknown committed
3688
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3689
        mysql_bin_log.write(&qinfo);
3690 3691 3692 3693 3694 3695
      }
    }
    else
    {
      if (lex->columns.elements)
      {
unknown's avatar
unknown committed
3696 3697
	my_message(ER_ILLEGAL_GRANT_FOR_TABLE, ER(ER_ILLEGAL_GRANT_FOR_TABLE),
                   MYF(0));
unknown's avatar
unknown committed
3698
        goto error;
3699 3700 3701 3702 3703 3704 3705 3706
      }
      else
	res = mysql_grant(thd, select_lex->db, lex->users_list, lex->grant,
			  lex->sql_command == SQLCOM_REVOKE);
      if (!res)
      {
	if (mysql_bin_log.is_open())
	{
unknown's avatar
unknown committed
3707
          thd->clear_error();
3708
	  Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3709 3710
	  mysql_bin_log.write(&qinfo);
	}
3711
	if (lex->sql_command == SQLCOM_GRANT)
3712
	{
unknown's avatar
unknown committed
3713 3714 3715
	  List_iterator <LEX_USER> str_list(lex->users_list);
	  LEX_USER *user;
	  while ((user=str_list++))
unknown's avatar
unknown committed
3716
	    reset_mqh(user);
3717
	}
3718 3719 3720 3721
      }
    }
    break;
  }
unknown's avatar
SCRUM  
unknown committed
3722
#endif /*!NO_EMBEDDED_ACCESS_CHECKS*/
unknown's avatar
unknown committed
3723
  case SQLCOM_RESET:
3724 3725 3726
    /*
      RESET commands are never written to the binary log, so we have to
      initialize this variable because RESET shares the same code as FLUSH
3727 3728 3729 3730
    */
    lex->no_write_to_binlog= 1;
  case SQLCOM_FLUSH:
  {
unknown's avatar
VIEW  
unknown committed
3731
    if (check_global_access(thd,RELOAD_ACL) || check_db_used(thd, all_tables))
unknown's avatar
unknown committed
3732
      goto error;
3733 3734 3735 3736 3737
    /*
      reload_acl_and_cache() will tell us if we are allowed to write to the
      binlog or not.
    */
    bool write_to_binlog;
unknown's avatar
unknown committed
3738
    if (!reload_acl_and_cache(thd, lex->type, first_table, &write_to_binlog))
3739 3740 3741 3742 3743 3744 3745 3746 3747
    {
      /*
        We WANT to write and we CAN write.
        ! we write after unlocking the table.
      */
      if (!lex->no_write_to_binlog && write_to_binlog)
      {
        if (mysql_bin_log.is_open())
        {
3748
          Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
3749 3750 3751 3752 3753
          mysql_bin_log.write(&qinfo);
        }
      }
      send_ok(thd);
    }
unknown's avatar
unknown committed
3754
    break;
3755
  }
unknown's avatar
unknown committed
3756
  case SQLCOM_KILL:
3757 3758 3759
  {
    Item *it= (Item *)lex->value_list.head();

unknown's avatar
unknown committed
3760
    if ((!it->fixed && it->fix_fields(lex->thd, 0, &it)) || it->check_cols(1))
3761 3762 3763 3764 3765 3766
    {
      my_message(ER_SET_CONSTANTS_ONLY, ER(ER_SET_CONSTANTS_ONLY),
		 MYF(0));
      goto error;
    }
    kill_one_thread(thd, (ulong)it->val_int(), lex->type & ONLY_KILL_QUERY);
unknown's avatar
unknown committed
3767
    break;
3768
  }
unknown's avatar
unknown committed
3769
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
3770
  case SQLCOM_SHOW_GRANTS:
3771 3772
    if ((thd->priv_user &&
	 !strcmp(thd->priv_user,lex->grant_user->user.str)) ||
unknown's avatar
unknown committed
3773
	!check_access(thd, SELECT_ACL, "mysql",0,1,0))
unknown's avatar
unknown committed
3774 3775 3776 3777
    {
      res = mysql_show_grants(thd,lex->grant_user);
    }
    break;
unknown's avatar
unknown committed
3778
#endif
3779
  case SQLCOM_HA_OPEN:
unknown's avatar
VIEW  
unknown committed
3780 3781 3782
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables) ||
	check_table_access(thd, SELECT_ACL, all_tables, 0))
3783
      goto error;
unknown's avatar
unknown committed
3784
    res= mysql_ha_open(thd, first_table, 0);
3785 3786
    break;
  case SQLCOM_HA_CLOSE:
unknown's avatar
VIEW  
unknown committed
3787 3788
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables))
3789
      goto error;
unknown's avatar
VIEW  
unknown committed
3790
    res= mysql_ha_close(thd, first_table);
3791 3792
    break;
  case SQLCOM_HA_READ:
unknown's avatar
VIEW  
unknown committed
3793
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3794 3795 3796 3797 3798
    /*
      There is no need to check for table permissions here, because
      if a user has no permissions to read a table, he won't be
      able to open it (with SQLCOM_HA_OPEN) in the first place.
    */
unknown's avatar
VIEW  
unknown committed
3799
    if (check_db_used(thd, all_tables))
3800
      goto error;
3801
    res= mysql_ha_read(thd, first_table, lex->ha_read_mode, lex->ident.str,
unknown's avatar
VIEW  
unknown committed
3802 3803
                       lex->insert_list, lex->ha_rkey_mode, select_lex->where,
                       select_lex->select_limit, select_lex->offset_limit);
3804 3805
    break;

unknown's avatar
unknown committed
3806
  case SQLCOM_BEGIN:
unknown's avatar
unknown committed
3807
    if (begin_trans(thd))
unknown's avatar
unknown committed
3808
      goto error;
unknown's avatar
unknown committed
3809
    send_ok(thd);
unknown's avatar
unknown committed
3810 3811
    break;
  case SQLCOM_COMMIT:
3812
    if (end_trans(thd, lex->tx_release ? COMMIT_RELEASE :
unknown's avatar
unknown committed
3813
                              lex->tx_chain ? COMMIT_AND_CHAIN : COMMIT))
unknown's avatar
unknown committed
3814
      goto error;
3815
    send_ok(thd);
unknown's avatar
unknown committed
3816 3817
    break;
  case SQLCOM_ROLLBACK:
3818
    if (end_trans(thd, lex->tx_release ? ROLLBACK_RELEASE :
unknown's avatar
unknown committed
3819
                              lex->tx_chain ? ROLLBACK_AND_CHAIN : ROLLBACK))
unknown's avatar
unknown committed
3820
      goto error;
3821
    send_ok(thd);
unknown's avatar
unknown committed
3822
    break;
unknown's avatar
unknown committed
3823
  case SQLCOM_RELEASE_SAVEPOINT:
unknown's avatar
unknown committed
3824
  {
3825 3826
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
unknown's avatar
unknown committed
3827 3828 3829
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
3830
                       (uchar *)sv->name, sv->length) == 0)
unknown's avatar
unknown committed
3831 3832
        break;
    }
3833
    if (sv)
unknown's avatar
unknown committed
3834
    {
3835
      if (ha_release_savepoint(thd, sv))
unknown's avatar
unknown committed
3836
        res= TRUE; // cannot happen
unknown's avatar
unknown committed
3837 3838
      else
        send_ok(thd);
3839
      thd->transaction.savepoints=sv->prev;
unknown's avatar
unknown committed
3840
    }
3841
    else
unknown's avatar
unknown committed
3842
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
unknown's avatar
unknown committed
3843
    break;
unknown's avatar
unknown committed
3844
  }
unknown's avatar
unknown committed
3845
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
unknown's avatar
unknown committed
3846
  {
3847 3848
    SAVEPOINT *sv;
    for (sv=thd->transaction.savepoints; sv; sv=sv->prev)
3849 3850 3851
    {
      if (my_strnncoll(system_charset_info,
                       (uchar *)lex->ident.str, lex->ident.length,
3852
                       (uchar *)sv->name, sv->length) == 0)
3853 3854
        break;
    }
3855
    if (sv)
3856
    {
3857
      if (ha_rollback_to_savepoint(thd, sv))
3858 3859
        res= TRUE; // cannot happen
      else
unknown's avatar
unknown committed
3860 3861 3862 3863 3864 3865 3866 3867
      {
        if ((thd->options & OPTION_STATUS_NO_TRANS_UPDATE) &&
            !thd->slave_thread)
          push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                       ER_WARNING_NOT_COMPLETE_ROLLBACK,
                       ER(ER_WARNING_NOT_COMPLETE_ROLLBACK));
        send_ok(thd);
      }
3868
      thd->transaction.savepoints=sv;
unknown's avatar
unknown committed
3869 3870
    }
    else
3871
      my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "SAVEPOINT", lex->ident.str);
unknown's avatar
unknown committed
3872
    break;
3873
  }
3874
  case SQLCOM_SAVEPOINT:
3875 3876
    if (!(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) ||
        !opt_using_transactions)
unknown's avatar
unknown committed
3877
      send_ok(thd);
unknown's avatar
unknown committed
3878
    else
3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916
    {
      SAVEPOINT **sv, *newsv;
      for (sv=&thd->transaction.savepoints; *sv; sv=&(*sv)->prev)
      {
        if (my_strnncoll(system_charset_info,
                         (uchar *)lex->ident.str, lex->ident.length,
                         (uchar *)(*sv)->name, (*sv)->length) == 0)
          break;
      }
      if (*sv) /* old savepoint of the same name exists */
      {
        newsv=*sv;
        ha_release_savepoint(thd, *sv); // it cannot fail
        *sv=(*sv)->prev;
      }
      else if ((newsv=(SAVEPOINT *) alloc_root(&thd->transaction.mem_root,
                                               savepoint_alloc_size)) == 0)
      {
        my_error(ER_OUT_OF_RESOURCES, MYF(0));
        break;
      }
      newsv->name=strmake_root(&thd->transaction.mem_root,
                               lex->ident.str, lex->ident.length);
      newsv->length=lex->ident.length;
      /*
        if we'll get an error here, don't add new savepoint to the list.
        we'll lose a little bit of memory in transaction mem_root, but it'll
        be free'd when transaction ends anyway
      */
      if (ha_savepoint(thd, newsv))
        res= TRUE;
      else
      {
        newsv->prev=thd->transaction.savepoints;
        thd->transaction.savepoints=newsv;
        send_ok(thd);
      }
    }
unknown's avatar
unknown committed
3917
    break;
3918 3919
  case SQLCOM_CREATE_PROCEDURE:
  case SQLCOM_CREATE_SPFUNCTION:
unknown's avatar
unknown committed
3920
  {
3921
    uint namelen;
3922
    char *name, *db;
unknown's avatar
unknown committed
3923
    int result;
3924

3925
    DBUG_ASSERT(lex->sphead != 0);
3926

3927
    if (check_access(thd, CREATE_PROC_ACL, lex->sphead->m_db.str, 0, 0, 0))
3928 3929 3930 3931 3932 3933
    {
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
    }

3934 3935 3936
    if (!lex->sphead->m_db.str || !lex->sphead->m_db.str[0])
    {
      lex->sphead->m_db.length= strlen(thd->db);
unknown's avatar
unknown committed
3937 3938
      lex->sphead->m_db.str= strmake_root(thd->mem_root, thd->db,
                                           lex->sphead->m_db.length);
3939
    }
3940 3941

    name= lex->sphead->name(&namelen);
3942
#ifdef HAVE_DLOPEN
unknown's avatar
unknown committed
3943 3944 3945
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION)
    {
      udf_func *udf = find_udf(name, namelen);
3946

unknown's avatar
unknown committed
3947
      if (udf)
3948
      {
3949
	my_error(ER_UDF_EXISTS, MYF(0), name);
unknown's avatar
unknown committed
3950
	delete lex->sphead;
3951
	lex->sphead= 0;
3952
	goto error;
3953
      }
unknown's avatar
unknown committed
3954 3955 3956 3957 3958
    }
#endif
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION &&
	!lex->sphead->m_has_return)
    {
3959
      my_error(ER_SP_NORETURN, MYF(0), name);
unknown's avatar
unknown committed
3960
      delete lex->sphead;
3961
      lex->sphead= 0;
unknown's avatar
unknown committed
3962 3963 3964
      goto error;
    }

3965 3966
    name= thd->strdup(name); 
    db= thd->strmake(lex->sphead->m_db.str, lex->sphead->m_db.length);
unknown's avatar
unknown committed
3967 3968
    res= (result= lex->sphead->create(thd));
    switch (result) {
unknown's avatar
unknown committed
3969
    case SP_OK:
3970
      lex->unit.cleanup();
unknown's avatar
unknown committed
3971 3972
      delete lex->sphead;
      lex->sphead= 0;
unknown's avatar
unknown committed
3973
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984
      /* only add privileges if really neccessary */
      if (sp_automatic_privileges &&
          check_procedure_access(thd, DEFAULT_CREATE_PROC_ACLS,
      				 db, name, 1))
      {
        close_thread_tables(thd);
        if (sp_grant_privileges(thd, db, name))
          push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
	  	       ER_PROC_AUTO_GRANT_FAIL,
		       ER(ER_PROC_AUTO_GRANT_FAIL));
      }
unknown's avatar
unknown committed
3985
#endif
3986
      send_ok(thd);
3987
      break;
unknown's avatar
unknown committed
3988
    case SP_WRITE_ROW_FAILED:
3989
      my_error(ER_SP_ALREADY_EXISTS, MYF(0), SP_TYPE_STRING(lex), name);
3990
      lex->unit.cleanup();
unknown's avatar
unknown committed
3991 3992 3993
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
3994
    case SP_NO_DB_ERROR:
3995
      my_error(ER_BAD_DB_ERROR, MYF(0), lex->sphead->m_db.str);
3996
      lex->unit.cleanup();
3997 3998 3999
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
unknown's avatar
unknown committed
4000
    default:
4001
      my_error(ER_SP_STORE_FAILED, MYF(0), SP_TYPE_STRING(lex), name);
4002
      lex->unit.cleanup();
unknown's avatar
unknown committed
4003 4004 4005
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
4006
    }
unknown's avatar
unknown committed
4007 4008
    break;
  }
4009 4010 4011 4012
  case SQLCOM_CALL:
    {
      sp_head *sp;

4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026
      /*
        This will cache all SP and SF and open and lock all tables
        required for execution.
      */
      if (check_table_access(thd, SELECT_ACL, all_tables, 0) ||
	  open_and_lock_tables(thd, all_tables))
       goto error;

      /*
        By this moment all needed SPs should be in cache so no need
        to look into DB. Moreover we may be unable to do it becuase
        we may don't have read lock on mysql.proc
      */
      if (!(sp= sp_find_procedure(thd, lex->spname, TRUE)))
4027
      {
4028
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0), "PROCEDURE",
unknown's avatar
unknown committed
4029
                 lex->spname->m_qname.str);
4030
	goto error;
4031 4032 4033
      }
      else
      {
4034
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4035
	st_sp_security_context save_ctx;
4036
#endif
unknown's avatar
unknown committed
4037
	ha_rows select_limit;
unknown's avatar
unknown committed
4038 4039
        /* bits that should be cleared in thd->server_status */
	uint bits_to_be_cleared= 0;
4040

4041
#ifndef EMBEDDED_LIBRARY
4042 4043
	my_bool nsok= thd->net.no_send_ok;
	thd->net.no_send_ok= TRUE;
4044
#endif
4045
	if (sp->m_multi_results)
4046
	{
4047
	  if (! (thd->client_capabilities & CLIENT_MULTI_RESULTS))
4048
	  {
unknown's avatar
unknown committed
4049
	    my_message(ER_SP_BADSELECT, ER(ER_SP_BADSELECT), MYF(0));
4050 4051 4052 4053 4054
#ifndef EMBEDDED_LIBRARY
	    thd->net.no_send_ok= nsok;
#endif
	    goto error;
	  }
unknown's avatar
unknown committed
4055 4056 4057 4058 4059 4060 4061
          /*
            If SERVER_MORE_RESULTS_EXISTS is not set,
            then remember that it should be cleared
          */
	  bits_to_be_cleared= (~thd->server_status &
                               SERVER_MORE_RESULTS_EXISTS);
	  thd->server_status|= SERVER_MORE_RESULTS_EXISTS;
4062 4063
	}

4064
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4065 4066 4067 4068 4069 4070 4071 4072
	if (check_procedure_access(thd, EXECUTE_ACL, 
				   sp->m_db.str, sp->m_name.str, 0))
	{
#ifndef EMBEDDED_LIBRARY
	  thd->net.no_send_ok= nsok;
#endif
	  goto error;
	}
4073
	sp_change_security_context(thd, sp, &save_ctx);
4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084
	if (save_ctx.changed && 
	    check_procedure_access(thd, EXECUTE_ACL, 
				   sp->m_db.str, sp->m_name.str, 0))
	{
#ifndef EMBEDDED_LIBRARY
	  thd->net.no_send_ok= nsok;
#endif
	  sp_restore_security_context(thd, sp, &save_ctx);
	  goto error;
	}

4085
#endif
unknown's avatar
unknown committed
4086 4087
	select_limit= thd->variables.select_limit;
	thd->variables.select_limit= HA_POS_ERROR;
4088

4089
	thd->row_count_func= 0;
4090
	res= sp->execute_procedure(thd, &lex->value_list);
4091

4092 4093 4094
	/*
          If warnings have been cleared, we have to clear total_warn_count
          too, otherwise the clients get confused.
4095 4096 4097 4098
	 */
	if (thd->warn_list.is_empty())
	  thd->total_warn_count= 0;

unknown's avatar
unknown committed
4099
	thd->variables.select_limit= select_limit;
4100
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4101
	sp_restore_security_context(thd, sp, &save_ctx);
4102
#endif
4103

4104
#ifndef EMBEDDED_LIBRARY
4105
	thd->net.no_send_ok= nsok;
4106
#endif
unknown's avatar
unknown committed
4107
        thd->server_status&= ~bits_to_be_cleared;
4108

unknown's avatar
unknown committed
4109
	if (!res)
unknown's avatar
unknown committed
4110 4111
	  send_ok(thd, (ulong) (thd->row_count_func < 0 ? 0 :
                                thd->row_count_func));
4112 4113
	else
	  goto error;		// Substatement should already have sent error
4114
      }
4115
      break;
4116 4117
    }
  case SQLCOM_ALTER_PROCEDURE:
4118
  case SQLCOM_ALTER_FUNCTION:
4119
    {
unknown's avatar
unknown committed
4120
      int result;
4121 4122 4123 4124
      sp_head *sp;
      st_sp_chistics chistics;

      memcpy(&chistics, &lex->sp_chistics, sizeof(chistics));
unknown's avatar
unknown committed
4125
      if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
4126
	sp= sp_find_procedure(thd, lex->spname);
4127
      else
4128
	sp= sp_find_function(thd, lex->spname);
unknown's avatar
unknown committed
4129
      mysql_reset_errors(thd, 0);
4130
      if (! sp)
4131 4132 4133 4134 4135 4136 4137 4138 4139
      {
	if (lex->spname->m_db.str)
	  result= SP_KEY_NOT_FOUND;
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
      }
4140 4141
      else
      {
4142 4143 4144
        if (check_procedure_access(thd, ALTER_PROC_ACL, sp->m_db.str, 
				  sp->m_name.str, 0))
	  goto error;
4145 4146
	memcpy(&lex->sp_chistics, &chistics, sizeof(lex->sp_chistics));
	if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
unknown's avatar
merge  
unknown committed
4147
	  result= sp_update_procedure(thd, lex->spname, &lex->sp_chistics);
4148
	else
unknown's avatar
merge  
unknown committed
4149
	  result= sp_update_function(thd, lex->spname, &lex->sp_chistics);
4150
      }
unknown's avatar
unknown committed
4151
      switch (result)
4152
      {
unknown's avatar
unknown committed
4153
      case SP_OK:
4154
	send_ok(thd);
unknown's avatar
unknown committed
4155 4156
	break;
      case SP_KEY_NOT_FOUND:
4157 4158
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
unknown's avatar
unknown committed
4159 4160
	goto error;
      default:
4161 4162
	my_error(ER_SP_CANT_ALTER, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
unknown's avatar
unknown committed
4163
	goto error;
4164
      }
4165
      break;
4166 4167
    }
  case SQLCOM_DROP_PROCEDURE:
4168
  case SQLCOM_DROP_FUNCTION:
4169
    {
4170
      sp_head *sp;
unknown's avatar
unknown committed
4171
      int result;
4172
      char *db, *name;
4173

4174
      if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
4175 4176 4177
	sp= sp_find_procedure(thd, lex->spname);
      else
	sp= sp_find_function(thd, lex->spname);
unknown's avatar
unknown committed
4178
      mysql_reset_errors(thd, 0);
4179
      if (sp)
4180
      {
4181 4182 4183
        db= thd->strdup(sp->m_db.str);
	name= thd->strdup(sp->m_name.str);
	if (check_procedure_access(thd, ALTER_PROC_ACL, db, name, 0))
unknown's avatar
merge  
unknown committed
4184
          goto error;
unknown's avatar
unknown committed
4185
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4186 4187 4188 4189 4190 4191 4192
	if (sp_automatic_privileges &&
	    sp_revoke_privileges(thd, db, name))
	{
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_WARN, 
		       ER_PROC_AUTO_REVOKE_FAIL,
		       ER(ER_PROC_AUTO_REVOKE_FAIL));
	}
unknown's avatar
unknown committed
4193
#endif
4194
	if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
unknown's avatar
merge  
unknown committed
4195
	  result= sp_drop_procedure(thd, lex->spname);
4196
	else
unknown's avatar
merge  
unknown committed
4197
	  result= sp_drop_function(thd, lex->spname);
4198 4199 4200
      }
      else
      {
4201
#ifdef HAVE_DLOPEN
4202 4203 4204 4205 4206 4207 4208 4209 4210
	if (lex->sql_command == SQLCOM_DROP_FUNCTION)
	{
          udf_func *udf = find_udf(lex->spname->m_name.str,
                                   lex->spname->m_name.length);
          if (udf)
          {
	    if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 0))
	      goto error;
	    if (!(res = mysql_drop_function(thd, &lex->spname->m_name)))
4211
	    {
4212 4213
	      send_ok(thd);
	      break;
4214 4215
	    }
	  }
4216
	}
4217
#endif
4218 4219 4220 4221 4222 4223 4224
	if (lex->spname->m_db.str)
	  result= SP_KEY_NOT_FOUND;
	else
	{
	  my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
	  goto error;
	}
4225
      }
unknown's avatar
unknown committed
4226 4227
      res= result;
      switch (result)
4228 4229
      {
      case SP_OK:
4230
	send_ok(thd);
4231 4232
	break;
      case SP_KEY_NOT_FOUND:
4233 4234
	if (lex->drop_if_exists)
	{
4235
	  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
4236
			      ER_SP_DOES_NOT_EXIST, ER(ER_SP_DOES_NOT_EXIST),
4237
			      SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4238
	  res= FALSE;
4239 4240 4241
	  send_ok(thd);
	  break;
	}
4242 4243
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4244 4245
	goto error;
      default:
4246 4247
	my_error(ER_SP_DROP_FAILED, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_qname.str);
4248
	goto error;
4249
      }
4250
      break;
4251
    }
unknown's avatar
unknown committed
4252 4253
  case SQLCOM_SHOW_CREATE_PROC:
    {
4254
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
4255
      {
4256
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4257 4258
	goto error;
      }
unknown's avatar
unknown committed
4259
      if (sp_show_create_procedure(thd, lex->spname) != SP_OK)
4260
      {			/* We don't distinguish between errors for now */
4261 4262
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4263 4264 4265 4266 4267 4268
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_CREATE_FUNC:
    {
4269
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
4270
      {
4271
	my_error(ER_TOO_LONG_IDENT, MYF(0), lex->spname->m_name.str);
unknown's avatar
unknown committed
4272 4273
	goto error;
      }
unknown's avatar
unknown committed
4274
      if (sp_show_create_function(thd, lex->spname) != SP_OK)
4275
      {			/* We don't distinguish between errors for now */
4276 4277
	my_error(ER_SP_DOES_NOT_EXIST, MYF(0),
                 SP_COM_STRING(lex), lex->spname->m_name.str);
unknown's avatar
unknown committed
4278 4279 4280 4281 4282 4283
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_STATUS_PROC:
    {
4284
      res= sp_show_status_procedure(thd, (lex->wild ?
unknown's avatar
unknown committed
4285 4286 4287 4288 4289
					  lex->wild->ptr() : NullS));
      break;
    }
  case SQLCOM_SHOW_STATUS_FUNC:
    {
4290
      res= sp_show_status_function(thd, (lex->wild ? 
unknown's avatar
unknown committed
4291 4292 4293
					 lex->wild->ptr() : NullS));
      break;
    }
unknown's avatar
VIEW  
unknown committed
4294 4295
  case SQLCOM_CREATE_VIEW:
    {
4296 4297 4298
      if (!(res= mysql_create_view(thd, thd->lex->create_view_mode)) &&
          mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
4299
        thd->clear_error();
4300 4301 4302
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
        mysql_bin_log.write(&qinfo);
      }
unknown's avatar
VIEW  
unknown committed
4303 4304 4305 4306
      break;
    }
  case SQLCOM_DROP_VIEW:
    {
unknown's avatar
unknown committed
4307 4308 4309
      if (check_table_access(thd, DROP_ACL, all_tables, 0) ||
          end_active_trans(thd))
        goto error;
4310 4311 4312
      if (!(res= mysql_drop_view(thd, first_table, thd->lex->drop_mode)) &&
          mysql_bin_log.is_open())
      {
unknown's avatar
unknown committed
4313
        thd->clear_error();
4314 4315 4316
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0, FALSE);
        mysql_bin_log.write(&qinfo);
      }
unknown's avatar
VIEW  
unknown committed
4317 4318
      break;
    }
4319 4320
  case SQLCOM_CREATE_TRIGGER:
  {
4321 4322 4323
    res= mysql_create_or_drop_trigger(thd, all_tables, 1);

    /* We don't care about trigger body after this point */
4324 4325 4326 4327 4328 4329 4330 4331 4332
    delete lex->sphead;
    lex->sphead= 0;
    break;
  }
  case SQLCOM_DROP_TRIGGER:
  {
    res= mysql_create_or_drop_trigger(thd, all_tables, 0);
    break;
  }
4333 4334 4335
  case SQLCOM_XA_START:
    if (thd->transaction.xa_state == XA_IDLE && thd->lex->xa_opt == XA_RESUME)
    {
unknown's avatar
unknown committed
4336
      if (! thd->transaction.xid.eq(thd->lex->xid))
4337 4338 4339 4340 4341 4342 4343 4344
      {
        my_error(ER_XAER_NOTA, MYF(0));
        break;
      }
      thd->transaction.xa_state=XA_ACTIVE;
      send_ok(thd);
      break;
    }
unknown's avatar
unknown committed
4345
    if (thd->lex->xa_opt != XA_NONE)
4346 4347 4348 4349 4350 4351
    { // JOIN is not supported yet. TODO
      my_error(ER_XAER_INVAL, MYF(0));
      break;
    }
    if (thd->transaction.xa_state != XA_NOTR)
    {
unknown's avatar
unknown committed
4352 4353
      my_error(ER_XAER_RMFAIL, MYF(0),
               xa_state_names[thd->transaction.xa_state]);
4354 4355 4356 4357 4358 4359 4360 4361 4362
      break;
    }
    if (thd->active_transaction() || thd->locked_tables)
    {
      my_error(ER_XAER_OUTSIDE, MYF(0));
      break;
    }
    DBUG_ASSERT(thd->transaction.xid.is_null());
    thd->transaction.xa_state=XA_ACTIVE;
unknown's avatar
unknown committed
4363
    thd->transaction.xid.set(thd->lex->xid);
4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377
    thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
                   OPTION_BEGIN);
    thd->server_status|= SERVER_STATUS_IN_TRANS;
    send_ok(thd);
    break;
  case SQLCOM_XA_END:
    /* fake it */
    if (thd->lex->xa_opt != XA_NONE)
    { // SUSPEND and FOR MIGRATE are not supported yet. TODO
      my_error(ER_XAER_INVAL, MYF(0));
      break;
    }
    if (thd->transaction.xa_state != XA_ACTIVE)
    {
unknown's avatar
unknown committed
4378 4379
      my_error(ER_XAER_RMFAIL, MYF(0),
               xa_state_names[thd->transaction.xa_state]);
4380 4381
      break;
    }
unknown's avatar
unknown committed
4382
    if (!thd->transaction.xid.eq(thd->lex->xid))
4383 4384 4385 4386 4387 4388 4389 4390 4391 4392
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
    thd->transaction.xa_state=XA_IDLE;
    send_ok(thd);
    break;
  case SQLCOM_XA_PREPARE:
    if (thd->transaction.xa_state != XA_IDLE)
    {
unknown's avatar
unknown committed
4393 4394
      my_error(ER_XAER_RMFAIL, MYF(0),
               xa_state_names[thd->transaction.xa_state]);
4395 4396
      break;
    }
unknown's avatar
unknown committed
4397
    if (!thd->transaction.xid.eq(thd->lex->xid))
4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411
    {
      my_error(ER_XAER_NOTA, MYF(0));
      break;
    }
    if (ha_prepare(thd))
    {
      my_error(ER_XA_RBROLLBACK, MYF(0));
      thd->transaction.xa_state=XA_NOTR;
      break;
    }
    thd->transaction.xa_state=XA_PREPARED;
    send_ok(thd);
    break;
  case SQLCOM_XA_COMMIT:
unknown's avatar
unknown committed
4412
    if (!thd->transaction.xid.eq(thd->lex->xid))
4413
    {
unknown's avatar
unknown committed
4414
      if (!(res= !ha_commit_or_rollback_by_xid(thd->lex->xid, 1)))
4415
        my_error(ER_XAER_NOTA, MYF(0));
unknown's avatar
unknown committed
4416 4417
      else
        send_ok(thd);
4418 4419 4420 4421
      break;
    }
    if (thd->transaction.xa_state == XA_IDLE && thd->lex->xa_opt == XA_ONE_PHASE)
    {
unknown's avatar
unknown committed
4422 4423 4424
      int r;
      if ((r= ha_commit(thd)))
        my_error(r == 1 ? ER_XA_RBROLLBACK : ER_XAER_RMERR, MYF(0));
4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437
      else
        send_ok(thd);
    }
    else
    if (thd->transaction.xa_state == XA_PREPARED && thd->lex->xa_opt == XA_NONE)
    {
      if (ha_commit_one_phase(thd, 1))
        my_error(ER_XAER_RMERR, MYF(0));
      else
        send_ok(thd);
    }
    else
    {
unknown's avatar
unknown committed
4438 4439
      my_error(ER_XAER_RMFAIL, MYF(0),
               xa_state_names[thd->transaction.xa_state]);
4440 4441 4442 4443 4444 4445 4446
      break;
    }
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
    thd->transaction.xa_state=XA_NOTR;
    break;
  case SQLCOM_XA_ROLLBACK:
unknown's avatar
unknown committed
4447
    if (!thd->transaction.xid.eq(thd->lex->xid))
4448
    {
unknown's avatar
unknown committed
4449
      if (!(res= !ha_commit_or_rollback_by_xid(thd->lex->xid, 0)))
4450
        my_error(ER_XAER_NOTA, MYF(0));
unknown's avatar
unknown committed
4451 4452
      else
        send_ok(thd);
4453 4454 4455 4456 4457
      break;
    }
    if (thd->transaction.xa_state != XA_IDLE &&
        thd->transaction.xa_state != XA_PREPARED)
    {
unknown's avatar
unknown committed
4458 4459
      my_error(ER_XAER_RMFAIL, MYF(0),
               xa_state_names[thd->transaction.xa_state]);
4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470
      break;
    }
    if (ha_rollback(thd))
      my_error(ER_XAER_RMERR, MYF(0));
    else
      send_ok(thd);
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
    thd->transaction.xa_state=XA_NOTR;
    break;
  case SQLCOM_XA_RECOVER:
4471
    res= mysql_xa_recover(thd);
4472 4473 4474
    break;
  default:
    DBUG_ASSERT(0);                             /* Impossible */
4475
    send_ok(thd);
unknown's avatar
unknown committed
4476 4477
    break;
  }
unknown's avatar
unknown committed
4478
  thd->proc_info="query end";
4479
  if (thd->one_shot_set)
unknown's avatar
unknown committed
4480 4481 4482 4483 4484 4485 4486 4487
  {
    /*
      If this is a SET, do nothing. This is to allow mysqlbinlog to print
      many SET commands (in this case we want the charset temp setting to
      live until the real query). This is also needed so that SET
      CHARACTER_SET_CLIENT... does not cancel itself immediately.
    */
    if (lex->sql_command != SQLCOM_SET_OPTION)
4488
    {
unknown's avatar
unknown committed
4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500
      thd->variables.character_set_client=
        global_system_variables.character_set_client;
      thd->variables.collation_connection=
        global_system_variables.collation_connection;
      thd->variables.collation_database=
        global_system_variables.collation_database;
      thd->variables.collation_server=
        global_system_variables.collation_server;
      thd->update_charset();
      thd->variables.time_zone=
        global_system_variables.time_zone;
      thd->one_shot_set= 0;
4501
    }
unknown's avatar
unknown committed
4502
  }
4503

4504 4505 4506 4507 4508
  /*
    The return value for ROW_COUNT() is "implementation dependent" if
    the statement is not DELETE, INSERT or UPDATE (or a CALL executing
    such a statement), but -1 is what JDBC and ODBC wants.
   */
4509
  if (lex->sql_command != SQLCOM_CALL && uc_update_queries[lex->sql_command]<2)
4510
    thd->row_count_func= -1;
unknown's avatar
unknown committed
4511
  goto cleanup;
unknown's avatar
unknown committed
4512 4513

error:
unknown's avatar
unknown committed
4514
  res= 1;
4515

unknown's avatar
unknown committed
4516
cleanup:
unknown's avatar
unknown committed
4517 4518 4519 4520 4521 4522 4523 4524
  if (unlikely(slave_fake_lock))
  {
    DBUG_PRINT("info",("undoing faked lock"));
    thd->lock= thd->locked_tables;
    thd->locked_tables= fake_prev_lock;
    if (thd->lock == thd->locked_tables)
      thd->lock= 0;
  }
unknown's avatar
unknown committed
4525
  DBUG_RETURN(res || thd->net.report_error);
unknown's avatar
unknown committed
4526 4527 4528
}


unknown's avatar
unknown committed
4529 4530
/*
  Check grants for commands which work only with one table and all other
4531
  tables belonging to subselects or implicitly opened tables.
unknown's avatar
unknown committed
4532

4533
  SYNOPSIS
unknown's avatar
unknown committed
4534 4535
    check_one_table_access()
    thd			Thread handler
4536
    privilege		requested privilege
unknown's avatar
VIEW  
unknown committed
4537
    all_tables		global table list of query
unknown's avatar
unknown committed
4538 4539 4540

  RETURN
    0 - OK
unknown's avatar
unknown committed
4541
    1 - access denied, error is sent to client
unknown's avatar
unknown committed
4542 4543
*/

4544
bool check_one_table_access(THD *thd, ulong privilege, TABLE_LIST *all_tables)
unknown's avatar
unknown committed
4545
{
unknown's avatar
VIEW  
unknown committed
4546 4547
  if (check_access(thd, privilege, all_tables->db,
		   &all_tables->grant.privilege, 0, 0))
unknown's avatar
unknown committed
4548
    return 1;
unknown's avatar
unknown committed
4549

unknown's avatar
unknown committed
4550
  /* Show only 1 table for check_grant */
unknown's avatar
VIEW  
unknown committed
4551
  if (grant_option && check_grant(thd, privilege, all_tables, 0, 1, 0))
unknown's avatar
unknown committed
4552
    return 1;
unknown's avatar
unknown committed
4553

4554
  /* Check rights on tables of subselects and implictly opened tables */
unknown's avatar
unknown committed
4555
  TABLE_LIST *subselects_tables;
unknown's avatar
VIEW  
unknown committed
4556
  if ((subselects_tables= all_tables->next_global))
unknown's avatar
unknown committed
4557
  {
unknown's avatar
VIEW  
unknown committed
4558
    if ((check_table_access(thd, SELECT_ACL, subselects_tables, 0)))
unknown's avatar
unknown committed
4559 4560 4561
      return 1;
  }
  return 0;
unknown's avatar
unknown committed
4562 4563 4564
}


unknown's avatar
unknown committed
4565
/****************************************************************************
unknown's avatar
unknown committed
4566
  Get the user (global) and database privileges for all used tables
unknown's avatar
unknown committed
4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579

  NOTES
    The idea of EXTRA_ACL is that one will be granted access to the table if
    one has the asked privilege on any column combination of the table; For
    example to be able to check a table one needs to have SELECT privilege on
    any column of the table.

  RETURN
    0  ok
    1  If we can't get the privileges and we don't use table/column grants.

    save_priv	In this we store global and db level grants for the table
		Note that we don't store db level grants if the global grants
unknown's avatar
unknown committed
4580 4581
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
unknown's avatar
unknown committed
4582 4583 4584
****************************************************************************/

bool
unknown's avatar
unknown committed
4585
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
4586
	     bool dont_check_global_grants, bool no_errors)
unknown's avatar
unknown committed
4587
{
unknown's avatar
unknown committed
4588 4589
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
unknown's avatar
unknown committed
4590
  bool  db_is_pattern= test(want_access & GRANT_ACL);
unknown's avatar
unknown committed
4591 4592
#endif
  ulong dummy;
4593 4594 4595
  DBUG_ENTER("check_access");
  DBUG_PRINT("enter",("db: %s  want_access: %lu  master_access: %lu",
                      db ? db : "", want_access, thd->master_access));
unknown's avatar
unknown committed
4596 4597 4598 4599 4600
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

4601
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
unknown's avatar
unknown committed
4602
  {
4603
    DBUG_PRINT("error",("No database"));
4604
    if (!no_errors)
unknown's avatar
unknown committed
4605 4606
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                 MYF(0));                       /* purecov: tested */
unknown's avatar
unknown committed
4607
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
4608 4609
  }

unknown's avatar
unknown committed
4610 4611 4612
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
unknown's avatar
unknown committed
4613 4614
  if ((thd->master_access & want_access) == want_access)
  {
4615 4616 4617 4618 4619 4620 4621
    /*
      If we don't have a global SELECT privilege, we have to get the database
      specific access rights to be able to handle queries of type
      UPDATE t1 SET a=1 WHERE b > 0
    */
    db_access= thd->db_access;
    if (!(thd->master_access & SELECT_ACL) &&
unknown's avatar
unknown committed
4622
	(db && (!thd->db || db_is_pattern || strcmp(db,thd->db))))
unknown's avatar
unknown committed
4623
      db_access=acl_get(thd->host, thd->ip, thd->priv_user, db, db_is_pattern);
4624
    *save_priv=thd->master_access | db_access;
unknown's avatar
unknown committed
4625
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
4626
  }
4627
  if (((want_access & ~thd->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
4628
      ! db && dont_check_global_grants)
unknown's avatar
unknown committed
4629
  {						// We can never grant this
4630
    DBUG_PRINT("error",("No possible access"));
4631
    if (!no_errors)
4632 4633 4634 4635 4636 4637
      my_error(ER_ACCESS_DENIED_ERROR, MYF(0),
               thd->priv_user,
               thd->priv_host,
               (thd->password ?
                ER(ER_YES) :
                ER(ER_NO)));                    /* purecov: tested */
unknown's avatar
unknown committed
4638
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
4639 4640 4641
  }

  if (db == any_db)
unknown's avatar
unknown committed
4642
    DBUG_RETURN(FALSE);				// Allow select on anything
unknown's avatar
unknown committed
4643

unknown's avatar
unknown committed
4644
  if (db && (!thd->db || db_is_pattern || strcmp(db,thd->db)))
unknown's avatar
unknown committed
4645
    db_access=acl_get(thd->host, thd->ip, thd->priv_user, db, db_is_pattern);
unknown's avatar
unknown committed
4646 4647
  else
    db_access=thd->db_access;
4648
  DBUG_PRINT("info",("db_access: %lu", db_access));
unknown's avatar
unknown committed
4649
  /* Remove SHOW attribute and access rights we already have */
4650
  want_access &= ~(thd->master_access | EXTRA_ACL);
4651 4652
  DBUG_PRINT("info",("db_access: %lu  want_access: %lu",
                     db_access, want_access));
unknown's avatar
unknown committed
4653
  db_access= ((*save_priv=(db_access | thd->master_access)) & want_access);
4654 4655

  /* grant_option is set if there exists a single table or column grant */
unknown's avatar
unknown committed
4656
  if (db_access == want_access ||
4657
      (grant_option && !dont_check_global_grants &&
4658
       !(want_access & ~(db_access | TABLE_ACLS | PROC_ACLS))))
unknown's avatar
unknown committed
4659
    DBUG_RETURN(FALSE);				/* Ok */
4660 4661

  DBUG_PRINT("error",("Access denied"));
4662
  if (!no_errors)
4663 4664 4665 4666 4667 4668
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0),
             thd->priv_user,
             thd->priv_host,
             (db ? db : (thd->db ?
                         thd->db :
                         "unknown")));          /* purecov: tested */
unknown's avatar
unknown committed
4669
  DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
4670
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
4671 4672 4673
}


4674 4675 4676 4677 4678 4679 4680 4681 4682
/*
  check for global access and give descriptive error message if it fails

  SYNOPSIS
    check_global_access()
    thd			Thread handler
    want_access		Use should have any of these global rights

  WARNING
4683
    One gets access right if one has ANY of the rights in want_access
4684 4685 4686 4687 4688 4689 4690 4691
    This is useful as one in most cases only need one global right,
    but in some case we want to check if the user has SUPER or
    REPL_CLIENT_ACL rights.

  RETURN
    0	ok
    1	Access denied.  In this case an error is sent to the client
*/
unknown's avatar
unknown committed
4692 4693

bool check_global_access(THD *thd, ulong want_access)
unknown's avatar
unknown committed
4694
{
unknown's avatar
unknown committed
4695 4696 4697
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
unknown's avatar
unknown committed
4698
  char command[128];
4699
  if ((thd->master_access & want_access))
unknown's avatar
unknown committed
4700 4701
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
4702
  my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), command);
unknown's avatar
unknown committed
4703
  return 1;
unknown's avatar
unknown committed
4704
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
4705 4706 4707
}


unknown's avatar
unknown committed
4708
/*
unknown's avatar
unknown committed
4709 4710
  Check the privilege for all used tables.  Table privileges are cached
  in the table list for GRANT checking
unknown's avatar
unknown committed
4711 4712
*/

4713
bool
unknown's avatar
unknown committed
4714
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
4715
		   bool no_errors)
unknown's avatar
unknown committed
4716
{
unknown's avatar
unknown committed
4717 4718
  uint found=0;
  ulong found_access=0;
unknown's avatar
unknown committed
4719
  TABLE_LIST *org_tables=tables;
unknown's avatar
VIEW  
unknown committed
4720
  for (; tables; tables= tables->next_global)
unknown's avatar
unknown committed
4721
  {
4722
    if (tables->derived || tables->schema_table || tables->belong_to_view ||
4723
        (tables->table && (int)tables->table->s->tmp_table) ||
4724 4725
        my_tz_check_n_skip_implicit_tables(&tables,
                                           thd->lex->time_zone_tables_used))
unknown's avatar
unknown committed
4726
      continue;
unknown's avatar
unknown committed
4727 4728
    if ((thd->master_access & want_access) == (want_access & ~EXTRA_ACL) &&
	thd->db)
unknown's avatar
unknown committed
4729
      tables->grant.privilege= want_access;
unknown's avatar
unknown committed
4730
    else if (tables->db && tables->db == thd->db)
unknown's avatar
unknown committed
4731 4732 4733 4734 4735
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
4736 4737
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
			 0, no_errors))
unknown's avatar
unknown committed
4738 4739
	  return TRUE;				// Access denied
	found_access=tables->grant.privilege;
unknown's avatar
unknown committed
4740
	found=1;
unknown's avatar
unknown committed
4741 4742
      }
    }
4743
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
4744
			  0, no_errors))
4745
      return TRUE;
unknown's avatar
unknown committed
4746 4747
  }
  if (grant_option)
4748
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
unknown's avatar
unknown committed
4749
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
unknown's avatar
unknown committed
4750 4751 4752
  return FALSE;
}

4753

4754 4755 4756 4757 4758 4759 4760 4761
bool
check_procedure_access(THD *thd, ulong want_access,char *db, char *name,
		       bool no_errors)
{
  TABLE_LIST tables[1];
  
  bzero((char *)tables, sizeof(TABLE_LIST));
  tables->db= db;
4762
  tables->table_name= tables->alias= name;
4763 4764 4765 4766 4767 4768 4769
  
  if ((thd->master_access & want_access) == want_access && !thd->db)
    tables->grant.privilege= want_access;
  else if (check_access(thd,want_access,db,&tables->grant.privilege,
			0, no_errors))
    return TRUE;
  
unknown's avatar
unknown committed
4770
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4771 4772
  if (grant_option)
    return check_grant_procedure(thd, want_access, tables, no_errors);
unknown's avatar
unknown committed
4773
#endif
4774 4775 4776 4777

  return FALSE;
}

4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792

/*
  Check if the routine has any of the routine privileges

  SYNOPSIS
    check_some_routine_access()
    thd		 Thread handler
    db           Database name
    name         Routine name

  RETURN
    0            ok
    1            error
*/

4793
bool check_some_routine_access(THD *thd, const char *db, const char *name)
4794 4795 4796 4797 4798 4799 4800
{
  ulong save_priv;
  if (thd->master_access & SHOW_PROC_ACLS)
    return FALSE;
  if (!check_access(thd, SHOW_PROC_ACLS, db, &save_priv, 0, 1) ||
      (save_priv & SHOW_PROC_ACLS))
    return FALSE;
4801
  return check_routine_level_acl(thd, db, name);
4802 4803 4804
}


4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839
/*
  Check if the given table has any of the asked privileges

  SYNOPSIS
    check_some_access()
    thd		 Thread handler
    want_access	 Bitmap of possible privileges to check for

  RETURN
    0  ok
    1  error
*/


bool check_some_access(THD *thd, ulong want_access, TABLE_LIST *table)
{
  ulong access;
  DBUG_ENTER("check_some_access");

  /* This loop will work as long as we have less than 32 privileges */
  for (access= 1; access < want_access ; access<<= 1)
  {
    if (access & want_access)
    {
      if (!check_access(thd, access, table->db,
                        &table->grant.privilege, 0, 1) &&
          !grant_option || !check_grant(thd, access, table, 0, 1, 1))
        DBUG_RETURN(0);
    }
  }
  DBUG_PRINT("exit",("no matching access rights"));
  DBUG_RETURN(1);
}


4840 4841
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
4842 4843 4844 4845
{
  int error=0;
  if (table_list)
  {
4846
    /* Check that all tables use the current database */
4847
    TABLE_LIST *tmp;
unknown's avatar
VIEW  
unknown committed
4848
    for (tmp= table_list; tmp; tmp= tmp->next_local)
4849 4850 4851 4852
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
4853
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
unknown's avatar
unknown committed
4854
			     table_list,0);
4855 4856 4857 4858
  }
  return error;
}

unknown's avatar
unknown committed
4859 4860 4861

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
unknown's avatar
VIEW  
unknown committed
4862
  for (; tables; tables= tables->next_global)
unknown's avatar
unknown committed
4863 4864 4865 4866 4867
  {
    if (!tables->db)
    {
      if (!(tables->db=thd->db))
      {
unknown's avatar
unknown committed
4868 4869
	my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR),
                   MYF(0));                     /* purecov: tested */
unknown's avatar
unknown committed
4870 4871 4872 4873 4874 4875
	return TRUE;				/* purecov: tested */
      }
    }
  }
  return FALSE;
}
4876

4877

unknown's avatar
unknown committed
4878 4879 4880 4881 4882 4883 4884 4885 4886 4887
/****************************************************************************
	Check stack size; Send error if there isn't enough stack to continue
****************************************************************************/

#if STACK_DIRECTION < 0
#define used_stack(A,B) (long) (A - B)
#else
#define used_stack(A,B) (long) (B - A)
#endif

unknown's avatar
unknown committed
4888 4889 4890 4891
#ifndef DBUG_OFF
long max_stack_used;
#endif

4892
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
4893 4894 4895 4896 4897 4898 4899 4900
bool check_stack_overrun(THD *thd,char *buf __attribute__((unused)))
{
  long stack_used;
  if ((stack_used=used_stack(thd->thread_stack,(char*) &stack_used)) >=
      (long) thread_stack_min)
  {
    sprintf(errbuff[0],ER(ER_STACK_OVERRUN),stack_used,thread_stack);
    my_message(ER_STACK_OVERRUN,errbuff[0],MYF(0));
4901
    thd->fatal_error();
unknown's avatar
unknown committed
4902 4903
    return 1;
  }
unknown's avatar
unknown committed
4904 4905 4906
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
unknown's avatar
unknown committed
4907 4908
  return 0;
}
4909
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
4910 4911 4912 4913

#define MY_YACC_INIT 1000			// Start with big alloc
#define MY_YACC_MAX  32000			// Because of 'short'

4914
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
unknown's avatar
unknown committed
4915 4916
{
  LEX	*lex=current_lex;
4917
  ulong old_info=0;
unknown's avatar
unknown committed
4918 4919 4920 4921 4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943
  if ((uint) *yystacksize >= MY_YACC_MAX)
    return 1;
  if (!lex->yacc_yyvs)
    old_info= *yystacksize;
  *yystacksize= set_zone((*yystacksize)*2,MY_YACC_INIT,MY_YACC_MAX);
  if (!(lex->yacc_yyvs= (char*)
	my_realloc((gptr) lex->yacc_yyvs,
		   *yystacksize*sizeof(**yyvs),
		   MYF(MY_ALLOW_ZERO_PTR | MY_FREE_ON_ERROR))) ||
      !(lex->yacc_yyss= (char*)
	my_realloc((gptr) lex->yacc_yyss,
		   *yystacksize*sizeof(**yyss),
		   MYF(MY_ALLOW_ZERO_PTR | MY_FREE_ON_ERROR))))
    return 1;
  if (old_info)
  {						// Copy old info from stack
    memcpy(lex->yacc_yyss, (gptr) *yyss, old_info*sizeof(**yyss));
    memcpy(lex->yacc_yyvs, (gptr) *yyvs, old_info*sizeof(**yyvs));
  }
  *yyss=(short*) lex->yacc_yyss;
  *yyvs=(YYSTYPE*) lex->yacc_yyvs;
  return 0;
}


/****************************************************************************
4944
  Initialize global thd variables needed for query
unknown's avatar
unknown committed
4945 4946
****************************************************************************/

4947
void
unknown's avatar
unknown committed
4948
mysql_init_query(THD *thd, uchar *buf, uint length)
unknown's avatar
unknown committed
4949 4950
{
  DBUG_ENTER("mysql_init_query");
unknown's avatar
unknown committed
4951
  lex_start(thd, buf, length);
4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972
  mysql_reset_thd_for_next_command(thd);
  DBUG_VOID_RETURN;
}


/*
 Reset THD part responsible for command processing state.

 DESCRIPTION
   This needs to be called before execution of every statement
   (prepared or conventional).

 TODO
   Make it a method of THD and align its name with the rest of
   reset/end/start/init methods.
   Call it after we use THD for queries, not before.
*/

void mysql_reset_thd_for_next_command(THD *thd)
{
  DBUG_ENTER("mysql_reset_thd_for_next_command");
4973
  thd->free_list= 0;
4974
  thd->select_number= 1;
unknown's avatar
unknown committed
4975
  thd->total_warn_count=0;			// Warnings for this query
unknown's avatar
unknown committed
4976 4977
  thd->last_insert_id_used= thd->query_start_used= thd->insert_id_used=0;
  thd->sent_row_count= thd->examined_row_count= 0;
4978
  thd->is_fatal_error= thd->rand_used= thd->time_zone_used= 0;
unknown's avatar
unknown committed
4979
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
unknown's avatar
unknown committed
4980 4981
                          SERVER_QUERY_NO_INDEX_USED |
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
unknown's avatar
unknown committed
4982
  thd->tmp_table_used= 0;
unknown's avatar
unknown committed
4983 4984
  if (opt_bin_log)
    reset_dynamic(&thd->user_var_events);
4985
  thd->clear_error();
unknown's avatar
unknown committed
4986 4987 4988
  DBUG_VOID_RETURN;
}

4989

4990 4991 4992
void
mysql_init_select(LEX *lex)
{
unknown's avatar
unknown committed
4993
  SELECT_LEX *select_lex= lex->current_select;
unknown's avatar
unknown committed
4994
  select_lex->init_select();
4995
  select_lex->select_limit= HA_POS_ERROR;
4996 4997
  lex->orig_sql_command= SQLCOM_END;
  lex->wild= 0;
4998 4999
  if (select_lex == &lex->select_lex)
  {
5000
    DBUG_ASSERT(lex->result == 0);
5001 5002
    lex->exchange= 0;
  }
5003 5004
}

5005

unknown's avatar
unknown committed
5006
bool
unknown's avatar
unknown committed
5007
mysql_new_select(LEX *lex, bool move_down)
5008
{
unknown's avatar
unknown committed
5009
  SELECT_LEX *select_lex;
unknown's avatar
unknown committed
5010 5011
  DBUG_ENTER("mysql_new_select");

unknown's avatar
unknown committed
5012
  if (!(select_lex= new(lex->thd->mem_root) SELECT_LEX()))
unknown's avatar
unknown committed
5013
    DBUG_RETURN(1);
5014
  select_lex->select_number= ++lex->thd->select_number;
unknown's avatar
unknown committed
5015 5016
  select_lex->init_query();
  select_lex->init_select();
unknown's avatar
VIEW  
unknown committed
5017
  select_lex->parent_lex= lex;
unknown's avatar
unknown committed
5018 5019
  if (move_down)
  {
unknown's avatar
unknown committed
5020
    SELECT_LEX_UNIT *unit;
5021
    lex->subqueries= TRUE;
unknown's avatar
unknown committed
5022
    /* first select_lex of subselect or derived table */
unknown's avatar
unknown committed
5023
    if (!(unit= new(lex->thd->mem_root) SELECT_LEX_UNIT()))
unknown's avatar
unknown committed
5024
      DBUG_RETURN(1);
unknown's avatar
unknown committed
5025

unknown's avatar
unknown committed
5026 5027
    unit->init_query();
    unit->init_select();
5028
    unit->thd= lex->thd;
unknown's avatar
unknown committed
5029
    unit->include_down(lex->current_select);
unknown's avatar
unknown committed
5030 5031
    unit->link_next= 0;
    unit->link_prev= 0;
5032
    unit->return_to= lex->current_select;
unknown's avatar
unknown committed
5033
    select_lex->include_down(unit);
unknown's avatar
unknown committed
5034
    /* TODO: assign resolve_mode for fake subquery after merging with new tree */
unknown's avatar
unknown committed
5035 5036
  }
  else
unknown's avatar
unknown committed
5037
  {
unknown's avatar
VIEW  
unknown committed
5038 5039
    if (lex->current_select->order_list.first && !lex->current_select->braces)
    {
unknown's avatar
unknown committed
5040
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "ORDER BY");
unknown's avatar
unknown committed
5041
      DBUG_RETURN(1);
unknown's avatar
VIEW  
unknown committed
5042
    }
5043
    select_lex->include_neighbour(lex->current_select);
unknown's avatar
unknown committed
5044 5045 5046 5047 5048 5049 5050 5051
    SELECT_LEX_UNIT *unit= select_lex->master_unit();
    SELECT_LEX *fake= unit->fake_select_lex;
    if (!fake)
    {
      /*
	as far as we included SELECT_LEX for UNION unit should have
	fake SELECT_LEX for UNION processing
      */
unknown's avatar
unknown committed
5052
      if (!(fake= unit->fake_select_lex= new(lex->thd->mem_root) SELECT_LEX()))
unknown's avatar
unknown committed
5053
        DBUG_RETURN(1);
unknown's avatar
unknown committed
5054 5055 5056 5057 5058
      fake->include_standalone(unit,
			       (SELECT_LEX_NODE**)&unit->fake_select_lex);
      fake->select_number= INT_MAX;
      fake->make_empty_select();
      fake->linkage= GLOBAL_OPTIONS_TYPE;
5059
      fake->select_limit= HA_POS_ERROR;
unknown's avatar
unknown committed
5060 5061
    }
  }
unknown's avatar
unknown committed
5062

5063
  select_lex->master_unit()->global_parameters= select_lex;
5064
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
5065
  lex->current_select= select_lex;
5066
  select_lex->resolve_mode= SELECT_LEX::SELECT_MODE;
unknown's avatar
unknown committed
5067
  DBUG_RETURN(0);
5068
}
unknown's avatar
unknown committed
5069

5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084
/*
  Create a select to return the same output as 'SELECT @@var_name'.

  SYNOPSIS
    create_select_for_variable()
    var_name		Variable name

  DESCRIPTION
    Used for SHOW COUNT(*) [ WARNINGS | ERROR]

    This will crash with a core dump if the variable doesn't exists
*/

void create_select_for_variable(const char *var_name)
{
5085
  THD *thd;
5086
  LEX *lex;
5087
  LEX_STRING tmp, null_lex_string;
5088
  DBUG_ENTER("create_select_for_variable");
5089 5090

  thd= current_thd;
unknown's avatar
unknown committed
5091
  lex= thd->lex;
5092 5093 5094 5095
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
5096 5097 5098
  bzero((char*) &null_lex_string.str, sizeof(null_lex_string));
  add_item_to_list(thd, get_system_var(thd, OPT_SESSION, tmp,
				       null_lex_string));
5099 5100 5101
  DBUG_VOID_RETURN;
}

5102

unknown's avatar
unknown committed
5103 5104
void mysql_init_multi_delete(LEX *lex)
{
unknown's avatar
unknown committed
5105
  lex->sql_command=  SQLCOM_DELETE_MULTI;
unknown's avatar
unknown committed
5106
  mysql_init_select(lex);
5107
  lex->select_lex.select_limit= lex->unit.select_limit_cnt=
unknown's avatar
unknown committed
5108
    HA_POS_ERROR;
unknown's avatar
unknown committed
5109
  lex->select_lex.table_list.save_and_clear(&lex->auxilliary_table_list);
unknown's avatar
VIEW  
unknown committed
5110 5111
  lex->query_tables= 0;
  lex->query_tables_last= &lex->query_tables;
unknown's avatar
unknown committed
5112
}
unknown's avatar
unknown committed
5113

5114

5115 5116 5117 5118
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
unknown's avatar
unknown committed
5119

5120
void mysql_parse(THD *thd, char *inBuf, uint length)
unknown's avatar
unknown committed
5121 5122 5123
{
  DBUG_ENTER("mysql_parse");

unknown's avatar
unknown committed
5124
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
5125
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
unknown's avatar
unknown committed
5126
  {
unknown's avatar
unknown committed
5127
    LEX *lex= thd->lex;
5128
    if (!yyparse((void *)thd) && ! thd->is_fatal_error)
unknown's avatar
unknown committed
5129
    {
unknown's avatar
unknown committed
5130
#ifndef NO_EMBEDDED_ACCESS_CHECKS
5131
      if (mqh_used && thd->user_connect &&
5132
	  check_mqh(thd, lex->sql_command))
5133 5134 5135 5136
      {
	thd->net.error = 0;
      }
      else
unknown's avatar
unknown committed
5137
#endif
5138
      {
unknown's avatar
unknown committed
5139
	if (thd->net.report_error)
5140 5141
	{
	  if (thd->lex->sphead)
5142 5143 5144 5145
	  {
	    delete thd->lex->sphead;
	    thd->lex->sphead= NULL;
	  }
5146
	}
unknown's avatar
unknown committed
5147 5148
	else
	{
5149 5150 5151 5152 5153 5154 5155 5156 5157 5158
          /*
            Binlog logs a string starting from thd->query and having length
            thd->query_length; so we set thd->query_length correctly (to not
            log several statements in one event, when we executed only first).
            We set it to not see the ';' (otherwise it would get into binlog
            and Query_log_event::print() would give ';;' output).
            This also helps display only the current query in SHOW
            PROCESSLIST.
            Note that we don't need LOCK_thread_count to modify query_length.
          */
unknown's avatar
unknown committed
5159 5160
          if (lex->found_semicolon &&
              (thd->query_length= (ulong)(lex->found_semicolon - thd->query)))
5161 5162
            thd->query_length--;
          /* Actually execute the query */
unknown's avatar
unknown committed
5163
	  mysql_execute_command(thd);
unknown's avatar
SCRUM  
unknown committed
5164
	  query_cache_end_of_result(thd);
unknown's avatar
unknown committed
5165
	}
5166
      }
5167
      lex->unit.cleanup();
unknown's avatar
unknown committed
5168 5169
    }
    else
5170 5171
    {
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
5172
			 thd->is_fatal_error));
unknown's avatar
unknown committed
5173
      query_cache_abort(&thd->net);
5174
      lex->unit.cleanup();
5175
      if (thd->lex->sphead)
5176
      {
unknown's avatar
unknown committed
5177
	/* Clean up after failed stored procedure/function */
5178 5179 5180
	delete thd->lex->sphead;
	thd->lex->sphead= NULL;
      }
5181
    }
unknown's avatar
unknown committed
5182
    thd->proc_info="freeing items";
5183
    thd->end_statement();
5184
    thd->cleanup_after_query();
5185
    DBUG_ASSERT(thd->change_list.is_empty());
unknown's avatar
unknown committed
5186
  }
unknown's avatar
unknown committed
5187 5188 5189 5190
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
5191
#ifdef HAVE_REPLICATION
5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202
/*
  Usable by the replication SQL thread only: just parse a query to know if it
  can be ignored because of replicate-*-table rules.

  RETURN VALUES
    0	cannot be ignored
    1	can be ignored
*/

bool mysql_test_parse_for_slave(THD *thd, char *inBuf, uint length)
{
unknown's avatar
unknown committed
5203
  LEX *lex= thd->lex;
5204
  bool error= 0;
unknown's avatar
unknown committed
5205
  DBUG_ENTER("mysql_test_parse_for_slave");
5206

unknown's avatar
unknown committed
5207
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
5208
  if (!yyparse((void*) thd) && ! thd->is_fatal_error &&
5209
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
unknown's avatar
unknown committed
5210
    error= 1;                  /* Ignore question */
5211
  thd->end_statement();
5212
  thd->cleanup_after_query();
unknown's avatar
unknown committed
5213
  DBUG_RETURN(error);
5214
}
unknown's avatar
unknown committed
5215
#endif
unknown's avatar
unknown committed
5216

5217

unknown's avatar
unknown committed
5218

unknown's avatar
unknown committed
5219 5220 5221 5222 5223
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

unknown's avatar
unknown committed
5224
bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
unknown's avatar
unknown committed
5225
		       char *length, char *decimals,
5226
		       uint type_modifier,
5227 5228
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
5229 5230
		       char *change,
                       List<String> *interval_list, CHARSET_INFO *cs,
unknown's avatar
unknown committed
5231
		       uint uint_geom_type)
unknown's avatar
unknown committed
5232 5233
{
  register create_field *new_field;
unknown's avatar
unknown committed
5234
  LEX  *lex= thd->lex;
unknown's avatar
unknown committed
5235 5236 5237 5238
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
5239
    my_error(ER_TOO_LONG_IDENT, MYF(0), field_name); /* purecov: inspected */
unknown's avatar
unknown committed
5240 5241 5242 5243 5244
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
5245
    lex->key_list.push_back(new Key(Key::PRIMARY, NullS, HA_KEY_ALG_UNDEF,
5246
				    0, lex->col_list));
unknown's avatar
unknown committed
5247 5248 5249 5250 5251
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
5252
    lex->key_list.push_back(new Key(Key::UNIQUE, NullS, HA_KEY_ALG_UNDEF, 0,
unknown's avatar
unknown committed
5253 5254 5255 5256
				    lex->col_list));
    lex->col_list.empty();
  }

5257
  if (default_value)
unknown's avatar
unknown committed
5258
  {
5259
    /* 
unknown's avatar
unknown committed
5260 5261
      Default value should be literal => basic constants =>
      no need fix_fields()
5262 5263 5264
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
5265
    */
5266 5267 5268
    if (default_value->type() == Item::FUNC_ITEM && 
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
         type == FIELD_TYPE_TIMESTAMP))
5269
    {
5270
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
5271 5272 5273
      DBUG_RETURN(1);
    }
    else if (default_value->type() == Item::NULL_ITEM)
unknown's avatar
unknown committed
5274
    {
5275
      default_value= 0;
5276 5277 5278
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
5279
	my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
5280 5281 5282 5283 5284
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
5285
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name);
unknown's avatar
unknown committed
5286 5287 5288
      DBUG_RETURN(1);
    }
  }
5289 5290 5291

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
5292
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name);
5293 5294
    DBUG_RETURN(1);
  }
unknown's avatar
unknown committed
5295 5296 5297 5298

  if (!(new_field= new_create_field(thd, field_name, type, length, decimals,
		type_modifier, default_value, on_update_value,
		comment, change, interval_list, cs, uint_geom_type)))
unknown's avatar
unknown committed
5299
    DBUG_RETURN(1);
unknown's avatar
unknown committed
5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326

  lex->create_list.push_back(new_field);
  lex->last_field=new_field;
  DBUG_RETURN(0);
}

/*****************************************************************************
** Create field definition for create
** Return 0 on failure, otherwise return create_field instance
******************************************************************************/
  
create_field *
new_create_field(THD *thd, char *field_name, enum_field_types type,
		 char *length, char *decimals,
		 uint type_modifier, 
		 Item *default_value, Item *on_update_value,
		 LEX_STRING *comment,
		 char *change, List<String> *interval_list, CHARSET_INFO *cs,
		 uint uint_geom_type)
{
  register create_field *new_field;
  uint sign_len, allowed_type_modifier=0;
  ulong max_field_charlength= MAX_FIELD_CHARLENGTH;
  DBUG_ENTER("new_create_field");
  
  if (!(new_field=new create_field()))
    DBUG_RETURN(NULL);
unknown's avatar
unknown committed
5327 5328
  new_field->field=0;
  new_field->field_name=field_name;
5329
  new_field->def= default_value;
unknown's avatar
unknown committed
5330 5331 5332 5333 5334 5335 5336 5337 5338
  new_field->flags= type_modifier;
  new_field->unireg_check= (type_modifier & AUTO_INCREMENT_FLAG ?
			    Field::NEXT_NUMBER : Field::NONE);
  new_field->decimals= decimals ? (uint) set_zone(atoi(decimals),0,
						  NOT_FIXED_DEC-1) : 0;
  new_field->sql_type=type;
  new_field->length=0;
  new_field->change=change;
  new_field->interval=0;
5339
  new_field->pack_length= new_field->key_length= 0;
5340
  new_field->charset=cs;
unknown's avatar
unknown committed
5341
  new_field->geom_type= (Field::geometry_type) uint_geom_type;
unknown's avatar
unknown committed
5342

5343
  new_field->comment=*comment;
unknown's avatar
unknown committed
5344 5345 5346 5347 5348
  /*
    Set flag if this field doesn't have a default value
    Enum values has always the first value as a default (set in
    make_empty_rec().
  */
unknown's avatar
unknown committed
5349
  if (!default_value && !(type_modifier & AUTO_INCREMENT_FLAG) &&
unknown's avatar
unknown committed
5350 5351
      (type_modifier & NOT_NULL_FLAG) && type != FIELD_TYPE_TIMESTAMP &&
      type != FIELD_TYPE_ENUM)
unknown's avatar
unknown committed
5352 5353
    new_field->flags|= NO_DEFAULT_VALUE_FLAG;

5354 5355
  if (length && !(new_field->length= (uint) atoi(length)))
    length=0; /* purecov: inspected */
unknown's avatar
unknown committed
5356
  sign_len=type_modifier & UNSIGNED_FLAG ? 0 : 1;
unknown's avatar
unknown committed
5357 5358

  if (new_field->length && new_field->decimals &&
5359
      new_field->length < new_field->decimals+1 &&
unknown's avatar
unknown committed
5360
      new_field->decimals != NOT_FIXED_DEC)
5361
    new_field->length=new_field->decimals+1; /* purecov: inspected */
unknown's avatar
unknown committed
5362 5363 5364

  switch (type) {
  case FIELD_TYPE_TINY:
5365
    if (!length) new_field->length=MAX_TINYINT_WIDTH+sign_len;
unknown's avatar
unknown committed
5366 5367 5368
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_SHORT:
5369
    if (!length) new_field->length=MAX_SMALLINT_WIDTH+sign_len;
unknown's avatar
unknown committed
5370 5371 5372
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_INT24:
5373
    if (!length) new_field->length=MAX_MEDIUMINT_WIDTH+sign_len;
unknown's avatar
unknown committed
5374 5375 5376
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONG:
5377
    if (!length) new_field->length=MAX_INT_WIDTH+sign_len;
unknown's avatar
unknown committed
5378 5379 5380
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONGLONG:
5381
    if (!length) new_field->length=MAX_BIGINT_WIDTH;
unknown's avatar
unknown committed
5382 5383 5384 5385
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_NULL:
    break;
unknown's avatar
unknown committed
5386
  case FIELD_TYPE_NEWDECIMAL:
unknown's avatar
unknown committed
5387
    if (!length)
unknown's avatar
unknown committed
5388
    {
unknown's avatar
unknown committed
5389
      if (!(new_field->length= new_field->decimals))
unknown's avatar
unknown committed
5390 5391
        new_field->length= 10;                  // Default length for DECIMAL
    }
unknown's avatar
unknown committed
5392 5393 5394 5395 5396 5397
    new_field->pack_length=
      my_decimal_get_binary_size(new_field->length, new_field->decimals);
    if (new_field->length <= DECIMAL_MAX_LENGTH &&
        new_field->length >= new_field->decimals)
      break;
    my_error(ER_WRONG_FIELD_SPEC, MYF(0), field_name);
unknown's avatar
unknown committed
5398
    DBUG_RETURN(NULL);
5399 5400 5401 5402 5403 5404 5405 5406 5407
  case MYSQL_TYPE_VARCHAR:
    /*
      Long VARCHAR's are automaticly converted to blobs in mysql_prepare_table
      if they don't have a default value
    */
    max_field_charlength= MAX_FIELD_VARCHARLENGTH;
    break;
  case MYSQL_TYPE_STRING:
    break;
unknown's avatar
unknown committed
5408 5409 5410 5411
  case FIELD_TYPE_BLOB:
  case FIELD_TYPE_TINY_BLOB:
  case FIELD_TYPE_LONG_BLOB:
  case FIELD_TYPE_MEDIUM_BLOB:
unknown's avatar
unknown committed
5412
  case FIELD_TYPE_GEOMETRY:
unknown's avatar
unknown committed
5413 5414 5415 5416 5417 5418
    if (default_value)				// Allow empty as default value
    {
      String str,*res;
      res=default_value->val_str(&str);
      if (res->length())
      {
5419 5420
	my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0),
                 field_name); /* purecov: inspected */
unknown's avatar
unknown committed
5421
	DBUG_RETURN(NULL);
unknown's avatar
unknown committed
5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439
      }
      new_field->def=0;
    }
    new_field->flags|=BLOB_FLAG;
    break;
  case FIELD_TYPE_YEAR:
    if (!length || new_field->length != 2)
      new_field->length=4;			// Default length
    new_field->flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
    break;
  case FIELD_TYPE_FLOAT:
    /* change FLOAT(precision) to FLOAT or DOUBLE */
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    if (length && !decimals)
    {
      uint tmp_length=new_field->length;
      if (tmp_length > PRECISION_FOR_DOUBLE)
      {
5440
	my_error(ER_WRONG_FIELD_SPEC, MYF(0), field_name);
unknown's avatar
unknown committed
5441
	DBUG_RETURN(NULL);
unknown's avatar
unknown committed
5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469
      }
      else if (tmp_length > PRECISION_FOR_FLOAT)
      {
	new_field->sql_type=FIELD_TYPE_DOUBLE;
	new_field->length=DBL_DIG+7;			// -[digits].E+###
      }
      else
	new_field->length=FLT_DIG+6;			// -[digits].E+##
      new_field->decimals= NOT_FIXED_DEC;
      break;
    }
    if (!length)
    {
      new_field->length =  FLT_DIG+6;
      new_field->decimals= NOT_FIXED_DEC;
    }
    break;
  case FIELD_TYPE_DOUBLE:
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    if (!length)
    {
      new_field->length = DBL_DIG+7;
      new_field->decimals=NOT_FIXED_DEC;
    }
    break;
  case FIELD_TYPE_TIMESTAMP:
    if (!length)
      new_field->length= 14;			// Full date YYYYMMDDHHMMSS
5470
    else if (new_field->length != 19)
unknown's avatar
unknown committed
5471
    {
5472 5473 5474 5475
      /*
        We support only even TIMESTAMP lengths less or equal than 14
        and 19 as length of 4.1 compatible representation.
      */
unknown's avatar
unknown committed
5476 5477 5478
      new_field->length=((new_field->length+1)/2)*2; /* purecov: inspected */
      new_field->length= min(new_field->length,14); /* purecov: inspected */
    }
5479
    new_field->flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499
    if (default_value)
    {
      /* Grammar allows only NOW() value for ON UPDATE clause */
      if (default_value->type() == Item::FUNC_ITEM && 
          ((Item_func*)default_value)->functype() == Item_func::NOW_FUNC)
      {
        new_field->unireg_check= (on_update_value?Field::TIMESTAMP_DNUN_FIELD:
                                                  Field::TIMESTAMP_DN_FIELD);
        /*
          We don't need default value any longer moreover it is dangerous.
          Everything handled by unireg_check further.
        */
        new_field->def= 0;
      }
      else
        new_field->unireg_check= (on_update_value?Field::TIMESTAMP_UN_FIELD:
                                                  Field::NONE);
    }
    else
    {
5500 5501 5502 5503 5504 5505 5506 5507
      /*
        If we have default TIMESTAMP NOT NULL column without explicit DEFAULT
        or ON UPDATE values then for the sake of compatiblity we should treat
        this column as having DEFAULT NOW() ON UPDATE NOW() (when we don't
        have another TIMESTAMP column with auto-set option before this one)
        or DEFAULT 0 (in other cases).
        So here we are setting TIMESTAMP_OLD_FIELD only temporary, and will
        replace this value by TIMESTAMP_DNUN_FIELD or NONE later when
5508
        information about all TIMESTAMP fields in table will be availiable.
5509 5510 5511

        If we have TIMESTAMP NULL column without explicit DEFAULT value
        we treat it as having DEFAULT NULL attribute.
5512
      */
unknown's avatar
unknown committed
5513 5514 5515 5516 5517
      new_field->unireg_check= (on_update_value ?
                                Field::TIMESTAMP_UN_FIELD :
                                (new_field->flags & NOT_NULL_FLAG ?
                                 Field::TIMESTAMP_OLD_FIELD:
                                 Field::NONE));
5518
    }
unknown's avatar
unknown committed
5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534
    break;
  case FIELD_TYPE_DATE:				// Old date type
    if (protocol_version != PROTOCOL_VERSION-1)
      new_field->sql_type=FIELD_TYPE_NEWDATE;
    /* fall trough */
  case FIELD_TYPE_NEWDATE:
    new_field->length=10;
    break;
  case FIELD_TYPE_TIME:
    new_field->length=10;
    break;
  case FIELD_TYPE_DATETIME:
    new_field->length=19;
    break;
  case FIELD_TYPE_SET:
    {
5535
      if (interval_list->elements > sizeof(longlong)*8)
unknown's avatar
unknown committed
5536
      {
5537
	my_error(ER_TOO_BIG_SET, MYF(0), field_name); /* purecov: inspected */
unknown's avatar
unknown committed
5538
	DBUG_RETURN(NULL);
unknown's avatar
unknown committed
5539
      }
5540
      new_field->pack_length= get_set_pack_length(interval_list->elements);
5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551

      List_iterator<String> it(*interval_list);
      String *tmp;
      while ((tmp= it++))
        new_field->interval_list.push_back(tmp);
      /*
        Set fake length to 1 to pass the below conditions.
        Real length will be set in mysql_prepare_table()
        when we know the character set of the column
      */
      new_field->length= 1;
unknown's avatar
unknown committed
5552
      break;
unknown's avatar
unknown committed
5553 5554 5555
    }
  case FIELD_TYPE_ENUM:
    {
5556
      // Should be safe
5557
      new_field->pack_length= get_enum_pack_length(interval_list->elements);
5558

5559 5560 5561 5562 5563
      List_iterator<String> it(*interval_list);
      String *tmp;
      while ((tmp= it++))
        new_field->interval_list.push_back(tmp);
      new_field->length= 1; // See comment for FIELD_TYPE_SET above.
unknown's avatar
unknown committed
5564
      break;
unknown's avatar
unknown committed
5565
   }
5566 5567
  case MYSQL_TYPE_VAR_STRING:
    DBUG_ASSERT(0);                             // Impossible
5568
    break;
unknown's avatar
unknown committed
5569 5570 5571 5572 5573 5574 5575 5576
  case MYSQL_TYPE_BIT:
    {
      if (!length)
        new_field->length= 1;
      if (new_field->length > MAX_BIT_FIELD_LENGTH)
      {
        my_error(ER_TOO_BIG_FIELDLENGTH, MYF(0), field_name,
                 MAX_BIT_FIELD_LENGTH);
unknown's avatar
unknown committed
5577
        DBUG_RETURN(NULL);
unknown's avatar
unknown committed
5578 5579 5580 5581
      }
      new_field->pack_length= (new_field->length + 7) / 8;
      break;
    }
unknown's avatar
unknown committed
5582 5583
  case FIELD_TYPE_DECIMAL:
    DBUG_ASSERT(0); /* Was obsolete */
unknown's avatar
unknown committed
5584 5585
  }

5586 5587 5588 5589 5590 5591 5592
  if (!(new_field->flags & BLOB_FLAG) &&
      ((new_field->length > max_field_charlength && type != FIELD_TYPE_SET && 
        type != FIELD_TYPE_ENUM &&
        (type != MYSQL_TYPE_VARCHAR || default_value)) ||
       (!new_field->length &&
        type != MYSQL_TYPE_STRING &&
        type != MYSQL_TYPE_VARCHAR && type != FIELD_TYPE_GEOMETRY)))
unknown's avatar
unknown committed
5593
  {
5594
    my_error(ER_TOO_BIG_FIELDLENGTH, MYF(0),
unknown's avatar
unknown committed
5595
             field_name, max_field_charlength); /* purecov: inspected */
unknown's avatar
unknown committed
5596
    DBUG_RETURN(NULL);
unknown's avatar
unknown committed
5597 5598 5599 5600
  }
  type_modifier&= AUTO_INCREMENT_FLAG;
  if ((~allowed_type_modifier) & type_modifier)
  {
5601
    my_error(ER_WRONG_FIELD_SPEC, MYF(0), field_name);
unknown's avatar
unknown committed
5602
    DBUG_RETURN(NULL);
unknown's avatar
unknown committed
5603
  }
unknown's avatar
unknown committed
5604
  DBUG_RETURN(new_field);
unknown's avatar
unknown committed
5605 5606
}

5607

unknown's avatar
unknown committed
5608 5609 5610 5611 5612 5613 5614 5615
/* Store position for column in ALTER TABLE .. ADD column */

void store_position_for_column(const char *name)
{
  current_lex->last_field->after=my_const_cast(char*) (name);
}

bool
unknown's avatar
unknown committed
5616
add_proc_to_list(THD* thd, Item *item)
unknown's avatar
unknown committed
5617 5618 5619 5620
{
  ORDER *order;
  Item	**item_ptr;

unknown's avatar
unknown committed
5621
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
unknown's avatar
unknown committed
5622 5623 5624 5625 5626
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
unknown's avatar
unknown committed
5627
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
5628 5629 5630 5631 5632 5633 5634 5635
  return 0;
}


/* Fix escaping of _, % and \ in database and table names (for ODBC) */

static void remove_escape(char *name)
{
5636 5637
  if (!*name)					// For empty DB names
    return;
unknown's avatar
unknown committed
5638 5639
  char *to;
#ifdef USE_MB
unknown's avatar
unknown committed
5640
  char *strend=name+(uint) strlen(name);
unknown's avatar
unknown committed
5641 5642 5643 5644 5645
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
5646 5647
    if (use_mb(system_charset_info) &&
        (l = my_ismbchar(system_charset_info, name, strend)))
unknown's avatar
unknown committed
5648 5649 5650 5651 5652 5653 5654 5655
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
unknown's avatar
unknown committed
5656
      name++;					// Skip '\\'
unknown's avatar
unknown committed
5657 5658 5659 5660 5661 5662 5663 5664 5665 5666
    *to++= *name;
  }
  *to=0;
}

/****************************************************************************
** save order by and tables in own lists
****************************************************************************/


unknown's avatar
unknown committed
5667
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
unknown's avatar
unknown committed
5668 5669 5670
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
unknown's avatar
unknown committed
5671
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
unknown's avatar
unknown committed
5672
    DBUG_RETURN(1);
unknown's avatar
unknown committed
5673 5674
  order->item_ptr= item;
  order->item= &order->item_ptr;
unknown's avatar
unknown committed
5675 5676 5677
  order->asc = asc;
  order->free_me=0;
  order->used=0;
5678
  order->counter_used= 0;
unknown's avatar
unknown committed
5679
  list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
5680 5681 5682 5683
  DBUG_RETURN(0);
}


unknown's avatar
unknown committed
5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702
/*
  Add a table to list of used tables

  SYNOPSIS
    add_table_to_list()
    table		Table to add
    alias		alias for table (or null if no alias)
    table_options	A set of the following bits:
			TL_OPTION_UPDATING	Table will be updated
			TL_OPTION_FORCE_INDEX	Force usage of index
    lock_type		How table should be locked
    use_index		List of indexed used in USE INDEX
    ignore_index	List of indexed used in IGNORE INDEX

    RETURN
      0		Error
      #		Pointer to TABLE_LIST element added to the total table list
*/

unknown's avatar
unknown committed
5703 5704
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
5705
					     LEX_STRING *alias,
unknown's avatar
unknown committed
5706 5707
					     ulong table_options,
					     thr_lock_type lock_type,
5708 5709
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
unknown's avatar
unknown committed
5710
                                             LEX_STRING *option)
unknown's avatar
unknown committed
5711 5712 5713
{
  register TABLE_LIST *ptr;
  char *alias_str;
5714
  LEX *lex= thd->lex;
unknown's avatar
unknown committed
5715 5716 5717 5718 5719
  DBUG_ENTER("add_table_to_list");

  if (!table)
    DBUG_RETURN(0);				// End of memory
  alias_str= alias ? alias->str : table->table.str;
unknown's avatar
unknown committed
5720
  if (check_table_name(table->table.str,table->table.length) ||
5721
      table->db.str && check_db_name(table->db.str))
unknown's avatar
unknown committed
5722
  {
5723
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
unknown's avatar
unknown committed
5724 5725 5726 5727
    DBUG_RETURN(0);
  }

  if (!alias)					/* Alias is case sensitive */
5728 5729 5730
  {
    if (table->sel)
    {
unknown's avatar
unknown committed
5731 5732
      my_message(ER_DERIVED_MUST_HAVE_ALIAS,
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
5733 5734
      DBUG_RETURN(0);
    }
5735
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
unknown's avatar
unknown committed
5736
      DBUG_RETURN(0);
5737
  }
unknown's avatar
unknown committed
5738
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
5739
    DBUG_RETURN(0);				/* purecov: inspected */
unknown's avatar
unknown committed
5740
  if (table->db.str)
5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751
  {
    ptr->db= table->db.str;
    ptr->db_length= table->db.length;
  }
  else if (thd->db)
  {
    ptr->db= thd->db;
    ptr->db_length= thd->db_length;
  }
  else
  {
5752 5753
    /* The following can't be "" as we may do 'casedn_str()' on it */
    ptr->db= empty_c_string;
5754 5755
    ptr->db_length= 0;
  }
5756 5757
  if (thd->current_arena->is_stmt_prepare())
    ptr->db= thd->strdup(ptr->db);
unknown's avatar
unknown committed
5758

5759
  ptr->alias= alias_str;
5760 5761
  if (lower_case_table_names && table->table.length)
    my_casedn_str(files_charset_info, table->table.str);
5762 5763
  ptr->table_name=table->table.str;
  ptr->table_name_length=table->table.length;
5764
  ptr->lock_type=   lock_type;
unknown's avatar
unknown committed
5765 5766
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
unknown's avatar
unknown committed
5767
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
5768
  ptr->derived=	    table->sel;
5769 5770 5771
  if (!my_strcasecmp(system_charset_info, ptr->db,
                     information_schema_name.str))
  {
5772
    ST_SCHEMA_TABLE *schema_table= find_schema_table(thd, ptr->table_name);
5773 5774 5775
    if (!schema_table ||
        (schema_table->hidden && 
         lex->orig_sql_command == SQLCOM_END))  // not a 'show' command
5776
    {
unknown's avatar
unknown committed
5777
      my_error(ER_UNKNOWN_TABLE, MYF(0),
5778
               ptr->table_name, information_schema_name.str);
5779 5780
      DBUG_RETURN(0);
    }
5781
    ptr->schema_table_name= ptr->table_name;
5782 5783
    ptr->schema_table= schema_table;
  }
5784
  ptr->select_lex=  lex->current_select;
unknown's avatar
unknown committed
5785
  ptr->cacheable_table= 1;
5786 5787 5788 5789 5790 5791
  if (use_index_arg)
    ptr->use_index=(List<String> *) thd->memdup((gptr) use_index_arg,
						sizeof(*use_index_arg));
  if (ignore_index_arg)
    ptr->ignore_index=(List<String> *) thd->memdup((gptr) ignore_index_arg,
						   sizeof(*ignore_index_arg));
unknown's avatar
unknown committed
5792
  ptr->option= option ? option->str : 0;
unknown's avatar
unknown committed
5793
  /* check that used name is unique */
5794
  if (lock_type != TL_IGNORE)
unknown's avatar
unknown committed
5795
  {
5796
    for (TABLE_LIST *tables=(TABLE_LIST*) table_list.first ;
unknown's avatar
unknown committed
5797
	 tables ;
unknown's avatar
VIEW  
unknown committed
5798
	 tables=tables->next_local)
unknown's avatar
unknown committed
5799
    {
5800 5801
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
unknown's avatar
unknown committed
5802
      {
5803
	my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str); /* purecov: tested */
unknown's avatar
unknown committed
5804 5805
	DBUG_RETURN(0);				/* purecov: tested */
      }
unknown's avatar
unknown committed
5806 5807
    }
  }
5808
  /* Link table in local list (list for current select) */
unknown's avatar
VIEW  
unknown committed
5809
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next_local);
5810
  /* Link table in global list (all used tables) */
5811
  lex->add_to_query_tables(ptr);
unknown's avatar
unknown committed
5812 5813 5814
  DBUG_RETURN(ptr);
}

unknown's avatar
unknown committed
5815

5816 5817 5818 5819
/*
  Initialize a new table list for a nested join

  SYNOPSIS
unknown's avatar
unknown committed
5820
    init_nested_join()
5821
    thd         current thread
5822

5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840 5841
  DESCRIPTION
    The function initializes a structure of the TABLE_LIST type
    for a nested join. It sets up its nested join list as empty.
    The created structure is added to the front of the current
    join list in the st_select_lex object. Then the function
    changes the current nest level for joins to refer to the newly
    created empty list after having saved the info on the old level
    in the initialized structure.

  RETURN VALUE
    0,  if success
    1,  otherwise
*/

bool st_select_lex::init_nested_join(THD *thd)
{
  TABLE_LIST *ptr;
  NESTED_JOIN *nested_join;
  DBUG_ENTER("init_nested_join");
5842

5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))) ||
      !(nested_join= ptr->nested_join=
                    (NESTED_JOIN *) thd->calloc(sizeof(NESTED_JOIN))))
    DBUG_RETURN(1);
  join_list->push_front(ptr);
  ptr->embedding= embedding;
  ptr->join_list= join_list;
  embedding= ptr;
  join_list= &nested_join->join_list;
  join_list->empty();
  DBUG_RETURN(0);
}


/*
  End a nested join table list

  SYNOPSIS
    end_nested_join()
    thd         current thread

  DESCRIPTION
    The function returns to the previous join nest level.
    If the current level contains only one member, the function
5867
    moves it one level up, eliminating the nest.
5868 5869 5870 5871 5872 5873 5874 5875 5876

  RETURN VALUE
    Pointer to TABLE_LIST element added to the total table list, if success
    0, otherwise
*/

TABLE_LIST *st_select_lex::end_nested_join(THD *thd)
{
  TABLE_LIST *ptr;
5877
  NESTED_JOIN *nested_join;
5878
  DBUG_ENTER("end_nested_join");
5879

unknown's avatar
unknown committed
5880
  DBUG_ASSERT(embedding);
5881 5882 5883
  ptr= embedding;
  join_list= ptr->join_list;
  embedding= ptr->embedding;
5884
  nested_join= ptr->nested_join;
5885 5886 5887 5888 5889 5890 5891 5892 5893
  if (nested_join->join_list.elements == 1)
  {
    TABLE_LIST *embedded= nested_join->join_list.head();
    join_list->pop();
    embedded->join_list= join_list;
    embedded->embedding= embedding;
    join_list->push_front(embedded);
    ptr= embedded;
  }
5894
  else if (nested_join->join_list.elements == 0)
unknown's avatar
unknown committed
5895 5896
  {
    join_list->pop();
5897
    ptr= 0;                                     // return value
unknown's avatar
unknown committed
5898
  }
5899 5900 5901 5902 5903 5904 5905 5906
  DBUG_RETURN(ptr);
}


/*
  Nest last join operation

  SYNOPSIS
5907
    nest_last_join()
5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922
    thd         current thread

  DESCRIPTION
    The function nest last join operation as if it was enclosed in braces.

  RETURN VALUE
    Pointer to TABLE_LIST element created for the new nested join, if success
    0, otherwise
*/

TABLE_LIST *st_select_lex::nest_last_join(THD *thd)
{
  TABLE_LIST *ptr;
  NESTED_JOIN *nested_join;
  DBUG_ENTER("nest_last_join");
5923

5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))) ||
      !(nested_join= ptr->nested_join=
                    (NESTED_JOIN *) thd->calloc(sizeof(NESTED_JOIN))))
    DBUG_RETURN(0);
  ptr->embedding= embedding;
  ptr->join_list= join_list;
  List<TABLE_LIST> *embedded_list= &nested_join->join_list;
  embedded_list->empty();
  for (int i=0; i < 2; i++)
  {
    TABLE_LIST *table= join_list->pop();
    table->join_list= embedded_list;
    table->embedding= ptr;
    embedded_list->push_back(table);
  }
  join_list->push_front(ptr);
  nested_join->used_tables= nested_join->not_null_tables= (table_map) 0;
  DBUG_RETURN(ptr);
}


/*
5946
  Save names for a join with using clause
5947

5948 5949 5950 5951 5952 5953 5954
  SYNOPSIS
    save_names_for_using_list
    tab1      left table in join
    tab2      right table in join

  DESCRIPTION
    The function saves the full names of the tables in st_select_lex
5955 5956
    to be able to build later an on expression to replace the using clause.

5957
  RETURN VALUE
5958 5959
    None
*/
5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978 5979 5980

void st_select_lex::save_names_for_using_list(TABLE_LIST *tab1,
                                              TABLE_LIST *tab2)
{
  while (tab1->nested_join)
  {
    tab1= tab1->nested_join->join_list.head();
  }
  db1= tab1->db;
  table1= tab1->alias;
  while (tab2->nested_join)
  {
    TABLE_LIST *next;
    List_iterator_fast<TABLE_LIST> it(tab2->nested_join->join_list);
    tab2= it++;
    while ((next= it++))
      tab2= next;
  }
  db2= tab2->db;
  table2= tab2->alias;
}
5981

5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009 6010 6011 6012 6013 6014 6015

/*
  Add a table to the current join list

  SYNOPSIS
    add_joined_table()
    table       the table to add

  DESCRIPTION
    The function puts a table in front of the current join list
    of st_select_lex object.
    Thus, joined tables are put into this list in the reverse order
    (the most outer join operation follows first).

  RETURN VALUE
    None
*/

void st_select_lex::add_joined_table(TABLE_LIST *table)
{
  DBUG_ENTER("add_joined_table");
  join_list->push_front(table);
  table->join_list= join_list;
  table->embedding= embedding;
  DBUG_VOID_RETURN;
}


/*
  Convert a right join into equivalent left join

  SYNOPSIS
    convert_right_join()
    thd         current thread
6016 6017 6018

  DESCRIPTION
    The function takes the current join list t[0],t[1] ... and
6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035 6036 6037 6038 6039 6040 6041
    effectively converts it into the list t[1],t[0] ...
    Although the outer_join flag for the new nested table contains
    JOIN_TYPE_RIGHT, it will be handled as the inner table of a left join
    operation.

  EXAMPLES
    SELECT * FROM t1 RIGHT JOIN t2 ON on_expr =>
      SELECT * FROM t2 LEFT JOIN t1 ON on_expr

    SELECT * FROM t1,t2 RIGHT JOIN t3 ON on_expr =>
      SELECT * FROM t1,t3 LEFT JOIN t2 ON on_expr

    SELECT * FROM t1,t2 RIGHT JOIN (t3,t4) ON on_expr =>
      SELECT * FROM t1,(t3,t4) LEFT JOIN t2 ON on_expr

    SELECT * FROM t1 LEFT JOIN t2 ON on_expr1 RIGHT JOIN t3  ON on_expr2 =>
      SELECT * FROM t3 LEFT JOIN (t1 LEFT JOIN t2 ON on_expr2) ON on_expr1

  RETURN
    Pointer to the table representing the inner table, if success
    0, otherwise
*/

6042
TABLE_LIST *st_select_lex::convert_right_join()
6043 6044
{
  TABLE_LIST *tab2= join_list->pop();
6045
  TABLE_LIST *tab1= join_list->pop();
6046 6047 6048 6049 6050 6051 6052 6053 6054
  DBUG_ENTER("convert_right_join");

  join_list->push_front(tab2);
  join_list->push_front(tab1);
  tab1->outer_join|= JOIN_TYPE_RIGHT;

  DBUG_RETURN(tab1);
}

unknown's avatar
unknown committed
6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066 6067
/*
  Set lock for all tables in current select level

  SYNOPSIS:
    set_lock_for_tables()
    lock_type			Lock to set for tables

  NOTE:
    If lock is a write lock, then tables->updating is set 1
    This is to get tables_ok to know that the table is updated by the
    query
*/

unknown's avatar
unknown committed
6068
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
unknown's avatar
unknown committed
6069 6070 6071 6072 6073 6074
{
  bool for_update= lock_type >= TL_READ_NO_INSERT;
  DBUG_ENTER("set_lock_for_tables");
  DBUG_PRINT("enter", ("lock_type: %d  for_update: %d", lock_type,
		       for_update));

unknown's avatar
VIEW  
unknown committed
6075 6076 6077
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first;
       tables;
       tables= tables->next_local)
unknown's avatar
unknown committed
6078 6079 6080 6081 6082 6083 6084
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
6085

unknown's avatar
unknown committed
6086 6087
void add_join_on(TABLE_LIST *b,Item *expr)
{
6088
  if (expr)
6089
  {
6090 6091 6092 6093
    if (!b->on_expr)
      b->on_expr=expr;
    else
    {
unknown's avatar
unknown committed
6094
      /* This only happens if you have both a right and left join */
6095 6096 6097
      b->on_expr=new Item_cond_and(b->on_expr,expr);
    }
    b->on_expr->top_level_item();
6098
  }
unknown's avatar
unknown committed
6099 6100 6101
}


6102 6103 6104 6105 6106 6107 6108
/*
  Mark that we have a NATURAL JOIN between two tables

  SYNOPSIS
    add_join_natural()
    a			Table to do normal join with
    b			Do normal join with this table
6109

6110 6111 6112 6113 6114 6115 6116 6117 6118 6119
  IMPLEMENTATION
    This function just marks that table b should be joined with a.
    The function setup_cond() will create in b->on_expr a list
    of equal condition between all fields of the same name.

    SELECT * FROM t1 NATURAL LEFT JOIN t2
     <=>
    SELECT * FROM t1 LEFT JOIN t2 ON (t1.i=t2.i and t1.j=t2.j ... )
*/

unknown's avatar
unknown committed
6120 6121 6122 6123 6124
void add_join_natural(TABLE_LIST *a,TABLE_LIST *b)
{
  b->natural_join=a;
}

6125
/*
6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142
  Reload/resets privileges and the different caches.

  SYNOPSIS
    reload_acl_and_cache()
    thd			Thread handler
    options             What should be reset/reloaded (tables, privileges,
    slave...)
    tables              Tables to flush (if any)
    write_to_binlog     Depending on 'options', it may be very bad to write the
                        query to the binlog (e.g. FLUSH SLAVE); this is a
                        pointer where, if it is not NULL, reload_acl_and_cache()
                        will put 0 if it thinks we really should not write to
                        the binlog. Otherwise it will put 1.

  RETURN
    0	 ok
    !=0  error
6143 6144
*/

6145 6146
bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
                          bool *write_to_binlog)
unknown's avatar
unknown committed
6147 6148 6149
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
6150
  bool tmp_write_to_binlog= 1;
unknown's avatar
SCRUM  
unknown committed
6151
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
6152 6153
  if (options & REFRESH_GRANT)
  {
6154
    acl_reload(thd);
unknown's avatar
unknown committed
6155
    grant_reload(thd);
6156
    reset_mqh((LEX_USER *)NULL, TRUE);
unknown's avatar
unknown committed
6157
  }
unknown's avatar
SCRUM  
unknown committed
6158
#endif
unknown's avatar
unknown committed
6159 6160
  if (options & REFRESH_LOG)
  {
6161
    /*
unknown's avatar
unknown committed
6162 6163
      Flush the normal query log, the update log, the binary log,
      the slow query log, and the relay log (if it exists).
6164
    */
unknown's avatar
unknown committed
6165

6166
    /*
6167 6168 6169 6170 6171
     Writing this command to the binlog may result in infinite loops when doing
     mysqlbinlog|mysql, and anyway it does not really make sense to log it
     automatically (would cause more trouble to users than it would help them)
    */
    tmp_write_to_binlog= 0;
unknown's avatar
unknown committed
6172 6173
    mysql_log.new_file(1);
    mysql_slow_log.new_file(1);
6174
    mysql_bin_log.rotate_and_purge(RP_FORCE_ROTATE);
unknown's avatar
unknown committed
6175
#ifdef HAVE_REPLICATION
6176
    pthread_mutex_lock(&LOCK_active_mi);
6177
    rotate_relay_log(active_mi);
6178
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
6179
#endif
unknown's avatar
unknown committed
6180 6181
    if (ha_flush_logs())
      result=1;
unknown's avatar
unknown committed
6182 6183
    if (flush_error_log())
      result=1;
unknown's avatar
unknown committed
6184
  }
unknown's avatar
unknown committed
6185
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
6186 6187
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
unknown's avatar
unknown committed
6188
    query_cache.pack();				// FLUSH QUERY CACHE
6189
    options &= ~REFRESH_QUERY_CACHE;    // Don't flush cache, just free memory
unknown's avatar
unknown committed
6190 6191 6192
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
unknown's avatar
unknown committed
6193
    query_cache.flush();			// RESET QUERY CACHE
unknown's avatar
unknown committed
6194
  }
unknown's avatar
unknown committed
6195
#endif /*HAVE_QUERY_CACHE*/
6196 6197 6198 6199 6200
  /*
    Note that if REFRESH_READ_LOCK bit is set then REFRESH_TABLES is set too
    (see sql_yacc.yy)
  */
  if (options & (REFRESH_TABLES | REFRESH_READ_LOCK)) 
unknown's avatar
unknown committed
6201
  {
6202
    if ((options & REFRESH_READ_LOCK) && thd)
unknown's avatar
unknown committed
6203
    {
unknown's avatar
unknown committed
6204 6205 6206 6207
      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
6208
      tmp_write_to_binlog= 0;
6209 6210
      if (lock_global_read_lock(thd))
	return 1;
6211 6212
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                 tables);
6213 6214 6215 6216 6217 6218
      if (make_global_read_lock_block_commit(thd))
      {
        /* Don't leave things in a half-locked state */
        unlock_global_read_lock(thd);
        return 1;
      }
unknown's avatar
unknown committed
6219
    }
6220 6221
    else
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
unknown's avatar
unknown committed
6222
    my_dbopt_cleanup();
unknown's avatar
unknown committed
6223 6224 6225
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
unknown's avatar
unknown committed
6226
  if (thd && (options & REFRESH_STATUS))
unknown's avatar
unknown committed
6227 6228 6229
    refresh_status();
  if (options & REFRESH_THREADS)
    flush_thread_cache();
unknown's avatar
unknown committed
6230
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
6231
  if (options & REFRESH_MASTER)
6232 6233
  {
    tmp_write_to_binlog= 0;
6234 6235
    if (reset_master(thd))
      result=1;
6236
  }
6237
#endif
unknown's avatar
unknown committed
6238
#ifdef OPENSSL
6239 6240 6241 6242 6243 6244
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
unknown's avatar
unknown committed
6245
#ifdef HAVE_REPLICATION
6246 6247
 if (options & REFRESH_SLAVE)
 {
6248
   tmp_write_to_binlog= 0;
6249
   pthread_mutex_lock(&LOCK_active_mi);
6250
   if (reset_slave(thd, active_mi))
6251
     result=1;
6252
   pthread_mutex_unlock(&LOCK_active_mi);
6253
 }
6254
#endif
6255
 if (options & REFRESH_USER_RESOURCES)
unknown's avatar
unknown committed
6256
   reset_mqh((LEX_USER *) NULL);
6257 6258
 if (write_to_binlog)
   *write_to_binlog= tmp_write_to_binlog;
6259
 return result;
unknown's avatar
unknown committed
6260 6261
}

6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273
/*
  kill on thread

  SYNOPSIS
    kill_one_thread()
    thd			Thread class
    id			Thread id

  NOTES
    This is written such that we have a short lock on LOCK_thread_count
*/

unknown's avatar
SCRUM  
unknown committed
6274
void kill_one_thread(THD *thd, ulong id, bool only_kill_query)
unknown's avatar
unknown committed
6275 6276 6277
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
6278 6279
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  I_List_iterator<THD> it(threads);
unknown's avatar
unknown committed
6280 6281 6282 6283
  while ((tmp=it++))
  {
    if (tmp->thread_id == id)
    {
6284 6285
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
unknown's avatar
unknown committed
6286 6287 6288
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
6289 6290 6291 6292 6293
  if (tmp)
  {
    if ((thd->master_access & SUPER_ACL) ||
	!strcmp(thd->user,tmp->user))
    {
unknown's avatar
SCRUM  
unknown committed
6294
      tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
6295 6296 6297 6298 6299 6300 6301
      error=0;
    }
    else
      error=ER_KILL_DENIED_ERROR;
    pthread_mutex_unlock(&tmp->LOCK_delete);
  }

unknown's avatar
unknown committed
6302
  if (!error)
6303
    send_ok(thd);
unknown's avatar
unknown committed
6304
  else
unknown's avatar
unknown committed
6305
    my_error(error, MYF(0), id);
unknown's avatar
unknown committed
6306 6307
}

unknown's avatar
unknown committed
6308

unknown's avatar
unknown committed
6309 6310 6311 6312 6313 6314 6315 6316
/* Clear most status variables */

static void refresh_status(void)
{
  pthread_mutex_lock(&LOCK_status);
  for (struct show_var_st *ptr=status_vars; ptr->name; ptr++)
  {
    if (ptr->type == SHOW_LONG)
6317
      *(ulong*) ptr->value= 0;
6318 6319 6320 6321 6322 6323 6324
    else if (ptr->type == SHOW_LONG_STATUS)
    {
      THD *thd= current_thd;
      /* We must update the global status before cleaning up the thread */
      add_to_status(&global_status_var, &thd->status_var);
      bzero((char*) &thd->status_var, sizeof(thd->status_var));
    }
unknown's avatar
unknown committed
6325
  }
unknown's avatar
unknown committed
6326 6327
  /* Reset the counters of all key caches (default and named). */
  process_key_caches(reset_key_cache_counters);
unknown's avatar
unknown committed
6328 6329
  pthread_mutex_unlock(&LOCK_status);
}
6330 6331 6332 6333


	/* If pointer is not a null pointer, append filename to it */

unknown's avatar
unknown committed
6334 6335
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name)
6336
{
6337
  char buff[FN_REFLEN],*ptr, *end;
6338 6339 6340 6341 6342 6343 6344
  if (!*filename_ptr)
    return 0;					// nothing to do

  /* Check that the filename is not too long and it's a hard path */
  if (strlen(*filename_ptr)+strlen(table_name) >= FN_REFLEN-1 ||
      !test_if_hard_path(*filename_ptr))
  {
6345
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
6346 6347 6348 6349
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
6350
  end=convert_dirname(buff, *filename_ptr, NullS);
unknown's avatar
unknown committed
6351
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
6352 6353
    return 1;					// End of memory
  *filename_ptr=ptr;
6354
  strxmov(ptr,buff,table_name,NullS);
6355 6356
  return 0;
}
6357

6358

6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372
/*
  Check if the select is a simple select (not an union)

  SYNOPSIS
    check_simple_select()

  RETURN VALUES
    0	ok
    1	error	; In this case the error messege is sent to the client
*/

bool check_simple_select()
{
  THD *thd= current_thd;
6373 6374
  LEX *lex= thd->lex;
  if (lex->current_select != &lex->select_lex)
6375 6376
  {
    char command[80];
6377 6378
    strmake(command, lex->yylval->symbol.str,
	    min(lex->yylval->symbol.length, sizeof(command)-1));
6379
    my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
6380 6381 6382 6383
    return 1;
  }
  return 0;
}
unknown's avatar
unknown committed
6384

unknown's avatar
unknown committed
6385 6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396 6397 6398 6399 6400
/*
  Setup locking for multi-table updates. Used by the replication slave.
  Replication slave SQL thread examines (all_tables_not_ok()) the
  locking state of referenced tables to determine if the query has to
  be executed or ignored. Since in multi-table update, the 
  'default' lock is read-only, this lock is corrected early enough by
  calling this function, before the slave decides to execute/ignore.

  SYNOPSIS
    check_multi_update_lock()
    thd		Current thread

  RETURN VALUES
    0	ok
    1	error
*/
unknown's avatar
unknown committed
6401
static bool check_multi_update_lock(THD *thd)
unknown's avatar
unknown committed
6402 6403
{
  bool res= 1;
unknown's avatar
unknown committed
6404 6405
  LEX *lex= thd->lex;
  TABLE_LIST *table, *tables= lex->query_tables;
unknown's avatar
unknown committed
6406 6407 6408 6409 6410 6411 6412 6413 6414
  DBUG_ENTER("check_multi_update_lock");
  
  if (check_db_used(thd, tables))
    goto error;

  /*
    Ensure that we have UPDATE or SELECT privilege for each table
    The exact privilege is checked in mysql_multi_update()
  */
unknown's avatar
unknown committed
6415
  for (table= tables ; table ; table= table->next_local)
unknown's avatar
unknown committed
6416
  {
unknown's avatar
unknown committed
6417 6418
    TABLE_LIST *save= table->next_local;
    table->next_local= 0;
unknown's avatar
unknown committed
6419 6420 6421
    if ((check_access(thd, UPDATE_ACL, table->db, &table->grant.privilege,0,1) ||
        (grant_option && check_grant(thd, UPDATE_ACL, table,0,1,1))) &&
	check_one_table_access(thd, SELECT_ACL, table))
unknown's avatar
unknown committed
6422
	goto error;
unknown's avatar
unknown committed
6423
    table->next_local= save;
unknown's avatar
unknown committed
6424 6425
  }
    
unknown's avatar
unknown committed
6426
  if (mysql_multi_update_prepare(thd))
unknown's avatar
unknown committed
6427 6428 6429 6430 6431 6432 6433
    goto error;
  
  res= 0;
  
error:
  DBUG_RETURN(res);
}
unknown's avatar
unknown committed
6434

unknown's avatar
unknown committed
6435

unknown's avatar
unknown committed
6436
Comp_creator *comp_eq_creator(bool invert)
unknown's avatar
unknown committed
6437
{
unknown's avatar
unknown committed
6438
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
unknown's avatar
unknown committed
6439 6440
}

unknown's avatar
unknown committed
6441

unknown's avatar
unknown committed
6442
Comp_creator *comp_ge_creator(bool invert)
unknown's avatar
unknown committed
6443
{
unknown's avatar
unknown committed
6444
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
unknown's avatar
unknown committed
6445 6446
}

unknown's avatar
unknown committed
6447

unknown's avatar
unknown committed
6448
Comp_creator *comp_gt_creator(bool invert)
unknown's avatar
unknown committed
6449
{
unknown's avatar
unknown committed
6450
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
unknown's avatar
unknown committed
6451 6452
}

unknown's avatar
unknown committed
6453

unknown's avatar
unknown committed
6454
Comp_creator *comp_le_creator(bool invert)
unknown's avatar
unknown committed
6455
{
unknown's avatar
unknown committed
6456
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
unknown's avatar
unknown committed
6457 6458
}

unknown's avatar
unknown committed
6459

unknown's avatar
unknown committed
6460
Comp_creator *comp_lt_creator(bool invert)
unknown's avatar
unknown committed
6461
{
unknown's avatar
unknown committed
6462
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
unknown's avatar
unknown committed
6463 6464
}

unknown's avatar
unknown committed
6465

unknown's avatar
unknown committed
6466
Comp_creator *comp_ne_creator(bool invert)
unknown's avatar
unknown committed
6467
{
unknown's avatar
unknown committed
6468
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
unknown's avatar
unknown committed
6469
}
unknown's avatar
unknown committed
6470 6471 6472 6473 6474 6475 6476 6477 6478 6479 6480 6481 6482 6483 6484 6485 6486 6487 6488 6489


/*
  Construct ALL/ANY/SOME subquery Item

  SYNOPSIS
    all_any_subquery_creator()
    left_expr - pointer to left expression
    cmp - compare function creator
    all - true if we create ALL subquery
    select_lex - pointer on parsed subquery structure

  RETURN VALUE
    constructed Item (or 0 if out of memory)
*/
Item * all_any_subquery_creator(Item *left_expr,
				chooser_compare_func_creator cmp,
				bool all,
				SELECT_LEX *select_lex)
{
unknown's avatar
unknown committed
6490
  if ((cmp == &comp_eq_creator) && !all)       //  = ANY <=> IN
unknown's avatar
unknown committed
6491
    return new Item_in_subselect(left_expr, select_lex);
unknown's avatar
unknown committed
6492 6493

  if ((cmp == &comp_ne_creator) && all)        // <> ALL <=> NOT IN
unknown's avatar
unknown committed
6494 6495 6496
    return new Item_func_not(new Item_in_subselect(left_expr, select_lex));

  Item_allany_subselect *it=
6497
    new Item_allany_subselect(left_expr, (*cmp)(all), select_lex, all);
unknown's avatar
unknown committed
6498
  if (all)
6499
    return it->upper_item= new Item_func_not_all(it);	/* ALL */
unknown's avatar
unknown committed
6500

6501
  return it->upper_item= new Item_func_nop_all(it);      /* ANY/SOME */
unknown's avatar
unknown committed
6502
}
6503 6504


6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516
/*
  CREATE INDEX and DROP INDEX are implemented by calling ALTER TABLE with
  the proper arguments.  This isn't very fast but it should work for most
  cases.

  In the future ALTER TABLE will notice that only added indexes
  and create these one by one for the existing table without having to do
  a full rebuild.

  One should normally create all indexes with CREATE TABLE or ALTER TABLE.
*/

unknown's avatar
unknown committed
6517
bool mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
6518 6519
{
  List<create_field> fields;
6520 6521
  ALTER_INFO alter_info;
  alter_info.flags= ALTER_ADD_INDEX;
6522 6523 6524 6525 6526
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_create_index");
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.default_table_charset= thd->variables.collation_database;
6527
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
6528
				&create_info, table_list,
6529
				fields, keys, 0, (ORDER*)0,
unknown's avatar
unknown committed
6530
				DUP_ERROR, 0, &alter_info, 1));
6531 6532 6533
}


unknown's avatar
unknown committed
6534
bool mysql_drop_index(THD *thd, TABLE_LIST *table_list, ALTER_INFO *alter_info)
6535 6536 6537 6538 6539 6540 6541 6542
{
  List<create_field> fields;
  List<Key> keys;
  HA_CREATE_INFO create_info;
  DBUG_ENTER("mysql_drop_index");
  bzero((char*) &create_info,sizeof(create_info));
  create_info.db_type=DB_TYPE_DEFAULT;
  create_info.default_table_charset= thd->variables.collation_database;
6543 6544
  alter_info->clear();
  alter_info->flags= ALTER_DROP_INDEX;
6545
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->table_name,
6546
				&create_info, table_list,
6547
				fields, keys, 0, (ORDER*)0,
unknown's avatar
unknown committed
6548
				DUP_ERROR, 0, alter_info, 1));
6549
}
unknown's avatar
merge  
unknown committed
6550 6551


6552 6553 6554 6555 6556
/*
  Multi update query pre-check

  SYNOPSIS
    multi_update_precheck()
unknown's avatar
unknown committed
6557
    thd		Thread handler
unknown's avatar
VIEW  
unknown committed
6558
    tables	Global/local table list (have to be the same)
6559

unknown's avatar
unknown committed
6560
  RETURN VALUE
unknown's avatar
unknown committed
6561 6562
    FALSE OK
    TRUE  Error
6563
*/
unknown's avatar
unknown committed
6564

unknown's avatar
unknown committed
6565
bool multi_update_precheck(THD *thd, TABLE_LIST *tables)
6566 6567 6568 6569 6570
{
  const char *msg= 0;
  TABLE_LIST *table;
  LEX *lex= thd->lex;
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
6571
  DBUG_ENTER("multi_update_precheck");
6572 6573 6574

  if (select_lex->item_list.elements != lex->value_list.elements)
  {
6575
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
6576
    DBUG_RETURN(TRUE);
6577 6578 6579 6580 6581
  }
  /*
    Ensure that we have UPDATE or SELECT privilege for each table
    The exact privilege is checked in mysql_multi_update()
  */
unknown's avatar
VIEW  
unknown committed
6582
  for (table= tables; table; table= table->next_local)
6583
  {
6584 6585 6586 6587 6588 6589
    if (table->derived)
      table->grant.privilege= SELECT_ACL;
    else if ((check_access(thd, UPDATE_ACL, table->db,
                           &table->grant.privilege, 0, 1) ||
              grant_option &&
              check_grant(thd, UPDATE_ACL, table, 0, 1, 1)) &&
unknown's avatar
unknown committed
6590 6591 6592
             (check_access(thd, SELECT_ACL, table->db,
                           &table->grant.privilege, 0, 0) ||
              grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
unknown's avatar
unknown committed
6593
      DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
6594

unknown's avatar
VIEW  
unknown committed
6595
    table->table_in_first_from_clause= 1;
6596
  }
unknown's avatar
unknown committed
6597 6598 6599
  /*
    Is there tables of subqueries?
  */
6600 6601
  if (&lex->select_lex != lex->all_selects_list)
  {
6602
    DBUG_PRINT("info",("Checking sub query list"));
unknown's avatar
VIEW  
unknown committed
6603
    for (table= tables; table; table= table->next_global)
6604
    {
unknown's avatar
unknown committed
6605 6606 6607
      if (!my_tz_check_n_skip_implicit_tables(&table,
                                              lex->time_zone_tables_used) &&
          !table->table_in_first_from_clause)
6608 6609 6610
      {
	if (check_access(thd, SELECT_ACL, table->db,
			 &table->grant.privilege, 0, 0) ||
unknown's avatar
unknown committed
6611
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
unknown's avatar
unknown committed
6612
	  DBUG_RETURN(TRUE);
6613 6614 6615 6616 6617 6618 6619 6620 6621 6622 6623 6624
      }
    }
  }

  if (select_lex->order_list.elements)
    msg= "ORDER BY";
  else if (select_lex->select_limit && select_lex->select_limit !=
	   HA_POS_ERROR)
    msg= "LIMIT";
  if (msg)
  {
    my_error(ER_WRONG_USAGE, MYF(0), "UPDATE", msg);
unknown's avatar
unknown committed
6625
    DBUG_RETURN(TRUE);
6626
  }
unknown's avatar
unknown committed
6627
  DBUG_RETURN(FALSE);
6628 6629 6630 6631 6632 6633 6634
}

/*
  Multi delete query pre-check

  SYNOPSIS
    multi_delete_precheck()
unknown's avatar
unknown committed
6635
    thd			Thread handler
unknown's avatar
VIEW  
unknown committed
6636
    tables		Global/local table list
unknown's avatar
unknown committed
6637
    table_count		Pointer to table counter
6638

unknown's avatar
unknown committed
6639
  RETURN VALUE
unknown's avatar
unknown committed
6640 6641
    FALSE OK
    TRUE  error
6642
*/
unknown's avatar
unknown committed
6643 6644

bool multi_delete_precheck(THD *thd, TABLE_LIST *tables, uint *table_count)
6645 6646 6647 6648
{
  SELECT_LEX *select_lex= &thd->lex->select_lex;
  TABLE_LIST *aux_tables=
    (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
unknown's avatar
unknown committed
6649
  TABLE_LIST *target_tbl;
unknown's avatar
VIEW  
unknown committed
6650
  DBUG_ENTER("multi_delete_precheck");
unknown's avatar
unknown committed
6651 6652

  *table_count= 0;
6653 6654 6655 6656 6657 6658

  /* sql_yacc guarantees that tables and aux_tables are not zero */
  DBUG_ASSERT(aux_tables != 0);
  if (check_db_used(thd, tables) || check_db_used(thd,aux_tables) ||
      check_table_access(thd,SELECT_ACL, tables,0) ||
      check_table_access(thd,DELETE_ACL, aux_tables,0))
unknown's avatar
unknown committed
6659
    DBUG_RETURN(TRUE);
6660 6661
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
  {
unknown's avatar
unknown committed
6662 6663
    my_message(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE,
               ER(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE), MYF(0));
unknown's avatar
unknown committed
6664
    DBUG_RETURN(TRUE);
6665
  }
unknown's avatar
VIEW  
unknown committed
6666
  for (target_tbl= aux_tables; target_tbl; target_tbl= target_tbl->next_local)
6667 6668 6669 6670
  {
    (*table_count)++;
    /* All tables in aux_tables must be found in FROM PART */
    TABLE_LIST *walk;
unknown's avatar
VIEW  
unknown committed
6671
    for (walk= tables; walk; walk= walk->next_local)
6672
    {
unknown's avatar
unknown committed
6673 6674 6675
      if (!my_strcasecmp(table_alias_charset,
			 target_tbl->alias, walk->alias) &&
	  !strcmp(walk->db, target_tbl->db))
6676 6677 6678 6679
	break;
    }
    if (!walk)
    {
6680
      my_error(ER_UNKNOWN_TABLE, MYF(0),
6681
               target_tbl->table_name, "MULTI DELETE");
unknown's avatar
unknown committed
6682
      DBUG_RETURN(TRUE);
6683
    }
unknown's avatar
unknown committed
6684
    walk->lock_type= target_tbl->lock_type;
unknown's avatar
VIEW  
unknown committed
6685
    target_tbl->correspondent_table= walk;	// Remember corresponding table
6686
  }
unknown's avatar
unknown committed
6687
  DBUG_RETURN(FALSE);
6688 6689 6690
}


unknown's avatar
unknown committed
6691 6692 6693 6694 6695
/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
unknown's avatar
unknown committed
6696 6697
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
6698 6699

  RETURN VALUE
unknown's avatar
unknown committed
6700 6701
    FALSE OK
    TRUE  Error
unknown's avatar
unknown committed
6702
*/
unknown's avatar
unknown committed
6703

unknown's avatar
unknown committed
6704
bool update_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
6705 6706 6707 6708
{
  DBUG_ENTER("update_precheck");
  if (thd->lex->select_lex.item_list.elements != thd->lex->value_list.elements)
  {
unknown's avatar
unknown committed
6709
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
6710
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
6711
  }
unknown's avatar
unknown committed
6712 6713
  DBUG_RETURN(check_db_used(thd, tables) ||
	       check_one_table_access(thd, UPDATE_ACL, tables));
unknown's avatar
unknown committed
6714 6715 6716 6717 6718 6719 6720 6721
}


/*
  simple DELETE query pre-check

  SYNOPSIS
    delete_precheck()
unknown's avatar
unknown committed
6722 6723
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
6724 6725

  RETURN VALUE
unknown's avatar
unknown committed
6726 6727
    FALSE  OK
    TRUE   error
unknown's avatar
unknown committed
6728
*/
unknown's avatar
unknown committed
6729

unknown's avatar
unknown committed
6730
bool delete_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
6731 6732 6733
{
  DBUG_ENTER("delete_precheck");
  if (check_one_table_access(thd, DELETE_ACL, tables))
unknown's avatar
unknown committed
6734
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
6735
  /* Set privilege for the WHERE clause */
unknown's avatar
unknown committed
6736
  tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
unknown's avatar
unknown committed
6737
  DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
6738 6739 6740 6741 6742 6743 6744 6745
}


/*
  simple INSERT query pre-check

  SYNOPSIS
    insert_precheck()
unknown's avatar
unknown committed
6746 6747
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
6748 6749

  RETURN VALUE
unknown's avatar
unknown committed
6750 6751
    FALSE  OK
    TRUE   error
unknown's avatar
unknown committed
6752
*/
unknown's avatar
unknown committed
6753

unknown's avatar
merge  
unknown committed
6754
bool insert_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
6755 6756 6757 6758
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

unknown's avatar
unknown committed
6759 6760 6761 6762
  /*
    Check that we have modify privileges for the first table and
    select privileges for the rest
  */
unknown's avatar
unknown committed
6763 6764 6765
  ulong privilege= (INSERT_ACL |
                    (lex->duplicates == DUP_REPLACE ? DELETE_ACL : 0) |
                    (lex->value_list.elements ? UPDATE_ACL : 0));
unknown's avatar
unknown committed
6766 6767

  if (check_one_table_access(thd, privilege, tables))
unknown's avatar
unknown committed
6768
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
6769

unknown's avatar
unknown committed
6770
  if (lex->update_list.elements != lex->value_list.elements)
unknown's avatar
unknown committed
6771
  {
unknown's avatar
unknown committed
6772
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
unknown's avatar
unknown committed
6773
    DBUG_RETURN(TRUE);
unknown's avatar
unknown committed
6774
  }
unknown's avatar
unknown committed
6775
  DBUG_RETURN(FALSE);
6776
}
unknown's avatar
unknown committed
6777 6778 6779 6780 6781 6782 6783


/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
unknown's avatar
unknown committed
6784 6785 6786
    thd			Thread handler
    tables		Global table list
    create_table	Table which will be created
unknown's avatar
unknown committed
6787 6788

  RETURN VALUE
unknown's avatar
unknown committed
6789 6790
    FALSE   OK
    TRUE   Error
unknown's avatar
unknown committed
6791
*/
unknown's avatar
unknown committed
6792

unknown's avatar
unknown committed
6793 6794
bool create_table_precheck(THD *thd, TABLE_LIST *tables,
                           TABLE_LIST *create_table)
unknown's avatar
unknown committed
6795 6796
{
  LEX *lex= thd->lex;
6797 6798
  SELECT_LEX *select_lex= &lex->select_lex;
  ulong want_priv;
unknown's avatar
merge  
unknown committed
6799
  bool error= TRUE;                                 // Error message is given
unknown's avatar
unknown committed
6800
  DBUG_ENTER("create_table_precheck");
6801 6802 6803

  want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
              CREATE_TMP_ACL : CREATE_ACL);
unknown's avatar
unknown committed
6804 6805 6806 6807 6808 6809
  lex->create_info.alias= create_table->alias;
  if (check_access(thd, want_priv, create_table->db,
		   &create_table->grant.privilege, 0, 0) ||
      check_merge_table_access(thd, create_table->db,
			       (TABLE_LIST *)
			       lex->create_info.merge_list.first))
6810 6811 6812 6813 6814 6815 6816 6817 6818 6819
    goto err;
  if (grant_option && want_priv != CREATE_TMP_ACL &&
      check_grant(thd, want_priv, create_table, 0, UINT_MAX, 0))
    goto err;

  if (select_lex->item_list.elements)
  {
    /* Check permissions for used tables in CREATE TABLE ... SELECT */

    /*
unknown's avatar
unknown committed
6820 6821 6822
      Only do the check for PS, becasue we on execute we have to check that
      against the opened tables to ensure we don't use a table that is part
      of the view (which can only be done after the table has been opened).
6823
    */
unknown's avatar
unknown committed
6824
    if (thd->current_arena->is_stmt_prepare())
6825
    {
unknown's avatar
unknown committed
6826 6827 6828 6829
      /*
        For temporary tables we don't have to check if the created table exists
      */
      if (!(lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) &&
unknown's avatar
unknown committed
6830
          find_table_in_global_list(tables, create_table->db,
6831
                                    create_table->table_name))
unknown's avatar
unknown committed
6832
      {
6833
	error= FALSE;
unknown's avatar
unknown committed
6834 6835 6836
        goto err;
      }
    }
6837 6838 6839
    if (tables && check_table_access(thd, SELECT_ACL, tables,0))
      goto err;
  }
unknown's avatar
merge  
unknown committed
6840
  error= FALSE;
6841 6842 6843

err:
  DBUG_RETURN(error);
unknown's avatar
unknown committed
6844
}
unknown's avatar
unknown committed
6845 6846 6847 6848 6849 6850 6851


/*
  negate given expression

  SYNOPSIS
    negate_expression()
6852
    thd  thread handler
unknown's avatar
unknown committed
6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880
    expr expression for negation

  RETURN
    negated expression
*/

Item *negate_expression(THD *thd, Item *expr)
{
  Item *negated;
  if (expr->type() == Item::FUNC_ITEM &&
      ((Item_func *) expr)->functype() == Item_func::NOT_FUNC)
  {
    /* it is NOT(NOT( ... )) */
    Item *arg= ((Item_func *) expr)->arguments()[0];
    enum_parsing_place place= thd->lex->current_select->parsing_place;
    if (arg->is_bool_func() || place == IN_WHERE || place == IN_HAVING)
      return arg;
    /*
      if it is not boolean function then we have to emulate value of
      not(not(a)), it will be a != 0
    */
    return new Item_func_ne(arg, new Item_int((char*) "0", 0, 1));
  }

  if ((negated= expr->neg_transformer(thd)) != 0)
    return negated;
  return new Item_func_not(expr);
}