sql_parse.cc 180 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 18
   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"
#include "sql_acl.h"
19
#include "sql_repl.h"
20
#include "repl_failsafe.h"
unknown's avatar
unknown committed
21 22 23 24
#include <m_ctype.h>
#include <myisam.h>
#include <my_dir.h>

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

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

unknown's avatar
unknown committed
32 33 34 35 36 37 38 39 40 41 42
#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
43 44 45
#define SSL_HANDSHAKE_SIZE      2
#define NORMAL_HANDSHAKE_SIZE   6
#define MIN_HANDSHAKE_SIZE      2
unknown's avatar
unknown committed
46
#else
unknown's avatar
unknown committed
47
#define MIN_HANDSHAKE_SIZE      6
unknown's avatar
unknown committed
48
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
49

50 51 52 53 54 55 56 57 58
/* 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 || \
   (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

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

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

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

86
static char empty_c_string[1]= {0};		// Used for not defined 'db'
unknown's avatar
unknown committed
87 88 89 90

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

unknown's avatar
unknown committed
107 108 109 110 111
static void unlock_locked_tables(THD *thd)
{
  if (thd->locked_tables)
  {
    thd->lock=thd->locked_tables;
112
    thd->locked_tables=0;			// Will be automatically closed
unknown's avatar
unknown committed
113 114 115 116
    close_thread_tables(thd);			// Free tables
  }
}

117

unknown's avatar
unknown committed
118
static bool end_active_trans(THD *thd)
119
{
unknown's avatar
unknown committed
120
  int error=0;
unknown's avatar
unknown committed
121
  if (thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN |
unknown's avatar
unknown committed
122
		      OPTION_TABLE_LOCK))
123
  {
124 125
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
126
    if (ha_commit(thd))
unknown's avatar
unknown committed
127
      error=1;
128
  }
unknown's avatar
unknown committed
129
  return error;
130 131 132
}


unknown's avatar
unknown committed
133
#ifdef HAVE_REPLICATION
134 135 136
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
137
          ((thd->lex->sql_command != SQLCOM_DELETE_MULTI) ||
unknown's avatar
unknown committed
138 139
           !tables_ok(thd,
		      (TABLE_LIST *)thd->lex->auxilliary_table_list.first)));
140
}
unknown's avatar
unknown committed
141
#endif
142 143


144 145
static HASH hash_user_connections;

unknown's avatar
unknown committed
146 147
static int get_or_create_user_conn(THD *thd, const char *user,
				   const char *host,
unknown's avatar
unknown committed
148
				   USER_RESOURCES *mqh)
149 150
{
  int return_val=0;
unknown's avatar
unknown committed
151
  uint temp_len, user_len;
152 153 154 155 156 157
  char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];
  struct  user_conn *uc;

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

158 159
  user_len=strlen(user);
  temp_len= (strmov(strmov(temp_user, user)+1, host) - temp_user)+1;
160
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
161 162
  if (!(uc = (struct  user_conn *) hash_search(&hash_user_connections,
					       (byte*) temp_user, temp_len)))
163
  {
unknown's avatar
unknown committed
164 165 166
    /* 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
167 168
			 MYF(MY_WME)))))
    {
169
      send_error(thd, 0, NullS);		// Out of memory
170 171
      return_val=1;
      goto end;
unknown's avatar
unknown committed
172
    }
173 174
    uc->user=(char*) (uc+1);
    memcpy(uc->user,temp_user,temp_len+1);
175 176
    uc->user_len= user_len;
    uc->host=uc->user + uc->user_len +  1;
177
    uc->len = temp_len;
178 179 180
    uc->connections = 1;
    uc->questions=uc->updates=uc->conn_per_hour=0;
    uc->user_resources=*mqh;
unknown's avatar
unknown committed
181
    if (max_user_connections && mqh->connections > max_user_connections)
182
      uc->user_resources.connections = max_user_connections;
183
    uc->intime=thd->thr_create_time;
unknown's avatar
SCRUM  
unknown committed
184
    if (my_hash_insert(&hash_user_connections, (byte*) uc))
185 186
    {
      my_free((char*) uc,0);
187
      send_error(thd, 0, NullS);		// Out of memory
188 189 190 191 192
      return_val=1;
      goto end;
    }
  }
  thd->user_connect=uc;
193
  uc->connections++;
194 195 196
end:
  (void) pthread_mutex_unlock(&LOCK_user_conn);
  return return_val;
unknown's avatar
unknown committed
197

198
}
199 200 201


/*
202
    Check if user exist and password supplied is correct. 
203 204
  SYNOPSIS
    check_user()
205 206 207 208
    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.
209
    passwd       scrambled password received from client
210 211 212 213
    passwd_len   length of scrambled password
    db           database name to connect to, may be NULL
    check_count  dont know exactly

214
    Note, that host, user and passwd may point to communication buffer.
215
    Current implementation does not depend on that, but future changes
216 217 218
    should be done with this in mind; 'thd' is INOUT, all other params
    are 'IN'.

219 220 221
  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
222 223
   -1  access denied or handshake error; error is sent to client;
   >0  error, not sent to client
unknown's avatar
unknown committed
224 225
*/

unknown's avatar
unknown committed
226 227 228
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
229
{
230
  DBUG_ENTER("check_user");
unknown's avatar
unknown committed
231
  
unknown's avatar
unknown committed
232 233
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  thd->master_access= GLOBAL_ACLS;			// Full rights
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248
  /* 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
249 250
#else

251 252 253 254 255
  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);
  
256
  /*
257 258
    If the server is running in secure auth mode, short scrambles are 
    forbidden.
259
  */
260
  if (opt_secure_auth_local && passwd_len == SCRAMBLE_LENGTH_323)
unknown's avatar
unknown committed
261
  {
262 263 264
    net_printf(thd, ER_NOT_SUPPORTED_AUTH_MODE);
    mysql_log.write(thd, COM_CONNECT, ER(ER_NOT_SUPPORTED_AUTH_MODE));
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
265
  }
unknown's avatar
unknown committed
266 267 268 269
  if (passwd_len != 0 &&
      passwd_len != SCRAMBLE_LENGTH &&
      passwd_len != SCRAMBLE_LENGTH_323)
    DBUG_RETURN(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
270

271
  /*
272
    Clear thd->db as it points to something, that will be freed when 
273
    connection is closed. We don't want to accidentally free a wrong pointer
274 275
    if connect failed. Also in case of 'CHANGE USER' failure, current
    database will be switched to 'no database selected'.
276
  */
277 278
  thd->db= 0;
  thd->db_length= 0;
unknown's avatar
unknown committed
279
  
280
  USER_RESOURCES ur;
281
  int res= acl_getroot(thd, &ur, passwd, passwd_len);
unknown's avatar
unknown committed
282
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
283
  if (res == -1)
unknown's avatar
unknown committed
284
  {
unknown's avatar
unknown committed
285 286 287 288 289 290
    /*
      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.
    */
291
    NET *net= &thd->net;
292
    if (opt_secure_auth_local)
293
    {
294 295 296 297 298 299
      net_printf(thd, ER_SERVER_IS_IN_SECURE_AUTH_MODE,
                 thd->user, thd->host_or_ip);
      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
300
    /* We have to read very specific packet size */
301
    if (send_old_password_request(thd) ||
unknown's avatar
unknown committed
302 303
        my_net_read(net) != SCRAMBLE_LENGTH_323 + 1)
    {                                               
unknown's avatar
unknown committed
304 305 306 307 308
      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 */
309
    res= acl_getroot(thd, &ur, (char *) net->read_pos, SCRAMBLE_LENGTH_323);
unknown's avatar
unknown committed
310
  }
unknown's avatar
unknown committed
311
#endif /*EMBEDDED_LIBRARY*/
unknown's avatar
unknown committed
312 313
  /* here res is always >= 0 */
  if (res == 0)
unknown's avatar
unknown committed
314
  {
315
    if (!(thd->master_access & NO_ACCESS)) // authentication is OK 
316
    {
unknown's avatar
unknown committed
317 318 319 320 321 322 323 324 325 326
      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)
327
      {
unknown's avatar
unknown committed
328 329
        VOID(pthread_mutex_lock(&LOCK_thread_count));
        bool count_ok= thread_count < max_connections + delayed_insert_threads
330
                       || (thd->master_access & SUPER_ACL);
unknown's avatar
unknown committed
331 332 333 334 335 336
        VOID(pthread_mutex_unlock(&LOCK_thread_count));
        if (!count_ok)
        {                                         // too many connections 
          send_error(thd, ER_CON_COUNT_ERROR);
          DBUG_RETURN(-1);
        }
337
      }
unknown's avatar
unknown committed
338

unknown's avatar
unknown committed
339 340 341 342 343 344 345 346
      /* 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*) "");

347
      /*
348 349 350
        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.
351
      */
unknown's avatar
unknown committed
352 353 354
      thd->db_access=0;

      /* Don't allow user to connect if he has done too many queries */
unknown's avatar
unknown committed
355 356 357 358 359 360 361 362 363
      if ((ur.questions || ur.updates || ur.connections ||
	   max_user_connections) &&
	  get_or_create_user_conn(thd,thd->user,thd->host_or_ip,&ur))
	DBUG_RETURN(-1);
      if (thd->user_connect &&
	  (thd->user_connect->user_resources.connections ||
	   max_user_connections) &&
	  check_for_max_user_connections(thd, thd->user_connect))
	DBUG_RETURN(-1);
unknown's avatar
unknown committed
364 365 366

      /* Change database if necessary: OK or FAIL is sent in mysql_change_db */
      if (db && db[0])
367
      {
unknown's avatar
unknown committed
368 369 370 371 372 373
        if (mysql_change_db(thd, db))
        {
          if (thd->user_connect)
            decrease_user_connections(thd->user_connect);
          DBUG_RETURN(-1);
        }
374 375
      }
      else
unknown's avatar
unknown committed
376
	send_ok(thd);
unknown's avatar
unknown committed
377 378 379
      thd->password= test(passwd_len);          // remember for error messages 
      /* Ready to handle queries */
      DBUG_RETURN(0);
unknown's avatar
unknown committed
380 381
    }
  }
unknown's avatar
unknown committed
382
  else if (res == 2) // client gave short hash, server has long hash
unknown's avatar
unknown committed
383
  {
unknown's avatar
unknown committed
384 385 386
    net_printf(thd, ER_NOT_SUPPORTED_AUTH_MODE);
    mysql_log.write(thd,COM_CONNECT,ER(ER_NOT_SUPPORTED_AUTH_MODE));
    DBUG_RETURN(-1);
unknown's avatar
unknown committed
387
  }
unknown's avatar
unknown committed
388 389 390 391 392 393 394 395 396
  net_printf(thd, ER_ACCESS_DENIED_ERROR,
             thd->user,
             thd->host_or_ip,
             passwd_len ? ER(ER_YES) : ER(ER_NO));
  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
397
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
398 399
}

unknown's avatar
unknown committed
400
/*
unknown's avatar
unknown committed
401 402
  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
403 404
*/

405 406
extern "C" byte *get_key_conn(user_conn *buff, uint *length,
			      my_bool not_used __attribute__((unused)))
unknown's avatar
unknown committed
407 408 409 410 411
{
  *length=buff->len;
  return (byte*) buff->user;
}

412
extern "C" void free_user(struct user_conn *uc)
unknown's avatar
unknown committed
413 414 415 416
{
  my_free((char*) uc,MYF(0));
}

unknown's avatar
unknown committed
417
void init_max_user_conn(void)
unknown's avatar
unknown committed
418
{
unknown's avatar
unknown committed
419 420
  (void) hash_init(&hash_user_connections,system_charset_info,max_connections,
		   0,0,
421
		   (hash_get_key) get_key_conn, (hash_free_key) free_user,
422
		   0);
unknown's avatar
unknown committed
423 424 425
}


unknown's avatar
unknown committed
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442
/*
  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
443 444
#ifndef NO_EMBEDDED_ACCESS_CHECKS

445
static int check_for_max_user_connections(THD *thd, USER_CONN *uc)
unknown's avatar
unknown committed
446
{
447
  int error=0;
448
  DBUG_ENTER("check_for_max_user_connections");
unknown's avatar
unknown committed
449

450
  (void) pthread_mutex_lock(&LOCK_user_conn);
451
  if (max_user_connections &&
unknown's avatar
unknown committed
452
      max_user_connections < (uint) uc->connections)
unknown's avatar
unknown committed
453
  {
454
    net_printf(thd,ER_TOO_MANY_USER_CONNECTIONS, uc->user);
455 456
    error=1;
    goto end;
unknown's avatar
unknown committed
457
  }
458
  if (uc->user_resources.connections &&
459
      uc->user_resources.connections <= uc->conn_per_hour)
460
  {
461
    net_printf(thd, ER_USER_LIMIT_REACHED, uc->user,
462
	       "max_connections",
463 464 465 466
	       (long) uc->user_resources.connections);
    error=1;
    goto end;
  }
467
  uc->conn_per_hour++;
unknown's avatar
unknown committed
468 469

  end:
470 471
  if (error)
    uc->connections--; // no need for decrease_user_connections() here
472
  (void) pthread_mutex_unlock(&LOCK_user_conn);
473
  DBUG_RETURN(error);
unknown's avatar
unknown committed
474
}
unknown's avatar
unknown committed
475
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
476

unknown's avatar
unknown committed
477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
/*
  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.
*/

495
static void decrease_user_connections(USER_CONN *uc)
unknown's avatar
unknown committed
496
{
497
  DBUG_ENTER("decrease_user_connections");
498 499 500
  (void) pthread_mutex_lock(&LOCK_user_conn);
  DBUG_ASSERT(uc->connections);
  if (!--uc->connections && !mqh_used)
unknown's avatar
unknown committed
501 502
  {
    /* Last connection for user; Delete it */
unknown's avatar
unknown committed
503
    (void) hash_delete(&hash_user_connections,(byte*) uc);
unknown's avatar
unknown committed
504
  }
505
  (void) pthread_mutex_unlock(&LOCK_user_conn);
506
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
507 508
}

509

unknown's avatar
unknown committed
510 511 512 513 514
void free_max_user_conn(void)
{
  hash_free(&hash_user_connections);
}

unknown's avatar
unknown committed
515

516 517 518
/*
  Mark all commands that somehow changes a table
  This is used to check number of updates / hour
unknown's avatar
unknown committed
519 520 521

  sql_command is actually set to SQLCOM_END sometimes
  so we need the +1 to include it in the array.
522 523
*/

unknown's avatar
unknown committed
524
char  uc_update_queries[SQLCOM_END+1];
525 526 527

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

530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548
  uc_update_queries[SQLCOM_CREATE_TABLE]=1;
  uc_update_queries[SQLCOM_CREATE_INDEX]=1;
  uc_update_queries[SQLCOM_ALTER_TABLE]=1;
  uc_update_queries[SQLCOM_UPDATE]=1;
  uc_update_queries[SQLCOM_INSERT]=1;
  uc_update_queries[SQLCOM_INSERT_SELECT]=1;
  uc_update_queries[SQLCOM_DELETE]=1;
  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;
  uc_update_queries[SQLCOM_REPLACE]=1;
  uc_update_queries[SQLCOM_REPLACE_SELECT]=1;
  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_DELETE_MULTI]=1;
  uc_update_queries[SQLCOM_DROP_INDEX]=1;
549
  uc_update_queries[SQLCOM_UPDATE_MULTI]=1;
unknown's avatar
VIEW  
unknown committed
550 551
  uc_update_queries[SQLCOM_CREATE_VIEW]=1;
  uc_update_queries[SQLCOM_DROP_VIEW]=1;
552 553
}

unknown's avatar
unknown committed
554 555
bool is_update_query(enum enum_sql_command command)
{
unknown's avatar
unknown committed
556
  DBUG_ASSERT(command >= 0 && command <= SQLCOM_END);
unknown's avatar
unknown committed
557 558
  return uc_update_queries[command];
}
559

unknown's avatar
unknown committed
560 561 562
/*
  Check if maximum queries per hour limit has been reached
  returns 0 if OK.
unknown's avatar
unknown committed
563

564 565 566
  In theory we would need a mutex in the USER_CONN structure for this to
  be 100 % safe, but as the worst scenario is that we would miss counting
  a couple of queries, this isn't critical.
unknown's avatar
unknown committed
567 568
*/

569

570
static bool check_mqh(THD *thd, uint check_command)
unknown's avatar
unknown committed
571
{
unknown's avatar
unknown committed
572 573 574
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return(0);
#else
unknown's avatar
unknown committed
575
  bool error=0;
unknown's avatar
unknown committed
576
  time_t check_time = thd->start_time ?  thd->start_time : time(NULL);
577
  USER_CONN *uc=thd->user_connect;
unknown's avatar
unknown committed
578
  DBUG_ENTER("check_mqh");
579
  DBUG_ASSERT(uc != 0);
unknown's avatar
unknown committed
580

unknown's avatar
unknown committed
581
  /* If more than a hour since last check, reset resource checking */
582 583 584 585 586 587 588 589 590
  if (check_time  - uc->intime >= 3600)
  {
    (void) pthread_mutex_lock(&LOCK_user_conn);
    uc->questions=1;
    uc->updates=0;
    uc->conn_per_hour=0;
    uc->intime=check_time;
    (void) pthread_mutex_unlock(&LOCK_user_conn);
  }
unknown's avatar
unknown committed
591
  /* Check that we have not done too many questions / hour */
592 593 594
  if (uc->user_resources.questions &&
      uc->questions++ >= uc->user_resources.questions)
  {
595
    net_printf(thd, ER_USER_LIMIT_REACHED, uc->user, "max_questions",
596 597 598 599
	       (long) uc->user_resources.questions);
    error=1;
    goto end;
  }
600
  if (check_command < (uint) SQLCOM_END)
unknown's avatar
unknown committed
601
  {
unknown's avatar
unknown committed
602 603 604 605
    /* 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)
    {
606
      net_printf(thd, ER_USER_LIMIT_REACHED, uc->user, "max_updates",
unknown's avatar
unknown committed
607 608 609 610
		 (long) uc->user_resources.updates);
      error=1;
      goto end;
    }
unknown's avatar
unknown committed
611 612
  }
end:
613
  DBUG_RETURN(error);
unknown's avatar
unknown committed
614
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
615 616
}

unknown's avatar
unknown committed
617

unknown's avatar
unknown committed
618
static void reset_mqh(THD *thd, LEX_USER *lu, bool get_them= 0)
619
{
unknown's avatar
unknown committed
620
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
621
  (void) pthread_mutex_lock(&LOCK_user_conn);
unknown's avatar
unknown committed
622
  if (lu)  // for GRANT
623
  {
624
    USER_CONN *uc;
625
    uint temp_len=lu->user.length+lu->host.length+2;
626 627
    char temp_user[USERNAME_LENGTH+HOSTNAME_LENGTH+2];

unknown's avatar
unknown committed
628 629
    memcpy(temp_user,lu->user.str,lu->user.length);
    memcpy(temp_user+lu->user.length+1,lu->host.str,lu->host.length);
630
    temp_user[lu->user.length]='\0'; temp_user[temp_len-1]=0;
unknown's avatar
unknown committed
631
    if ((uc = (struct  user_conn *) hash_search(&hash_user_connections,
632
						(byte*) temp_user, temp_len)))
633 634
    {
      uc->questions=0;
635
      get_mqh(temp_user,&temp_user[lu->user.length+1],uc);
636 637
      uc->updates=0;
      uc->conn_per_hour=0;
638 639
    }
  }
unknown's avatar
unknown committed
640
  else
641
  {
unknown's avatar
unknown committed
642
    /* for FLUSH PRIVILEGES and FLUSH USER_RESOURCES */
unknown's avatar
unknown committed
643
    for (uint idx=0;idx < hash_user_connections.records; idx++)
644
    {
unknown's avatar
unknown committed
645 646
      USER_CONN *uc=(struct user_conn *) hash_element(&hash_user_connections,
						      idx);
647 648 649 650 651
      if (get_them)
	get_mqh(uc->user,uc->host,uc);
      uc->questions=0;
      uc->updates=0;
      uc->conn_per_hour=0;
652 653
    }
  }
unknown's avatar
unknown committed
654
  (void) pthread_mutex_unlock(&LOCK_user_conn);
unknown's avatar
unknown committed
655
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
656
}
unknown's avatar
unknown committed
657

unknown's avatar
unknown committed
658
/*
659
    Perform handshake, authorize client and update thd ACL variables.
660
  SYNOPSIS
661
    check_connection()
662
    thd  thread handle
663 664

  RETURN
665
     0  success, OK is sent to user, thd is updated.
666 667
    -1  error, which is sent to user
   > 0  error code (not sent to user)
unknown's avatar
unknown committed
668 669
*/

unknown's avatar
unknown committed
670 671
#ifndef EMBEDDED_LIBRARY
static int check_connection(THD *thd)
unknown's avatar
unknown committed
672
{
673
  uint connect_errors= 0;
unknown's avatar
unknown committed
674
  NET *net= &thd->net;
675

676 677 678
  DBUG_PRINT("info",
             ("New connection received on %s", vio_description(net->vio)));

unknown's avatar
unknown committed
679 680
  if (!thd->host)                           // If TCP/IP connection
  {
681
    char ip[30];
682

683
    if (vio_peer_addr(net->vio, ip, &thd->peer_port))
unknown's avatar
unknown committed
684
      return (ER_BAD_HOST_ERROR);
685
    if (!(thd->ip= my_strdup(ip,MYF(0))))
unknown's avatar
unknown committed
686
      return (ER_OUT_OF_RESOURCES);
687
    thd->host_or_ip= thd->ip;
unknown's avatar
unknown committed
688 689 690
#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
691
    {
unknown's avatar
unknown committed
692 693
      thd->host= (char*) my_localhost;
      thd->host_or_ip= my_localhost;
unknown's avatar
unknown committed
694
    }
unknown's avatar
unknown committed
695 696 697
    else
#endif
    {
698 699 700 701 702 703
      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
704
	{
705
	  thd->host[min(strlen(thd->host), HOSTNAME_LENGTH)]= 0;
unknown's avatar
unknown committed
706 707
	  thd->host_or_ip= thd->host;
	}
708 709 710
	if (connect_errors > max_connect_errors)
	  return(ER_HOST_IS_BLOCKED);
      }
unknown's avatar
unknown committed
711
    }
unknown's avatar
unknown committed
712 713 714
    DBUG_PRINT("info",("Host: %s  ip: %s",
		       thd->host ? thd->host : "unknown host",
		       thd->ip ? thd->ip : "unknown ip"));
unknown's avatar
unknown committed
715 716 717
    if (acl_check_host(thd->host,thd->ip))
      return(ER_HOST_NOT_PRIVILEGED);
  }
718
  else /* Hostname given means that the connection was on a socket */
unknown's avatar
unknown committed
719
  {
unknown's avatar
unknown committed
720
    DBUG_PRINT("info",("Host: %s",thd->host));
721 722
    thd->host_or_ip= thd->host;
    thd->ip= 0;
723
    bzero((char*) &thd->remote, sizeof(struct sockaddr));
unknown's avatar
unknown committed
724 725
  }
  vio_keepalive(net->vio, TRUE);
726 727
  ulong pkt_len= 0;
  char *end;
unknown's avatar
unknown committed
728
  {
unknown's avatar
unknown committed
729
    /* buff[] needs to big enough to hold the server_version variable */
730
    char buff[SERVER_VERSION_LENGTH + SCRAMBLE_LENGTH + 64];
731 732
    ulong client_flags = (CLIENT_LONG_FLAG | CLIENT_CONNECT_WITH_DB |
			  CLIENT_PROTOCOL_41 | CLIENT_SECURE_CONNECTION);
unknown's avatar
unknown committed
733

734 735 736 737 738
    if (opt_using_transactions)
      client_flags|=CLIENT_TRANSACTIONS;
#ifdef HAVE_COMPRESS
    client_flags |= CLIENT_COMPRESS;
#endif /* HAVE_COMPRESS */
unknown's avatar
unknown committed
739 740
#ifdef HAVE_OPENSSL
    if (ssl_acceptor_fd)
741
      client_flags |= CLIENT_SSL;       /* Wow, SSL is available! */
unknown's avatar
unknown committed
742
#endif /* HAVE_OPENSSL */
unknown's avatar
unknown committed
743

744 745 746 747 748 749 750 751 752 753 754
    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
755
      tail: that's why first part of the scramble is placed here, and second
756 757
      part at the end of packet.
    */
758
    end= strmake(end, thd->scramble, SCRAMBLE_LENGTH_323) + 1;
759 760 761
   
    int2store(end, client_flags);
    /* write server characteristics: up to 16 bytes allowed */
762
    end[2]=(char) default_charset_info->number;
763 764 765 766 767 768 769 770 771
    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
772
			  (uint) (end-buff)) ||
773
	(pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
774 775 776 777 778 779 780 781 782 783 784
	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
785
  if (thd->packet.alloc(thd->variables.net_buffer_length))
unknown's avatar
unknown committed
786 787 788
    return(ER_OUT_OF_RESOURCES);

  thd->client_capabilities=uint2korr(net->read_pos);
789 790 791 792 793 794 795 796 797 798 799
#ifdef TO_BE_REMOVED_IN_4_1_RELEASE
  /*
    This is just a safety check against any client that would use the old
    CLIENT_CHANGE_USER flag
  */
  if ((thd->client_capabilities & CLIENT_PROTOCOL_41) &&
      !(thd->client_capabilities & (CLIENT_RESERVED |
				    CLIENT_SECURE_CONNECTION |
				    CLIENT_MULTI_RESULTS)))
    thd->client_capabilities&= ~CLIENT_PROTOCOL_41;
#endif
800 801 802 803
  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
804 805 806 807 808 809 810
    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
    */
811
    if (!(thd->variables.character_set_client=
unknown's avatar
unknown committed
812 813 814 815
	  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))
816
    {
817 818
      thd->variables.character_set_client=
	global_system_variables.character_set_client;
819 820
      thd->variables.collation_connection=
	global_system_variables.collation_connection;
821 822
      thd->variables.character_set_results=
	global_system_variables.character_set_results;
823 824 825
    }
    else
    {
826
      thd->variables.character_set_results=
827 828 829
      thd->variables.collation_connection= 
	thd->variables.character_set_client;
    }
unknown's avatar
unknown committed
830
    thd->update_charset();
831
    end= (char*) net->read_pos+32;
832 833 834 835 836 837 838
  }
  else
  {
    thd->max_client_packet_length= uint3korr(net->read_pos+2);
    end= (char*) net->read_pos+5;
  }

839
  if (thd->client_capabilities & CLIENT_IGNORE_SPACE)
840
    thd->variables.sql_mode|= MODE_IGNORE_SPACE;
unknown's avatar
unknown committed
841
#ifdef HAVE_OPENSSL
unknown's avatar
unknown committed
842
  DBUG_PRINT("info", ("client capabilities: %d", thd->client_capabilities));
unknown's avatar
unknown committed
843 844 845
  if (thd->client_capabilities & CLIENT_SSL)
  {
    /* Do the SSL layering. */
846 847 848 849 850
    if (!ssl_acceptor_fd)
    {
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
unknown's avatar
unknown committed
851
    DBUG_PRINT("info", ("IO layer change in progress..."));
unknown's avatar
unknown committed
852 853 854 855 856
    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
857
      return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
858
    }
unknown's avatar
unknown committed
859
    DBUG_PRINT("info", ("Reading user information over SSL layer"));
860
    if ((pkt_len= my_net_read(net)) == packet_error ||
unknown's avatar
unknown committed
861 862
	pkt_len < NORMAL_HANDSHAKE_SIZE)
    {
unknown's avatar
unknown committed
863 864
      DBUG_PRINT("error", ("Failed to read user information (pkt_len= %lu)",
			   pkt_len));
unknown's avatar
unknown committed
865 866 867 868
      inc_host_errors(&thd->remote.sin_addr);
      return(ER_HANDSHAKE_ERROR);
    }
  }
869 870 871
#endif

  if (end >= (char*) net->read_pos+ pkt_len +2)
unknown's avatar
unknown committed
872
  {
873 874
    inc_host_errors(&thd->remote.sin_addr);
    return(ER_HANDSHAKE_ERROR);
unknown's avatar
unknown committed
875 876 877
  }

  if (thd->client_capabilities & CLIENT_INTERACTIVE)
878
    thd->variables.net_wait_timeout= thd->variables.net_interactive_timeout;
879
  if ((thd->client_capabilities & CLIENT_TRANSACTIONS) &&
880 881
      opt_using_transactions)
    net->return_status= &thd->server_status;
unknown's avatar
unknown committed
882
  net->read_timeout=(uint) thd->variables.net_read_timeout;
unknown's avatar
unknown committed
883

884 885
  char *user= end;
  char *passwd= strend(user)+1;
unknown's avatar
unknown committed
886
  char *db= passwd;
887
  char db_buff[NAME_LEN+1];                     // buffer to store db in utf8 
unknown's avatar
unknown committed
888
  char user_buff[USERNAME_LENGTH+1];		// buffer to store user in utf8
unknown's avatar
unknown committed
889 890 891 892 893 894 895 896 897
  /* 
    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'.
  */
  uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ? 
    *passwd++ : strlen(passwd);
  db= thd->client_capabilities & CLIENT_CONNECT_WITH_DB ?
    db + passwd_len + 1 : 0;
unknown's avatar
unknown committed
898

unknown's avatar
unknown committed
899 900
  /* Since 4.1 all database names are stored in utf8 */
  if (db)
unknown's avatar
unknown committed
901
  {
902 903 904 905
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info,
                             db, strlen(db),
                             thd->charset())]= 0;
906
    db= db_buff;
unknown's avatar
unknown committed
907
  }
unknown's avatar
unknown committed
908

unknown's avatar
unknown committed
909 910 911 912 913 914 915 916
  if (user)
  {
    user_buff[copy_and_convert(user_buff, sizeof(user_buff)-1,
			       system_charset_info, user, strlen(user),
			       thd->charset())]= '\0';
    user= user_buff;
  }

917 918
  if (thd->user)
    x_free(thd->user);
919 920
  if (!(thd->user= my_strdup(user, MYF(0))))
    return (ER_OUT_OF_RESOURCES);
unknown's avatar
unknown committed
921
  return check_user(thd, COM_CONNECT, passwd, passwd_len, db, TRUE);
unknown's avatar
unknown committed
922 923
}

924

925 926
void execute_init_command(THD *thd, sys_var_str *init_command_var,
			  rw_lock_t *var_mutex)
unknown's avatar
unknown committed
927 928 929 930
{
  Vio* save_vio;
  ulong save_client_capabilities;

931 932 933 934 935 936 937 938 939
  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
940 941
  save_client_capabilities= thd->client_capabilities;
  thd->client_capabilities|= CLIENT_MULTI_QUERIES;
942 943 944 945
  /*
    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
946 947 948
  save_vio= thd->net.vio;
  thd->net.vio= 0;
  dispatch_command(COM_QUERY, thd, thd->query, thd->query_length+1);
949
  rw_unlock(var_mutex);
unknown's avatar
unknown committed
950 951 952 953 954
  thd->client_capabilities= save_client_capabilities;
  thd->net.vio= save_vio;
}


unknown's avatar
unknown committed
955 956 957 958
pthread_handler_decl(handle_one_connection,arg)
{
  THD *thd=(THD*) arg;
  uint launch_time  =
unknown's avatar
unknown committed
959
    (uint) ((thd->thr_create_time = time(NULL)) - thd->connect_time);
unknown's avatar
unknown committed
960 961 962 963 964
  if (launch_time >= slow_launch_time)
    statistic_increment(slow_launch_threads,&LOCK_status );

  pthread_detach_this_thread();

965
#if !defined( __WIN__) && !defined(OS2)	// Win32 calls this in pthread_create
unknown's avatar
unknown committed
966
  /* The following calls needs to be done before we call DBUG_ macros */
967
  if (!(test_flags & TEST_NO_THREADS) & my_thread_init())
unknown's avatar
unknown committed
968
  {
969
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
970
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
971 972 973 974 975
    end_thread(thd,0);
    return 0;
  }
#endif

976 977 978 979 980 981 982
  /*
    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
983 984
  DBUG_PRINT("info", ("handle_one_connection called by thread %d\n",
		      thd->thread_id));
unknown's avatar
unknown committed
985
  /* now that we've called my_thread_init(), it is safe to call DBUG_* */
unknown's avatar
unknown committed
986

unknown's avatar
unknown committed
987
#if defined(__WIN__)
unknown's avatar
unknown committed
988
  init_signals();				// IRENA; testing ?
unknown's avatar
unknown committed
989
#elif !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
990 991 992 993 994 995
  sigset_t set;
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
#endif
  if (thd->store_globals())
  {
996
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
997
    statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
998 999 1000 1001 1002 1003 1004 1005 1006 1007
    end_thread(thd,0);
    return 0;
  }

  do
  {
    int error;
    NET *net= &thd->net;
    thd->thread_stack= (char*) &thd;

1008
    if ((error=check_connection(thd)))
unknown's avatar
unknown committed
1009 1010
    {						// Wrong permissions
      if (error > 0)
1011
	net_printf(thd,error,thd->host_or_ip);
unknown's avatar
unknown committed
1012 1013
#ifdef __NT__
      if (vio_type(net->vio) == VIO_TYPE_NAMEDPIPE)
1014
	my_sleep(1000);				/* must wait after eof() */
unknown's avatar
unknown committed
1015
#endif
1016
      statistic_increment(aborted_connects,&LOCK_status);
unknown's avatar
unknown committed
1017 1018
      goto end_thread;
    }
unknown's avatar
unknown committed
1019 1020 1021
#ifdef __NETWARE__
    netware_reg_user(thd->ip, thd->user, "MySQL");
#endif
1022
    if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1023 1024 1025 1026
      thd->options |= OPTION_BIG_SELECTS;
    if (thd->client_capabilities & CLIENT_COMPRESS)
      net->compress=1;				// Use compression

unknown's avatar
unknown committed
1027
    thd->version= refresh_version;
1028 1029 1030
    thd->proc_info= 0;
    thd->set_time();
    thd->init_for_queries();
unknown's avatar
unknown committed
1031

unknown's avatar
unknown committed
1032
    if (sys_init_connect.value_length && !(thd->master_access & SUPER_ACL))
unknown's avatar
unknown committed
1033
    {
1034 1035
      execute_init_command(thd, &sys_init_connect, &LOCK_sys_init_connect);
      if (thd->query_error)
unknown's avatar
unknown committed
1036
	thd->killed= THD::KILL_CONNECTION;
unknown's avatar
unknown committed
1037 1038 1039
    }

    thd->proc_info=0;
unknown's avatar
unknown committed
1040
    thd->set_time();
1041
    thd->init_for_queries();
unknown's avatar
SCRUM  
unknown committed
1042
    while (!net->error && net->vio != 0 && !(thd->killed == THD::KILL_CONNECTION))
unknown's avatar
unknown committed
1043 1044 1045 1046
    {
      if (do_command(thd))
	break;
    }
1047 1048
    if (thd->user_connect)
      decrease_user_connections(thd->user_connect);
unknown's avatar
unknown committed
1049
    if (net->error && net->vio != 0 && net->report_error)
unknown's avatar
unknown committed
1050
    {
1051
      if (!thd->killed && thd->variables.log_warnings > 1)
unknown's avatar
unknown committed
1052
	sql_print_warning(ER(ER_NEW_ABORTING_CONNECTION),
unknown's avatar
unknown committed
1053 1054 1055 1056 1057
                          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)));
1058
      send_error(thd,net->last_errno,NullS);
unknown's avatar
unknown committed
1059
      statistic_increment(aborted_threads,&LOCK_status);
unknown's avatar
unknown committed
1060
    }
1061 1062 1063 1064
    else if (thd->killed)
    {
      statistic_increment(aborted_threads,&LOCK_status);
    }
1065
    
unknown's avatar
unknown committed
1066
end_thread:
1067
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078
    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
1079 1080
#endif /* EMBEDDED_LIBRARY */

1081 1082 1083 1084
/*
  Execute commands from bootstrap_file.
  Used when creating the initial grant tables
*/
unknown's avatar
unknown committed
1085

1086
extern "C" pthread_handler_decl(handle_bootstrap,arg)
unknown's avatar
unknown committed
1087
{
1088 1089 1090
  THD *thd=(THD*) arg;
  FILE *file=bootstrap_file;
  char *buff;
unknown's avatar
unknown committed
1091

1092
  /* The following must be called before DBUG_ENTER */
1093
  if (my_thread_init() || thd->store_globals())
unknown's avatar
unknown committed
1094
  {
unknown's avatar
unknown committed
1095
#ifndef EMBEDDED_LIBRARY
1096
    close_connection(thd, ER_OUT_OF_RESOURCES, 1);
unknown's avatar
unknown committed
1097
#endif
1098
    thd->fatal_error();
1099
    goto end;
unknown's avatar
unknown committed
1100
  }
1101 1102
  DBUG_ENTER("handle_bootstrap");

unknown's avatar
unknown committed
1103
#ifndef EMBEDDED_LIBRARY
1104 1105
  pthread_detach_this_thread();
  thd->thread_stack= (char*) &thd;
unknown's avatar
unknown committed
1106
#if !defined(__WIN__) && !defined(OS2) && !defined(__NETWARE__)
unknown's avatar
unknown committed
1107
  sigset_t set;
1108 1109
  VOID(sigemptyset(&set));			// Get mask in use
  VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
unknown's avatar
unknown committed
1110
#endif
unknown's avatar
unknown committed
1111
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
1112

1113
  if (thd->variables.max_join_size == HA_POS_ERROR)
unknown's avatar
unknown committed
1114 1115 1116 1117
    thd->options |= OPTION_BIG_SELECTS;

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

1120
  buff= (char*) thd->net.buff;
1121
  thd->init_for_queries();
unknown's avatar
unknown committed
1122 1123
  while (fgets(buff, thd->net.max_packet, file))
  {
unknown's avatar
unknown committed
1124
    uint length=(uint) strlen(buff);
1125 1126 1127 1128 1129 1130
    if (buff[length-1]!='\n' && !feof(file))
    {
      send_error(thd,ER_NET_PACKET_TOO_LARGE, NullS);
      thd->is_fatal_error= 1;
      break;
    }
unknown's avatar
unknown committed
1131
    while (length && (my_isspace(thd->charset(), buff[length-1]) ||
1132
           buff[length-1] == ';'))
unknown's avatar
unknown committed
1133 1134
      length--;
    buff[length]=0;
1135
    thd->query_length=length;
unknown's avatar
unknown committed
1136 1137
    thd->query= thd->memdup_w_gap(buff, length+1, thd->db_length+1);
    thd->query[length] = '\0';
1138 1139 1140 1141
    /*
      We don't need to obtain LOCK_thread_count here because in bootstrap
      mode we have only one thread.
    */
unknown's avatar
unknown committed
1142
    thd->query_id=query_id++;
1143
    if (mqh_used && thd->user_connect && check_mqh(thd, SQLCOM_END))
1144 1145 1146 1147 1148 1149
    {
      thd->net.error = 0;
      close_thread_tables(thd);			// Free tables
      free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
      break;
    }
unknown's avatar
unknown committed
1150 1151
    mysql_parse(thd,thd->query,length);
    close_thread_tables(thd);			// Free tables
1152
    if (thd->is_fatal_error)
1153
      break;
1154
    free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
1155
    free_root(&thd->transaction.mem_root,MYF(MY_KEEP_PREALLOC));
unknown's avatar
unknown committed
1156
  }
1157 1158 1159

  /* thd->fatal_error should be set in case something went wrong */
end:
unknown's avatar
unknown committed
1160
#ifndef EMBEDDED_LIBRARY
1161 1162 1163
  (void) pthread_mutex_lock(&LOCK_thread_count);
  thread_count--;
  (void) pthread_mutex_unlock(&LOCK_thread_count);
1164
  (void) pthread_cond_broadcast(&COND_thread_count);
1165 1166
  my_thread_end();
  pthread_exit(0);
unknown's avatar
unknown committed
1167
#endif
1168
  DBUG_RETURN(0);				// Never reached
unknown's avatar
unknown committed
1169 1170
}

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

1173
void free_items(Item *item)
unknown's avatar
unknown committed
1174
{
unknown's avatar
unknown committed
1175
  DBUG_ENTER("free_items");
1176
  for (; item ; item=item->next)
1177
    item->delete_self();
unknown's avatar
unknown committed
1178
  DBUG_VOID_RETURN;
unknown's avatar
unknown committed
1179 1180
}

1181 1182 1183 1184 1185 1186 1187 1188
    /* 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
1189 1190 1191 1192 1193 1194 1195
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;
1196
  if (!(table_list = (TABLE_LIST*) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
1197
    DBUG_RETURN(1); // out of memory
unknown's avatar
VIEW  
unknown committed
1198 1199 1200 1201
  table_list->db= db;
  table_list->real_name= table_list->alias= tbl_name;
  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
1202

1203 1204
  if (!db || check_db_name(db))
  {
1205
    net_printf(thd,ER_WRONG_DB_NAME, db ? db : "NULL");
1206 1207
    goto err;
  }
1208
  if (lower_case_table_names)
1209
    my_casedn_str(files_charset_info, tbl_name);
unknown's avatar
unknown committed
1210
  remove_escape(table_list->real_name);
1211 1212 1213 1214

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

unknown's avatar
unknown committed
1215
  if (check_one_table_access(thd, SELECT_ACL, table_list))
unknown's avatar
unknown committed
1216 1217
    goto err;
  thd->free_list = 0;
unknown's avatar
unknown committed
1218
  thd->query_length=(uint) strlen(tbl_name);
unknown's avatar
unknown committed
1219
  thd->query = tbl_name;
1220 1221
  if ((error = mysqld_dump_create_info(thd, table, -1)))
  {
1222
    my_error(ER_GET_ERRNO, MYF(0), my_errno);
1223 1224
    goto err;
  }
unknown's avatar
unknown committed
1225
  net_flush(&thd->net);
1226
  if ((error= table->file->dump(thd,fd)))
1227
    my_error(ER_GET_ERRNO, MYF(0), error);
unknown's avatar
unknown committed
1228

unknown's avatar
unknown committed
1229 1230
err:
  close_thread_tables(thd);
unknown's avatar
unknown committed
1231
  DBUG_RETURN(error);
unknown's avatar
unknown committed
1232 1233 1234
}


1235
#ifndef EMBEDDED_LIBRARY
1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246

/*
  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
1247 1248 1249
bool do_command(THD *thd)
{
  char *packet;
unknown's avatar
unknown committed
1250 1251
  uint old_timeout;
  ulong packet_length;
unknown's avatar
unknown committed
1252 1253 1254 1255 1256
  NET *net;
  enum enum_server_command command;
  DBUG_ENTER("do_command");

  net= &thd->net;
unknown's avatar
unknown committed
1257 1258 1259 1260
  /*
    indicator of uninitialized lex => normal flow of errors handling
    (see my_message_sql)
  */
1261
  thd->lex->current_select= 0;
unknown's avatar
unknown committed
1262 1263

  packet=0;
unknown's avatar
unknown committed
1264
  old_timeout=net->read_timeout;
unknown's avatar
unknown committed
1265
  /* Wait max for 8 hours */
unknown's avatar
unknown committed
1266
  net->read_timeout=(uint) thd->variables.net_wait_timeout;
unknown's avatar
unknown committed
1267
  thd->clear_error();				// Clear error message
unknown's avatar
unknown committed
1268 1269 1270 1271

  net_new_transaction(net);
  if ((packet_length=my_net_read(net)) == packet_error)
  {
1272 1273 1274 1275 1276
    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)
1277 1278
    {
      statistic_increment(aborted_threads,&LOCK_status);
1279
      DBUG_RETURN(TRUE);			// We have to close it.
1280
    }
1281
    send_error(thd,net->last_errno,NullS);
1282
    net->error= 0;
1283
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
1284 1285 1286
  }
  else
  {
unknown's avatar
unknown committed
1287
    if (thd->killed == THD::KILL_QUERY || thd->killed == THD::KILL_BAD_DATA)
unknown's avatar
SCRUM  
unknown committed
1288
      thd->killed= THD::NOT_KILLED;
unknown's avatar
SCRUM  
unknown committed
1289

unknown's avatar
unknown committed
1290 1291
    packet=(char*) net->read_pos;
    command = (enum enum_server_command) (uchar) packet[0];
1292 1293
    if (command >= COM_END)
      command= COM_END;				// Wrong command
unknown's avatar
unknown committed
1294 1295 1296
    DBUG_PRINT("info",("Command on %s = %d (%s)",
		       vio_description(net->vio), command,
		       command_name[command]));
unknown's avatar
unknown committed
1297
  }
unknown's avatar
unknown committed
1298
  net->read_timeout=old_timeout;		// restore it
1299 1300 1301 1302 1303 1304 1305 1306 1307
  /*
    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
1308
  DBUG_RETURN(dispatch_command(command,thd, packet+1, (uint) packet_length));
1309
}
1310
#endif  /* EMBEDDED_LIBRARY */
1311

1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
/*
   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
*/
1327

1328 1329 1330 1331
bool dispatch_command(enum enum_server_command command, THD *thd,
		      char* packet, uint packet_length)
{
  NET *net= &thd->net;
1332
  bool error= 0;
1333 1334 1335
  DBUG_ENTER("dispatch_command");

  thd->command=command;
unknown's avatar
unknown committed
1336 1337 1338 1339
  /*
    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
  */
1340
  thd->slow_command=FALSE;
1341
  thd->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
unknown's avatar
unknown committed
1342
  thd->set_time();
unknown's avatar
unknown committed
1343 1344 1345 1346 1347
  VOID(pthread_mutex_lock(&LOCK_thread_count));
  thd->query_id=query_id;
  if (command != COM_STATISTICS && command != COM_PING)
    query_id++;
  thread_running++;
1348
  /* TODO: set thd->lex->sql_command to SQLCOM_END here */
unknown's avatar
unknown committed
1349
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1350

1351 1352
  thd->server_status&=
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
1353
  switch (command) {
unknown's avatar
unknown committed
1354
  case COM_INIT_DB:
unknown's avatar
unknown committed
1355 1356
  {
    LEX_STRING tmp;
1357 1358
    statistic_increment(thd->status_var.com_stat[SQLCOM_CHANGE_DB],
			&LOCK_status);
unknown's avatar
unknown committed
1359 1360 1361 1362 1363 1364
    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
1365
#ifdef HAVE_REPLICATION
1366 1367
  case COM_REGISTER_SLAVE:
  {
1368
    if (!register_slave(thd, (uchar*)packet, packet_length))
1369
      send_ok(thd);
1370 1371
    break;
  }
1372
#endif
unknown's avatar
unknown committed
1373
  case COM_TABLE_DUMP:
1374 1375 1376 1377 1378
  {
    char *db, *tbl_name;
    uint db_len= *(uchar*) packet;
    uint tbl_len= *(uchar*) (packet + db_len + 1);

1379
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1380
    thd->slow_command= TRUE;
1381 1382 1383 1384 1385 1386 1387
    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);
    if (mysql_table_dump(thd, db, tbl_name, -1))
      send_error(thd); // dump to NET
    break;
  }
unknown's avatar
unknown committed
1388 1389
  case COM_CHANGE_USER:
  {
unknown's avatar
unknown committed
1390
    thd->change_user();
1391
    thd->clear_error();                         // if errors from rollback
unknown's avatar
unknown committed
1392

1393
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1394
    char *user= (char*) packet;
unknown's avatar
unknown committed
1395
    char *passwd= strend(user)+1;
unknown's avatar
unknown committed
1396 1397 1398 1399 1400
    /* 
      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).
    */
1401
    char db_buff[NAME_LEN+1];                 // buffer to store db in utf8 
unknown's avatar
unknown committed
1402 1403 1404 1405
    char *db= passwd;
    uint passwd_len= thd->client_capabilities & CLIENT_SECURE_CONNECTION ? 
      *passwd++ : strlen(passwd);
    db+= passwd_len + 1;
1406
#ifndef EMBEDDED_LIBRARY
1407
    /* Small check for incoming packet */
unknown's avatar
unknown committed
1408
    if ((uint) ((uchar*) db - net->read_pos) > packet_length)
1409 1410 1411 1412
    {
      send_error(thd, ER_UNKNOWN_COM_ERROR);
      break;
    }
1413
#endif
1414
    /* Convert database name to utf8 */
1415 1416 1417 1418
    db_buff[copy_and_convert(db_buff, sizeof(db_buff)-1,
                             system_charset_info, db, strlen(db),
                             thd->charset())]= 0;
    db= db_buff;
unknown's avatar
unknown committed
1419

1420 1421 1422 1423 1424 1425 1426
    /* 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
1427
    USER_CONN *save_user_connect= thd->user_connect;
unknown's avatar
unknown committed
1428 1429
    
    if (!(thd->user= my_strdup(user, MYF(0))))
1430 1431 1432 1433 1434
    {
      thd->user= save_user;
      send_error(thd, ER_OUT_OF_RESOURCES);
      break;
    }
unknown's avatar
unknown committed
1435

unknown's avatar
unknown committed
1436 1437
    /* Clear variables that are allocated */
    thd->user_connect= 0;
unknown's avatar
unknown committed
1438
    int res= check_user(thd, COM_CHANGE_USER, passwd, passwd_len, db, FALSE);
unknown's avatar
unknown committed
1439

1440 1441
    if (res)
    {
1442
      /* authentication failure, we shall restore old user */
1443 1444 1445 1446 1447
      if (res > 0)
        send_error(thd, ER_UNKNOWN_COM_ERROR);
      x_free(thd->user);
      thd->user= save_user;
      thd->priv_user= save_priv_user;
unknown's avatar
unknown committed
1448
      thd->user_connect= save_user_connect;
1449 1450 1451 1452 1453 1454 1455 1456
      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
1457 1458
      if (save_user_connect)
	decrease_user_connections(save_user_connect);
1459 1460 1461
      x_free((gptr) save_db);
      x_free((gptr) save_user);
    }
unknown's avatar
unknown committed
1462 1463
    break;
  }
unknown's avatar
unknown committed
1464 1465
  case COM_EXECUTE:
  {
1466
    mysql_stmt_execute(thd, packet, packet_length);
unknown's avatar
unknown committed
1467 1468
    break;
  }
1469 1470 1471 1472 1473
  case COM_FETCH:
  {
    mysql_stmt_fetch(thd, packet, packet_length);
    break;
  }
unknown's avatar
unknown committed
1474 1475
  case COM_LONG_DATA:
  {
1476
    mysql_stmt_get_longdata(thd, packet, packet_length);
unknown's avatar
unknown committed
1477 1478 1479 1480
    break;
  }
  case COM_PREPARE:
  {
1481
    mysql_stmt_prepare(thd, packet, packet_length);
unknown's avatar
unknown committed
1482 1483
    break;
  }
unknown's avatar
unknown committed
1484 1485 1486 1487 1488
  case COM_CLOSE_STMT:
  {
    mysql_stmt_free(thd, packet);
    break;
  }
1489 1490 1491 1492 1493
  case COM_RESET_STMT:
  {
    mysql_stmt_reset(thd, packet);
    break;
  }
unknown's avatar
unknown committed
1494 1495
  case COM_QUERY:
  {
1496 1497
    if (alloc_query(thd, packet, packet_length))
      break;					// fatal error is set
1498
    mysql_log.write(thd,command,"%s",thd->query);
1499
    DBUG_PRINT("query",("%-.4096s",thd->query));
1500
    mysql_parse(thd,thd->query, thd->query_length);
1501

unknown's avatar
unknown committed
1502
    while (!thd->killed && !thd->is_fatal_error && thd->lex->found_colon)
1503
    {
unknown's avatar
unknown committed
1504
      char *packet= thd->lex->found_colon;
1505
      /*
1506
        Multiple queries exits, execute them individually
1507
	in embedded server - just store them to be executed later 
1508
      */
1509
#ifndef EMBEDDED_LIBRARY
1510
      if (thd->lock || thd->open_tables || thd->derived_tables)
1511
        close_thread_tables(thd);
1512 1513
#endif
      ulong length= thd->query_length-(ulong)(packet-thd->query);
1514

1515
      /* Remove garbage at start of query */
unknown's avatar
unknown committed
1516
      while (my_isspace(thd->charset(), *packet) && length > 0)
1517 1518 1519 1520
      {
        packet++;
        length--;
      }
unknown's avatar
unknown committed
1521
      VOID(pthread_mutex_lock(&LOCK_thread_count));
1522
      thd->query_length= length;
1523 1524
      thd->query= packet;
      thd->query_id= query_id++;
1525
      /* TODO: set thd->lex->sql_command to SQLCOM_END here */
1526
      VOID(pthread_mutex_unlock(&LOCK_thread_count));
1527
#ifndef EMBEDDED_LIBRARY
1528
      mysql_parse(thd, packet, length);
1529
#else
unknown's avatar
unknown committed
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
      /*
	'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
1540
	thd->query_rest.copy(packet, length, thd->query_rest.charset());
1541 1542
      break;
#endif /*EMBEDDED_LIBRARY*/
1543 1544
    }

unknown's avatar
unknown committed
1545 1546 1547 1548 1549
    if (!(specialflag & SPECIAL_NO_PRIOR))
      my_pthread_setprio(pthread_self(),WAIT_PRIOR);
    DBUG_PRINT("info",("query ready"));
    break;
  }
1550
  case COM_FIELD_LIST:				// This isn't actually needed
unknown's avatar
unknown committed
1551
#ifdef DONT_ALLOW_SHOW_COMMANDS
1552
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
unknown's avatar
unknown committed
1553 1554 1555
    break;
#else
  {
1556
    char *fields, *pend;
unknown's avatar
unknown committed
1557
    TABLE_LIST table_list;
unknown's avatar
unknown committed
1558 1559
    LEX_STRING conv_name;

1560 1561
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_FIELDS],
			&LOCK_status);
unknown's avatar
unknown committed
1562 1563 1564
    bzero((char*) &table_list,sizeof(table_list));
    if (!(table_list.db=thd->db))
    {
1565
      send_error(thd,ER_NO_DB_ERROR);
unknown's avatar
unknown committed
1566 1567
      break;
    }
1568
    pend= strend(packet);
unknown's avatar
unknown committed
1569 1570 1571
    thd->convert_string(&conv_name, system_charset_info,
			packet, (uint) (pend-packet), thd->charset());
    table_list.alias= table_list.real_name= conv_name.str;
1572
    packet= pend+1;
unknown's avatar
unknown committed
1573
    /*  command not cachable => no gap for data base name */
unknown's avatar
unknown committed
1574 1575
    if (!(thd->query=fields=thd->memdup(packet,thd->query_length+1)))
      break;
1576
    mysql_log.write(thd,command,"%s %s",table_list.real_name,fields);
1577
    if (lower_case_table_names)
unknown's avatar
unknown committed
1578
      my_casedn_str(files_charset_info, table_list.real_name);
unknown's avatar
unknown committed
1579 1580
    remove_escape(table_list.real_name);	// This can't have wildcards

unknown's avatar
unknown committed
1581 1582
    if (check_access(thd,SELECT_ACL,table_list.db,&table_list.grant.privilege,
		     0, 0))
unknown's avatar
unknown committed
1583
      break;
unknown's avatar
unknown committed
1584 1585
    if (grant_option &&
	check_grant(thd, SELECT_ACL, &table_list, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
1586
      break;
1587 1588 1589 1590 1591 1592 1593
    /* 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);

1594 1595
    /* switch on VIEW optimisation: do not fill temporary tables */
    thd->lex->sql_command= SQLCOM_SHOW_FIELDS;
unknown's avatar
unknown committed
1596
    mysqld_list_fields(thd,&table_list,fields);
1597
    thd->lex->unit.cleanup();
1598
    thd->cleanup_after_query();
unknown's avatar
unknown committed
1599 1600 1601 1602
    break;
  }
#endif
  case COM_QUIT:
1603
    /* We don't calculate statistics for this command */
1604
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1605 1606 1607 1608
    net->error=0;				// Don't give 'abort' message
    error=TRUE;					// End server
    break;

unknown's avatar
unknown committed
1609
  case COM_CREATE_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1610
    {
unknown's avatar
unknown committed
1611
      char *db=thd->strdup(packet), *alias;
1612
      HA_CREATE_INFO create_info;
unknown's avatar
unknown committed
1613

1614 1615
      statistic_increment(thd->status_var.com_stat[SQLCOM_CREATE_DB],
			  &LOCK_status);
1616
      // null test to handle EOM
unknown's avatar
unknown committed
1617
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1618
      {
1619
	net_printf(thd,ER_WRONG_DB_NAME, db ? db : "NULL");
1620 1621
	break;
      }
unknown's avatar
unknown committed
1622
      if (check_access(thd,CREATE_ACL,db,0,1,0))
unknown's avatar
unknown committed
1623
	break;
1624
      mysql_log.write(thd,command,packet);
1625
      bzero(&create_info, sizeof(create_info));
1626
      if (mysql_create_db(thd, (lower_case_table_names == 2 ? alias : db),
1627
                          &create_info, 0) < 0)
unknown's avatar
unknown committed
1628
        send_error(thd, thd->killed ? ER_SERVER_SHUTDOWN : 0);
unknown's avatar
unknown committed
1629 1630
      break;
    }
unknown's avatar
unknown committed
1631
  case COM_DROP_DB:				// QQ: To be removed
unknown's avatar
unknown committed
1632
    {
1633 1634
      statistic_increment(thd->status_var.com_stat[SQLCOM_DROP_DB],
			  &LOCK_status);
unknown's avatar
unknown committed
1635
      char *db=thd->strdup(packet), *alias;
unknown's avatar
unknown committed
1636
      /*  null test to handle EOM */
unknown's avatar
unknown committed
1637
      if (!db || !(alias= thd->strdup(db)) || check_db_name(db))
1638
      {
1639
	net_printf(thd,ER_WRONG_DB_NAME, db ? db : "NULL");
1640 1641
	break;
      }
unknown's avatar
unknown committed
1642
      if (check_access(thd,DROP_ACL,db,0,1,0))
1643
	break;
unknown's avatar
unknown committed
1644 1645
      if (thd->locked_tables || thd->active_transaction())
      {
1646
	send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
unknown's avatar
unknown committed
1647
	break;
unknown's avatar
unknown committed
1648
      }
1649
      mysql_log.write(thd,command,db);
1650 1651
      if (mysql_rm_db(thd, (lower_case_table_names == 2 ? alias : db),
                      0, 0) < 0)
unknown's avatar
unknown committed
1652
        send_error(thd, thd->killed ? ER_SERVER_SHUTDOWN : 0);
unknown's avatar
unknown committed
1653 1654
      break;
    }
1655
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1656 1657
  case COM_BINLOG_DUMP:
    {
1658
      statistic_increment(thd->status_var.com_other,&LOCK_status);
1659
      thd->slow_command = TRUE;
unknown's avatar
unknown committed
1660
      if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
1661
	break;
1662
      mysql_log.write(thd,command, 0);
unknown's avatar
unknown committed
1663

unknown's avatar
unknown committed
1664 1665
      ulong pos;
      ushort flags;
1666
      uint32 slave_server_id;
1667
      /* TODO: The following has to be changed to an 8 byte integer */
1668 1669
      pos = uint4korr(packet);
      flags = uint2korr(packet + 4);
unknown's avatar
unknown committed
1670
      thd->server_id=0; /* avoid suicide */
unknown's avatar
unknown committed
1671
      if ((slave_server_id= uint4korr(packet+6))) // mysqlbinlog.server_id==0
unknown's avatar
unknown committed
1672
	kill_zombie_dump_threads(slave_server_id);
1673
      thd->server_id = slave_server_id;
1674
      mysql_binlog_send(thd, thd->strdup(packet + 10), (my_off_t) pos, flags);
unknown's avatar
unknown committed
1675
      unregister_slave(thd,1,1);
unknown's avatar
unknown committed
1676
      /*  fake COM_QUIT -- if we get here, the thread needs to terminate */
1677 1678
      error = TRUE;
      net->error = 0;
unknown's avatar
unknown committed
1679 1680
      break;
    }
1681
#endif
unknown's avatar
unknown committed
1682 1683
  case COM_REFRESH:
    {
1684 1685
      statistic_increment(thd->status_var.com_stat[SQLCOM_FLUSH],
			  &LOCK_status);
unknown's avatar
unknown committed
1686
      ulong options= (ulong) (uchar) packet[0];
unknown's avatar
unknown committed
1687
      if (check_global_access(thd,RELOAD_ACL))
unknown's avatar
unknown committed
1688
	break;
1689
      mysql_log.write(thd,command,NullS);
1690 1691 1692 1693
      if (reload_acl_and_cache(thd, options, (TABLE_LIST*) 0, NULL))
        send_error(thd, 0);
      else
        send_ok(thd);
unknown's avatar
unknown committed
1694 1695
      break;
    }
1696
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1697
  case COM_SHUTDOWN:
1698
  {
1699
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
1700
    if (check_global_access(thd,SHUTDOWN_ACL))
unknown's avatar
unknown committed
1701
      break; /* purecov: inspected */
1702
    /*
1703 1704 1705 1706
      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].
1707
    */
1708 1709
    enum mysql_enum_shutdown_level level=
      (enum mysql_enum_shutdown_level) (uchar) packet[0];
1710
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1711 1712 1713 1714 1715 1716 1717 1718
    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");
      send_error(thd);
      break;
    }
1719
    DBUG_PRINT("quit",("Got shutdown command for level %u", level));
1720
    mysql_log.write(thd,command,NullS);
1721
    send_eof(thd);
unknown's avatar
unknown committed
1722 1723 1724
#ifdef __WIN__
    sleep(1);					// must wait after eof()
#endif
unknown's avatar
unknown committed
1725
#ifndef OS2
1726
    send_eof(thd);				// This is for 'quit request'
unknown's avatar
unknown committed
1727
#endif
1728
    close_connection(thd, 0, 1);
unknown's avatar
unknown committed
1729 1730 1731 1732
    close_thread_tables(thd);			// Free before kill
    kill_mysql();
    error=TRUE;
    break;
1733
  }
1734
#endif
unknown's avatar
unknown committed
1735 1736
  case COM_STATISTICS:
  {
1737
    mysql_log.write(thd,command,NullS);
1738 1739
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_STATUS],
			&LOCK_status);
unknown's avatar
unknown committed
1740
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1741
    char buff[200];
unknown's avatar
unknown committed
1742 1743 1744
#else
    char *buff= thd->net.last_error;
#endif
1745
    ulong uptime = (ulong) (thd->start_time - start_time);
unknown's avatar
unknown committed
1746
    sprintf((char*) buff,
1747
	    "Uptime: %ld  Threads: %d  Questions: %lu  Slow queries: %ld  Opens: %ld  Flush tables: %ld  Open tables: %u  Queries per second avg: %.3f",
unknown's avatar
unknown committed
1748
	    uptime,
1749 1750
	    (int) thread_count,thd->query_id,thd->status_var.long_query_count,
	    thd->status_var.opened_tables,refresh_version, cached_tables(),
unknown's avatar
unknown committed
1751 1752
	    uptime ? (float)thd->query_id/(float)uptime : 0);
#ifdef SAFEMALLOC
1753
    if (sf_malloc_cur_memory)				// Using SAFEMALLOC
unknown's avatar
unknown committed
1754
      sprintf(strend(buff), "  Memory in use: %ldK  Max memory used: %ldK",
1755 1756
	      (sf_malloc_cur_memory+1023L)/1024L,
	      (sf_malloc_max_memory+1023L)/1024L);
unknown's avatar
unknown committed
1757 1758
#endif
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
1759
    VOID(my_net_write(net, buff,(uint) strlen(buff)));
unknown's avatar
unknown committed
1760
    VOID(net_flush(net));
unknown's avatar
unknown committed
1761
#endif
unknown's avatar
unknown committed
1762 1763 1764
    break;
  }
  case COM_PING:
1765
    statistic_increment(thd->status_var.com_other, &LOCK_status);
1766
    send_ok(thd);				// Tell client we are alive
unknown's avatar
unknown committed
1767 1768
    break;
  case COM_PROCESS_INFO:
1769 1770
    statistic_increment(thd->status_var.com_stat[SQLCOM_SHOW_PROCESSLIST],
			&LOCK_status);
unknown's avatar
unknown committed
1771
    if (!thd->priv_user[0] && check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
1772
      break;
1773
    mysql_log.write(thd,command,NullS);
unknown's avatar
unknown committed
1774 1775
    mysqld_list_processes(thd,
			  thd->master_access & PROCESS_ACL ? 
unknown's avatar
unknown committed
1776
			  NullS : thd->priv_user, 0);
unknown's avatar
unknown committed
1777 1778 1779
    break;
  case COM_PROCESS_KILL:
  {
1780
    statistic_increment(thd->status_var.com_stat[SQLCOM_KILL], &LOCK_status);
1781
    ulong id=(ulong) uint4korr(packet);
unknown's avatar
SCRUM  
unknown committed
1782
    kill_one_thread(thd,id,false);
unknown's avatar
unknown committed
1783 1784
    break;
  }
1785 1786
  case COM_SET_OPTION:
  {
1787 1788
    statistic_increment(thd->status_var.com_stat[SQLCOM_SET_OPTION],
			&LOCK_status);
1789 1790 1791 1792
    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
1793
      send_eof(thd);
1794 1795 1796
      break;
    case MYSQL_OPTION_MULTI_STATEMENTS_OFF:
      thd->client_capabilities&= ~CLIENT_MULTI_STATEMENTS;
unknown's avatar
unknown committed
1797
      send_eof(thd);
1798 1799 1800 1801 1802 1803 1804
      break;
    default:
      send_error(thd, ER_UNKNOWN_COM_ERROR);
      break;
    }
    break;
  }
unknown's avatar
unknown committed
1805
  case COM_DEBUG:
1806
    statistic_increment(thd->status_var.com_other, &LOCK_status);
unknown's avatar
unknown committed
1807
    if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
1808 1809
      break;					/* purecov: inspected */
    mysql_print_status(thd);
1810
    mysql_log.write(thd,command,NullS);
1811
    send_eof(thd);
unknown's avatar
unknown committed
1812 1813 1814 1815 1816
    break;
  case COM_SLEEP:
  case COM_CONNECT:				// Impossible here
  case COM_TIME:				// Impossible from client
  case COM_DELAYED_INSERT:
1817
  case COM_END:
unknown's avatar
unknown committed
1818
  default:
1819
    send_error(thd, ER_UNKNOWN_COM_ERROR);
unknown's avatar
unknown committed
1820 1821
    break;
  }
1822
  if (thd->lock || thd->open_tables || thd->derived_tables)
unknown's avatar
unknown committed
1823 1824 1825 1826 1827
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }

1828
  if (thd->is_fatal_error)
1829
    send_error(thd,0);				// End of memory ?
unknown's avatar
unknown committed
1830 1831

  time_t start_of_query=thd->start_time;
1832
  thd->end_time();				// Set start time
1833

1834
  /* If not reading from backup and if the query took too long */
1835
  if (!thd->slow_command && !thd->user_time) // do not log 'slow_command' queries
unknown's avatar
unknown committed
1836
  {
1837 1838
    thd->proc_info="logging slow query";

1839 1840
    if ((ulong) (thd->start_time - thd->time_after_lock) >
	thd->variables.long_query_time ||
1841 1842
	((thd->server_status &
	  (SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED)) &&
1843
	 (specialflag & SPECIAL_LOG_QUERIES_NOT_USING_INDEXES)))
1844
    {
1845
      thd->status_var.long_query_count++;
1846 1847
      mysql_slow_log.write(thd, thd->query, thd->query_length, start_of_query);
    }
unknown's avatar
unknown committed
1848
  }
1849
  thd->proc_info="cleaning up";
unknown's avatar
unknown committed
1850 1851 1852 1853
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For process list
  thd->proc_info=0;
  thd->command=COM_SLEEP;
  thd->query=0;
unknown's avatar
unknown committed
1854
  thd->query_length=0;
unknown's avatar
unknown committed
1855 1856
  thread_running--;
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
unknown's avatar
unknown committed
1857
  thd->packet.shrink(thd->variables.net_buffer_length);	// Reclaim some memory
1858

1859
  free_root(&thd->mem_root,MYF(MY_KEEP_PREALLOC));
unknown's avatar
unknown committed
1860 1861 1862
  DBUG_RETURN(error);
}

1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880

/*
  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
    0	ok
    1	error;  In this case thd->fatal_error is set
*/

bool alloc_query(THD *thd, char *packet, ulong packet_length)
{
  packet_length--;				// Remove end null
1881
  /* Remove garbage at start and end of query */
unknown's avatar
unknown committed
1882
  while (my_isspace(thd->charset(),packet[0]) && packet_length > 0)
1883 1884 1885 1886 1887
  {
    packet++;
    packet_length--;
  }
  char *pos=packet+packet_length;		// Point at end null
unknown's avatar
unknown committed
1888
  while (packet_length > 0 &&
unknown's avatar
unknown committed
1889
	 (pos[-1] == ';' || my_isspace(thd->charset() ,pos[-1])))
1890 1891 1892 1893 1894
  {
    pos--;
    packet_length--;
  }
  /* We must allocate some extra memory for query cache */
unknown's avatar
unknown committed
1895
  thd->query_length= 0;                        // Extra safety: Avoid races
1896 1897
  if (!(thd->query= (char*) thd->memdup_w_gap((gptr) (packet),
					      packet_length,
1898 1899
					      thd->db_length+ 1 +
					      QUERY_CACHE_FLAGS_SIZE)))
1900 1901 1902
    return 1;
  thd->query[packet_length]=0;
  thd->query_length= packet_length;
1903 1904 1905 1906

  /* Reclaim some memory */
  thd->packet.shrink(thd->variables.net_buffer_length);
  thd->convert_buffer.shrink(thd->variables.net_buffer_length);
1907 1908 1909 1910 1911 1912

  if (!(specialflag & SPECIAL_NO_PRIOR))
    my_pthread_setprio(pthread_self(),QUERY_PRIOR);
  return 0;
}

unknown's avatar
unknown committed
1913 1914 1915 1916 1917
/****************************************************************************
** mysql_execute_command
** Execute command saved in thd and current_lex->sql_command
****************************************************************************/

1918
int
1919
mysql_execute_command(THD *thd)
unknown's avatar
unknown committed
1920
{
1921
  int	res= 0;
unknown's avatar
unknown committed
1922
  LEX	*lex= thd->lex;
unknown's avatar
unknown committed
1923
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
unknown's avatar
unknown committed
1924
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
1925
  /* first table of first SELECT_LEX */
unknown's avatar
unknown committed
1926
  TABLE_LIST *first_table= (TABLE_LIST*) select_lex->table_list.first;
unknown's avatar
VIEW  
unknown committed
1927 1928 1929
  /* list of all tables in query */
  TABLE_LIST *all_tables;
  /* most outer SELECT_LEX_UNIT of query */
1930
  SELECT_LEX_UNIT *unit= &lex->unit;
unknown's avatar
unknown committed
1931 1932
  DBUG_ENTER("mysql_execute_command");

unknown's avatar
VIEW  
unknown committed
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948
  /*
    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();
1949
  /* should be assigned after making first tables same */
unknown's avatar
VIEW  
unknown committed
1950 1951
  all_tables= lex->query_tables;

1952
  if (lex->sql_command != SQLCOM_CREATE_PROCEDURE &&
1953
      lex->sql_command != SQLCOM_CREATE_SPFUNCTION)
1954 1955 1956 1957 1958
  {
    if (sp_cache_functions(thd, lex))
      DBUG_RETURN(-1);
  }

1959 1960 1961 1962 1963 1964
  /*
    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.
  */
unknown's avatar
VIEW  
unknown committed
1965
  if (all_tables || &lex->select_lex != lex->all_selects_list)
1966 1967
    mysql_reset_errors(thd);

unknown's avatar
SCRUM  
unknown committed
1968
#ifdef HAVE_REPLICATION
1969 1970
  if (thd->slave_thread)
  {
unknown's avatar
unknown committed
1971
    /*
unknown's avatar
merge  
unknown committed
1972 1973 1974
      Skip if we are in the slave thread, some table rules have been
      given and the table list says the query should not be replicated
    */
unknown's avatar
VIEW  
unknown committed
1975
    if (all_tables_not_ok(thd, all_tables))
unknown's avatar
unknown committed
1976 1977 1978
    {
      /* we warn the slave SQL thread */
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
1979
      DBUG_RETURN(0);
unknown's avatar
unknown committed
1980
    }
unknown's avatar
merge  
unknown committed
1981 1982
#ifndef TO_BE_DELETED
    /*
1983 1984 1985
      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
1986
    */
1987 1988 1989
    if (lex->sql_command == SQLCOM_SELECT)
    {
      lex->sql_command = SQLCOM_DO;
unknown's avatar
unknown committed
1990
      lex->insert_list = &select_lex->item_list;
1991
    }
unknown's avatar
merge  
unknown committed
1992
#endif
1993
  }
unknown's avatar
unknown committed
1994
#endif /* !HAVE_REPLICATION */
1995

1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
  if (lex->time_zone_tables_used)
  {
    TABLE_LIST *tmp;
    if ((tmp= my_tz_get_table_list(thd, &lex->query_tables_last)) ==
        &fake_time_zone_tables_list)
    {
      send_error(thd, 0);
      DBUG_RETURN(-1);
    }
    lex->time_zone_tables_used= tmp;
    if (!all_tables)
      all_tables= tmp;
  }

2010 2011 2012 2013 2014
  /*
    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
2015
      !(thd->slave_thread || (thd->master_access & SUPER_ACL)) &&
2016 2017
      (uc_update_queries[lex->sql_command] > 0))
  {
unknown's avatar
unknown committed
2018
    net_printf(thd, ER_OPTION_PREVENTS_STATEMENT, "--read-only");
unknown's avatar
unknown committed
2019
    DBUG_RETURN(-1);
2020
  }
2021

2022 2023
  statistic_increment(thd->status_var.com_stat[lex->sql_command],
		      &LOCK_status);
unknown's avatar
unknown committed
2024 2025 2026
  switch (lex->sql_command) {
  case SQLCOM_SELECT:
  {
2027 2028 2029 2030 2031 2032 2033
    /* 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;
    }

2034
    select_result *result=lex->result;
unknown's avatar
VIEW  
unknown committed
2035
    if (all_tables)
unknown's avatar
unknown committed
2036
    {
unknown's avatar
VIEW  
unknown committed
2037 2038 2039 2040
      res= check_table_access(thd,
			      lex->exchange ? SELECT_ACL | FILE_ACL :
			      SELECT_ACL,
			      all_tables, 0);
unknown's avatar
unknown committed
2041 2042
    }
    else
unknown's avatar
VIEW  
unknown committed
2043 2044 2045
      res= check_access(thd,
			lex->exchange ? SELECT_ACL | FILE_ACL : SELECT_ACL,
			any_db, 0, 0, 0);
unknown's avatar
unknown committed
2046 2047 2048 2049 2050 2051
    if (res)
    {
      res=0;
      break;					// Error message is given
    }

unknown's avatar
VIEW  
unknown committed
2052
    if (!(res= open_and_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
2053
    {
unknown's avatar
unknown committed
2054
      if (lex->describe)
unknown's avatar
unknown committed
2055
      {
2056 2057 2058
	if (!(result= new select_send()))
	{
	  send_error(thd, ER_OUT_OF_RESOURCES);
2059
	  goto error;
2060 2061 2062
	}
	else
	  thd->send_explain_fields(result);
unknown's avatar
unknown committed
2063
	res= mysql_explain_union(thd, &thd->lex->unit, result);
unknown's avatar
unknown committed
2064 2065 2066 2067 2068
	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
2069
	  thd->lex->unit.print(&str);
unknown's avatar
unknown committed
2070 2071 2072 2073
	  str.append('\0');
	  push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
		       ER_YES, str.ptr());
	}
2074
	result->send_eof();
2075
        delete result;
unknown's avatar
unknown committed
2076 2077 2078
      }
      else
      {
2079
	if (!result && !(result= new select_send()))
unknown's avatar
unknown committed
2080
	{
2081 2082
	  res= -1;
	  break;
unknown's avatar
unknown committed
2083
	}
unknown's avatar
VIEW  
unknown committed
2084
	query_cache_store_query(thd, all_tables);
2085 2086 2087
	res= handle_select(thd, lex, result);
        if (result != lex->result)
          delete result;
unknown's avatar
unknown committed
2088
      }
unknown's avatar
unknown committed
2089
    }
unknown's avatar
unknown committed
2090 2091
    break;
  }
unknown's avatar
unknown committed
2092
  case SQLCOM_PREPARE:
2093
  {
2094 2095 2096 2097
    char *query_str;
    uint query_len;
    if (lex->prepared_stmt_code_is_varref)
    {
2098
      /* This is PREPARE stmt FROM @var. */
2099 2100 2101 2102
      String str;
      CHARSET_INFO *to_cs= thd->variables.collation_connection;
      bool need_conversion;
      user_var_entry *entry;
2103
      String *pstr= &str;
2104
      uint32 unused;
2105
      /*
2106 2107 2108
        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.
2109
      */
2110 2111
      if ((entry=
             (user_var_entry*)hash_search(&thd->user_vars,
2112 2113 2114 2115
                                          (byte*)lex->prepared_stmt_code.str,
                                          lex->prepared_stmt_code.length))
          && entry->value)
      {
2116 2117
        my_bool is_var_null;
        pstr= entry->val_str(&is_var_null, &str, NOT_FIXED_DEC);
2118 2119 2120 2121
        /*
          NULL value of variable checked early as entry->value so here
          we can't get NULL in normal conditions
        */
2122 2123
        DBUG_ASSERT(!is_var_null);
        if (!pstr)
2124 2125 2126 2127
        {
          res= -1;
          break;      // EOM (error should be reported by allocator)
        }
2128 2129
      }
      else
2130 2131 2132 2133 2134
      {
        /*
          variable absent or equal to NULL, so we need to set variable to
          something reasonable to get readable error message during parsing
        */
2135
        str.set("NULL", 4, &my_charset_latin1);
2136 2137
      }

2138
      need_conversion=
2139 2140
        String::needs_conversion(pstr->length(), pstr->charset(),
                                 to_cs, &unused);
2141

2142 2143
      query_len= need_conversion? (pstr->length() * to_cs->mbmaxlen) :
                                  pstr->length();
2144
      if (!(query_str= alloc_root(&thd->mem_root, query_len+1)))
2145 2146 2147 2148
      {
        res= -1;
        break;        // EOM (error should be reported by allocator)
      }
2149

2150
      if (need_conversion)
2151 2152
        query_len= copy_and_convert(query_str, query_len, to_cs, pstr->ptr(),
                                    pstr->length(), pstr->charset());
2153
      else
2154
        memcpy(query_str, pstr->ptr(), pstr->length());
2155
      query_str[query_len]= 0;
2156 2157 2158
    }
    else
    {
2159 2160
      query_str= lex->prepared_stmt_code.str;
      query_len= lex->prepared_stmt_code.length;
2161
      DBUG_PRINT("info", ("PREPARE: %.*s FROM '%.*s' \n",
2162 2163
                          lex->prepared_stmt_name.length,
                          lex->prepared_stmt_name.str,
2164
                          query_len, query_str));
2165
    }
unknown's avatar
unknown committed
2166
    thd->command= COM_PREPARE;
2167 2168
    if (!mysql_stmt_prepare(thd, query_str, query_len + 1,
                            &lex->prepared_stmt_name))
unknown's avatar
unknown committed
2169 2170 2171 2172 2173
      send_ok(thd, 0L, 0L, "Statement prepared");
    break;
  }
  case SQLCOM_EXECUTE:
  {
2174
    DBUG_PRINT("info", ("EXECUTE: %.*s\n",
2175 2176 2177
                        lex->prepared_stmt_name.length,
                        lex->prepared_stmt_name.str));
    mysql_sql_stmt_execute(thd, &lex->prepared_stmt_name);
unknown's avatar
unknown committed
2178 2179 2180 2181 2182
    lex->prepared_stmt_params.empty();
    break;
  }
  case SQLCOM_DEALLOCATE_PREPARE:
  {
2183 2184 2185 2186 2187
    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
2188
    {
2189 2190
      thd->stmt_map.erase(stmt);
      send_ok(thd);
unknown's avatar
unknown committed
2191
    }
2192
    else
2193 2194 2195 2196 2197 2198
    {
      res= -1;
      my_error(ER_UNKNOWN_STMT_HANDLER, MYF(0),
               lex->prepared_stmt_name.length, lex->prepared_stmt_name.str,
               "DEALLOCATE PREPARE");
    }
unknown's avatar
unknown committed
2199 2200
    break;
  }
unknown's avatar
unknown committed
2201
  case SQLCOM_DO:
unknown's avatar
VIEW  
unknown committed
2202 2203
    if (all_tables &&
	((res= check_table_access(thd, SELECT_ACL, all_tables, 0)) ||
2204
         (res= open_and_lock_tables(thd, all_tables))))
unknown's avatar
unknown committed
2205 2206 2207 2208 2209
	break;

    res= mysql_do(thd, *lex->insert_list);
    if (thd->net.report_error)
      res= -1;
unknown's avatar
unknown committed
2210 2211
    break;

2212
  case SQLCOM_EMPTY_QUERY:
2213
    send_ok(thd);
2214 2215
    break;

unknown's avatar
unknown committed
2216 2217 2218 2219
  case SQLCOM_HELP:
    res= mysqld_help(thd,lex->help_arg);
    break;

2220
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2221
  case SQLCOM_PURGE:
2222
  {
unknown's avatar
unknown committed
2223
    if (check_global_access(thd, SUPER_ACL))
2224
      goto error;
unknown's avatar
unknown committed
2225
    /* PURGE MASTER LOGS TO 'file' */
2226 2227 2228
    res = purge_master_logs(thd, lex->to_log);
    break;
  }
2229 2230 2231 2232
  case SQLCOM_PURGE_BEFORE:
  {
    if (check_global_access(thd, SUPER_ACL))
      goto error;
unknown's avatar
unknown committed
2233
    /* PURGE MASTER LOGS BEFORE 'data' */
2234 2235 2236
    res = purge_master_logs_before_date(thd, lex->purge_time);
    break;
  }
2237
#endif
unknown's avatar
unknown committed
2238 2239
  case SQLCOM_SHOW_WARNS:
  {
2240 2241
    res= mysqld_show_warnings(thd, (ulong)
			      ((1L << (uint) MYSQL_ERROR::WARN_LEVEL_NOTE) |
2242 2243 2244
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_WARN) |
			       (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR)
			       ));
unknown's avatar
unknown committed
2245 2246 2247 2248
    break;
  }
  case SQLCOM_SHOW_ERRORS:
  {
2249 2250
    res= mysqld_show_warnings(thd, (ulong)
			      (1L << (uint) MYSQL_ERROR::WARN_LEVEL_ERROR));
unknown's avatar
unknown committed
2251 2252
    break;
  }
unknown's avatar
unknown committed
2253 2254
  case SQLCOM_SHOW_NEW_MASTER:
  {
unknown's avatar
unknown committed
2255
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2256
      goto error;
2257
    /* This query don't work now. See comment in repl_failsafe.cc */
unknown's avatar
unknown committed
2258
#ifndef WORKING_NEW_MASTER
2259
    net_printf(thd, ER_NOT_SUPPORTED_YET, "SHOW NEW MASTER");
unknown's avatar
unknown committed
2260 2261
    res= 1;
#else
unknown's avatar
unknown committed
2262
    res = show_new_master(thd);
unknown's avatar
unknown committed
2263
#endif
unknown's avatar
unknown committed
2264 2265
    break;
  }
2266

unknown's avatar
unknown committed
2267
#ifdef HAVE_REPLICATION
2268 2269
  case SQLCOM_SHOW_SLAVE_HOSTS:
  {
unknown's avatar
unknown committed
2270
    if (check_global_access(thd, REPL_SLAVE_ACL))
2271 2272 2273 2274
      goto error;
    res = show_slave_hosts(thd);
    break;
  }
unknown's avatar
unknown committed
2275 2276
  case SQLCOM_SHOW_BINLOG_EVENTS:
  {
unknown's avatar
unknown committed
2277
    if (check_global_access(thd, REPL_SLAVE_ACL))
unknown's avatar
unknown committed
2278 2279 2280 2281
      goto error;
    res = show_binlog_events(thd);
    break;
  }
2282 2283
#endif

unknown's avatar
unknown committed
2284
  case SQLCOM_BACKUP_TABLE:
2285
  {
unknown's avatar
VIEW  
unknown committed
2286 2287 2288
    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
2289
	check_global_access(thd, FILE_ACL))
2290
      goto error; /* purecov: inspected */
2291
    thd->slow_command=TRUE;
unknown's avatar
VIEW  
unknown committed
2292
    res = mysql_backup_table(thd, first_table);
unknown's avatar
unknown committed
2293

2294 2295
    break;
  }
unknown's avatar
unknown committed
2296
  case SQLCOM_RESTORE_TABLE:
2297
  {
unknown's avatar
VIEW  
unknown committed
2298 2299 2300
    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
2301
	check_global_access(thd, FILE_ACL))
2302
      goto error; /* purecov: inspected */
2303
    thd->slow_command=TRUE;
unknown's avatar
VIEW  
unknown committed
2304
    res = mysql_restore_table(thd, first_table);
2305 2306
    break;
  }
unknown's avatar
unknown committed
2307 2308
  case SQLCOM_ASSIGN_TO_KEYCACHE:
  {
unknown's avatar
VIEW  
unknown committed
2309 2310 2311 2312
    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
2313
      goto error;
unknown's avatar
VIEW  
unknown committed
2314
    res= mysql_assign_to_keycache(thd, first_table, &lex->name_and_length);
unknown's avatar
unknown committed
2315 2316
    break;
  }
unknown's avatar
unknown committed
2317 2318
  case SQLCOM_PRELOAD_KEYS:
  {
unknown's avatar
VIEW  
unknown committed
2319 2320 2321 2322
    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))
2323
      goto error;
unknown's avatar
VIEW  
unknown committed
2324
    res = mysql_preload_keys(thd, first_table);
unknown's avatar
unknown committed
2325 2326
    break;
  }
unknown's avatar
unknown committed
2327
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2328
  case SQLCOM_CHANGE_MASTER:
2329
  {
unknown's avatar
unknown committed
2330
    if (check_global_access(thd, SUPER_ACL))
2331
      goto error;
2332
    pthread_mutex_lock(&LOCK_active_mi);
2333
    res = change_master(thd,active_mi);
2334
    pthread_mutex_unlock(&LOCK_active_mi);
2335 2336
    break;
  }
unknown's avatar
unknown committed
2337
  case SQLCOM_SHOW_SLAVE_STAT:
2338
  {
2339 2340
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2341
      goto error;
2342
    pthread_mutex_lock(&LOCK_active_mi);
2343
    res = show_master_info(thd,active_mi);
2344
    pthread_mutex_unlock(&LOCK_active_mi);
2345 2346
    break;
  }
unknown's avatar
unknown committed
2347
  case SQLCOM_SHOW_MASTER_STAT:
2348
  {
2349 2350
    /* Accept one of two privileges */
    if (check_global_access(thd, SUPER_ACL | REPL_CLIENT_ACL))
2351 2352 2353 2354
      goto error;
    res = show_binlog_info(thd);
    break;
  }
unknown's avatar
unknown committed
2355

2356
  case SQLCOM_LOAD_MASTER_DATA: // sync with master
unknown's avatar
unknown committed
2357
    if (check_global_access(thd, SUPER_ACL))
2358
      goto error;
2359 2360 2361 2362
    if (end_active_trans(thd))
      res= -1;
    else
      res = load_master_data(thd);
2363
    break;
unknown's avatar
unknown committed
2364
#endif /* HAVE_REPLICATION */
unknown's avatar
unknown committed
2365 2366 2367
#ifdef HAVE_INNOBASE_DB
  case SQLCOM_SHOW_INNODB_STATUS:
    {
2368
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2369 2370 2371 2372 2373
	goto error;
      res = innodb_show_status(thd);
      break;
    }
#endif
unknown's avatar
unknown committed
2374
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2375
  case SQLCOM_LOAD_MASTER_TABLE:
2376
  {
unknown's avatar
VIEW  
unknown committed
2377 2378 2379 2380 2381
    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
2382 2383 2384 2385
      goto error;				/* purecov: inspected */
    if (grant_option)
    {
      /* Check that the first table has CREATE privilege */
unknown's avatar
VIEW  
unknown committed
2386
      if (check_grant(thd, CREATE_ACL, all_tables, 0, 1, 0))
2387
	goto error;
unknown's avatar
unknown committed
2388
    }
unknown's avatar
VIEW  
unknown committed
2389
    if (strlen(first_table->real_name) > NAME_LEN)
unknown's avatar
unknown committed
2390
    {
unknown's avatar
VIEW  
unknown committed
2391
      net_printf(thd, ER_WRONG_TABLE_NAME, first_table->real_name);
unknown's avatar
unknown committed
2392 2393
      break;
    }
2394
    pthread_mutex_lock(&LOCK_active_mi);
2395 2396 2397 2398
    /*
      fetch_master_table will send the error to the client on failure.
      Give error if the table already exists.
    */
unknown's avatar
VIEW  
unknown committed
2399
    if (!fetch_master_table(thd, first_table->db, first_table->real_name,
2400
			    active_mi, 0, 0))
2401
    {
2402
      send_ok(thd);
2403
    }
2404
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2405
    break;
2406
  }
unknown's avatar
unknown committed
2407
#endif /* HAVE_REPLICATION */
2408

unknown's avatar
unknown committed
2409
  case SQLCOM_CREATE_TABLE:
unknown's avatar
unknown committed
2410
  {
unknown's avatar
VIEW  
unknown committed
2411 2412 2413 2414 2415
    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
2416

unknown's avatar
VIEW  
unknown committed
2417
    if ((res= create_table_precheck(thd, select_tables, create_table)))
unknown's avatar
unknown committed
2418 2419
      goto unsent_create_error;

2420 2421 2422
#ifndef HAVE_READLINK
    lex->create_info.data_file_name=lex->create_info.index_file_name=0;
#else
2423
    /* Fix names if symlinked tables */
unknown's avatar
unknown committed
2424
    if (append_file_to_dir(thd, &lex->create_info.data_file_name,
unknown's avatar
unknown committed
2425
			   create_table->real_name) ||
unknown's avatar
VIEW  
unknown committed
2426
	append_file_to_dir(thd, &lex->create_info.index_file_name,
unknown's avatar
unknown committed
2427
			   create_table->real_name))
2428 2429
    {
      res=-1;
2430
      goto unsent_create_error;
2431
    }
2432
#endif
2433
    /*
2434
      If we are using SET CHARSET without DEFAULT, add an implicit
2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445
      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;
    }
2446
    if (select_lex->item_list.elements)		// With select
unknown's avatar
unknown committed
2447 2448
    {
      select_result *result;
2449

2450
      select_lex->options|= SELECT_NO_UNLOCK;
unknown's avatar
unknown committed
2451
      unit->set_limit(select_lex, select_lex);
2452

unknown's avatar
VIEW  
unknown committed
2453
      if (!(res= open_and_lock_tables(thd, select_tables)))
2454
      {
2455 2456 2457 2458 2459 2460 2461 2462 2463 2464
        /*
          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))
        {
          net_printf(thd, ER_UPDATE_TABLE_USED, create_table->real_name);
          goto create_error;
        }
unknown's avatar
unknown committed
2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479
        /* 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))
            {
              net_printf(thd, ER_UPDATE_TABLE_USED, tab->real_name);
              goto create_error;
            }
          }
        }
2480

unknown's avatar
VIEW  
unknown committed
2481 2482 2483 2484 2485 2486
        if ((result= new select_create(create_table,
				       &lex->create_info,
				       lex->create_list,
				       lex->key_list,
				       select_lex->item_list,
				       lex->duplicates)))
2487 2488 2489 2490 2491 2492
        {
          /*
            CREATE from SELECT give its SELECT_LEX for SELECT,
            and item_list belong to SELECT
          */
          select_lex->resolve_mode= SELECT_LEX::SELECT_MODE;
2493
          res=handle_select(thd, lex, result);
2494
          select_lex->resolve_mode= SELECT_LEX::NOMATTER_MODE;
2495
          delete result;
2496
        }
unknown's avatar
unknown committed
2497
	/* reset for PS */
2498 2499
	lex->create_list.empty();
	lex->key_list.empty();
2500 2501
      }
    }
unknown's avatar
unknown committed
2502
    else
unknown's avatar
unknown committed
2503
    {
unknown's avatar
unknown committed
2504
      /* regular create */
unknown's avatar
unknown committed
2505
      if (lex->name)
unknown's avatar
unknown committed
2506
        res= mysql_create_like_table(thd, create_table, &lex->create_info, 
unknown's avatar
unknown committed
2507 2508
                                     (Table_ident *)lex->name); 
      else
2509
      {
unknown's avatar
VIEW  
unknown committed
2510 2511 2512
        res= mysql_create_table(thd, create_table->db,
				create_table->real_name, &lex->create_info,
				lex->create_list,
unknown's avatar
unknown committed
2513
				lex->key_list, 0, 0);
2514
      }
unknown's avatar
unknown committed
2515
      if (!res)
2516
	send_ok(thd);
unknown's avatar
unknown committed
2517
    }
unknown's avatar
VIEW  
unknown committed
2518
    lex->link_first_table_back(create_table, link_to_local);
2519 2520
    break;

2521
create_error:
unknown's avatar
VIEW  
unknown committed
2522
    res= 1;			//error reported
2523
unsent_create_error:
unknown's avatar
unknown committed
2524
    /* put tables back for PS rexecuting */
unknown's avatar
VIEW  
unknown committed
2525
    lex->link_first_table_back(create_table, link_to_local);
unknown's avatar
unknown committed
2526
    break;
unknown's avatar
unknown committed
2527
  }
unknown's avatar
unknown committed
2528
  case SQLCOM_CREATE_INDEX:
unknown's avatar
VIEW  
unknown committed
2529 2530
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, INDEX_ACL, all_tables))
unknown's avatar
unknown committed
2531
      goto error; /* purecov: inspected */
2532
    thd->slow_command=TRUE;
2533 2534 2535
    if (end_active_trans(thd))
      res= -1;
    else
unknown's avatar
VIEW  
unknown committed
2536
      res = mysql_create_index(thd, first_table, lex->key_list);
unknown's avatar
unknown committed
2537 2538
    break;

unknown's avatar
unknown committed
2539
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
2540
  case SQLCOM_SLAVE_START:
2541
  {
2542
    pthread_mutex_lock(&LOCK_active_mi);
2543
    start_slave(thd,active_mi,1 /* net report*/);
2544
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2545
    break;
2546
  }
unknown's avatar
unknown committed
2547
  case SQLCOM_SLAVE_STOP:
2548 2549 2550 2551 2552 2553
  /*
    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,
2554
      so it waits for the client thread because t is locked by it.
2555
    - then the client thread does SLAVE STOP.
2556 2557
      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.
2558 2559 2560 2561 2562
    To prevent that, refuse SLAVE STOP if the
    client thread has locked tables
  */
  if (thd->locked_tables || thd->active_transaction())
  {
2563
    send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
2564
    goto error;
2565
  }
2566
  {
2567
    pthread_mutex_lock(&LOCK_active_mi);
2568
    stop_slave(thd,active_mi,1/* net report*/);
2569
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
2570
    break;
2571
  }
unknown's avatar
unknown committed
2572
#endif /* HAVE_REPLICATION */
2573

unknown's avatar
unknown committed
2574
  case SQLCOM_ALTER_TABLE:
unknown's avatar
VIEW  
unknown committed
2575
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
2576
#if defined(DONT_ALLOW_SHOW_COMMANDS)
2577
    send_error(thd,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
2578
    goto error;
unknown's avatar
unknown committed
2579 2580
#else
    {
unknown's avatar
unknown committed
2581
      ulong priv=0;
unknown's avatar
unknown committed
2582
      if (lex->name && (!lex->name[0] || strlen(lex->name) > NAME_LEN))
unknown's avatar
unknown committed
2583
      {
2584
	net_printf(thd, ER_WRONG_TABLE_NAME, lex->name);
unknown's avatar
unknown committed
2585
	res= 1;
unknown's avatar
unknown committed
2586 2587
	break;
      }
2588
      if (!select_lex->db)
unknown's avatar
VIEW  
unknown committed
2589 2590 2591
	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
2592
	  check_access(thd,INSERT_ACL | CREATE_ACL,select_lex->db,&priv,0,0)||
unknown's avatar
VIEW  
unknown committed
2593
	  check_merge_table_access(thd, first_table->db,
2594 2595 2596
				   (TABLE_LIST *)
				   lex->create_info.merge_list.first))
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
2597 2598
      if (grant_option)
      {
unknown's avatar
VIEW  
unknown committed
2599
	if (check_grant(thd, ALTER_ACL, all_tables, 0, UINT_MAX, 0))
unknown's avatar
unknown committed
2600 2601 2602 2603 2604 2605
	  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));
	  tmp_table.real_name=lex->name;
2606
	  tmp_table.db=select_lex->db;
unknown's avatar
unknown committed
2607
	  tmp_table.grant.privilege=priv;
unknown's avatar
unknown committed
2608 2609
	  if (check_grant(thd, INSERT_ACL | CREATE_ACL, &tmp_table, 0,
			  UINT_MAX, 0))
unknown's avatar
unknown committed
2610 2611 2612
	    goto error;
	}
      }
2613 2614
      /* 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
2615
      /* ALTER TABLE ends previous transaction */
2616
      if (end_active_trans(thd))
unknown's avatar
unknown committed
2617 2618
	res= -1;
      else
unknown's avatar
unknown committed
2619
      {
2620
        thd->slow_command=TRUE;
2621
	res= mysql_alter_table(thd, select_lex->db, lex->name,
unknown's avatar
unknown committed
2622
			       &lex->create_info,
unknown's avatar
VIEW  
unknown committed
2623
			       first_table, lex->create_list,
2624
			       lex->key_list,
2625
			       select_lex->order_list.elements,
2626
                               (ORDER *) select_lex->order_list.first,
2627
			       lex->duplicates, &lex->alter_info);
unknown's avatar
unknown committed
2628
      }
unknown's avatar
unknown committed
2629 2630
      break;
    }
unknown's avatar
unknown committed
2631
#endif /*DONT_ALLOW_SHOW_COMMANDS*/
unknown's avatar
unknown committed
2632
  case SQLCOM_RENAME_TABLE:
unknown's avatar
unknown committed
2633
  {
unknown's avatar
VIEW  
unknown committed
2634
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
2635
    TABLE_LIST *table;
unknown's avatar
VIEW  
unknown committed
2636
    if (check_db_used(thd, all_tables))
unknown's avatar
unknown committed
2637
      goto error;
unknown's avatar
VIEW  
unknown committed
2638
    for (table= first_table; table; table= table->next_local->next_local)
unknown's avatar
unknown committed
2639
    {
unknown's avatar
unknown committed
2640
      if (check_access(thd, ALTER_ACL | DROP_ACL, table->db,
unknown's avatar
unknown committed
2641
		       &table->grant.privilege,0,0) ||
unknown's avatar
VIEW  
unknown committed
2642 2643
	  check_access(thd, INSERT_ACL | CREATE_ACL, table->next_local->db,
		       &table->next_local->grant.privilege, 0, 0))
unknown's avatar
unknown committed
2644 2645 2646
	goto error;
      if (grant_option)
      {
unknown's avatar
VIEW  
unknown committed
2647
	TABLE_LIST old_list, new_list;
unknown's avatar
unknown committed
2648 2649 2650 2651
	/*
	  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
2652 2653 2654 2655
	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,
2656
			    INSERT_ACL | CREATE_ACL) &&
unknown's avatar
VIEW  
unknown committed
2657
	     check_grant(thd, INSERT_ACL | CREATE_ACL, &new_list, 0, 1, 0)))
unknown's avatar
unknown committed
2658 2659 2660
	  goto error;
      }
    }
unknown's avatar
VIEW  
unknown committed
2661
    query_cache_invalidate3(thd, first_table, 0);
2662 2663
    if (end_active_trans(thd))
      res= -1;
unknown's avatar
VIEW  
unknown committed
2664
    else if (mysql_rename_tables(thd, first_table))
unknown's avatar
unknown committed
2665 2666
      res= -1;
    break;
unknown's avatar
unknown committed
2667
  }
2668
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
2669 2670
  case SQLCOM_SHOW_BINLOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
2671
    send_error(thd,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
2672
    goto error;
unknown's avatar
unknown committed
2673 2674
#else
    {
unknown's avatar
unknown committed
2675
      if (check_global_access(thd, SUPER_ACL))
unknown's avatar
unknown committed
2676 2677 2678 2679
	goto error;
      res = show_binlogs(thd);
      break;
    }
unknown's avatar
unknown committed
2680
#endif
2681
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
2682
  case SQLCOM_SHOW_CREATE:
unknown's avatar
VIEW  
unknown committed
2683
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
2684
#ifdef DONT_ALLOW_SHOW_COMMANDS
2685
    send_error(thd,ER_NOT_ALLOWED_COMMAND); /* purecov: inspected */
2686
    goto error;
unknown's avatar
unknown committed
2687
#else
unknown's avatar
unknown committed
2688
    {
unknown's avatar
VIEW  
unknown committed
2689 2690 2691
      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
2692
	goto error;
unknown's avatar
VIEW  
unknown committed
2693
      res = mysqld_show_create(thd, first_table);
unknown's avatar
unknown committed
2694 2695
      break;
    }
unknown's avatar
unknown committed
2696
#endif
2697 2698
  case SQLCOM_CHECKSUM:
  {
unknown's avatar
VIEW  
unknown committed
2699 2700 2701
    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))
2702
      goto error; /* purecov: inspected */
unknown's avatar
VIEW  
unknown committed
2703
    res = mysql_checksum_table(thd, first_table, &lex->check_opt);
2704 2705
    break;
  }
unknown's avatar
unknown committed
2706
  case SQLCOM_REPAIR:
2707
  {
unknown's avatar
VIEW  
unknown committed
2708 2709 2710
    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))
2711
      goto error; /* purecov: inspected */
2712
    thd->slow_command=TRUE;
unknown's avatar
VIEW  
unknown committed
2713
    res= mysql_repair_table(thd, first_table, &lex->check_opt);
2714 2715 2716 2717 2718 2719 2720 2721 2722
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
        mysql_bin_log.write(&qinfo);
      }
    }
2723 2724
    break;
  }
unknown's avatar
unknown committed
2725
  case SQLCOM_CHECK:
2726
  {
unknown's avatar
VIEW  
unknown committed
2727 2728 2729
    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))
2730
      goto error; /* purecov: inspected */
2731
    thd->slow_command=TRUE;
unknown's avatar
VIEW  
unknown committed
2732
    res = mysql_check_table(thd, first_table, &lex->check_opt);
2733 2734
    break;
  }
unknown's avatar
unknown committed
2735 2736
  case SQLCOM_ANALYZE:
  {
unknown's avatar
VIEW  
unknown committed
2737 2738 2739
    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
2740
      goto error; /* purecov: inspected */
2741
    thd->slow_command=TRUE;
unknown's avatar
VIEW  
unknown committed
2742
    res = mysql_analyze_table(thd, first_table, &lex->check_opt);
2743 2744 2745 2746 2747 2748 2749 2750 2751
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
        mysql_bin_log.write(&qinfo);
      }
    }
unknown's avatar
unknown committed
2752
    break;
unknown's avatar
unknown committed
2753
  }
2754

unknown's avatar
unknown committed
2755 2756
  case SQLCOM_OPTIMIZE:
  {
unknown's avatar
VIEW  
unknown committed
2757 2758 2759
    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
2760
      goto error; /* purecov: inspected */
2761
    thd->slow_command=TRUE;
2762
    res= (specialflag & (SPECIAL_SAFE_MODE | SPECIAL_NO_NEW_FUNC)) ?
unknown's avatar
VIEW  
unknown committed
2763 2764
      mysql_recreate_table(thd, first_table, 1) :
      mysql_optimize_table(thd, first_table, &lex->check_opt);
2765 2766 2767 2768 2769 2770 2771 2772 2773
    /* ! we write after unlocking the table */
    if (!res && !lex->no_write_to_binlog)
    {
      if (mysql_bin_log.is_open())
      {
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
        mysql_bin_log.write(&qinfo);
      }
    }
unknown's avatar
unknown committed
2774 2775 2776
    break;
  }
  case SQLCOM_UPDATE:
unknown's avatar
VIEW  
unknown committed
2777 2778
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (update_precheck(thd, all_tables))
unknown's avatar
unknown committed
2779
      break;
unknown's avatar
VIEW  
unknown committed
2780
    res= mysql_update(thd, all_tables,
2781 2782 2783
                      select_lex->item_list,
                      lex->value_list,
                      select_lex->where,
2784
		      select_lex->order_list.elements,
2785 2786 2787
                      (ORDER *) select_lex->order_list.first,
                      select_lex->select_limit,
                      lex->duplicates);
unknown's avatar
unknown committed
2788 2789
    if (thd->net.report_error)
      res= -1;
2790 2791
    break;
  case SQLCOM_UPDATE_MULTI:
unknown's avatar
unknown committed
2792
  {
unknown's avatar
VIEW  
unknown committed
2793 2794
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if ((res= multi_update_precheck(thd, all_tables)))
unknown's avatar
unknown committed
2795
      break;
unknown's avatar
VIEW  
unknown committed
2796
    res= mysql_multi_update(thd, all_tables,
unknown's avatar
unknown committed
2797 2798 2799 2800 2801
			    &select_lex->item_list,
			    &lex->value_list,
			    select_lex->where,
			    select_lex->options,
			    lex->duplicates, unit, select_lex);
unknown's avatar
unknown committed
2802
    break;
unknown's avatar
unknown committed
2803
  }
unknown's avatar
unknown committed
2804
  case SQLCOM_REPLACE:
2805 2806
  case SQLCOM_INSERT:
  {
unknown's avatar
VIEW  
unknown committed
2807
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
2808
    if ((res= insert_precheck(thd, all_tables)))
unknown's avatar
unknown committed
2809
      break;
unknown's avatar
VIEW  
unknown committed
2810 2811
    res= mysql_insert(thd, all_tables, lex->field_list, lex->many_values,
		      select_lex->item_list, lex->value_list,
unknown's avatar
unknown committed
2812 2813
                      (lex->value_list.elements ?
                       DUP_UPDATE : lex->duplicates));
unknown's avatar
unknown committed
2814 2815
    if (thd->net.report_error)
      res= -1;
unknown's avatar
VIEW  
unknown committed
2816 2817
    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
2818
    break;
2819
  }
unknown's avatar
unknown committed
2820 2821 2822
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  {
unknown's avatar
VIEW  
unknown committed
2823 2824
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if ((res= insert_select_precheck(thd, all_tables)))
2825
      break;
unknown's avatar
unknown committed
2826

2827
    /* Fix lock for first table */
unknown's avatar
VIEW  
unknown committed
2828 2829
    if (first_table->lock_type == TL_WRITE_DELAYED)
      first_table->lock_type= TL_WRITE;
2830

2831 2832
    /* Don't unlock tables until command is written to binary log */
    select_lex->options|= SELECT_NO_UNLOCK;
unknown's avatar
unknown committed
2833 2834

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

unknown's avatar
VIEW  
unknown committed
2837
    if (!(res= open_and_lock_tables(thd, all_tables)))
2838
    {
2839
      /*
2840 2841
        Is table which we are changing used somewhere in other parts of
        query
2842
      */
2843 2844 2845 2846 2847 2848
      if (unique_table(first_table, all_tables->next_independent()))
      {
        /* Using same table for INSERT and SELECT */
        select_lex->options |= OPTION_BUFFER_RESULT;
      }

unknown's avatar
VIEW  
unknown committed
2849 2850 2851
      if ((res= mysql_insert_select_prepare(thd)))
        break;
      if ((result= new select_insert(first_table, first_table->table,
2852 2853
                                     &lex->field_list, lex->duplicates,
                                     lex->duplicates == DUP_IGNORE)))
2854
      {
2855
	/* Skip first table, which is the table we are inserting in */
unknown's avatar
VIEW  
unknown committed
2856
	lex->select_lex.table_list.first= (byte*) first_table->next_local;
2857 2858 2859 2860 2861
        /*
          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;
unknown's avatar
VIEW  
unknown committed
2862
	res= handle_select(thd, lex, result);
2863
	/* revert changes for SP */
unknown's avatar
VIEW  
unknown committed
2864
	lex->select_lex.table_list.first= (byte*) first_table;
2865
	lex->select_lex.resolve_mode= SELECT_LEX::INSERT_MODE;
2866 2867
        delete result;
      }
unknown's avatar
unknown committed
2868
      if (thd->net.report_error)
2869
        res= -1;
2870 2871 2872
    }
    else
      res= -1;
unknown's avatar
VIEW  
unknown committed
2873 2874 2875 2876

    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
2877 2878
    break;
  }
2879
  case SQLCOM_TRUNCATE:
unknown's avatar
VIEW  
unknown committed
2880 2881
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, DELETE_ACL, all_tables))
unknown's avatar
unknown committed
2882
      goto error;
2883 2884 2885 2886 2887 2888
    /*
      Don't allow this within a transaction because we want to use
      re-generate table
    */
    if (thd->locked_tables || thd->active_transaction())
    {
2889
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION,NullS);
2890 2891
      goto error;
    }
unknown's avatar
VIEW  
unknown committed
2892

unknown's avatar
unknown committed
2893
    res= mysql_truncate(thd, first_table, 0);
2894
    break;
unknown's avatar
unknown committed
2895
  case SQLCOM_DELETE:
unknown's avatar
unknown committed
2896
  {
unknown's avatar
VIEW  
unknown committed
2897 2898
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if ((res= delete_precheck(thd, all_tables)))
unknown's avatar
unknown committed
2899
      break;
unknown's avatar
VIEW  
unknown committed
2900
    res = mysql_delete(thd, all_tables, select_lex->where,
2901
                       &select_lex->order_list,
unknown's avatar
unknown committed
2902
                       select_lex->select_limit, select_lex->options);
unknown's avatar
unknown committed
2903 2904
    if (thd->net.report_error)
      res= -1;
unknown's avatar
unknown committed
2905 2906
    break;
  }
2907
  case SQLCOM_DELETE_MULTI:
unknown's avatar
unknown committed
2908
  {
unknown's avatar
VIEW  
unknown committed
2909
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
2910 2911
    TABLE_LIST *aux_tables=
      (TABLE_LIST *)thd->lex->auxilliary_table_list.first;
unknown's avatar
unknown committed
2912
    uint table_count;
unknown's avatar
unknown committed
2913
    multi_delete *result;
unknown's avatar
unknown committed
2914

unknown's avatar
VIEW  
unknown committed
2915
    if ((res= multi_delete_precheck(thd, all_tables, &table_count)))
2916
      break;
unknown's avatar
unknown committed
2917

unknown's avatar
unknown committed
2918
    /* condition will be TRUE on SP re-excuting */
2919 2920
    if (select_lex->item_list.elements != 0)
      select_lex->item_list.empty();
unknown's avatar
unknown committed
2921
    if (add_item_to_list(thd, new Item_null()))
2922
    {
unknown's avatar
unknown committed
2923
      res= -1;
2924
      break;
unknown's avatar
unknown committed
2925
    }
2926

unknown's avatar
unknown committed
2927
    thd->proc_info="init";
unknown's avatar
unknown committed
2928 2929
    if ((res= open_and_lock_tables(thd, all_tables)) ||
        (res= mysql_multi_delete_prepare(thd)))
unknown's avatar
unknown committed
2930
      break;
2931

2932 2933
    if (!thd->is_fatal_error && (result= new multi_delete(thd,aux_tables,
							  table_count)))
unknown's avatar
unknown committed
2934
    {
2935 2936 2937
      res= mysql_select(thd, &select_lex->ref_pointer_array,
			select_lex->get_table_list(),
			select_lex->with_wild,
2938
			select_lex->item_list,
unknown's avatar
unknown committed
2939
			select_lex->where,
2940
			0, (ORDER *)NULL, (ORDER *)NULL, (Item *)NULL,
unknown's avatar
unknown committed
2941 2942
			(ORDER *)NULL,
			select_lex->options | thd->options |
unknown's avatar
unknown committed
2943
			SELECT_NO_JOIN_CACHE | SELECT_NO_UNLOCK,
2944
			result, unit, select_lex);
unknown's avatar
unknown committed
2945 2946
      if (thd->net.report_error)
	res= -1;
2947
      delete result;
unknown's avatar
unknown committed
2948 2949 2950 2951 2952 2953
    }
    else
      res= -1;					// Error is not sent
    close_thread_tables(thd);
    break;
  }
unknown's avatar
unknown committed
2954
  case SQLCOM_DROP_TABLE:
unknown's avatar
unknown committed
2955
  {
unknown's avatar
VIEW  
unknown committed
2956
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
2957 2958
    if (!lex->drop_temporary)
    {
unknown's avatar
VIEW  
unknown committed
2959
      if (check_table_access(thd, DROP_ACL, all_tables, 0))
2960 2961 2962 2963 2964 2965 2966
	goto error;				/* purecov: inspected */
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
    }
unknown's avatar
unknown committed
2967
    else
unknown's avatar
unknown committed
2968 2969 2970 2971 2972 2973
    {
      /*
	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
2974 2975
	To not generate such irrelevant "table does not exist errors",
	we silently add IF EXISTS if TEMPORARY was used.
unknown's avatar
unknown committed
2976 2977 2978 2979
      */
      if (thd->slave_thread)
	lex->drop_if_exists= 1;
    }
unknown's avatar
VIEW  
unknown committed
2980 2981
    res= mysql_rm_table(thd, first_table, lex->drop_if_exists,
			lex->drop_temporary);
unknown's avatar
unknown committed
2982 2983
  }
  break;
unknown's avatar
unknown committed
2984
  case SQLCOM_DROP_INDEX:
unknown's avatar
VIEW  
unknown committed
2985 2986
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_one_table_access(thd, INDEX_ACL, all_tables))
unknown's avatar
unknown committed
2987
      goto error;				/* purecov: inspected */
2988 2989 2990
    if (end_active_trans(thd))
      res= -1;
    else
unknown's avatar
VIEW  
unknown committed
2991
      res = mysql_drop_index(thd, first_table, &lex->alter_info);
unknown's avatar
unknown committed
2992 2993
    break;
  case SQLCOM_SHOW_DATABASES:
2994
#if defined(DONT_ALLOW_SHOW_COMMANDS)
2995
    send_error(thd,ER_NOT_ALLOWED_COMMAND);   /* purecov: inspected */
2996
    goto error;
unknown's avatar
unknown committed
2997 2998
#else
    if ((specialflag & SPECIAL_SKIP_SHOW_DB) &&
unknown's avatar
unknown committed
2999
	check_global_access(thd, SHOW_DB_ACL))
unknown's avatar
unknown committed
3000 3001 3002 3003 3004
      goto error;
    res= mysqld_show_dbs(thd, (lex->wild ? lex->wild->ptr() : NullS));
    break;
#endif
  case SQLCOM_SHOW_PROCESSLIST:
unknown's avatar
unknown committed
3005
    if (!thd->priv_user[0] && check_global_access(thd,PROCESS_ACL))
unknown's avatar
unknown committed
3006
      break;
unknown's avatar
unknown committed
3007 3008
    mysqld_list_processes(thd,
			  thd->master_access & PROCESS_ACL ? NullS :
unknown's avatar
unknown committed
3009
			  thd->priv_user,lex->verbose);
unknown's avatar
unknown committed
3010
    break;
unknown's avatar
unknown committed
3011 3012
  case SQLCOM_SHOW_STORAGE_ENGINES:
    res= mysqld_show_storage_engines(thd);
unknown's avatar
unknown committed
3013 3014 3015 3016 3017 3018 3019
    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
3020
  case SQLCOM_SHOW_STATUS:
3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032
    STATUS_VAR tmp;
    if (lex->option_type == OPT_GLOBAL)
    {
      pthread_mutex_lock(&LOCK_status);
      calc_sum_of_all_status(&tmp);
    }
    res= mysqld_show(thd, (lex->wild ? lex->wild->ptr() : NullS),
		     status_vars, OPT_GLOBAL, &LOCK_status,
		     (lex->option_type == OPT_GLOBAL ? 
		      &tmp: &thd->status_var));
    if (lex->option_type == OPT_GLOBAL)
      pthread_mutex_unlock(&LOCK_status);
unknown's avatar
unknown committed
3033 3034 3035
    break;
  case SQLCOM_SHOW_VARIABLES:
    res= mysqld_show(thd, (lex->wild ? lex->wild->ptr() : NullS),
3036
		     init_vars, lex->option_type,
3037
		     &LOCK_global_system_variables, 0);
unknown's avatar
unknown committed
3038
    break;
unknown's avatar
unknown committed
3039 3040
  case SQLCOM_SHOW_LOGS:
#ifdef DONT_ALLOW_SHOW_COMMANDS
3041
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
3042
    goto error;
unknown's avatar
unknown committed
3043 3044
#else
    {
unknown's avatar
unknown committed
3045
      if (grant_option && check_access(thd, FILE_ACL, any_db,0,0,0))
unknown's avatar
unknown committed
3046 3047 3048 3049 3050
	goto error;
      res= mysqld_show_logs(thd);
      break;
    }
#endif
unknown's avatar
unknown committed
3051
  case SQLCOM_SHOW_TABLES:
3052
    /* FALL THROUGH */
unknown's avatar
unknown committed
3053
#ifdef DONT_ALLOW_SHOW_COMMANDS
3054
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
3055
    goto error;
unknown's avatar
unknown committed
3056 3057
#else
    {
3058
      char *db=select_lex->db ? select_lex->db : thd->db;
unknown's avatar
unknown committed
3059 3060
      if (!db)
      {
unknown's avatar
unknown committed
3061
	send_error(thd,ER_NO_DB_ERROR);		/* purecov: inspected */
unknown's avatar
unknown committed
3062 3063 3064
	goto error;				/* purecov: inspected */
      }
      remove_escape(db);				// Fix escaped '_'
3065
      if (check_db_name(db))
unknown's avatar
unknown committed
3066
      {
3067
        net_printf(thd,ER_WRONG_DB_NAME, db);
3068
        goto error;
unknown's avatar
unknown committed
3069
      }
unknown's avatar
unknown committed
3070
      if (check_access(thd,SELECT_ACL,db,&thd->col_access,0,0))
unknown's avatar
unknown committed
3071
	goto error;				/* purecov: inspected */
unknown's avatar
unknown committed
3072
      if (!thd->col_access && check_grant_db(thd,db))
unknown's avatar
unknown committed
3073
      {
unknown's avatar
unknown committed
3074
	net_printf(thd, ER_DBACCESS_DENIED_ERROR,
unknown's avatar
unknown committed
3075 3076 3077 3078 3079
		   thd->priv_user,
		   thd->priv_host,
		   db);
	goto error;
      }
unknown's avatar
unknown committed
3080
      /* grant is checked in mysqld_show_tables */
3081
      if (lex->describe)
3082
        res= mysqld_extend_show_tables(thd,db,
3083
				       (lex->wild ? lex->wild->ptr() : NullS));
unknown's avatar
unknown committed
3084
      else
3085 3086 3087
	res= mysqld_show_tables(thd, db,
				(lex->wild ? lex->wild->ptr() : NullS),
				lex->verbose);
unknown's avatar
unknown committed
3088 3089 3090
      break;
    }
#endif
3091 3092 3093
  case SQLCOM_SHOW_OPEN_TABLES:
    res= mysqld_show_open_tables(thd,(lex->wild ? lex->wild->ptr() : NullS));
    break;
3094 3095
  case SQLCOM_SHOW_CHARSETS:
    res= mysqld_show_charsets(thd,(lex->wild ? lex->wild->ptr() : NullS));
3096
    break;
3097 3098 3099
  case SQLCOM_SHOW_COLLATIONS:
    res= mysqld_show_collations(thd,(lex->wild ? lex->wild->ptr() : NullS));
    break;
unknown's avatar
unknown committed
3100
  case SQLCOM_SHOW_FIELDS:
unknown's avatar
VIEW  
unknown committed
3101
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3102
#ifdef DONT_ALLOW_SHOW_COMMANDS
3103
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
3104
    goto error;
unknown's avatar
unknown committed
3105 3106
#else
    {
unknown's avatar
VIEW  
unknown committed
3107
      char *db= first_table->db;
unknown's avatar
unknown committed
3108
      remove_escape(db);			// Fix escaped '_'
unknown's avatar
VIEW  
unknown committed
3109
      remove_escape(first_table->real_name);
3110
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
unknown's avatar
VIEW  
unknown committed
3111
		       &first_table->grant.privilege, 0, 0))
unknown's avatar
unknown committed
3112
	goto error;				/* purecov: inspected */
unknown's avatar
VIEW  
unknown committed
3113
      if (grant_option && check_grant(thd, SELECT_ACL, first_table, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
3114
	goto error;
unknown's avatar
VIEW  
unknown committed
3115
      res= mysqld_show_fields(thd, first_table,
unknown's avatar
unknown committed
3116 3117
			      (lex->wild ? lex->wild->ptr() : NullS),
			      lex->verbose);
unknown's avatar
unknown committed
3118 3119 3120 3121
      break;
    }
#endif
  case SQLCOM_SHOW_KEYS:
unknown's avatar
VIEW  
unknown committed
3122
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3123
#ifdef DONT_ALLOW_SHOW_COMMANDS
3124
    send_error(thd,ER_NOT_ALLOWED_COMMAND);	/* purecov: inspected */
3125
    goto error;
unknown's avatar
unknown committed
3126 3127
#else
    {
unknown's avatar
VIEW  
unknown committed
3128
      char *db= first_table->db;
unknown's avatar
unknown committed
3129
      remove_escape(db);			// Fix escaped '_'
unknown's avatar
VIEW  
unknown committed
3130
      remove_escape(first_table->real_name);
unknown's avatar
unknown committed
3131
      if (check_access(thd,SELECT_ACL | EXTRA_ACL,db,
unknown's avatar
VIEW  
unknown committed
3132
		       &first_table->grant.privilege, 0, 0))
unknown's avatar
unknown committed
3133
	goto error;				/* purecov: inspected */
unknown's avatar
VIEW  
unknown committed
3134
      if (grant_option && check_grant(thd, SELECT_ACL, all_tables, 2, UINT_MAX, 0))
unknown's avatar
unknown committed
3135
	goto error;
unknown's avatar
VIEW  
unknown committed
3136
      res= mysqld_show_keys(thd, first_table);
unknown's avatar
unknown committed
3137 3138 3139 3140
      break;
    }
#endif
  case SQLCOM_CHANGE_DB:
3141
    mysql_change_db(thd,select_lex->db);
unknown's avatar
unknown committed
3142
    break;
3143

unknown's avatar
unknown committed
3144 3145
  case SQLCOM_LOAD:
  {
unknown's avatar
VIEW  
unknown committed
3146
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
unknown's avatar
unknown committed
3147
    uint privilege= (lex->duplicates == DUP_REPLACE ?
3148
		     INSERT_ACL | DELETE_ACL : INSERT_ACL);
3149 3150

    if (!lex->local_file)
unknown's avatar
unknown committed
3151
    {
unknown's avatar
VIEW  
unknown committed
3152
      if (check_access(thd, privilege | FILE_ACL, first_table->db, 0, 0, 0))
unknown's avatar
unknown committed
3153 3154 3155 3156
	goto error;
    }
    else
    {
3157
      if (!(thd->client_capabilities & CLIENT_LOCAL_FILES) ||
unknown's avatar
unknown committed
3158
	  ! opt_local_infile)
3159
      {
3160
	send_error(thd,ER_NOT_ALLOWED_COMMAND);
3161 3162
	goto error;
      }
unknown's avatar
VIEW  
unknown committed
3163
      if (check_one_table_access(thd, privilege, all_tables))
unknown's avatar
unknown committed
3164 3165
	goto error;
    }
unknown's avatar
VIEW  
unknown committed
3166
    res= mysql_load(thd, lex->exchange, first_table, lex->field_list,
3167 3168
                    lex->duplicates, (bool) lex->local_file,
		    lex->lock_option, lex->duplicates == DUP_IGNORE);
unknown's avatar
unknown committed
3169 3170
    break;
  }
3171

unknown's avatar
unknown committed
3172
  case SQLCOM_SET_OPTION:
3173 3174
  {
    List<set_var_base> *lex_var_list= &lex->var_list;
unknown's avatar
VIEW  
unknown committed
3175 3176 3177
    if (all_tables &&
	((res= check_table_access(thd, SELECT_ACL, all_tables, 0)) ||
	 (res= open_and_lock_tables(thd, all_tables))))
unknown's avatar
unknown committed
3178
      break;
3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192
    if (lex->one_shot_set && not_all_support_one_shot(lex_var_list))
    {
      my_printf_error(0, "The SET ONE_SHOT syntax is reserved for \
purposes internal to the MySQL server", MYF(0));
      res= -1;
      break;
    }
    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;
3193
      send_ok(thd);
3194
    }
unknown's avatar
unknown committed
3195 3196
    if (thd->net.report_error)
      res= -1;
unknown's avatar
unknown committed
3197
    break;
3198
  }
unknown's avatar
unknown committed
3199

unknown's avatar
unknown committed
3200
  case SQLCOM_UNLOCK_TABLES:
unknown's avatar
unknown committed
3201
    unlock_locked_tables(thd);
unknown's avatar
unknown committed
3202 3203
    if (thd->options & OPTION_TABLE_LOCK)
    {
unknown's avatar
unknown committed
3204
      end_active_trans(thd);
unknown's avatar
unknown committed
3205
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3206 3207
    }
    if (thd->global_read_lock)
3208
      unlock_global_read_lock(thd);
3209
    send_ok(thd);
unknown's avatar
unknown committed
3210 3211
    break;
  case SQLCOM_LOCK_TABLES:
unknown's avatar
unknown committed
3212
    unlock_locked_tables(thd);
unknown's avatar
VIEW  
unknown committed
3213
    if (check_db_used(thd, all_tables) || end_active_trans(thd))
unknown's avatar
unknown committed
3214
      goto error;
unknown's avatar
VIEW  
unknown committed
3215
    if (check_table_access(thd, LOCK_TABLES_ACL | SELECT_ACL, all_tables, 0))
3216
      goto error;
unknown's avatar
unknown committed
3217
    thd->in_lock_tables=1;
unknown's avatar
unknown committed
3218
    thd->options|= OPTION_TABLE_LOCK;
unknown's avatar
VIEW  
unknown committed
3219 3220

    if (!(res= open_and_lock_tables(thd, all_tables)))
unknown's avatar
unknown committed
3221
    {
3222 3223
#ifdef HAVE_QUERY_CACHE
      if (thd->variables.query_cache_wlock_invalidate)
unknown's avatar
VIEW  
unknown committed
3224
	query_cache.invalidate_locked_for_write(first_table);
3225
#endif /*HAVE_QUERY_CACHE*/
unknown's avatar
unknown committed
3226 3227
      thd->locked_tables=thd->lock;
      thd->lock=0;
3228
      send_ok(thd);
unknown's avatar
unknown committed
3229
    }
unknown's avatar
unknown committed
3230 3231
    else
      thd->options&= ~(ulong) (OPTION_TABLE_LOCK);
unknown's avatar
unknown committed
3232 3233 3234
    thd->in_lock_tables=0;
    break;
  case SQLCOM_CREATE_DB:
3235
  {
unknown's avatar
unknown committed
3236
    char *alias;
unknown's avatar
unknown committed
3237
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3238
    {
3239
      net_printf(thd,ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
3240 3241
      break;
    }
3242 3243 3244 3245 3246 3247 3248
    /*
      If in a slave thread :
      CREATE DATABASE DB was certainly not preceded by USE DB.
      For that reason, 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.
    */
3249
#ifdef HAVE_REPLICATION
3250 3251 3252
    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
3253 3254
    {
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
3255
      break;
unknown's avatar
unknown committed
3256
    }
3257
#endif
unknown's avatar
unknown committed
3258
    if (check_access(thd,CREATE_ACL,lex->name,0,1,0))
3259
      break;
unknown's avatar
unknown committed
3260
    res= mysql_create_db(thd,(lower_case_table_names == 2 ? alias : lex->name),
unknown's avatar
unknown committed
3261
			 &lex->create_info, 0);
3262 3263
    break;
  }
unknown's avatar
unknown committed
3264
  case SQLCOM_DROP_DB:
3265
  {
unknown's avatar
unknown committed
3266
    char *alias;
unknown's avatar
unknown committed
3267
    if (!(alias=thd->strdup(lex->name)) || check_db_name(lex->name))
unknown's avatar
unknown committed
3268
    {
3269
      net_printf(thd, ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
3270 3271
      break;
    }
3272 3273 3274 3275 3276 3277 3278
    /*
      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.
    */
3279
#ifdef HAVE_REPLICATION
3280 3281 3282
    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
3283 3284
    {
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
3285
      break;
unknown's avatar
unknown committed
3286
    }
3287
#endif
unknown's avatar
unknown committed
3288
    if (check_access(thd,DROP_ACL,lex->name,0,1,0))
3289
      break;
3290 3291
    if (thd->locked_tables || thd->active_transaction())
    {
3292
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
3293 3294
      goto error;
    }
3295 3296
    res=mysql_rm_db(thd, (lower_case_table_names == 2 ? alias : lex->name),
                    lex->drop_if_exists, 0);
3297 3298
    break;
  }
3299 3300 3301 3302
  case SQLCOM_ALTER_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3303
      net_printf(thd, ER_WRONG_DB_NAME, lex->name);
3304 3305
      break;
    }
unknown's avatar
unknown committed
3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321
    /*
      If in a slave thread :
      ALTER 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.
    */
#ifdef HAVE_REPLICATION
    if (thd->slave_thread && 
	(!db_ok(lex->name, replicate_do_db, replicate_ignore_db) ||
	 !db_ok_with_wild_table(lex->name)))
    {
      my_error(ER_SLAVE_IGNORED_TABLE, MYF(0));
      break;
    }
#endif
unknown's avatar
unknown committed
3322
    if (check_access(thd,ALTER_ACL,lex->name,0,1,0))
3323 3324 3325
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
3326
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
3327 3328
      goto error;
    }
3329
    res=mysql_alter_db(thd,lex->name,&lex->create_info);
3330 3331
    break;
  }
unknown's avatar
unknown committed
3332 3333 3334 3335
  case SQLCOM_SHOW_CREATE_DB:
  {
    if (!strip_sp(lex->name) || check_db_name(lex->name))
    {
3336
      net_printf(thd,ER_WRONG_DB_NAME, lex->name);
unknown's avatar
unknown committed
3337 3338
      break;
    }
unknown's avatar
unknown committed
3339
    if (check_access(thd,SELECT_ACL,lex->name,0,1,0))
unknown's avatar
unknown committed
3340 3341 3342
      break;
    if (thd->locked_tables || thd->active_transaction())
    {
3343
      send_error(thd,ER_LOCK_OR_ACTIVE_TRANSACTION);
unknown's avatar
unknown committed
3344 3345
      goto error;
    }
unknown's avatar
unknown committed
3346
    res=mysqld_show_create_db(thd,lex->name,&lex->create_info);
unknown's avatar
unknown committed
3347 3348
    break;
  }
unknown's avatar
unknown committed
3349
  case SQLCOM_CREATE_FUNCTION:                  // UDF function
unknown's avatar
unknown committed
3350 3351 3352 3353
  {
    sp_head *sph;
    if (check_access(thd,INSERT_ACL,"mysql",0,1,0))
      break;
unknown's avatar
unknown committed
3354
#ifdef HAVE_DLOPEN
3355
    if ((sph= sp_find_function(thd, lex->spname)))
unknown's avatar
unknown committed
3356
    {
3357
      net_printf(thd, ER_UDF_EXISTS, lex->spname->m_name.str);
unknown's avatar
unknown committed
3358 3359 3360 3361
      goto error;
    }
    if (!(res = mysql_create_function(thd,&lex->udf)))
      send_ok(thd);
unknown's avatar
unknown committed
3362
#else
unknown's avatar
unknown committed
3363
    res= -1;
unknown's avatar
unknown committed
3364 3365
#endif
    break;
unknown's avatar
unknown committed
3366
  }
unknown's avatar
unknown committed
3367
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3368 3369
  case SQLCOM_DROP_USER:
  {
unknown's avatar
unknown committed
3370
    if (check_access(thd, GRANT_ACL,"mysql",0,1,0))
3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384
      break;
    if (!(res= mysql_drop_user(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
	Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
	mysql_bin_log.write(&qinfo);
      }
      send_ok(thd);
    }
    break;
  }
  case SQLCOM_REVOKE_ALL:
  {
unknown's avatar
unknown committed
3385
    if (check_access(thd, GRANT_ACL ,"mysql",0,1,0))
3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397
      break;
    if (!(res = mysql_revoke_all(thd, lex->users_list)))
    {
      if (mysql_bin_log.is_open())
      {
	Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
	mysql_bin_log.write(&qinfo);
      }
      send_ok(thd);
    }
    break;
  }
3398 3399 3400 3401
  case SQLCOM_REVOKE:
  case SQLCOM_GRANT:
  {
    if (check_access(thd, lex->grant | lex->grant_tot_col | GRANT_ACL,
unknown's avatar
VIEW  
unknown committed
3402 3403 3404 3405
		     ((first_table && first_table->db) ?
		      first_table->db : select_lex->db),
		     first_table ? &first_table->grant.privilege : 0,
		     first_table ? 0 : 1, 0))
3406 3407
      goto error;

unknown's avatar
SCRUM  
unknown committed
3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420
    if (specialflag & SPECIAL_NO_RESOLVE)
    {
      LEX_USER *user;
      List_iterator <LEX_USER> user_list(lex->users_list);
      while ((user=user_list++))
      {
	if (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);
      }
    }
unknown's avatar
VIEW  
unknown committed
3421
    if (first_table)
3422 3423 3424 3425
    {
      if (grant_option && check_grant(thd,
				      (lex->grant | lex->grant_tot_col |
				       GRANT_ACL),
unknown's avatar
VIEW  
unknown committed
3426
				      all_tables, 0, UINT_MAX, 0))
3427
	goto error;
unknown's avatar
VIEW  
unknown committed
3428 3429
      if (!(res = mysql_table_grant(thd, all_tables, lex->users_list,
				    lex->columns, lex->grant,
3430 3431
				    lex->sql_command == SQLCOM_REVOKE)) &&
          mysql_bin_log.is_open())
3432
      {
unknown's avatar
unknown committed
3433
        thd->clear_error();
3434 3435
        Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
        mysql_bin_log.write(&qinfo);
3436 3437 3438 3439 3440 3441
      }
    }
    else
    {
      if (lex->columns.elements)
      {
3442
	send_error(thd,ER_ILLEGAL_GRANT_FOR_TABLE);
3443 3444 3445 3446 3447 3448 3449 3450 3451
	res=1;
      }
      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
3452
          thd->clear_error();
3453
	  Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
3454 3455
	  mysql_bin_log.write(&qinfo);
	}
3456
	if (mqh_used && lex->sql_command == SQLCOM_GRANT)
3457
	{
unknown's avatar
unknown committed
3458 3459 3460
	  List_iterator <LEX_USER> str_list(lex->users_list);
	  LEX_USER *user;
	  while ((user=str_list++))
3461
	    reset_mqh(thd,user);
3462
	}
3463 3464 3465 3466
      }
    }
    break;
  }
unknown's avatar
SCRUM  
unknown committed
3467
#endif /*!NO_EMBEDDED_ACCESS_CHECKS*/
unknown's avatar
unknown committed
3468
  case SQLCOM_RESET:
3469 3470 3471 3472 3473 3474 3475
    /* 
       RESET commands are never written to the binary log, so we have to
       initialize this variable because RESET shares the same code as FLUSH
    */
    lex->no_write_to_binlog= 1;
  case SQLCOM_FLUSH:
  {
unknown's avatar
VIEW  
unknown committed
3476
    if (check_global_access(thd,RELOAD_ACL) || check_db_used(thd, all_tables))
unknown's avatar
unknown committed
3477
      goto error;
3478 3479 3480 3481 3482
    /*
      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
VIEW  
unknown committed
3483
    if (reload_acl_and_cache(thd, lex->type, first_table, &write_to_binlog))
3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500
      send_error(thd, 0);
    else
    {
      /*
        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())
        {
          Query_log_event qinfo(thd, thd->query, thd->query_length, 0);
          mysql_bin_log.write(&qinfo);
        }
      }
      send_ok(thd);
    }
unknown's avatar
unknown committed
3501
    break;
3502
  }
unknown's avatar
unknown committed
3503
  case SQLCOM_KILL:
unknown's avatar
SCRUM  
unknown committed
3504
    kill_one_thread(thd,lex->thread_id, lex->type & ONLY_KILL_QUERY);
unknown's avatar
unknown committed
3505
    break;
unknown's avatar
unknown committed
3506
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
3507 3508
  case SQLCOM_SHOW_GRANTS:
    res=0;
3509 3510
    if ((thd->priv_user &&
	 !strcmp(thd->priv_user,lex->grant_user->user.str)) ||
unknown's avatar
unknown committed
3511
	!check_access(thd, SELECT_ACL, "mysql",0,1,0))
unknown's avatar
unknown committed
3512 3513 3514 3515
    {
      res = mysql_show_grants(thd,lex->grant_user);
    }
    break;
unknown's avatar
unknown committed
3516
#endif
3517
  case SQLCOM_HA_OPEN:
unknown's avatar
VIEW  
unknown committed
3518 3519 3520
    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))
3521
      goto error;
unknown's avatar
VIEW  
unknown committed
3522
    res= mysql_ha_open(thd, first_table);
3523 3524
    break;
  case SQLCOM_HA_CLOSE:
unknown's avatar
VIEW  
unknown committed
3525 3526
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
    if (check_db_used(thd, all_tables))
3527
      goto error;
unknown's avatar
VIEW  
unknown committed
3528
    res= mysql_ha_close(thd, first_table);
3529 3530
    break;
  case SQLCOM_HA_READ:
unknown's avatar
VIEW  
unknown committed
3531
    DBUG_ASSERT(first_table == all_tables && first_table != 0);
3532 3533 3534 3535 3536
    /*
      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
3537
    if (check_db_used(thd, all_tables))
3538
      goto error;
unknown's avatar
VIEW  
unknown committed
3539 3540 3541
    res= mysql_ha_read(thd, first_table, lex->ha_read_mode, lex->backup_dir,
                       lex->insert_list, lex->ha_rkey_mode, select_lex->where,
                       select_lex->select_limit, select_lex->offset_limit);
3542 3543
    break;

unknown's avatar
unknown committed
3544
  case SQLCOM_BEGIN:
unknown's avatar
unknown committed
3545 3546 3547
    if (thd->locked_tables)
    {
      thd->lock=thd->locked_tables;
3548
      thd->locked_tables=0;			// Will be automatically closed
unknown's avatar
unknown committed
3549 3550
      close_thread_tables(thd);			// Free tables
    }
unknown's avatar
unknown committed
3551 3552 3553 3554 3555 3556
    if (end_active_trans(thd))
    {
      res= -1;
    }
    else
    {
3557
      thd->options= ((thd->options & (ulong) ~(OPTION_STATUS_NO_TRANS_UPDATE)) |
unknown's avatar
unknown committed
3558 3559
		     OPTION_BEGIN);
      thd->server_status|= SERVER_STATUS_IN_TRANS;
3560
      send_ok(thd);
unknown's avatar
unknown committed
3561
    }
unknown's avatar
unknown committed
3562 3563
    break;
  case SQLCOM_COMMIT:
3564 3565 3566 3567 3568
    /*
      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...)
    */
unknown's avatar
unknown committed
3569
  {
3570
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
3571 3572
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
    if (!ha_commit(thd))
unknown's avatar
unknown committed
3573
    {
3574
      send_ok(thd);
unknown's avatar
unknown committed
3575
    }
unknown's avatar
unknown committed
3576 3577 3578
    else
      res= -1;
    break;
unknown's avatar
unknown committed
3579
  }
unknown's avatar
unknown committed
3580 3581 3582
  case SQLCOM_ROLLBACK:
    thd->server_status&= ~SERVER_STATUS_IN_TRANS;
    if (!ha_rollback(thd))
3583
    {
unknown's avatar
unknown committed
3584 3585 3586 3587 3588 3589 3590 3591 3592 3593
      /*
        If a non-transactional table was updated, warn; don't warn if this is a
        slave thread (because when a slave thread executes a ROLLBACK, it has
        been read from the binary log, so it's 100% sure and normal to produce
        error ER_WARNING_NOT_COMPLETE_ROLLBACK. If we sent the warning to the
        slave SQL thread, it would not stop the thread but just be printed in
        the error log; but we don't want users to wonder why they have this
        message in the error log, so we don't send it.
      */
      if ((thd->options & OPTION_STATUS_NO_TRANS_UPDATE) && !thd->slave_thread)
3594
	send_warning(thd,ER_WARNING_NOT_COMPLETE_ROLLBACK,0);
3595
      else
3596
	send_ok(thd);
3597
    }
unknown's avatar
unknown committed
3598 3599
    else
      res= -1;
3600
    thd->options&= ~(ulong) (OPTION_BEGIN | OPTION_STATUS_NO_TRANS_UPDATE);
unknown's avatar
unknown committed
3601
    break;
unknown's avatar
unknown committed
3602 3603 3604
  case SQLCOM_ROLLBACK_TO_SAVEPOINT:
    if (!ha_rollback_to_savepoint(thd, lex->savepoint_name))
    {
unknown's avatar
unknown committed
3605
      if ((thd->options & OPTION_STATUS_NO_TRANS_UPDATE) && !thd->slave_thread)
unknown's avatar
unknown committed
3606
	send_warning(thd, ER_WARNING_NOT_COMPLETE_ROLLBACK, 0);
unknown's avatar
unknown committed
3607
      else
unknown's avatar
unknown committed
3608
	send_ok(thd);
unknown's avatar
unknown committed
3609 3610 3611 3612
    }
    else
      res= -1;
    break;
3613
  case SQLCOM_SAVEPOINT:
unknown's avatar
unknown committed
3614
    if (!ha_savepoint(thd, lex->savepoint_name))
unknown's avatar
unknown committed
3615
      send_ok(thd);
unknown's avatar
unknown committed
3616 3617
    else
      res= -1;
3618
    break;
3619 3620
  case SQLCOM_CREATE_PROCEDURE:
  case SQLCOM_CREATE_SPFUNCTION:
unknown's avatar
unknown committed
3621
  {
3622 3623 3624
    uint namelen;
    char *name;

3625
    if (!lex->sphead)
3626
    {
unknown's avatar
unknown committed
3627
      res= -1;                                  // Shouldn't happen
3628
      break;
3629
    }
3630 3631 3632 3633 3634 3635 3636 3637 3638 3639

    if (! lex->sphead->m_db.str)
    {
      send_error(thd,ER_NO_DB_ERROR);
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
    }

    name= lex->sphead->name(&namelen);
3640
#ifdef HAVE_DLOPEN
unknown's avatar
unknown committed
3641 3642 3643
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION)
    {
      udf_func *udf = find_udf(name, namelen);
3644

unknown's avatar
unknown committed
3645
      if (udf)
3646
      {
unknown's avatar
unknown committed
3647
	net_printf(thd, ER_UDF_EXISTS, name);
unknown's avatar
unknown committed
3648
	delete lex->sphead;
3649
	lex->sphead= 0;
3650
	goto error;
3651
      }
unknown's avatar
unknown committed
3652 3653 3654 3655 3656 3657 3658
    }
#endif
    if (lex->sphead->m_type == TYPE_ENUM_FUNCTION &&
	!lex->sphead->m_has_return)
    {
      net_printf(thd, ER_SP_NORETURN, name);
      delete lex->sphead;
3659
      lex->sphead= 0;
unknown's avatar
unknown committed
3660 3661 3662 3663 3664 3665 3666
      goto error;
    }

    res= lex->sphead->create(thd);
    switch (res) {
    case SP_OK:
      send_ok(thd);
3667
      lex->unit.cleanup();
unknown's avatar
unknown committed
3668 3669
      delete lex->sphead;
      lex->sphead= 0;
3670
      break;
unknown's avatar
unknown committed
3671 3672
    case SP_WRITE_ROW_FAILED:
      net_printf(thd, ER_SP_ALREADY_EXISTS, SP_TYPE_STRING(lex), name);
3673
      lex->unit.cleanup();
unknown's avatar
unknown committed
3674 3675 3676
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
3677
    case SP_NO_DB_ERROR:
3678
      net_printf(thd, ER_BAD_DB_ERROR, lex->sphead->m_db.str);
3679
      lex->unit.cleanup();
3680 3681 3682
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
unknown's avatar
unknown committed
3683 3684
    default:
      net_printf(thd, ER_SP_STORE_FAILED, SP_TYPE_STRING(lex), name);
3685
      lex->unit.cleanup();
unknown's avatar
unknown committed
3686 3687 3688
      delete lex->sphead;
      lex->sphead= 0;
      goto error;
3689
    }
unknown's avatar
unknown committed
3690 3691
    break;
  }
3692 3693 3694 3695
  case SQLCOM_CALL:
    {
      sp_head *sp;

3696
      if (!(sp= sp_find_procedure(thd, lex->spname)))
3697
      {
3698
	net_printf(thd, ER_SP_DOES_NOT_EXIST, "PROCEDURE",
3699
		   lex->spname->m_qname.str);
3700
	goto error;
3701 3702 3703
      }
      else
      {
3704
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3705
	st_sp_security_context save_ctx;
3706
#endif
unknown's avatar
unknown committed
3707
	ha_rows select_limit;
3708 3709 3710
	uint smrx;
	LINT_INIT(smrx);

unknown's avatar
unknown committed
3711
	/* In case the arguments are subselects... */
unknown's avatar
VIEW  
unknown committed
3712 3713 3714
	if (all_tables &&
	    ((res= check_table_access(thd, SELECT_ACL, all_tables, 0)) ||
	     (res= open_and_lock_tables(thd, all_tables))))
unknown's avatar
unknown committed
3715
	{
3716
	  break;
unknown's avatar
unknown committed
3717
	}
3718

3719
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
3720 3721 3722 3723
	/*
          When executing substatements, they're assumed to send_error when
          it happens, but not to send_ok.
        */
3724 3725
	my_bool nsok= thd->net.no_send_ok;
	thd->net.no_send_ok= TRUE;
3726
#endif
3727
	if (sp->m_multi_results)
3728
	{
3729
	  if (! (thd->client_capabilities & CLIENT_MULTI_RESULTS))
3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740
	  {
	    send_error(thd, ER_SP_BADSELECT);
#ifndef EMBEDDED_LIBRARY
	    thd->net.no_send_ok= nsok;
#endif
	    goto error;
	  }
	  smrx= thd->server_status & SERVER_MORE_RESULTS_EXISTS;
	  thd->server_status |= SERVER_MORE_RESULTS_EXISTS;
	}

3741
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3742
	sp_change_security_context(thd, sp, &save_ctx);
3743
#endif
unknown's avatar
unknown committed
3744 3745
	select_limit= thd->variables.select_limit;
	thd->variables.select_limit= HA_POS_ERROR;
3746

3747
	thd->row_count_func= 0;
3748
	res= sp->execute_procedure(thd, &lex->value_list);
3749

unknown's avatar
unknown committed
3750
	thd->variables.select_limit= select_limit;
3751
#ifndef NO_EMBEDDED_ACCESS_CHECKS
3752
	sp_restore_security_context(thd, sp, &save_ctx);
3753
#endif
3754

3755
#ifndef EMBEDDED_LIBRARY
3756
	thd->net.no_send_ok= nsok;
3757
#endif
3758
	if (sp->m_multi_results)
3759 3760 3761 3762
	{
	  if (! smrx)
	    thd->server_status &= ~SERVER_MORE_RESULTS_EXISTS;
	}
3763

3764
	if (res == 0)
3765
	  send_ok(thd, (ulong) (thd->row_count_func < 0 ? 0 : thd->row_count_func));
3766 3767
	else
	  goto error;		// Substatement should already have sent error
3768
      }
3769
      break;
3770 3771
    }
  case SQLCOM_ALTER_PROCEDURE:
3772
  case SQLCOM_ALTER_FUNCTION:
3773
    {
3774 3775 3776 3777
      sp_head *sp;
      st_sp_chistics chistics;

      memcpy(&chistics, &lex->sp_chistics, sizeof(chistics));
unknown's avatar
unknown committed
3778
      if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
3779
	sp= sp_find_procedure(thd, lex->spname);
3780
      else
3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797
	sp= sp_find_function(thd, lex->spname);
      mysql_reset_errors(thd);
      if (! sp)
	res= SP_KEY_NOT_FOUND;
      else
      {
	if (check_sp_definer_access(thd, sp))
	{
	  res= -1;
	  break;
	}
	memcpy(&lex->sp_chistics, &chistics, sizeof(lex->sp_chistics));
	if (lex->sql_command == SQLCOM_ALTER_PROCEDURE)
	  res= sp_update_procedure(thd, lex->spname, &lex->sp_chistics);
	else
	  res= sp_update_function(thd, lex->spname, &lex->sp_chistics);
      }
unknown's avatar
unknown committed
3798
      switch (res)
3799
      {
unknown's avatar
unknown committed
3800
      case SP_OK:
3801
	send_ok(thd);
unknown's avatar
unknown committed
3802 3803
	break;
      case SP_KEY_NOT_FOUND:
3804
	net_printf(thd, ER_SP_DOES_NOT_EXIST, SP_COM_STRING(lex),
3805
		   lex->spname->m_qname.str);
unknown's avatar
unknown committed
3806 3807
	goto error;
      default:
3808
	net_printf(thd, ER_SP_CANT_ALTER, SP_COM_STRING(lex),
3809
		   lex->spname->m_qname.str);
unknown's avatar
unknown committed
3810
	goto error;
3811
      }
3812
      break;
3813 3814
    }
  case SQLCOM_DROP_PROCEDURE:
3815
  case SQLCOM_DROP_FUNCTION:
3816
    {
3817 3818
      sp_head *sp;

3819
      if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
3820 3821 3822 3823 3824 3825
	sp= sp_find_procedure(thd, lex->spname);
      else
	sp= sp_find_function(thd, lex->spname);
      mysql_reset_errors(thd);
      if (! sp)
	res= SP_KEY_NOT_FOUND;
3826 3827
      else
      {
3828
	if (check_sp_definer_access(thd, sp))
3829
	{
3830 3831 3832 3833 3834 3835 3836 3837 3838 3839
	  res= -1;
	  break;
	}
	if (lex->sql_command == SQLCOM_DROP_PROCEDURE)
	  res= sp_drop_procedure(thd, lex->spname);
	else
	{
	  res= sp_drop_function(thd, lex->spname);
#ifdef HAVE_DLOPEN
	  if (res == SP_KEY_NOT_FOUND)
3840
	  {
3841 3842 3843
	    udf_func *udf = find_udf(lex->spname->m_name.str,
				     lex->spname->m_name.length);
	    if (udf)
3844
	    {
3845 3846 3847 3848 3849 3850 3851
	      if (check_access(thd, DELETE_ACL, "mysql", 0, 1, 0))
		goto error;
	      if (!(res = mysql_drop_function(thd,&lex->spname->m_name)))
	      {
		send_ok(thd);
		break;
	      }
3852 3853 3854
	    }
	  }
#endif
3855
	}
3856 3857 3858 3859
      }
      switch (res)
      {
      case SP_OK:
3860
	send_ok(thd);
3861 3862
	break;
      case SP_KEY_NOT_FOUND:
3863 3864
	if (lex->drop_if_exists)
	{
3865
	  push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
3866
			      ER_SP_DOES_NOT_EXIST, ER(ER_SP_DOES_NOT_EXIST),
3867
			      SP_COM_STRING(lex), lex->spname->m_name.str);
3868 3869 3870 3871
	  res= 0;
	  send_ok(thd);
	  break;
	}
3872
	net_printf(thd, ER_SP_DOES_NOT_EXIST, SP_COM_STRING(lex),
3873
		   lex->spname->m_qname.str);
3874 3875
	goto error;
      default:
3876
	net_printf(thd, ER_SP_DROP_FAILED, SP_COM_STRING(lex),
3877
		   lex->spname->m_qname.str);
3878
	goto error;
3879
      }
3880
      break;
3881
    }
unknown's avatar
unknown committed
3882 3883 3884
  case SQLCOM_SHOW_CREATE_PROC:
    {
      res= -1;
3885
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
3886
      {
3887
	net_printf(thd, ER_TOO_LONG_IDENT, lex->spname->m_name.str);
unknown's avatar
unknown committed
3888 3889
	goto error;
      }
3890
      res= sp_show_create_procedure(thd, lex->spname);
3891 3892 3893
      if (res != SP_OK)
      {			/* We don't distinguish between errors for now */
	net_printf(thd, ER_SP_DOES_NOT_EXIST,
3894
		   SP_COM_STRING(lex), lex->spname->m_name.str);
3895
	res= 0;
unknown's avatar
unknown committed
3896 3897 3898 3899 3900 3901
	goto error;
      }
      break;
    }
  case SQLCOM_SHOW_CREATE_FUNC:
    {
3902
      if (lex->spname->m_name.length > NAME_LEN)
unknown's avatar
unknown committed
3903
      {
3904
	net_printf(thd, ER_TOO_LONG_IDENT, lex->spname->m_name.str);
unknown's avatar
unknown committed
3905 3906
	goto error;
      }
3907
      res= sp_show_create_function(thd, lex->spname);
3908 3909
      if (res != SP_OK)
      {			/* We don't distinguish between errors for now */
unknown's avatar
unknown committed
3910
	net_printf(thd, ER_SP_DOES_NOT_EXIST,
3911
		   SP_COM_STRING(lex), lex->spname->m_name.str);
3912
	res= 0;
unknown's avatar
unknown committed
3913 3914
	goto error;
      }
unknown's avatar
unknown committed
3915
      res= 0;
unknown's avatar
unknown committed
3916 3917 3918 3919
      break;
    }
  case SQLCOM_SHOW_STATUS_PROC:
    {
3920
      res= sp_show_status_procedure(thd, (lex->wild ?
unknown's avatar
unknown committed
3921 3922 3923 3924 3925
					  lex->wild->ptr() : NullS));
      break;
    }
  case SQLCOM_SHOW_STATUS_FUNC:
    {
3926
      res= sp_show_status_function(thd, (lex->wild ? 
unknown's avatar
unknown committed
3927 3928 3929
					 lex->wild->ptr() : NullS));
      break;
    }
unknown's avatar
VIEW  
unknown committed
3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946
  case SQLCOM_CREATE_VIEW:
    {
      res= mysql_create_view(thd, thd->lex->create_view_mode);
      break;
    }
  case SQLCOM_DROP_VIEW:
    {
      if (check_table_access(thd, DROP_ACL, all_tables, 0))
	goto error;
      if (end_active_trans(thd))
      {
	res= -1;
	break;
      }
      res= mysql_drop_view(thd, first_table, thd->lex->drop_mode);
      break;
    }
3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960
  case SQLCOM_CREATE_TRIGGER:
  {
    /* We don't care much about trigger body at that point */
    delete lex->sphead;
    lex->sphead= 0;

    res= mysql_create_or_drop_trigger(thd, all_tables, 1);
    break;
  }
  case SQLCOM_DROP_TRIGGER:
  {
    res= mysql_create_or_drop_trigger(thd, all_tables, 0);
    break;
  }
unknown's avatar
unknown committed
3961
  default:					/* Impossible */
3962
    send_ok(thd);
unknown's avatar
unknown committed
3963 3964
    break;
  }
unknown's avatar
unknown committed
3965
  thd->proc_info="query end";
3966
  if (thd->one_shot_set)
unknown's avatar
unknown committed
3967 3968 3969 3970 3971 3972 3973 3974
  {
    /*
      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)
3975
    {
unknown's avatar
unknown committed
3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987
      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;
3988
    }
unknown's avatar
unknown committed
3989
  }
3990

3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010
  /*
    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.
   */
  switch (lex->sql_command) {
  case SQLCOM_UPDATE:
  case SQLCOM_UPDATE_MULTI:
  case SQLCOM_REPLACE:
  case SQLCOM_INSERT:
  case SQLCOM_REPLACE_SELECT:
  case SQLCOM_INSERT_SELECT:
  case SQLCOM_DELETE:
  case SQLCOM_DELETE_MULTI:
  case SQLCOM_CALL:
    break;
  default:
    thd->row_count_func= -1;
  }

unknown's avatar
unknown committed
4011 4012 4013 4014
  /*
    We end up here if res == 0 and send_ok() has been done,
    or res != 0 and no send_error() has yet been done.
  */
unknown's avatar
unknown committed
4015
  if (res < 0)
unknown's avatar
SCRUM  
unknown committed
4016
    send_error(thd,thd->killed_errno());
4017
  DBUG_RETURN(res);
unknown's avatar
unknown committed
4018 4019

error:
unknown's avatar
unknown committed
4020
  /* We end up here if send_error() has already been done. */
4021
  DBUG_RETURN(-1);
unknown's avatar
unknown committed
4022 4023 4024
}


unknown's avatar
unknown committed
4025 4026 4027 4028
/*
  Check grants for commands which work only with one table and all other
  tables belong to subselects.

4029
  SYNOPSIS
unknown's avatar
unknown committed
4030 4031
    check_one_table_access()
    thd			Thread handler
4032
    privilege		requested privilege
unknown's avatar
VIEW  
unknown committed
4033
    all_tables		global table list of query
unknown's avatar
unknown committed
4034 4035 4036

  RETURN
    0 - OK
unknown's avatar
unknown committed
4037
    1 - access denied, error is sent to client
unknown's avatar
unknown committed
4038 4039
*/

4040
bool check_one_table_access(THD *thd, ulong privilege, TABLE_LIST *all_tables)
unknown's avatar
unknown committed
4041
{
unknown's avatar
VIEW  
unknown committed
4042 4043
  if (check_access(thd, privilege, all_tables->db,
		   &all_tables->grant.privilege, 0, 0))
unknown's avatar
unknown committed
4044
    return 1;
unknown's avatar
unknown committed
4045

unknown's avatar
unknown committed
4046
  /* Show only 1 table for check_grant */
unknown's avatar
VIEW  
unknown committed
4047
  if (grant_option && check_grant(thd, privilege, all_tables, 0, 1, 0))
unknown's avatar
unknown committed
4048
    return 1;
unknown's avatar
unknown committed
4049

unknown's avatar
unknown committed
4050
  /* Check rights on tables of subselect (if exists) */
unknown's avatar
unknown committed
4051
  TABLE_LIST *subselects_tables;
unknown's avatar
VIEW  
unknown committed
4052
  if ((subselects_tables= all_tables->next_global))
unknown's avatar
unknown committed
4053
  {
unknown's avatar
VIEW  
unknown committed
4054
    if ((check_table_access(thd, SELECT_ACL, subselects_tables, 0)))
unknown's avatar
unknown committed
4055 4056 4057
      return 1;
  }
  return 0;
unknown's avatar
unknown committed
4058 4059 4060
}


unknown's avatar
unknown committed
4061
/****************************************************************************
unknown's avatar
unknown committed
4062
  Get the user (global) and database privileges for all used tables
unknown's avatar
unknown committed
4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075

  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
4076 4077
                is enough to satisfy the request and the global grants contains
                a SELECT grant.
unknown's avatar
unknown committed
4078 4079 4080
****************************************************************************/

bool
unknown's avatar
unknown committed
4081
check_access(THD *thd, ulong want_access, const char *db, ulong *save_priv,
4082
	     bool dont_check_global_grants, bool no_errors)
unknown's avatar
unknown committed
4083
{
unknown's avatar
unknown committed
4084 4085 4086 4087
#ifndef NO_EMBEDDED_ACCESS_CHECKS
  ulong db_access;
#endif
  ulong dummy;
4088 4089 4090
  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
4091 4092 4093 4094 4095
  if (save_priv)
    *save_priv=0;
  else
    save_priv= &dummy;

4096
  if ((!db || !db[0]) && !thd->db && !dont_check_global_grants)
unknown's avatar
unknown committed
4097
  {
4098
    DBUG_PRINT("error",("No database"));
4099
    if (!no_errors)
4100
      send_error(thd,ER_NO_DB_ERROR);           /* purecov: tested */
unknown's avatar
unknown committed
4101
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
4102 4103
  }

unknown's avatar
unknown committed
4104 4105 4106
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  DBUG_RETURN(0);
#else
unknown's avatar
unknown committed
4107 4108
  if ((thd->master_access & want_access) == want_access)
  {
4109 4110 4111 4112 4113 4114 4115 4116
    /*
      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) &&
	(db && (!thd->db || strcmp(db,thd->db))))
4117
      db_access=acl_get(thd->host, thd->ip,
4118
			thd->priv_user, db, test(want_access & GRANT_ACL));
4119
    *save_priv=thd->master_access | db_access;
unknown's avatar
unknown committed
4120
    DBUG_RETURN(FALSE);
unknown's avatar
unknown committed
4121
  }
4122
  if (((want_access & ~thd->master_access) & ~(DB_ACLS | EXTRA_ACL)) ||
4123
      ! db && dont_check_global_grants)
unknown's avatar
unknown committed
4124
  {						// We can never grant this
4125
    DBUG_PRINT("error",("No possible access"));
4126
    if (!no_errors)
4127
      net_printf(thd,ER_ACCESS_DENIED_ERROR,
4128
		 thd->priv_user,
4129
		 thd->priv_host,
4130
		 thd->password ? ER(ER_YES) : ER(ER_NO));/* purecov: tested */
unknown's avatar
unknown committed
4131
    DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
4132 4133 4134
  }

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

unknown's avatar
unknown committed
4137
  if (db && (!thd->db || strcmp(db,thd->db)))
4138
    db_access=acl_get(thd->host, thd->ip,
4139
		      thd->priv_user, db, test(want_access & GRANT_ACL));
unknown's avatar
unknown committed
4140 4141
  else
    db_access=thd->db_access;
4142
  DBUG_PRINT("info",("db_access: %lu", db_access));
unknown's avatar
unknown committed
4143
  /* Remove SHOW attribute and access rights we already have */
4144
  want_access &= ~(thd->master_access | EXTRA_ACL);
4145 4146
  DBUG_PRINT("info",("db_access: %lu  want_access: %lu",
                     db_access, want_access));
unknown's avatar
unknown committed
4147
  db_access= ((*save_priv=(db_access | thd->master_access)) & want_access);
4148 4149

  /* grant_option is set if there exists a single table or column grant */
unknown's avatar
unknown committed
4150
  if (db_access == want_access ||
4151
      (grant_option && !dont_check_global_grants &&
4152
       !(want_access & ~(db_access | TABLE_ACLS))))
unknown's avatar
unknown committed
4153
    DBUG_RETURN(FALSE);				/* Ok */
4154 4155

  DBUG_PRINT("error",("Access denied"));
4156
  if (!no_errors)
4157
    net_printf(thd,ER_DBACCESS_DENIED_ERROR,
4158
	       thd->priv_user,
4159
	       thd->priv_host,
4160
	       db ? db : thd->db ? thd->db : "unknown"); /* purecov: tested */
unknown's avatar
unknown committed
4161
  DBUG_RETURN(TRUE);				/* purecov: tested */
unknown's avatar
unknown committed
4162
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
4163 4164 4165
}


4166 4167 4168 4169 4170 4171 4172 4173 4174
/*
  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
4175
    One gets access right if one has ANY of the rights in want_access
4176 4177 4178 4179 4180 4181 4182 4183
    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
4184 4185

bool check_global_access(THD *thd, ulong want_access)
unknown's avatar
unknown committed
4186
{
unknown's avatar
unknown committed
4187 4188 4189
#ifdef NO_EMBEDDED_ACCESS_CHECKS
  return 0;
#else
unknown's avatar
unknown committed
4190
  char command[128];
4191
  if ((thd->master_access & want_access))
unknown's avatar
unknown committed
4192 4193
    return 0;
  get_privilege_desc(command, sizeof(command), want_access);
4194
  net_printf(thd,ER_SPECIFIC_ACCESS_DENIED_ERROR,
unknown's avatar
unknown committed
4195 4196
	     command);
  return 1;
unknown's avatar
unknown committed
4197
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
unknown's avatar
unknown committed
4198 4199 4200
}


unknown's avatar
unknown committed
4201
/*
unknown's avatar
unknown committed
4202 4203
  Check the privilege for all used tables.  Table privileges are cached
  in the table list for GRANT checking
unknown's avatar
unknown committed
4204 4205
*/

4206
bool
unknown's avatar
unknown committed
4207
check_table_access(THD *thd, ulong want_access,TABLE_LIST *tables,
4208
		   bool no_errors)
unknown's avatar
unknown committed
4209
{
unknown's avatar
unknown committed
4210 4211
  uint found=0;
  ulong found_access=0;
unknown's avatar
unknown committed
4212
  TABLE_LIST *org_tables=tables;
unknown's avatar
VIEW  
unknown committed
4213
  for (; tables; tables= tables->next_global)
unknown's avatar
unknown committed
4214
  {
4215 4216 4217 4218
    if (tables->derived ||
        (tables->table && (int)tables->table->tmp_table) ||
        my_tz_check_n_skip_implicit_tables(&tables,
                                           thd->lex->time_zone_tables_used))
unknown's avatar
unknown committed
4219
      continue;
unknown's avatar
unknown committed
4220 4221
    if ((thd->master_access & want_access) == (want_access & ~EXTRA_ACL) &&
	thd->db)
unknown's avatar
unknown committed
4222
      tables->grant.privilege= want_access;
unknown's avatar
unknown committed
4223
    else if (tables->db && tables->db == thd->db)
unknown's avatar
unknown committed
4224 4225 4226 4227 4228
    {
      if (found && !grant_option)		// db already checked
	tables->grant.privilege=found_access;
      else
      {
4229 4230
	if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
			 0, no_errors))
unknown's avatar
unknown committed
4231 4232
	  return TRUE;				// Access denied
	found_access=tables->grant.privilege;
unknown's avatar
unknown committed
4233
	found=1;
unknown's avatar
unknown committed
4234 4235
      }
    }
4236
    else if (check_access(thd,want_access,tables->db,&tables->grant.privilege,
4237
			  0, no_errors))
4238
      return TRUE;
unknown's avatar
unknown committed
4239 4240
  }
  if (grant_option)
4241
    return check_grant(thd,want_access & ~EXTRA_ACL,org_tables,
unknown's avatar
unknown committed
4242
		       test(want_access & EXTRA_ACL), UINT_MAX, no_errors);
unknown's avatar
unknown committed
4243 4244 4245
  return FALSE;
}

4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281

/*
  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);
}


4282 4283
bool check_merge_table_access(THD *thd, char *db,
			      TABLE_LIST *table_list)
4284 4285 4286 4287
{
  int error=0;
  if (table_list)
  {
4288
    /* Check that all tables use the current database */
4289
    TABLE_LIST *tmp;
unknown's avatar
VIEW  
unknown committed
4290
    for (tmp= table_list; tmp; tmp= tmp->next_local)
4291 4292 4293 4294
    {
      if (!tmp->db || !tmp->db[0])
	tmp->db=db;
    }
4295
    error=check_table_access(thd, SELECT_ACL | UPDATE_ACL | DELETE_ACL,
unknown's avatar
unknown committed
4296
			     table_list,0);
4297 4298 4299 4300
  }
  return error;
}

unknown's avatar
unknown committed
4301 4302 4303

static bool check_db_used(THD *thd,TABLE_LIST *tables)
{
unknown's avatar
VIEW  
unknown committed
4304
  for (; tables; tables= tables->next_global)
unknown's avatar
unknown committed
4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316
  {
    if (!tables->db)
    {
      if (!(tables->db=thd->db))
      {
	send_error(thd,ER_NO_DB_ERROR);	/* purecov: tested */
	return TRUE;				/* purecov: tested */
      }
    }
  }
  return FALSE;
}
4317

4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352

/*
  Check if the given SP is owned by thd->priv_user/host, or priv_user is root.
  QQ This is not quite complete, but it will do as a basic security check
     for now. The question is exactly which rights should 'root' have?
     Should root have access regardless of host for instance?

  SYNOPSIS
    check_sp_definer_access()
    thd		 Thread handler
    sp           The SP pointer

  RETURN
    0  ok
    1  error     Error message has been sent
*/

static bool
check_sp_definer_access(THD *thd, sp_head *sp)
{
  LEX_STRING *usr, *hst;

  if (strcmp("root", thd->priv_user) == 0)
    return FALSE;		/* QQ Any root is ok now */
  usr= &sp->m_definer_user;
  hst= &sp->m_definer_host;
  if (strncmp(thd->priv_user, usr->str, usr->length) == 0 &&
      strncmp(thd->priv_host, hst->str, hst->length) == 0)
    return FALSE;		/* Both user and host must match */

  my_error(ER_SP_ACCESS_DENIED_ERROR, MYF(0), sp->m_qname.str);
  return TRUE;			/* Not definer or root */
}


unknown's avatar
unknown committed
4353 4354 4355 4356 4357 4358 4359 4360 4361 4362
/****************************************************************************
	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
4363 4364 4365 4366
#ifndef DBUG_OFF
long max_stack_used;
#endif

4367
#ifndef EMBEDDED_LIBRARY
unknown's avatar
unknown committed
4368 4369 4370 4371 4372 4373 4374 4375
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));
4376
    thd->fatal_error();
unknown's avatar
unknown committed
4377 4378
    return 1;
  }
unknown's avatar
unknown committed
4379 4380 4381
#ifndef DBUG_OFF
  max_stack_used= max(max_stack_used, stack_used);
#endif
unknown's avatar
unknown committed
4382 4383
  return 0;
}
4384
#endif /* EMBEDDED_LIBRARY */
unknown's avatar
unknown committed
4385 4386 4387 4388

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

4389
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
unknown's avatar
unknown committed
4390 4391
{
  LEX	*lex=current_lex;
4392
  ulong old_info=0;
unknown's avatar
unknown committed
4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418
  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;
}


/****************************************************************************
4419
  Initialize global thd variables needed for query
unknown's avatar
unknown committed
4420 4421
****************************************************************************/

4422
void
unknown's avatar
unknown committed
4423
mysql_init_query(THD *thd, uchar *buf, uint length)
unknown's avatar
unknown committed
4424 4425
{
  DBUG_ENTER("mysql_init_query");
unknown's avatar
unknown committed
4426
  lex_start(thd, buf, length);
4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447
  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");
4448
  thd->free_list= 0;
4449
  thd->select_number= 1;
unknown's avatar
unknown committed
4450
  thd->total_warn_count=0;			// Warnings for this query
unknown's avatar
unknown committed
4451 4452
  thd->last_insert_id_used= thd->query_start_used= thd->insert_id_used=0;
  thd->sent_row_count= thd->examined_row_count= 0;
4453
  thd->is_fatal_error= thd->rand_used= thd->time_zone_used= 0;
unknown's avatar
unknown committed
4454
  thd->server_status&= ~ (SERVER_MORE_RESULTS_EXISTS | 
unknown's avatar
unknown committed
4455 4456
                          SERVER_QUERY_NO_INDEX_USED |
                          SERVER_QUERY_NO_GOOD_INDEX_USED);
unknown's avatar
unknown committed
4457
  thd->tmp_table_used= 0;
unknown's avatar
unknown committed
4458 4459
  if (opt_bin_log)
    reset_dynamic(&thd->user_var_events);
4460
  thd->clear_error();
unknown's avatar
unknown committed
4461 4462 4463
  DBUG_VOID_RETURN;
}

4464

4465 4466 4467
void
mysql_init_select(LEX *lex)
{
unknown's avatar
unknown committed
4468
  SELECT_LEX *select_lex= lex->current_select;
unknown's avatar
unknown committed
4469
  select_lex->init_select();
4470
  select_lex->select_limit= HA_POS_ERROR;
4471 4472
  if (select_lex == &lex->select_lex)
  {
4473
    DBUG_ASSERT(lex->result == 0);
4474 4475
    lex->exchange= 0;
  }
4476 4477
}

4478

unknown's avatar
unknown committed
4479
bool
unknown's avatar
unknown committed
4480
mysql_new_select(LEX *lex, bool move_down)
4481
{
unknown's avatar
unknown committed
4482
  SELECT_LEX *select_lex = new(&lex->thd->mem_root) SELECT_LEX();
unknown's avatar
unknown committed
4483 4484
  if (!select_lex)
    return 1;
4485
  select_lex->select_number= ++lex->thd->select_number;
unknown's avatar
unknown committed
4486 4487
  select_lex->init_query();
  select_lex->init_select();
unknown's avatar
VIEW  
unknown committed
4488
  select_lex->parent_lex= lex;
unknown's avatar
unknown committed
4489 4490 4491
  if (move_down)
  {
    /* first select_lex of subselect or derived table */
unknown's avatar
unknown committed
4492
    SELECT_LEX_UNIT *unit= new(&lex->thd->mem_root) SELECT_LEX_UNIT();
unknown's avatar
unknown committed
4493 4494 4495 4496
    if (!unit)
      return 1;
    unit->init_query();
    unit->init_select();
4497
    unit->thd= lex->thd;
unknown's avatar
unknown committed
4498
    unit->include_down(lex->current_select);
unknown's avatar
unknown committed
4499 4500
    unit->link_next= 0;
    unit->link_prev= 0;
4501
    unit->return_to= lex->current_select;
unknown's avatar
unknown committed
4502
    select_lex->include_down(unit);
unknown's avatar
unknown committed
4503
    /* TODO: assign resolve_mode for fake subquery after merging with new tree */
unknown's avatar
unknown committed
4504 4505
  }
  else
unknown's avatar
unknown committed
4506
  {
unknown's avatar
VIEW  
unknown committed
4507 4508 4509 4510 4511
    if (lex->current_select->order_list.first && !lex->current_select->braces)
    {
      net_printf(lex->thd, ER_WRONG_USAGE, "UNION", "ORDER BY");
      return 1;
    }
4512
    select_lex->include_neighbour(lex->current_select);
unknown's avatar
unknown committed
4513 4514 4515 4516 4517 4518 4519 4520
    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
4521
      fake= unit->fake_select_lex= new(&lex->thd->mem_root) SELECT_LEX();
unknown's avatar
unknown committed
4522 4523 4524 4525 4526
      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;
4527
      fake->select_limit= HA_POS_ERROR;
unknown's avatar
unknown committed
4528 4529
    }
  }
unknown's avatar
unknown committed
4530

4531
  select_lex->master_unit()->global_parameters= select_lex;
4532
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
4533
  lex->current_select= select_lex;
4534
  select_lex->resolve_mode= SELECT_LEX::SELECT_MODE;
unknown's avatar
unknown committed
4535
  return 0;
4536
}
unknown's avatar
unknown committed
4537

4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552
/*
  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)
{
4553
  THD *thd;
4554
  LEX *lex;
4555
  LEX_STRING tmp, null_lex_string;
4556
  DBUG_ENTER("create_select_for_variable");
4557 4558

  thd= current_thd;
unknown's avatar
unknown committed
4559
  lex= thd->lex;
4560 4561 4562 4563
  mysql_init_select(lex);
  lex->sql_command= SQLCOM_SELECT;
  tmp.str= (char*) var_name;
  tmp.length=strlen(var_name);
4564 4565 4566
  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));
4567 4568 4569
  DBUG_VOID_RETURN;
}

4570

unknown's avatar
unknown committed
4571 4572
void mysql_init_multi_delete(LEX *lex)
{
unknown's avatar
unknown committed
4573
  lex->sql_command=  SQLCOM_DELETE_MULTI;
unknown's avatar
unknown committed
4574
  mysql_init_select(lex);
4575
  lex->select_lex.select_limit= lex->unit.select_limit_cnt=
unknown's avatar
unknown committed
4576
    HA_POS_ERROR;
unknown's avatar
unknown committed
4577
  lex->select_lex.table_list.save_and_clear(&lex->auxilliary_table_list);
unknown's avatar
VIEW  
unknown committed
4578 4579
  lex->query_tables= 0;
  lex->query_tables_last= &lex->query_tables;
unknown's avatar
unknown committed
4580
}
unknown's avatar
unknown committed
4581

4582

4583 4584 4585 4586
/*
  When you modify mysql_parse(), you may need to mofify
  mysql_test_parse_for_slave() in this same file.
*/
unknown's avatar
unknown committed
4587

4588
void mysql_parse(THD *thd, char *inBuf, uint length)
unknown's avatar
unknown committed
4589 4590 4591
{
  DBUG_ENTER("mysql_parse");

unknown's avatar
unknown committed
4592
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
4593
  if (query_cache_send_result_to_client(thd, inBuf, length) <= 0)
unknown's avatar
unknown committed
4594
  {
unknown's avatar
unknown committed
4595
    LEX *lex= thd->lex;
4596
    if (!yyparse((void *)thd) && ! thd->is_fatal_error)
unknown's avatar
unknown committed
4597
    {
unknown's avatar
unknown committed
4598
#ifndef NO_EMBEDDED_ACCESS_CHECKS
4599
      if (mqh_used && thd->user_connect &&
4600
	  check_mqh(thd, lex->sql_command))
4601 4602 4603 4604
      {
	thd->net.error = 0;
      }
      else
unknown's avatar
unknown committed
4605
#endif
4606
      {
unknown's avatar
unknown committed
4607
	if (thd->net.report_error)
4608
	{
unknown's avatar
unknown committed
4609
	  send_error(thd, 0, NullS);
4610
	  if (thd->lex->sphead)
4611 4612 4613 4614 4615 4616
	  {
	    if (lex != thd->lex)
	      thd->lex->sphead->restore_lex(thd);
	    delete thd->lex->sphead;
	    thd->lex->sphead= NULL;
	  }
4617
	}
unknown's avatar
unknown committed
4618 4619 4620
	else
	{
	  mysql_execute_command(thd);
unknown's avatar
SCRUM  
unknown committed
4621
	  query_cache_end_of_result(thd);
unknown's avatar
unknown committed
4622
	}
4623
      }
4624
      lex->unit.cleanup();
unknown's avatar
unknown committed
4625 4626
    }
    else
4627 4628
    {
      DBUG_PRINT("info",("Command aborted. Fatal_error: %d",
4629
			 thd->is_fatal_error));
unknown's avatar
unknown committed
4630
      query_cache_abort(&thd->net);
4631
      lex->unit.cleanup();
4632
      if (thd->lex->sphead)
4633
      {
unknown's avatar
unknown committed
4634
	/* Clean up after failed stored procedure/function */
4635 4636 4637 4638 4639
	if (lex != thd->lex)
	  thd->lex->sphead->restore_lex(thd);
	delete thd->lex->sphead;
	thd->lex->sphead= NULL;
      }
4640
    }
unknown's avatar
unknown committed
4641
    thd->proc_info="freeing items";
4642
    thd->end_statement();
4643
    thd->cleanup_after_query();
4644
    DBUG_ASSERT(thd->change_list.is_empty());
unknown's avatar
unknown committed
4645
  }
unknown's avatar
unknown committed
4646 4647 4648 4649
  DBUG_VOID_RETURN;
}


unknown's avatar
unknown committed
4650
#ifdef HAVE_REPLICATION
4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661
/*
  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
4662
  LEX *lex= thd->lex;
4663
  bool error= 0;
unknown's avatar
unknown committed
4664
  DBUG_ENTER("mysql_test_parse_for_slave");
4665

unknown's avatar
unknown committed
4666
  mysql_init_query(thd, (uchar*) inBuf, length);
unknown's avatar
unknown committed
4667
  if (!yyparse((void*) thd) && ! thd->is_fatal_error &&
4668
      all_tables_not_ok(thd,(TABLE_LIST*) lex->select_lex.table_list.first))
unknown's avatar
unknown committed
4669
    error= 1;                  /* Ignore question */
4670
  thd->end_statement();
4671
  thd->cleanup_after_query();
unknown's avatar
unknown committed
4672
  DBUG_RETURN(error);
4673
}
unknown's avatar
unknown committed
4674
#endif
unknown's avatar
unknown committed
4675

4676

unknown's avatar
unknown committed
4677

4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702
/*
  Calculate interval lengths.
  Strip trailing spaces from all strings.
  After this function call:
  - ENUM uses max_length
  - SET uses tot_length.
*/
void calculate_interval_lengths(THD *thd, TYPELIB *interval,
                                uint *max_length, uint *tot_length)
{
  const char **pos;
  uint *len;
  CHARSET_INFO *cs= thd->variables.character_set_client;
  *max_length= *tot_length= 0;
  for (pos= interval->type_names, len= interval->type_lengths;
       *pos ; pos++, len++)
  {
    *len= (uint) strip_sp((char*) *pos);
    uint length= cs->cset->numchars(cs, *pos, *pos + *len);
    *tot_length+= length;
    set_if_bigger(*max_length, length);
  }
}


unknown's avatar
unknown committed
4703 4704 4705 4706 4707
/*****************************************************************************
** Store field definition for create
** Return 0 if ok
******************************************************************************/

unknown's avatar
unknown committed
4708
bool add_field_to_list(THD *thd, char *field_name, enum_field_types type,
unknown's avatar
unknown committed
4709
		       char *length, char *decimals,
4710
		       uint type_modifier,
4711 4712
		       Item *default_value, Item *on_update_value,
                       LEX_STRING *comment,
unknown's avatar
unknown committed
4713 4714
		       char *change, TYPELIB *interval, CHARSET_INFO *cs,
		       uint uint_geom_type)
unknown's avatar
unknown committed
4715 4716
{
  register create_field *new_field;
unknown's avatar
unknown committed
4717
  LEX  *lex= thd->lex;
unknown's avatar
unknown committed
4718
  uint allowed_type_modifier=0;
unknown's avatar
unknown committed
4719
  uint sign_len;
4720
  char warn_buff[MYSQL_ERRMSG_SIZE];
unknown's avatar
unknown committed
4721 4722 4723 4724
  DBUG_ENTER("add_field_to_list");

  if (strlen(field_name) > NAME_LEN)
  {
4725
    net_printf(thd, ER_TOO_LONG_IDENT, field_name); /* purecov: inspected */
unknown's avatar
unknown committed
4726 4727 4728 4729 4730
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  if (type_modifier & PRI_KEY_FLAG)
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
4731
    lex->key_list.push_back(new Key(Key::PRIMARY, NullS, HA_KEY_ALG_UNDEF,
4732
				    0, lex->col_list));
unknown's avatar
unknown committed
4733 4734 4735 4736 4737
    lex->col_list.empty();
  }
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
  {
    lex->col_list.push_back(new key_part_spec(field_name,0));
4738
    lex->key_list.push_back(new Key(Key::UNIQUE, NullS, HA_KEY_ALG_UNDEF, 0,
unknown's avatar
unknown committed
4739 4740 4741 4742
				    lex->col_list));
    lex->col_list.empty();
  }

4743
  if (default_value)
unknown's avatar
unknown committed
4744
  {
4745
    /* 
unknown's avatar
unknown committed
4746 4747
      Default value should be literal => basic constants =>
      no need fix_fields()
4748 4749 4750
      
      We allow only one function as part of default value - 
      NOW() as default for TIMESTAMP type.
4751
    */
4752 4753 4754
    if (default_value->type() == Item::FUNC_ITEM && 
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
         type == FIELD_TYPE_TIMESTAMP))
4755
    {
unknown's avatar
unknown committed
4756
      net_printf(thd, ER_INVALID_DEFAULT, field_name);
4757 4758 4759
      DBUG_RETURN(1);
    }
    else if (default_value->type() == Item::NULL_ITEM)
unknown's avatar
unknown committed
4760
    {
4761
      default_value= 0;
4762 4763 4764
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
	  NOT_NULL_FLAG)
      {
unknown's avatar
unknown committed
4765
	net_printf(thd,ER_INVALID_DEFAULT,field_name);
4766 4767 4768 4769 4770
	DBUG_RETURN(1);
      }
    }
    else if (type_modifier & AUTO_INCREMENT_FLAG)
    {
unknown's avatar
unknown committed
4771
      net_printf(thd, ER_INVALID_DEFAULT, field_name);
unknown's avatar
unknown committed
4772 4773 4774
      DBUG_RETURN(1);
    }
  }
4775 4776 4777 4778 4779 4780 4781

  if (on_update_value && type != FIELD_TYPE_TIMESTAMP)
  {
    net_printf(thd, ER_INVALID_ON_UPDATE, field_name);
    DBUG_RETURN(1);
  }
    
unknown's avatar
unknown committed
4782 4783 4784 4785
  if (!(new_field=new create_field()))
    DBUG_RETURN(1);
  new_field->field=0;
  new_field->field_name=field_name;
4786
  new_field->def= default_value;
unknown's avatar
unknown committed
4787 4788 4789 4790 4791 4792 4793 4794 4795 4796
  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;
  new_field->pack_length=0;
4797
  new_field->charset=cs;
unknown's avatar
unknown committed
4798
  new_field->geom_type= (Field::geometry_type) uint_geom_type;
unknown's avatar
unknown committed
4799

4800 4801 4802 4803 4804 4805 4806 4807
  if (!comment)
  {
    new_field->comment.str=0;
    new_field->comment.length=0;
  }
  else
  {
    /* In this case comment is always of type Item_string */
unknown's avatar
unknown committed
4808 4809
    new_field->comment.str=   (char*) comment->str;
    new_field->comment.length=comment->length;
4810
  }
unknown's avatar
unknown committed
4811 4812 4813 4814 4815
  /*
    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
4816
  if (!default_value && !(type_modifier & AUTO_INCREMENT_FLAG) &&
unknown's avatar
unknown committed
4817 4818
      (type_modifier & NOT_NULL_FLAG) && type != FIELD_TYPE_TIMESTAMP &&
      type != FIELD_TYPE_ENUM)
unknown's avatar
unknown committed
4819 4820
    new_field->flags|= NO_DEFAULT_VALUE_FLAG;

4821 4822
  if (length && !(new_field->length= (uint) atoi(length)))
    length=0; /* purecov: inspected */
unknown's avatar
unknown committed
4823
  sign_len=type_modifier & UNSIGNED_FLAG ? 0 : 1;
unknown's avatar
unknown committed
4824 4825

  if (new_field->length && new_field->decimals &&
4826
      new_field->length < new_field->decimals+1 &&
unknown's avatar
unknown committed
4827
      new_field->decimals != NOT_FIXED_DEC)
4828
    new_field->length=new_field->decimals+1; /* purecov: inspected */
unknown's avatar
unknown committed
4829 4830 4831

  switch (type) {
  case FIELD_TYPE_TINY:
4832
    if (!length) new_field->length=MAX_TINYINT_WIDTH+sign_len;
unknown's avatar
unknown committed
4833 4834 4835
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_SHORT:
4836
    if (!length) new_field->length=MAX_SMALLINT_WIDTH+sign_len;
unknown's avatar
unknown committed
4837 4838 4839
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_INT24:
4840
    if (!length) new_field->length=MAX_MEDIUMINT_WIDTH+sign_len;
unknown's avatar
unknown committed
4841 4842 4843
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONG:
4844
    if (!length) new_field->length=MAX_INT_WIDTH+sign_len;
unknown's avatar
unknown committed
4845 4846 4847
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_LONGLONG:
4848
    if (!length) new_field->length=MAX_BIGINT_WIDTH;
unknown's avatar
unknown committed
4849 4850 4851 4852 4853 4854
    allowed_type_modifier= AUTO_INCREMENT_FLAG;
    break;
  case FIELD_TYPE_NULL:
    break;
  case FIELD_TYPE_DECIMAL:
    if (!length)
unknown's avatar
unknown committed
4855 4856
    {
      if ((new_field->length= new_field->decimals))
4857 4858
        new_field->length++;
      else
unknown's avatar
unknown committed
4859 4860
        new_field->length= 10;                  // Default length for DECIMAL
    }
4861 4862 4863 4864 4865 4866
    if (new_field->length < MAX_FIELD_WIDTH)	// Skip wrong argument
    {
      new_field->length+=sign_len;
      if (new_field->decimals)
	new_field->length++;
    }
unknown's avatar
unknown committed
4867
    break;
4868 4869
  case FIELD_TYPE_STRING:
  case FIELD_TYPE_VAR_STRING:
4870
    if (new_field->length <= MAX_FIELD_CHARLENGTH || default_value)
4871 4872 4873 4874
      break;
    /* Convert long CHAR() and VARCHAR columns to TEXT or BLOB */
    new_field->sql_type= FIELD_TYPE_BLOB;
    sprintf(warn_buff, ER(ER_AUTO_CONVERT), field_name, "CHAR",
unknown's avatar
unknown committed
4875
	    (cs == &my_charset_bin) ? "BLOB" : "TEXT");
4876
    push_warning(thd, MYSQL_ERROR::WARN_LEVEL_NOTE, ER_AUTO_CONVERT,
4877 4878
		 warn_buff);
    /* fall through */
unknown's avatar
unknown committed
4879 4880 4881 4882
  case FIELD_TYPE_BLOB:
  case FIELD_TYPE_TINY_BLOB:
  case FIELD_TYPE_LONG_BLOB:
  case FIELD_TYPE_MEDIUM_BLOB:
unknown's avatar
unknown committed
4883
  case FIELD_TYPE_GEOMETRY:
4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897
    if (new_field->length)
    {
      /* The user has given a length to the blob column */
      if (new_field->length < 256)
	type= FIELD_TYPE_TINY_BLOB;
      if (new_field->length < 65536)
	type= FIELD_TYPE_BLOB;
      else if (new_field->length < 256L*256L*256L)
	type= FIELD_TYPE_MEDIUM_BLOB;
      else
	type= FIELD_TYPE_LONG_BLOB;
      new_field->length= 0;
    }
    new_field->sql_type= type;
unknown's avatar
unknown committed
4898 4899 4900 4901 4902 4903
    if (default_value)				// Allow empty as default value
    {
      String str,*res;
      res=default_value->val_str(&str);
      if (res->length())
      {
4904
	net_printf(thd,ER_BLOB_CANT_HAVE_DEFAULT,field_name); /* purecov: inspected */
unknown's avatar
unknown committed
4905 4906 4907 4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920 4921 4922 4923
	DBUG_RETURN(1); /* purecov: inspected */
      }
      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)
      {
4924
	net_printf(thd,ER_WRONG_FIELD_SPEC,field_name);
unknown's avatar
unknown committed
4925 4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953
	DBUG_RETURN(1);
      }
      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
4954
    else if (new_field->length != 19)
unknown's avatar
unknown committed
4955
    {
4956 4957 4958 4959
      /*
        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
4960 4961 4962
      new_field->length=((new_field->length+1)/2)*2; /* purecov: inspected */
      new_field->length= min(new_field->length,14); /* purecov: inspected */
    }
4963
    new_field->flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983
    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
    {
4984 4985 4986 4987 4988 4989 4990 4991
      /*
        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
4992
        information about all TIMESTAMP fields in table will be availiable.
4993 4994 4995

        If we have TIMESTAMP NULL column without explicit DEFAULT value
        we treat it as having DEFAULT NULL attribute.
4996
      */
unknown's avatar
unknown committed
4997 4998 4999 5000 5001
      new_field->unireg_check= (on_update_value ?
                                Field::TIMESTAMP_UN_FIELD :
                                (new_field->flags & NOT_NULL_FLAG ?
                                 Field::TIMESTAMP_OLD_FIELD:
                                 Field::NONE));
5002
    }
unknown's avatar
unknown committed
5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020
    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:
    {
      if (interval->count > sizeof(longlong)*8)
      {
5021
	net_printf(thd,ER_TOO_BIG_SET,field_name); /* purecov: inspected */
unknown's avatar
unknown committed
5022 5023 5024 5025 5026 5027
	DBUG_RETURN(1);				/* purecov: inspected */
      }
      new_field->pack_length=(interval->count+7)/8;
      if (new_field->pack_length > 4)
	new_field->pack_length=8;
      new_field->interval=interval;
5028 5029 5030 5031
      uint dummy_max_length;
      calculate_interval_lengths(thd, interval,
                                 &dummy_max_length, &new_field->length);
      new_field->length+= (interval->count - 1);
unknown's avatar
unknown committed
5032 5033 5034
      set_if_smaller(new_field->length,MAX_FIELD_WIDTH-1);
      if (default_value)
      {
5035 5036
	char *not_used;
	uint not_used2;
5037
	bool not_used3;
5038

unknown's avatar
unknown committed
5039 5040 5041
	thd->cuted_fields=0;
	String str,*res;
	res=default_value->val_str(&str);
5042 5043 5044
	(void) find_set(interval, res->ptr(), res->length(),
                        &my_charset_bin,
                        &not_used, &not_used2, &not_used3);
unknown's avatar
unknown committed
5045 5046
	if (thd->cuted_fields)
	{
5047
	  net_printf(thd,ER_INVALID_DEFAULT,field_name);
unknown's avatar
unknown committed
5048 5049 5050 5051 5052 5053 5054 5055 5056
	  DBUG_RETURN(1);
	}
      }
    }
    break;
  case FIELD_TYPE_ENUM:
    {
      new_field->interval=interval;
      new_field->pack_length=interval->count < 256 ? 1 : 2; // Should be safe
5057 5058 5059 5060

      uint dummy_tot_length;
      calculate_interval_lengths(thd, interval,
                                 &new_field->length, &dummy_tot_length);
unknown's avatar
unknown committed
5061 5062 5063 5064 5065
      set_if_smaller(new_field->length,MAX_FIELD_WIDTH-1);
      if (default_value)
      {
	String str,*res;
	res=default_value->val_str(&str);
5066 5067
	res->strip_sp();
	if (!find_type(interval, res->ptr(), res->length(), 0))
unknown's avatar
unknown committed
5068
	{
5069
	  net_printf(thd,ER_INVALID_DEFAULT,field_name);
unknown's avatar
unknown committed
5070 5071 5072 5073 5074 5075 5076
	  DBUG_RETURN(1);
	}
      }
      break;
    }
  }

5077 5078
  if ((new_field->length > MAX_FIELD_CHARLENGTH && type != FIELD_TYPE_SET && 
       type != FIELD_TYPE_ENUM) ||
unknown's avatar
unknown committed
5079
      (!new_field->length && !(new_field->flags & BLOB_FLAG) &&
5080
       type != FIELD_TYPE_STRING &&
unknown's avatar
SCRUM  
unknown committed
5081
       type != FIELD_TYPE_VAR_STRING && type != FIELD_TYPE_GEOMETRY))
unknown's avatar
unknown committed
5082
  {
5083
    net_printf(thd,ER_TOO_BIG_FIELDLENGTH,field_name,
5084
	       MAX_FIELD_CHARLENGTH);		/* purecov: inspected */
unknown's avatar
unknown committed
5085 5086 5087 5088 5089
    DBUG_RETURN(1);				/* purecov: inspected */
  }
  type_modifier&= AUTO_INCREMENT_FLAG;
  if ((~allowed_type_modifier) & type_modifier)
  {
5090
    net_printf(thd,ER_WRONG_FIELD_SPEC,field_name);
unknown's avatar
unknown committed
5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111
    DBUG_RETURN(1);
  }
  if (!new_field->pack_length)
    new_field->pack_length=calc_pack_length(new_field->sql_type ==
					    FIELD_TYPE_VAR_STRING ?
					    FIELD_TYPE_STRING :
					    new_field->sql_type,
					    new_field->length);
  lex->create_list.push_back(new_field);
  lex->last_field=new_field;
  DBUG_RETURN(0);
}

/* 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
5112
add_proc_to_list(THD* thd, Item *item)
unknown's avatar
unknown committed
5113 5114 5115 5116
{
  ORDER *order;
  Item	**item_ptr;

unknown's avatar
unknown committed
5117
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER)+sizeof(Item*))))
unknown's avatar
unknown committed
5118 5119 5120 5121 5122
    return 1;
  item_ptr = (Item**) (order+1);
  *item_ptr= item;
  order->item=item_ptr;
  order->free_me=0;
unknown's avatar
unknown committed
5123
  thd->lex->proc_list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
5124 5125 5126 5127 5128 5129 5130 5131
  return 0;
}


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

static void remove_escape(char *name)
{
5132 5133
  if (!*name)					// For empty DB names
    return;
unknown's avatar
unknown committed
5134 5135
  char *to;
#ifdef USE_MB
unknown's avatar
unknown committed
5136
  char *strend=name+(uint) strlen(name);
unknown's avatar
unknown committed
5137 5138 5139 5140 5141 5142
#endif
  for (to=name; *name ; name++)
  {
#ifdef USE_MB
    int l;
/*    if ((l = ismbchar(name, name+MBMAXLEN))) { Wei He: I think it's wrong */
5143 5144
    if (use_mb(system_charset_info) &&
        (l = my_ismbchar(system_charset_info, name, strend)))
unknown's avatar
unknown committed
5145 5146 5147 5148 5149 5150 5151 5152
    {
	while (l--)
	    *to++ = *name++;
	name--;
	continue;
    }
#endif
    if (*name == '\\' && name[1])
unknown's avatar
unknown committed
5153
      name++;					// Skip '\\'
unknown's avatar
unknown committed
5154 5155 5156 5157 5158 5159 5160 5161 5162 5163
    *to++= *name;
  }
  *to=0;
}

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


unknown's avatar
unknown committed
5164
bool add_to_list(THD *thd, SQL_LIST &list,Item *item,bool asc)
unknown's avatar
unknown committed
5165 5166 5167
{
  ORDER *order;
  DBUG_ENTER("add_to_list");
unknown's avatar
unknown committed
5168
  if (!(order = (ORDER *) thd->alloc(sizeof(ORDER))))
unknown's avatar
unknown committed
5169
    DBUG_RETURN(1);
unknown's avatar
unknown committed
5170 5171
  order->item_ptr= item;
  order->item= &order->item_ptr;
unknown's avatar
unknown committed
5172 5173 5174
  order->asc = asc;
  order->free_me=0;
  order->used=0;
5175
  order->counter_used= 0;
unknown's avatar
unknown committed
5176
  list.link_in_list((byte*) order,(byte**) &order->next);
unknown's avatar
unknown committed
5177 5178 5179 5180
  DBUG_RETURN(0);
}


unknown's avatar
unknown committed
5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199
/*
  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
5200 5201
TABLE_LIST *st_select_lex::add_table_to_list(THD *thd,
					     Table_ident *table,
5202
					     LEX_STRING *alias,
unknown's avatar
unknown committed
5203 5204
					     ulong table_options,
					     thr_lock_type lock_type,
5205 5206
					     List<String> *use_index_arg,
					     List<String> *ignore_index_arg,
unknown's avatar
unknown committed
5207
                                             LEX_STRING *option)
unknown's avatar
unknown committed
5208 5209 5210
{
  register TABLE_LIST *ptr;
  char *alias_str;
5211
  LEX *lex= thd->lex;
unknown's avatar
unknown committed
5212 5213 5214 5215 5216
  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
5217
  if (check_table_name(table->table.str,table->table.length) ||
5218
      table->db.str && check_db_name(table->db.str))
unknown's avatar
unknown committed
5219
  {
5220
    net_printf(thd, ER_WRONG_TABLE_NAME, table->table.str);
unknown's avatar
unknown committed
5221 5222 5223 5224
    DBUG_RETURN(0);
  }

  if (!alias)					/* Alias is case sensitive */
5225 5226 5227 5228 5229 5230
  {
    if (table->sel)
    {
      net_printf(thd,ER_DERIVED_MUST_HAVE_ALIAS);
      DBUG_RETURN(0);
    }
5231
    if (!(alias_str=thd->memdup(alias_str,table->table.length+1)))
unknown's avatar
unknown committed
5232
      DBUG_RETURN(0);
5233
  }
unknown's avatar
unknown committed
5234
  if (!(ptr = (TABLE_LIST *) thd->calloc(sizeof(TABLE_LIST))))
unknown's avatar
unknown committed
5235
    DBUG_RETURN(0);				/* purecov: inspected */
unknown's avatar
unknown committed
5236
  if (table->db.str)
5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247
  {
    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
  {
5248 5249
    /* The following can't be "" as we may do 'casedn_str()' on it */
    ptr->db= empty_c_string;
5250 5251
    ptr->db_length= 0;
  }
5252 5253
  if (thd->current_arena->is_stmt_prepare())
    ptr->db= thd->strdup(ptr->db);
unknown's avatar
unknown committed
5254

5255
  ptr->alias= alias_str;
5256 5257
  if (lower_case_table_names && table->table.length)
    my_casedn_str(files_charset_info, table->table.str);
unknown's avatar
unknown committed
5258
  ptr->real_name=table->table.str;
5259
  ptr->real_name_length=table->table.length;
5260
  ptr->lock_type=   lock_type;
unknown's avatar
unknown committed
5261 5262
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
unknown's avatar
unknown committed
5263
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
5264
  ptr->derived=	    table->sel;
5265
  ptr->select_lex=  lex->current_select;
unknown's avatar
unknown committed
5266
  ptr->cacheable_table= 1;
5267 5268 5269 5270 5271 5272
  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
5273
  ptr->option= option ? option->str : 0;
unknown's avatar
unknown committed
5274
  /* check that used name is unique */
5275
  if (lock_type != TL_IGNORE)
unknown's avatar
unknown committed
5276
  {
5277
    for (TABLE_LIST *tables=(TABLE_LIST*) table_list.first ;
unknown's avatar
unknown committed
5278
	 tables ;
unknown's avatar
VIEW  
unknown committed
5279
	 tables=tables->next_local)
unknown's avatar
unknown committed
5280
    {
5281 5282
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
	  !strcmp(ptr->db, tables->db))
unknown's avatar
unknown committed
5283
      {
5284
	net_printf(thd,ER_NONUNIQ_TABLE,alias_str); /* purecov: tested */
unknown's avatar
unknown committed
5285 5286
	DBUG_RETURN(0);				/* purecov: tested */
      }
unknown's avatar
unknown committed
5287 5288
    }
  }
5289
  /* Link table in local list (list for current select) */
unknown's avatar
VIEW  
unknown committed
5290
  table_list.link_in_list((byte*) ptr, (byte**) &ptr->next_local);
5291
  /* Link table in global list (all used tables) */
5292
  lex->add_to_query_tables(ptr);
unknown's avatar
unknown committed
5293 5294 5295
  DBUG_RETURN(ptr);
}

unknown's avatar
unknown committed
5296

5297 5298 5299 5300
/*
  Initialize a new table list for a nested join

  SYNOPSIS
5301
    init_table_list()
5302
    thd         current thread
5303

5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320 5321 5322
  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");
5323

5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347
  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
5348
    moves it one level up, eliminating the nest.
5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379

  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;
  DBUG_ENTER("end_nested_join");
  ptr= embedding;
  join_list= ptr->join_list;
  embedding= ptr->embedding;
  NESTED_JOIN *nested_join= ptr->nested_join;
  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;
  }
  DBUG_RETURN(ptr);
}


/*
  Nest last join operation

  SYNOPSIS
5380
    nest_last_join()
5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395
    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");
5396

5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418
  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);
}


/*
5419
  Save names for a join with using clause
5420

5421 5422 5423 5424 5425 5426 5427
  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
5428 5429
    to be able to build later an on expression to replace the using clause.

5430
  RETURN VALUE
5431 5432
    None
*/
5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453

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;
}
5454

5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488

/*
  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
5489 5490 5491

  DESCRIPTION
    The function takes the current join list t[0],t[1] ... and
5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514
    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
*/

5515
TABLE_LIST *st_select_lex::convert_right_join()
5516 5517
{
  TABLE_LIST *tab2= join_list->pop();
5518
  TABLE_LIST *tab1= join_list->pop();
5519 5520 5521 5522 5523 5524 5525 5526 5527
  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
5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540
/*
  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
5541
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
unknown's avatar
unknown committed
5542 5543 5544 5545 5546 5547
{
  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
5548 5549 5550
  for (TABLE_LIST *tables= (TABLE_LIST*) table_list.first;
       tables;
       tables= tables->next_local)
unknown's avatar
unknown committed
5551 5552 5553 5554 5555 5556 5557
  {
    tables->lock_type= lock_type;
    tables->updating=  for_update;
  }
  DBUG_VOID_RETURN;
}

unknown's avatar
unknown committed
5558

unknown's avatar
unknown committed
5559 5560
void add_join_on(TABLE_LIST *b,Item *expr)
{
5561
  if (expr)
5562
  {
5563 5564 5565 5566
    if (!b->on_expr)
      b->on_expr=expr;
    else
    {
unknown's avatar
unknown committed
5567
      /* This only happens if you have both a right and left join */
5568 5569 5570
      b->on_expr=new Item_cond_and(b->on_expr,expr);
    }
    b->on_expr->top_level_item();
5571
  }
unknown's avatar
unknown committed
5572 5573 5574
}


5575 5576 5577 5578 5579 5580 5581
/*
  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
5582

5583 5584 5585 5586 5587 5588 5589 5590 5591 5592
  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
5593 5594 5595 5596 5597
void add_join_natural(TABLE_LIST *a,TABLE_LIST *b)
{
  b->natural_join=a;
}

5598
/*
5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615
  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
5616 5617
*/

5618 5619
bool reload_acl_and_cache(THD *thd, ulong options, TABLE_LIST *tables,
                          bool *write_to_binlog)
unknown's avatar
unknown committed
5620 5621 5622
{
  bool result=0;
  select_errors=0;				/* Write if more errors */
5623
  bool tmp_write_to_binlog= 1;
unknown's avatar
SCRUM  
unknown committed
5624
#ifndef NO_EMBEDDED_ACCESS_CHECKS
unknown's avatar
unknown committed
5625 5626
  if (options & REFRESH_GRANT)
  {
5627
    acl_reload(thd);
unknown's avatar
unknown committed
5628
    grant_reload(thd);
5629
    if (mqh_used)
unknown's avatar
unknown committed
5630
      reset_mqh(thd,(LEX_USER *) NULL,TRUE);
unknown's avatar
unknown committed
5631
  }
unknown's avatar
SCRUM  
unknown committed
5632
#endif
unknown's avatar
unknown committed
5633 5634
  if (options & REFRESH_LOG)
  {
5635
    /*
unknown's avatar
unknown committed
5636 5637
      Flush the normal query log, the update log, the binary log,
      the slow query log, and the relay log (if it exists).
5638
    */
unknown's avatar
unknown committed
5639

5640 5641 5642 5643 5644 5645
    /* 
     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
5646 5647 5648
    mysql_log.new_file(1);
    mysql_bin_log.new_file(1);
    mysql_slow_log.new_file(1);
unknown's avatar
unknown committed
5649
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
5650
    if (mysql_bin_log.is_open() && expire_logs_days)
5651 5652 5653
    {
      long purge_time= time(0) - expire_logs_days*24*60*60;
      if (purge_time >= 0)
5654
	mysql_bin_log.purge_logs_before_date(purge_time);
5655
    }
5656
    pthread_mutex_lock(&LOCK_active_mi);
5657
    rotate_relay_log(active_mi);
5658
    pthread_mutex_unlock(&LOCK_active_mi);
unknown's avatar
unknown committed
5659
#endif
unknown's avatar
unknown committed
5660 5661
    if (ha_flush_logs())
      result=1;
unknown's avatar
unknown committed
5662 5663
    if (flush_error_log())
      result=1;
unknown's avatar
unknown committed
5664
  }
unknown's avatar
unknown committed
5665
#ifdef HAVE_QUERY_CACHE
unknown's avatar
unknown committed
5666 5667
  if (options & REFRESH_QUERY_CACHE_FREE)
  {
unknown's avatar
unknown committed
5668
    query_cache.pack();				// FLUSH QUERY CACHE
unknown's avatar
unknown committed
5669
    options &= ~REFRESH_QUERY_CACHE; 	// Don't flush cache, just free memory
unknown's avatar
unknown committed
5670 5671 5672
  }
  if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
  {
unknown's avatar
unknown committed
5673
    query_cache.flush();			// RESET QUERY CACHE
unknown's avatar
unknown committed
5674
  }
unknown's avatar
unknown committed
5675
#endif /*HAVE_QUERY_CACHE*/
5676 5677 5678 5679 5680
  /*
    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
5681
  {
5682
    if ((options & REFRESH_READ_LOCK) && thd)
unknown's avatar
unknown committed
5683
    {
unknown's avatar
unknown committed
5684 5685 5686 5687
      /*
	Writing to the binlog could cause deadlocks, as we don't log
	UNLOCK TABLES
      */
5688
      tmp_write_to_binlog= 0;
5689 5690
      if (lock_global_read_lock(thd))
	return 1;
5691 5692 5693
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1,
                                 tables);
      make_global_read_lock_block_commit(thd);
unknown's avatar
unknown committed
5694
    }
5695 5696
    else
      result=close_cached_tables(thd,(options & REFRESH_FAST) ? 0 : 1, tables);
unknown's avatar
unknown committed
5697
    my_dbopt_cleanup();
unknown's avatar
unknown committed
5698 5699 5700 5701 5702 5703 5704
  }
  if (options & REFRESH_HOSTS)
    hostname_cache_refresh();
  if (options & REFRESH_STATUS)
    refresh_status();
  if (options & REFRESH_THREADS)
    flush_thread_cache();
unknown's avatar
unknown committed
5705
#ifdef HAVE_REPLICATION
unknown's avatar
unknown committed
5706
  if (options & REFRESH_MASTER)
5707 5708
  {
    tmp_write_to_binlog= 0;
5709 5710
    if (reset_master(thd))
      result=1;
5711
  }
5712
#endif
unknown's avatar
unknown committed
5713
#ifdef OPENSSL
5714 5715 5716 5717 5718 5719
   if (options & REFRESH_DES_KEY_FILE)
   {
     if (des_key_file)
       result=load_des_key_file(des_key_file);
   }
#endif
unknown's avatar
unknown committed
5720
#ifdef HAVE_REPLICATION
5721 5722
 if (options & REFRESH_SLAVE)
 {
5723
   tmp_write_to_binlog= 0;
5724
   pthread_mutex_lock(&LOCK_active_mi);
5725
   if (reset_slave(thd, active_mi))
5726
     result=1;
5727
   pthread_mutex_unlock(&LOCK_active_mi);
5728
 }
5729
#endif
5730
 if (options & REFRESH_USER_RESOURCES)
5731
   reset_mqh(thd,(LEX_USER *) NULL);
5732 5733
 if (write_to_binlog)
   *write_to_binlog= tmp_write_to_binlog;
5734
 return result;
unknown's avatar
unknown committed
5735 5736
}

5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748
/*
  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
5749
void kill_one_thread(THD *thd, ulong id, bool only_kill_query)
unknown's avatar
unknown committed
5750 5751 5752
{
  THD *tmp;
  uint error=ER_NO_SUCH_THREAD;
5753 5754
  VOID(pthread_mutex_lock(&LOCK_thread_count)); // For unlink from list
  I_List_iterator<THD> it(threads);
unknown's avatar
unknown committed
5755 5756 5757 5758
  while ((tmp=it++))
  {
    if (tmp->thread_id == id)
    {
5759 5760
      pthread_mutex_lock(&tmp->LOCK_delete);	// Lock from delete
      break;
unknown's avatar
unknown committed
5761 5762 5763
    }
  }
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
5764 5765 5766 5767 5768
  if (tmp)
  {
    if ((thd->master_access & SUPER_ACL) ||
	!strcmp(thd->user,tmp->user))
    {
unknown's avatar
SCRUM  
unknown committed
5769
      tmp->awake(only_kill_query ? THD::KILL_QUERY : THD::KILL_CONNECTION);
5770 5771 5772 5773 5774 5775 5776
      error=0;
    }
    else
      error=ER_KILL_DENIED_ERROR;
    pthread_mutex_unlock(&tmp->LOCK_delete);
  }

unknown's avatar
unknown committed
5777
  if (!error)
5778
    send_ok(thd);
unknown's avatar
unknown committed
5779
  else
5780
    net_printf(thd,error,id);
unknown's avatar
unknown committed
5781 5782 5783 5784 5785 5786 5787 5788 5789 5790
}

/* 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)
5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802
      *(ulong*) ptr->value= 0;
    else if (ptr->type == SHOW_KEY_CACHE_LONG)
    {
      /*
	Reset value in 'default' key cache.
	This needs to be recoded when we have thread specific key values
      */
      char *value= (((char*) sql_key_cache) +
		    (uint) ((char*) (ptr->value) -
			    (char*) &dflt_key_cache_var));
      *(ulong*) value= 0;
    }
5803 5804 5805 5806 5807 5808 5809
    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
5810 5811 5812
  }
  pthread_mutex_unlock(&LOCK_status);
}
5813 5814 5815 5816


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

unknown's avatar
unknown committed
5817 5818
static bool append_file_to_dir(THD *thd, const char **filename_ptr,
			       const char *table_name)
5819
{
5820
  char buff[FN_REFLEN],*ptr, *end;
5821 5822 5823 5824 5825 5826 5827
  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))
  {
5828
    my_error(ER_WRONG_TABLE_NAME, MYF(0), *filename_ptr);
5829 5830 5831 5832
    return 1;
  }
  /* Fix is using unix filename format on dos */
  strmov(buff,*filename_ptr);
5833
  end=convert_dirname(buff, *filename_ptr, NullS);
unknown's avatar
unknown committed
5834
  if (!(ptr=thd->alloc((uint) (end-buff)+(uint) strlen(table_name)+1)))
5835 5836
    return 1;					// End of memory
  *filename_ptr=ptr;
5837
  strxmov(ptr,buff,table_name,NullS);
5838 5839
  return 0;
}
5840

5841

5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855
/*
  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;
unknown's avatar
unknown committed
5856
  if (thd->lex->current_select != &thd->lex->select_lex)
5857 5858
  {
    char command[80];
unknown's avatar
unknown committed
5859 5860
    strmake(command, thd->lex->yylval->symbol.str,
	    min(thd->lex->yylval->symbol.length, sizeof(command)-1));
5861
    net_printf(thd, ER_CANT_USE_OPTION_HERE, command);
5862 5863 5864 5865
    return 1;
  }
  return 0;
}
unknown's avatar
unknown committed
5866

unknown's avatar
unknown committed
5867

unknown's avatar
unknown committed
5868
Comp_creator *comp_eq_creator(bool invert)
unknown's avatar
unknown committed
5869
{
unknown's avatar
unknown committed
5870
  return invert?(Comp_creator *)&ne_creator:(Comp_creator *)&eq_creator;
unknown's avatar
unknown committed
5871 5872
}

unknown's avatar
unknown committed
5873

unknown's avatar
unknown committed
5874
Comp_creator *comp_ge_creator(bool invert)
unknown's avatar
unknown committed
5875
{
unknown's avatar
unknown committed
5876
  return invert?(Comp_creator *)&lt_creator:(Comp_creator *)&ge_creator;
unknown's avatar
unknown committed
5877 5878
}

unknown's avatar
unknown committed
5879

unknown's avatar
unknown committed
5880
Comp_creator *comp_gt_creator(bool invert)
unknown's avatar
unknown committed
5881
{
unknown's avatar
unknown committed
5882
  return invert?(Comp_creator *)&le_creator:(Comp_creator *)&gt_creator;
unknown's avatar
unknown committed
5883 5884
}

unknown's avatar
unknown committed
5885

unknown's avatar
unknown committed
5886
Comp_creator *comp_le_creator(bool invert)
unknown's avatar
unknown committed
5887
{
unknown's avatar
unknown committed
5888
  return invert?(Comp_creator *)&gt_creator:(Comp_creator *)&le_creator;
unknown's avatar
unknown committed
5889 5890
}

unknown's avatar
unknown committed
5891

unknown's avatar
unknown committed
5892
Comp_creator *comp_lt_creator(bool invert)
unknown's avatar
unknown committed
5893
{
unknown's avatar
unknown committed
5894
  return invert?(Comp_creator *)&ge_creator:(Comp_creator *)&lt_creator;
unknown's avatar
unknown committed
5895 5896
}

unknown's avatar
unknown committed
5897

unknown's avatar
unknown committed
5898
Comp_creator *comp_ne_creator(bool invert)
unknown's avatar
unknown committed
5899
{
unknown's avatar
unknown committed
5900
  return invert?(Comp_creator *)&eq_creator:(Comp_creator *)&ne_creator;
unknown's avatar
unknown committed
5901
}
unknown's avatar
unknown committed
5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921


/*
  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
5922
  if ((cmp == &comp_eq_creator) && !all)       //  = ANY <=> IN
unknown's avatar
unknown committed
5923
    return new Item_in_subselect(left_expr, select_lex);
unknown's avatar
unknown committed
5924 5925

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

  Item_allany_subselect *it=
5929
    new Item_allany_subselect(left_expr, (*cmp)(all), select_lex, all);
unknown's avatar
unknown committed
5930 5931 5932 5933 5934
  if (all)
    return it->upper_not= new Item_func_not_all(it);	/* ALL */

  return it;						/* ANY/SOME */
}
5935 5936


5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950 5951
/*
  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.
*/

int mysql_create_index(THD *thd, TABLE_LIST *table_list, List<Key> &keys)
{
  List<create_field> fields;
5952 5953
  ALTER_INFO alter_info;
  alter_info.flags= ALTER_ADD_INDEX;
5954 5955 5956 5957 5958 5959 5960
  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;
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->real_name,
				&create_info, table_list,
5961 5962
				fields, keys, 0, (ORDER*)0,
				DUP_ERROR, &alter_info));
5963 5964 5965
}


5966
int mysql_drop_index(THD *thd, TABLE_LIST *table_list, ALTER_INFO *alter_info)
5967 5968 5969 5970 5971 5972 5973 5974
{
  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;
5975 5976
  alter_info->clear();
  alter_info->flags= ALTER_DROP_INDEX;
5977 5978
  DBUG_RETURN(mysql_alter_table(thd,table_list->db,table_list->real_name,
				&create_info, table_list,
5979 5980
				fields, keys, 0, (ORDER*)0,
				DUP_ERROR, alter_info));
5981
}
unknown's avatar
merge  
unknown committed
5982 5983


5984 5985 5986 5987 5988
/*
  Multi update query pre-check

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

unknown's avatar
unknown committed
5992
  RETURN VALUE
unknown's avatar
unknown committed
5993 5994 5995
    0   OK
    1   Error (message is sent to user)
    -1  Error (message is not sent to user)
5996
*/
unknown's avatar
unknown committed
5997

5998 5999 6000 6001 6002 6003
int multi_update_precheck(THD *thd, TABLE_LIST *tables)
{
  const char *msg= 0;
  TABLE_LIST *table;
  LEX *lex= thd->lex;
  SELECT_LEX *select_lex= &lex->select_lex;
unknown's avatar
VIEW  
unknown committed
6004
  DBUG_ENTER("multi_update_precheck");
6005 6006 6007 6008 6009 6010 6011 6012 6013 6014

  if (select_lex->item_list.elements != lex->value_list.elements)
  {
    my_error(ER_WRONG_VALUE_COUNT, MYF(0));
    DBUG_RETURN(-1);
  }
  /*
    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
6015
  for (table= tables; table; table= table->next_local)
6016
  {
6017 6018 6019 6020 6021 6022
    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
6023 6024 6025
             (check_access(thd, SELECT_ACL, table->db,
                           &table->grant.privilege, 0, 0) ||
              grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0)))
6026
      DBUG_RETURN(1);
unknown's avatar
unknown committed
6027

unknown's avatar
VIEW  
unknown committed
6028
    table->table_in_first_from_clause= 1;
6029
  }
unknown's avatar
unknown committed
6030 6031 6032
  /*
    Is there tables of subqueries?
  */
6033 6034
  if (&lex->select_lex != lex->all_selects_list)
  {
6035
    DBUG_PRINT("info",("Checking sub query list"));
unknown's avatar
VIEW  
unknown committed
6036
    for (table= tables; table; table= table->next_global)
6037
    {
unknown's avatar
unknown committed
6038
      if (!table->table_in_first_from_clause && table->derived)
6039 6040 6041
      {
	if (check_access(thd, SELECT_ACL, table->db,
			 &table->grant.privilege, 0, 0) ||
unknown's avatar
unknown committed
6042
	    grant_option && check_grant(thd, SELECT_ACL, table, 0, 1, 0))
6043 6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063 6064 6065
	  DBUG_RETURN(1);
      }
    }
  }

  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);
    DBUG_RETURN(-1);
  }
  DBUG_RETURN(0);
}

/*
  Multi delete query pre-check

  SYNOPSIS
    multi_delete_precheck()
unknown's avatar
unknown committed
6066
    thd			Thread handler
unknown's avatar
VIEW  
unknown committed
6067
    tables		Global/local table list
unknown's avatar
unknown committed
6068
    table_count		Pointer to table counter
6069

unknown's avatar
unknown committed
6070
  RETURN VALUE
unknown's avatar
unknown committed
6071 6072 6073
    0   OK
    1   error (message is sent to user)
    -1  error (message is not sent to user)
6074 6075 6076 6077 6078 6079
*/
int multi_delete_precheck(THD *thd, TABLE_LIST *tables, uint *table_count)
{
  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
6080
  TABLE_LIST *target_tbl;
unknown's avatar
VIEW  
unknown committed
6081
  DBUG_ENTER("multi_delete_precheck");
unknown's avatar
unknown committed
6082 6083

  *table_count= 0;
6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095

  /* 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))
    DBUG_RETURN(1);
  if ((thd->options & OPTION_SAFE_UPDATES) && !select_lex->where)
  {
    my_error(ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE, MYF(0));
    DBUG_RETURN(-1);
  }
unknown's avatar
VIEW  
unknown committed
6096
  for (target_tbl= aux_tables; target_tbl; target_tbl= target_tbl->next_local)
6097 6098 6099 6100
  {
    (*table_count)++;
    /* All tables in aux_tables must be found in FROM PART */
    TABLE_LIST *walk;
unknown's avatar
VIEW  
unknown committed
6101
    for (walk= tables; walk; walk= walk->next_local)
6102
    {
unknown's avatar
unknown committed
6103 6104 6105
      if (!my_strcasecmp(table_alias_charset,
			 target_tbl->alias, walk->alias) &&
	  !strcmp(walk->db, target_tbl->db))
6106 6107 6108 6109
	break;
    }
    if (!walk)
    {
unknown's avatar
unknown committed
6110 6111
      my_error(ER_UNKNOWN_TABLE, MYF(0), target_tbl->real_name,
	       "MULTI DELETE");
6112 6113
      DBUG_RETURN(-1);
    }
unknown's avatar
unknown committed
6114
    walk->lock_type= target_tbl->lock_type;
unknown's avatar
VIEW  
unknown committed
6115
    target_tbl->correspondent_table= walk;	// Remember corresponding table
6116 6117 6118 6119 6120 6121 6122 6123 6124
  }
  DBUG_RETURN(0);
}


/*
  INSERT ... SELECT query pre-check

  SYNOPSIS
6125
    insert_delete_precheck()
unknown's avatar
unknown committed
6126 6127
    thd		Thread handler
    tables	Global table list
6128

unknown's avatar
unknown committed
6129
  RETURN VALUE
unknown's avatar
unknown committed
6130 6131 6132
    0   OK
    1   Error (message is sent to user)
    -1  Error (message is not sent to user)
6133
*/
unknown's avatar
unknown committed
6134

6135 6136 6137 6138 6139 6140 6141 6142 6143
int insert_select_precheck(THD *thd, TABLE_LIST *tables)
{
  DBUG_ENTER("insert_select_precheck");
  /*
    Check that we have modify privileges for the first table and
    select privileges for the rest
  */
  ulong privilege= (thd->lex->duplicates == DUP_REPLACE ?
		    INSERT_ACL | DELETE_ACL : INSERT_ACL);
unknown's avatar
unknown committed
6144 6145 6146 6147 6148 6149 6150 6151 6152
  DBUG_RETURN(check_one_table_access(thd, privilege, tables) ? 1 : 0);
}


/*
  simple UPDATE query pre-check

  SYNOPSIS
    update_precheck()
unknown's avatar
unknown committed
6153 6154
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
6155 6156

  RETURN VALUE
unknown's avatar
unknown committed
6157 6158 6159
    0   OK
    1   Error (message is sent to user)
    -1  Error (message is not sent to user)
unknown's avatar
unknown committed
6160
*/
unknown's avatar
unknown committed
6161

unknown's avatar
unknown committed
6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177 6178 6179
int update_precheck(THD *thd, TABLE_LIST *tables)
{
  DBUG_ENTER("update_precheck");
  if (thd->lex->select_lex.item_list.elements != thd->lex->value_list.elements)
  {
    my_error(ER_WRONG_VALUE_COUNT, MYF(0));
    DBUG_RETURN(-1);
  }
  DBUG_RETURN((check_db_used(thd, tables) ||
	       check_one_table_access(thd, UPDATE_ACL, tables)) ? 1 : 0);
}


/*
  simple DELETE query pre-check

  SYNOPSIS
    delete_precheck()
unknown's avatar
unknown committed
6180 6181
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
6182 6183

  RETURN VALUE
unknown's avatar
unknown committed
6184 6185 6186
    0   OK
    1   error (message is sent to user)
    -1  error (message is not sent to user)
unknown's avatar
unknown committed
6187
*/
unknown's avatar
unknown committed
6188

unknown's avatar
unknown committed
6189 6190 6191 6192 6193
int delete_precheck(THD *thd, TABLE_LIST *tables)
{
  DBUG_ENTER("delete_precheck");
  if (check_one_table_access(thd, DELETE_ACL, tables))
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6194
  /* Set privilege for the WHERE clause */
unknown's avatar
unknown committed
6195 6196 6197 6198 6199 6200 6201 6202 6203 6204
  tables->grant.want_privilege=(SELECT_ACL & ~tables->grant.privilege);
  DBUG_RETURN(0);
}


/*
  simple INSERT query pre-check

  SYNOPSIS
    insert_precheck()
unknown's avatar
unknown committed
6205 6206
    thd		Thread handler
    tables	Global table list
unknown's avatar
unknown committed
6207 6208

  RETURN VALUE
unknown's avatar
unknown committed
6209 6210 6211
    0   OK
    1   error (message is sent to user)
    -1  error (message is not sent to user)
unknown's avatar
unknown committed
6212
*/
unknown's avatar
unknown committed
6213

6214
int insert_precheck(THD *thd, TABLE_LIST *tables)
unknown's avatar
unknown committed
6215 6216 6217 6218
{
  LEX *lex= thd->lex;
  DBUG_ENTER("insert_precheck");

unknown's avatar
unknown committed
6219 6220 6221
  ulong privilege= (INSERT_ACL |
                    (lex->duplicates == DUP_REPLACE ? DELETE_ACL : 0) |
                    (lex->value_list.elements ? UPDATE_ACL : 0));
unknown's avatar
unknown committed
6222 6223

  if (check_one_table_access(thd, privilege, tables))
6224
    DBUG_RETURN(1);
unknown's avatar
unknown committed
6225 6226 6227 6228 6229 6230

  if (lex->select_lex.item_list.elements != lex->value_list.elements)
  {
    my_error(ER_WRONG_VALUE_COUNT, MYF(0));
    DBUG_RETURN(-1);
  }
6231 6232
  DBUG_RETURN(0);
}
unknown's avatar
unknown committed
6233 6234 6235 6236 6237 6238 6239


/*
  CREATE TABLE query pre-check

  SYNOPSIS
    create_table_precheck()
unknown's avatar
unknown committed
6240 6241 6242
    thd			Thread handler
    tables		Global table list
    create_table	Table which will be created
unknown's avatar
unknown committed
6243 6244

  RETURN VALUE
unknown's avatar
unknown committed
6245 6246
    0   OK
    1   Error (message is sent to user)
unknown's avatar
unknown committed
6247
*/
unknown's avatar
unknown committed
6248

unknown's avatar
unknown committed
6249 6250 6251 6252
int create_table_precheck(THD *thd, TABLE_LIST *tables,
			  TABLE_LIST *create_table)
{
  LEX *lex= thd->lex;
6253 6254 6255
  SELECT_LEX *select_lex= &lex->select_lex;
  ulong want_priv;
  int error= 1;                                 // Error message is given
unknown's avatar
unknown committed
6256
  DBUG_ENTER("create_table_precheck");
6257 6258 6259

  want_priv= ((lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) ?
              CREATE_TMP_ACL : CREATE_ACL);
unknown's avatar
unknown committed
6260 6261 6262 6263 6264 6265
  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))
6266 6267 6268 6269 6270 6271 6272 6273 6274 6275
    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
6276 6277 6278
      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).
6279
    */
unknown's avatar
unknown committed
6280
    if (thd->current_arena->is_stmt_prepare())
6281
    {
unknown's avatar
unknown committed
6282 6283 6284 6285
      /*
        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
6286 6287
          find_table_in_global_list(tables, create_table->db,
                                    create_table->real_name))
unknown's avatar
unknown committed
6288 6289
      {
        net_printf(thd,ER_UPDATE_TABLE_USED, create_table->real_name);
6290

unknown's avatar
unknown committed
6291 6292 6293
        goto err;
      }
    }
6294 6295 6296 6297 6298 6299 6300
    if (tables && check_table_access(thd, SELECT_ACL, tables,0))
      goto err;
  }
  error= 0;

err:
  DBUG_RETURN(error);
unknown's avatar
unknown committed
6301
}
unknown's avatar
unknown committed
6302 6303 6304 6305 6306 6307 6308


/*
  negate given expression

  SYNOPSIS
    negate_expression()
6309
    thd  thread handler
unknown's avatar
unknown committed
6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323 6324 6325 6326 6327 6328 6329 6330 6331 6332 6333 6334 6335 6336 6337
    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);
}