sp_head.cc 45.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/* Copyright (C) 2002 MySQL AB

   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.

   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.

   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 */

#ifdef __GNUC__
#pragma implementation
#endif

#include "mysql_priv.h"
#include "sp_head.h"
23
#include "sp.h"
24 25
#include "sp_pcontext.h"
#include "sp_rcontext.h"
26
#include "sp_cache.h"
27

28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
Item_result
sp_map_result_type(enum enum_field_types type)
{
  switch (type)
  {
  case MYSQL_TYPE_TINY:
  case MYSQL_TYPE_SHORT:
  case MYSQL_TYPE_LONG:
  case MYSQL_TYPE_LONGLONG:
  case MYSQL_TYPE_INT24:
    return INT_RESULT;
  case MYSQL_TYPE_DECIMAL:
  case MYSQL_TYPE_FLOAT:
  case MYSQL_TYPE_DOUBLE:
    return REAL_RESULT;
  default:
    return STRING_RESULT;
  }
}

48 49 50 51 52 53 54 55 56 57 58
/*
 * Returns TRUE if the 'cmd' is a command that might result in
 * multiple result sets being sent back.
 * Note: This does not include SQLCOM_SELECT which is treated
 *       separately in sql_yacc.yy.
 */
bool
sp_multi_results_command(enum enum_sql_command cmd)
{
  switch (cmd) {
  case SQLCOM_ANALYZE:
59
  case SQLCOM_CHECKSUM:
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
  case SQLCOM_HA_READ:
  case SQLCOM_SHOW_BINLOGS:
  case SQLCOM_SHOW_BINLOG_EVENTS:
  case SQLCOM_SHOW_CHARSETS:
  case SQLCOM_SHOW_COLLATIONS:
  case SQLCOM_SHOW_COLUMN_TYPES:
  case SQLCOM_SHOW_CREATE:
  case SQLCOM_SHOW_CREATE_DB:
  case SQLCOM_SHOW_CREATE_FUNC:
  case SQLCOM_SHOW_CREATE_PROC:
  case SQLCOM_SHOW_DATABASES:
  case SQLCOM_SHOW_ERRORS:
  case SQLCOM_SHOW_FIELDS:
  case SQLCOM_SHOW_GRANTS:
  case SQLCOM_SHOW_INNODB_STATUS:
  case SQLCOM_SHOW_KEYS:
  case SQLCOM_SHOW_LOGS:
  case SQLCOM_SHOW_MASTER_STAT:
  case SQLCOM_SHOW_NEW_MASTER:
  case SQLCOM_SHOW_OPEN_TABLES:
  case SQLCOM_SHOW_PRIVILEGES:
  case SQLCOM_SHOW_PROCESSLIST:
  case SQLCOM_SHOW_SLAVE_HOSTS:
  case SQLCOM_SHOW_SLAVE_STAT:
  case SQLCOM_SHOW_STATUS:
  case SQLCOM_SHOW_STATUS_FUNC:
  case SQLCOM_SHOW_STATUS_PROC:
  case SQLCOM_SHOW_STORAGE_ENGINES:
  case SQLCOM_SHOW_TABLES:
  case SQLCOM_SHOW_VARIABLES:
  case SQLCOM_SHOW_WARNS:
    return TRUE;
  default:
    return FALSE;
  }
}

97 98 99
/* Evaluate a (presumed) func item. Always returns an item, the parameter
** if nothing else.
*/
100 101
Item *
sp_eval_func_item(THD *thd, Item *it, enum enum_field_types type)
102
{
103
  DBUG_ENTER("sp_eval_func_item");
104
  it= it->this_item();
105
  DBUG_PRINT("info", ("type: %d", type));
106

107
  if (!it->fixed && it->fix_fields(thd, 0, &it))
108 109
  {
    DBUG_PRINT("info", ("fix_fields() failed"));
110
    DBUG_RETURN(NULL);
111
  }
112

113
  /* QQ How do we do this? Is there some better way? */
114
  if (type == MYSQL_TYPE_NULL)
115 116
    it= new Item_null();
  else
117
  {
118 119
    switch (sp_map_result_type(type)) {
    case INT_RESULT:
120 121 122 123
      {
	longlong i= it->val_int();

	if (it->null_value)
124 125
	{
	  DBUG_PRINT("info", ("INT_RESULT: null"));
126
	  it= new Item_null();
127
	}
128
	else
129 130
	{
	  DBUG_PRINT("info", ("INT_RESULT: %d", i));
131
	  it= new Item_int(it->val_int());
132
	}
133 134
	break;
      }
135
    case REAL_RESULT:
136
      {
137
	double d= it->val_real();
138 139

	if (it->null_value)
140 141
	{
	  DBUG_PRINT("info", ("REAL_RESULT: null"));
142
	  it= new Item_null();
143
	}
144
	else
145
	{
146 147 148 149
	  /* There's some difference between Item::new_item() and the
	   * constructor; the former crashes, the latter works... weird. */
	  uint8 decimals= it->decimals;
	  uint32 max_length= it->max_length;
150
	  DBUG_PRINT("info", ("REAL_RESULT: %g", d));
151
	  it= new Item_real(it->val_real());
152 153
	  it->decimals= decimals;
	  it->max_length= max_length;
154
	}
155 156
	break;
      }
157 158 159
    default:
      {
	char buffer[MAX_FIELD_WIDTH];
pem@mysql.telia.com's avatar
pem@mysql.telia.com committed
160
	String tmp(buffer, sizeof(buffer), it->collation.collation);
161 162
	String *s= it->val_str(&tmp);

163
	if (it->null_value)
164 165
	{
	  DBUG_PRINT("info", ("default result: null"));
166
	  it= new Item_null();
167
	}
168
	else
169 170
	{
	  DBUG_PRINT("info",("default result: %*s",s->length(),s->c_ptr_quick()));
171 172
	  it= new Item_string(thd->strmake(s->c_ptr_quick(), s->length()),
			      s->length(), it->collation.collation);
173
	}
174 175
	break;
      }
176 177 178
    }
  }

179
  DBUG_RETURN(it);
180 181
}

182 183 184 185 186 187 188 189 190 191 192

/*
 *
 *  sp_name
 *
 */

void
sp_name::init_qname(THD *thd)
{
  m_qname.length= m_db.length+m_name.length+1;
monty@mysql.com's avatar
monty@mysql.com committed
193
  m_qname.str= thd->alloc(m_qname.length+1);
194 195 196 197 198
  sprintf(m_qname.str, "%*s.%*s",
	  m_db.length, (m_db.length ? m_db.str : ""),
	  m_name.length, m_name.str);
}

199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
sp_name *
sp_name_current_db_new(THD *thd, LEX_STRING name)
{
  sp_name *qname;

  if (! thd->db)
    qname= new sp_name(name);
  else
  {
    LEX_STRING db;

    db.length= strlen(thd->db);
    db.str= thd->strmake(thd->db, db.length);
    qname= new sp_name(db, name);
  }
  qname->init_qname(thd);
  return qname;
}


219 220 221 222 223 224 225 226 227
/* ------------------------------------------------------------------ */


/*
 *
 *  sp_head
 *
 */

228 229 230 231 232 233 234 235
void *
sp_head::operator new(size_t size)
{
  DBUG_ENTER("sp_head::operator new");
  MEM_ROOT own_root;
  sp_head *sp;

  init_alloc_root(&own_root, MEM_ROOT_BLOCK_SIZE, MEM_ROOT_PREALLOC);
monty@mysql.com's avatar
monty@mysql.com committed
236 237
  sp= (sp_head *) alloc_root(&own_root, size);
  sp->main_mem_root= own_root;
238
  DBUG_PRINT("info", ("mem_root 0x%lx", (ulong) &sp->mem_root));
239 240 241 242 243 244 245 246
  DBUG_RETURN(sp);
}

void 
sp_head::operator delete(void *ptr, size_t size)
{
  DBUG_ENTER("sp_head::operator delete");
  MEM_ROOT own_root;
monty@mysql.com's avatar
monty@mysql.com committed
247
  sp_head *sp= (sp_head *) ptr;
248

monty@mysql.com's avatar
monty@mysql.com committed
249 250
  /* Make a copy of main_mem_root as free_root will free the sp */
  own_root= sp->main_mem_root;
251 252
  DBUG_PRINT("info", ("mem_root 0x%lx moved to 0x%lx",
                      (ulong) &sp->mem_root, (ulong) &own_root));
253 254 255 256 257
  free_root(&own_root, MYF(0));

  DBUG_VOID_RETURN;
}

258

259
sp_head::sp_head()
260
  :Item_arena((bool)FALSE), m_returns_cs(NULL), m_has_return(FALSE),
261
   m_simple_case(FALSE), m_multi_results(FALSE), m_in_handler(FALSE)
262
{
263 264
  extern byte *
    sp_table_key(const byte *ptr, uint *plen, my_bool first);
265
  DBUG_ENTER("sp_head::sp_head");
266

267
  state= INITIALIZED;
268 269
  m_backpatch.empty();
  m_lex.empty();
270
  hash_init(&m_sptabs, system_charset_info, 0, 0, 0, sp_table_key, 0, 0);
271 272 273
  DBUG_VOID_RETURN;
}

274

275
void
276
sp_head::init(LEX *lex)
277 278
{
  DBUG_ENTER("sp_head::init");
279

280
  lex->spcont= m_pcont= new sp_pcontext(NULL);
281 282 283 284 285
  /*
    Altough trg_table_fields list is used only in triggers we init for all
    types of stored procedures to simplify reset_lex()/restore_lex() code.
  */
  lex->trg_table_fields.empty();
286 287
  my_init_dynamic_array(&m_instr, sizeof(sp_instr *), 16, 8);
  m_param_begin= m_param_end= m_returns_begin= m_returns_end= m_body_begin= 0;
288 289 290 291
  m_qname.str= m_db.str= m_name.str= m_params.str= m_retstr.str=
    m_body.str= m_defstr.str= 0;
  m_qname.length= m_db.length= m_name.length= m_params.length=
    m_retstr.length= m_body.length= m_defstr.length= 0;
292
  m_returns_cs= NULL;
293 294 295 296
  DBUG_VOID_RETURN;
}

void
297
sp_head::init_strings(THD *thd, LEX *lex, sp_name *name)
298 299
{
  DBUG_ENTER("sp_head::init_strings");
300
  uint n;			/* Counter for nul trimming */ 
301
  /* During parsing, we must use thd->mem_root */
monty@mysql.com's avatar
monty@mysql.com committed
302
  MEM_ROOT *root= thd->mem_root;
303

304
  /* We have to copy strings to get them into the right memroot */
305 306
  if (name)
  {
307
    m_db.length= name->m_db.length;
308
    if (name->m_db.length == 0)
309
      m_db.str= NULL;
310 311 312 313 314 315 316 317 318 319
    else
      m_db.str= strmake_root(root, name->m_db.str, name->m_db.length);
    m_name.length= name->m_name.length;
    m_name.str= strmake_root(root, name->m_name.str, name->m_name.length);

    if (name->m_qname.length == 0)
      name->init_qname(thd);
    m_qname.length= name->m_qname.length;
    m_qname.str= strmake_root(root, name->m_qname.str, m_qname.length);
  }
320
  else if (thd->db)
321
  {
322
    m_db.length= thd->db_length;
323
    m_db.str= strmake_root(root, thd->db, m_db.length);
324
  }
325

326
  if (m_param_begin && m_param_end)
327
  {
328 329 330
    m_params.length= m_param_end - m_param_begin;
    m_params.str= strmake_root(root,
                               (char *)m_param_begin, m_params.length);
331
  }
332

333 334 335
  if (m_returns_begin && m_returns_end)
  {
    /* QQ KLUDGE: We can't seem to cut out just the type in the parser
336 337 338 339
       (without the RETURNS), so we'll have to do it here. :-(
       Furthermore, if there's a character type as well, it's not include
       (beyond the m_returns_end pointer), in which case we need
       m_returns_cs. */
340 341 342 343 344 345 346 347 348 349 350
    char *p= (char *)m_returns_begin+strspn((char *)m_returns_begin,"\t\n\r ");
    p+= strcspn(p, "\t\n\r ");
    p+= strspn(p, "\t\n\r ");
    if (p < (char *)m_returns_end)
      m_returns_begin= (uchar *)p;
    /* While we're at it, trim the end too. */
    p= (char *)m_returns_end-1;
    while (p > (char *)m_returns_begin &&
	   (*p == '\t' || *p == '\n' || *p == '\r' || *p == ' '))
      p-= 1;
    m_returns_end= (uchar *)p+1;
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
    if (m_returns_cs)
    {
      String s((char *)m_returns_begin, m_returns_end - m_returns_begin,
	       system_charset_info);

      s.append(' ');
      s.append(m_returns_cs->csname);
      m_retstr.length= s.length();
      m_retstr.str= strmake_root(root, s.ptr(), m_retstr.length);
    }
    else
    {
      m_retstr.length= m_returns_end - m_returns_begin;
      m_retstr.str= strmake_root(root,
				 (char *)m_returns_begin, m_retstr.length);
    }
367
  }
368 369 370 371 372 373 374 375
  m_body.length= lex->ptr - m_body_begin;
  /* Trim nuls at the end */
  n= 0;
  while (m_body.length && m_body_begin[m_body.length-1] == '\0')
  {
    m_body.length-= 1;
    n+= 1;
  }
376
  m_body.str= strmake_root(root, (char *)m_body_begin, m_body.length);
377 378
  m_defstr.length= lex->ptr - lex->buf;
  m_defstr.length-= n;
379
  m_defstr.str= strmake_root(root, (char *)lex->buf, m_defstr.length);
380
  DBUG_VOID_RETURN;
381 382 383 384 385
}

int
sp_head::create(THD *thd)
{
386
  DBUG_ENTER("sp_head::create");
387 388
  int ret;

389 390
  DBUG_PRINT("info", ("type: %d name: %s params: %s body: %s",
		      m_type, m_name.str, m_params.str, m_body.str));
391

392
#ifndef DBUG_OFF
393
  optimize();
394
  {
395 396 397 398 399 400
    String s;
    sp_instr *i;
    uint ip= 0;
    while ((i = get_instr(ip)))
    {
      char buf[8];
401

402 403 404 405 406 407 408 409
      sprintf(buf, "%4u: ", ip);
      s.append(buf);
      i->print(&s);
      s.append('\n');
      ip+= 1;
    }
    s.append('\0');
    DBUG_PRINT("info", ("Code %s\n%s", m_qname.str, s.ptr()));
410 411 412
  }
#endif

413
  if (m_type == TYPE_ENUM_FUNCTION)
414
    ret= sp_create_function(thd, this);
415
  else
416
    ret= sp_create_procedure(thd, this);
417

418
  DBUG_RETURN(ret);
419 420
}

421 422 423 424 425 426 427
sp_head::~sp_head()
{
  destroy();
  if (m_thd)
    restore_thd_mem_root(m_thd);
}

428 429 430
void
sp_head::destroy()
{
431 432
  sp_instr *i;
  LEX *lex;
433 434
  DBUG_ENTER("sp_head::destroy");
  DBUG_PRINT("info", ("name: %s", m_name.str));
435 436 437

  for (uint ip = 0 ; (i = get_instr(ip)) ; ip++)
    delete i;
438 439
  delete_dynamic(&m_instr);
  m_pcont->destroy();
440
  free_items(free_list);
441 442 443 444 445
  while ((lex= (LEX *)m_lex.pop()))
  {
    if (lex != &m_thd->main_lex) // We got interrupted and have lex'es left
      delete lex;
  }
446 447
  if (m_sptabs.array.buffer)
    hash_free(&m_sptabs);
448
  DBUG_VOID_RETURN;
449
}
450

451 452 453
int
sp_head::execute(THD *thd)
{
454
  DBUG_ENTER("sp_head::execute");
455
  char olddb[128];
456
  bool dbchanged;
457
  sp_rcontext *ctx;
458
  int ret= 0;
459
  uint ip= 0;
460 461
  Item_arena *old_arena;

462

463
#ifndef EMBEDDED_LIBRARY
464
  if (check_stack_overrun(thd, olddb))
465 466 467 468
  {
    DBUG_RETURN(-1);
  }
#endif
469

470
  dbchanged= FALSE;
471 472
  if (m_db.length &&
      (ret= sp_use_new_db(thd, m_db.str, olddb, sizeof(olddb), 0, &dbchanged)))
473
    goto done;
474

475
  if ((ctx= thd->spcont))
476
    ctx->clear_handler();
477
  thd->query_error= 0;
478
  old_arena= thd->current_arena;
479
  thd->current_arena= this;
480

481 482 483
  do
  {
    sp_instr *i;
484
    uint hip;			// Handler ip
485 486 487 488 489 490

    i = get_instr(ip);	// Returns NULL when we're done.
    if (i == NULL)
      break;
    DBUG_PRINT("execute", ("Instruction %u", ip));
    ret= i->execute(thd, &ip);
491 492
    if (i->free_list)
      cleanup_items(i->free_list);
493
    // Check if an exception has occurred and a handler has been found
494 495 496
    // Note: We havo to check even if ret==0, since warnings (and some
    //       errors don't return a non-zero value.
    if (!thd->killed && ctx)
497 498 499 500 501 502 503 504 505 506
    {
      uint hf;

      switch (ctx->found_handler(&hip, &hf))
      {
      case SP_HANDLER_NONE:
	break;
      case SP_HANDLER_CONTINUE:
	ctx->save_variables(hf);
	ctx->push_hstack(ip);
507
        // Fall through
508 509 510 511
      default:
	ip= hip;
	ret= 0;
	ctx->clear_handler();
512
	ctx->in_handler= TRUE;
513
        thd->clear_error();
514 515 516
	continue;
      }
    }
517
  } while (ret == 0 && !thd->killed);
518

519
  cleanup_items(thd->current_arena->free_list);
520 521
  thd->current_arena= old_arena;

522
 done:
523 524
  DBUG_PRINT("info", ("ret=%d killed=%d query_error=%d",
		      ret, thd->killed, thd->query_error));
525

526
  if (thd->killed)
527
    ret= -1;
528 529
  /* If the DB has changed, the pointer has changed too, but the
     original thd->db will then have been freed */
530
  if (dbchanged)
531
  {
532
    if (! thd->killed)
533
      ret= sp_change_db(thd, olddb, 0);
534
  }
535 536 537 538 539 540 541
  DBUG_RETURN(ret);
}


int
sp_head::execute_function(THD *thd, Item **argp, uint argcount, Item **resp)
{
542
  DBUG_ENTER("sp_head::execute_function");
543
  DBUG_PRINT("info", ("function %s", m_name.str));
544 545 546 547
  uint csize = m_pcont->max_pvars();
  uint params = m_pcont->current_pvars();
  uint hmax = m_pcont->max_handlers();
  uint cmax = m_pcont->max_cursors();
548 549 550 551 552
  sp_rcontext *octx = thd->spcont;
  sp_rcontext *nctx = NULL;
  uint i;
  int ret;

553 554 555 556
  if (argcount != params)
  {
    // Need to use my_printf_error here, or it will not terminate the
    // invoking query properly.
557 558
    my_error(ER_SP_WRONG_NO_OF_ARGS, MYF(0),
             "FUNCTION", m_name.str, params, argcount);
559 560 561 562
    DBUG_RETURN(-1);
  }

  // QQ Should have some error checking here? (types, etc...)
563
  nctx= new sp_rcontext(csize, hmax, cmax);
564 565
  for (i= 0 ; i < params && i < argcount ; i++)
  {
566
    sp_pvar_t *pvar = m_pcont->find_pvar(i);
567
    Item *it= sp_eval_func_item(thd, *argp++, pvar->type);
568

569 570 571 572 573 574
    if (it)
      nctx->push_item(it);
    else
    {
      DBUG_RETURN(-1);
    }
575
  }
monty@mysql.com's avatar
monty@mysql.com committed
576 577 578 579 580 581
#ifdef NOT_WORKING
  /*
    Close tables opened for subselect in argument list
    This can't be done as this will close all other tables used
    by the query.
  */
582
  close_thread_tables(thd);
monty@mysql.com's avatar
monty@mysql.com committed
583
#endif
584
  // The rest of the frame are local variables which are all IN.
585 586 587 588 589 590 591 592 593 594 595
  // Default all variables to null (those with default clauses will
  // be set by an set instruction).
  {
    Item_null *nit= NULL;	// Re-use this, and only create if needed
    for (; i < csize ; i++)
    {
      if (! nit)
	nit= new Item_null();
      nctx->push_item(nit);
    }
  }
596 597 598
  thd->spcont= nctx;

  ret= execute(thd);
599 600

  if (m_type == TYPE_ENUM_FUNCTION && ret == 0)
601
  {
602
    /* We need result only in function but not in trigger */
603 604 605 606 607 608
    Item *it= nctx->get_result();

    if (it)
      *resp= it;
    else
    {
609
      my_error(ER_SP_NORETURNEND, MYF(0), m_name.str);
610 611 612
      ret= -1;
    }
  }
613

614
  nctx->pop_all_cursors();	// To avoid memory leaks after an error
615 616 617 618 619 620 621
  thd->spcont= octx;
  DBUG_RETURN(ret);
}

int
sp_head::execute_procedure(THD *thd, List<Item> *args)
{
622
  DBUG_ENTER("sp_head::execute_procedure");
623
  DBUG_PRINT("info", ("procedure %s", m_name.str));
624
  int ret= 0;
625 626 627 628
  uint csize = m_pcont->max_pvars();
  uint params = m_pcont->current_pvars();
  uint hmax = m_pcont->max_handlers();
  uint cmax = m_pcont->max_cursors();
629 630
  sp_rcontext *octx = thd->spcont;
  sp_rcontext *nctx = NULL;
631
  my_bool tmp_octx = FALSE;	// True if we have allocated a temporary octx
632

633 634
  if (args->elements != params)
  {
635 636
    my_error(ER_SP_WRONG_NO_OF_ARGS, MYF(0), "PROCEDURE",
             m_name.str, params, args->elements);
637 638 639
    DBUG_RETURN(-1);
  }

640
  if (csize > 0 || hmax > 0 || cmax > 0)
641
  {
642
    Item_null *nit= NULL;	// Re-use this, and only create if needed
643
    uint i;
644
    List_iterator_fast<Item> li(*args);
645
    Item *it;
646

647
    nctx= new sp_rcontext(csize, hmax, cmax);
648 649
    if (! octx)
    {				// Create a temporary old context
650 651
      octx= new sp_rcontext(csize, hmax, cmax);
      tmp_octx= TRUE;
652
    }
653
    // QQ: Should do type checking?
654 655
    for (i = 0 ; (it= li++) && i < params ; i++)
    {
656
      sp_pvar_t *pvar = m_pcont->find_pvar(i);
657

658 659
      if (! pvar)
	nctx->set_oindex(i, -1); // Shouldn't happen
660
      else
661 662
      {
	if (pvar->mode == sp_param_out)
663 664 665 666 667
	{
	  if (! nit)
	    nit= new Item_null();
	  nctx->push_item(nit); // OUT
	}
668
	else
669 670 671 672 673 674 675 676 677 678 679
	{
	  Item *it2= sp_eval_func_item(thd, it,pvar->type);

	  if (it2)
	    nctx->push_item(it2); // IN or INOUT
	  else
	  {
	    ret= -1;		// Eval failed
	    break;
	  }
	}
680
	// Note: If it's OUT or INOUT, it must be a variable.
681 682
	// QQ: We can check for global variables here, or should we do it
	//     while parsing?
683 684 685 686 687
	if (pvar->mode == sp_param_in)
	  nctx->set_oindex(i, -1); // IN
	else			// OUT or INOUT
	  nctx->set_oindex(i, static_cast<Item_splocal *>(it)->get_offset());
      }
688
    }
689 690
    // Clean up the joins before closing the tables.
    thd->lex->unit.cleanup();
691 692 693
    // Close tables opened for subselect in argument list
    close_thread_tables(thd);

694
    // The rest of the frame are local variables which are all IN.
695 696
    // Default all variables to null (those with default clauses will
    // be set by an set instruction).
697
    for (; i < csize ; i++)
698
    {
699 700 701
      if (! nit)
	nit= new Item_null();
      nctx->push_item(nit);
702
    }
703 704 705
    thd->spcont= nctx;
  }

706 707
  if (! ret)
    ret= execute(thd);
708

709
  if (!ret && csize > 0)
710
  {
711
    List_iterator_fast<Item> li(*args);
712
    Item *it;
713 714 715 716

    // Copy back all OUT or INOUT values to the previous frame, or
    // set global user variables
    for (uint i = 0 ; (it= li++) && i < params ; i++)
717 718 719 720
    {
      int oi = nctx->get_oindex(i);

      if (oi >= 0)
721 722 723 724
      {
	if (! tmp_octx)
	  octx->set_item(nctx->get_oindex(i), nctx->get_item(i));
	else
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
	{
	  // QQ Currently we just silently ignore non-user-variable arguments.
	  //    We should check this during parsing, when setting up the call
	  //    above
	  if (it->type() == Item::FUNC_ITEM)
	  {
	    Item_func *fi= static_cast<Item_func*>(it);

	    if (fi->functype() == Item_func::GUSERVAR_FUNC)
	    {			// A global user variable
	      Item *item= nctx->get_item(i);
	      Item_func_set_user_var *suv;
	      Item_func_get_user_var *guv=
		static_cast<Item_func_get_user_var*>(fi);

	      suv= new Item_func_set_user_var(guv->get_name(), item);
	      suv->fix_fields(thd, NULL, &item);
	      suv->fix_length_and_dec();
pem@mysql.comhem.se's avatar
pem@mysql.comhem.se committed
743
	      suv->check();
744 745 746
	      suv->update();
	    }
	  }
747 748
	}
      }
749 750 751
    }
  }

752 753 754 755 756 757
  if (tmp_octx)
    octx= NULL;
  if (nctx)
    nctx->pop_all_cursors();	// To avoid memory leaks after an error
  thd->spcont= octx;

758
  DBUG_RETURN(ret);
759 760 761
}


762
// Reset lex during parsing, before we parse a sub statement.
763 764 765
void
sp_head::reset_lex(THD *thd)
{
766 767
  DBUG_ENTER("sp_head::reset_lex");
  LEX *sublex;
768
  LEX *oldlex= thd->lex;
769

770
  (void)m_lex.push_front(oldlex);
771
  thd->lex= sublex= new st_lex;
serg@serg.mylan's avatar
serg@serg.mylan committed
772

773
  /* Reset most stuff. The length arguments doesn't matter here. */
monty@mysql.com's avatar
monty@mysql.com committed
774
  lex_start(thd, oldlex->buf, (ulong) (oldlex->end_of_query - oldlex->ptr));
serg@serg.mylan's avatar
serg@serg.mylan committed
775

776
  /* We must reset ptr and end_of_query again */
777 778 779
  sublex->ptr= oldlex->ptr;
  sublex->end_of_query= oldlex->end_of_query;
  sublex->tok_start= oldlex->tok_start;
serg@serg.mylan's avatar
serg@serg.mylan committed
780
  sublex->yylineno= oldlex->yylineno;
781
  /* And keep the SP stuff too */
782 783
  sublex->sphead= oldlex->sphead;
  sublex->spcont= oldlex->spcont;
784 785
  /* And trigger related stuff too */
  sublex->trg_chistics= oldlex->trg_chistics;
786
  sublex->trg_table_fields.empty();
787
  sublex->sp_lex_in_use= FALSE;
788
  DBUG_VOID_RETURN;
789 790
}

791
// Restore lex during parsing, after we have parsed a sub statement.
792 793 794
void
sp_head::restore_lex(THD *thd)
{
795 796
  DBUG_ENTER("sp_head::restore_lex");
  LEX *sublex= thd->lex;
797 798 799 800
  LEX *oldlex= (LEX *)m_lex.pop();

  if (! oldlex)
    return;			// Nothing to restore
801

802
  // Update some state in the old one first
803 804
  oldlex->ptr= sublex->ptr;
  oldlex->next_state= sublex->next_state;
805
  oldlex->trg_table_fields.push_back(&sublex->trg_table_fields);
806

807
  // Collect some data from the sub statement lex.
808 809
  sp_merge_hash(&oldlex->spfuns, &sublex->spfuns);
  sp_merge_hash(&oldlex->spprocs, &sublex->spprocs);
810
  // Merge used tables
811
  sp_merge_table_list(thd, &m_sptabs, sublex->query_tables, sublex);
812 813 814
  if (! sublex->sp_lex_in_use)
    delete sublex;
  thd->lex= oldlex;
815
  DBUG_VOID_RETURN;
816 817
}

818
void
819
sp_head::push_backpatch(sp_instr *i, sp_label_t *lab)
820
{
821
  bp_t *bp= (bp_t *)sql_alloc(sizeof(bp_t));
822 823 824 825 826 827 828

  if (bp)
  {
    bp->lab= lab;
    bp->instr= i;
    (void)m_backpatch.push_front(bp);
  }
829 830 831
}

void
832
sp_head::backpatch(sp_label_t *lab)
833
{
834
  bp_t *bp;
835
  uint dest= instructions();
836
  List_iterator_fast<bp_t> li(m_backpatch);
837

838
  while ((bp= li++))
839 840 841 842
  {
    if (bp->lab == lab ||
	(bp->lab->type == SP_LAB_REF &&
	 my_strcasecmp(system_charset_info, bp->lab->name, lab->name) == 0))
843
    {
844 845 846 847 848
      if (bp->lab->type != SP_LAB_REF)
	bp->instr->backpatch(dest, lab->ctx);
      else
      {
	sp_label_t *dstlab= bp->lab->ctx->find_label(lab->name);
849

850 851 852 853 854 855
	if (dstlab)
	{
	  bp->lab= lab;
	  bp->instr->backpatch(dest, dstlab->ctx);
	}
      }
856 857 858 859 860 861 862 863 864
    }
  }
}

int
sp_head::check_backpatch(THD *thd)
{
  bp_t *bp;
  List_iterator_fast<bp_t> li(m_backpatch);
865

866 867 868 869
  while ((bp= li++))
  {
    if (bp->lab->type == SP_LAB_REF)
    {
870
      my_error(ER_SP_LILABEL_MISMATCH, MYF(0), "GOTO", bp->lab->name);
871
      return -1;
872
    }
873 874
  }
  return 0;
875 876
}

877 878 879
void
sp_head::set_info(char *definer, uint definerlen,
		  longlong created, longlong modified,
880
		  st_sp_chistics *chistics, ulong sql_mode)
881 882 883 884 885 886 887
{
  char *p= strchr(definer, '@');
  uint len;

  if (! p)
    p= definer;		// Weird...
  len= p-definer;
monty@mysql.com's avatar
monty@mysql.com committed
888
  m_definer_user.str= strmake_root(mem_root, definer, len);
889 890
  m_definer_user.length= len;
  len= definerlen-len-1;
monty@mysql.com's avatar
monty@mysql.com committed
891
  m_definer_host.str= strmake_root(mem_root, p+1, len);
892 893 894
  m_definer_host.length= len;
  m_created= created;
  m_modified= modified;
monty@mysql.com's avatar
monty@mysql.com committed
895 896
  m_chistics= (st_sp_chistics *) memdup_root(mem_root, (char*) chistics,
                                             sizeof(*chistics));
897 898 899
  if (m_chistics->comment.length == 0)
    m_chistics->comment.str= 0;
  else
monty@mysql.com's avatar
monty@mysql.com committed
900
    m_chistics->comment.str= strmake_root(mem_root,
901 902
					  m_chistics->comment.str,
					  m_chistics->comment.length);
903
  m_sql_mode= sql_mode;
904 905
}

906 907 908
void
sp_head::reset_thd_mem_root(THD *thd)
{
909
  DBUG_ENTER("sp_head::reset_thd_mem_root");
910
  m_thd_root= thd->mem_root;
monty@mysql.com's avatar
monty@mysql.com committed
911
  thd->mem_root= &main_mem_root;
912 913 914
  DBUG_PRINT("info", ("mem_root 0x%lx moved to thd mem root 0x%lx",
                      (ulong) &mem_root, (ulong) &thd->mem_root));
  free_list= thd->free_list; // Keep the old list
915 916 917
  thd->free_list= NULL;	// Start a new one
  /* Copy the db, since substatements will point to it */
  m_thd_db= thd->db;
monty@mysql.com's avatar
monty@mysql.com committed
918
  thd->db= thd->strmake(thd->db, thd->db_length);
919
  m_thd= thd;
920
  DBUG_VOID_RETURN;
921 922 923 924 925
}

void
sp_head::restore_thd_mem_root(THD *thd)
{
926 927
  DBUG_ENTER("sp_head::restore_thd_mem_root");
  Item *flist= free_list;	// The old list
928 929 930
  set_item_arena(thd);          // Get new free_list and mem_root
  state= INITIALIZED;

931 932
  DBUG_PRINT("info", ("mem_root 0x%lx returned from thd mem root 0x%lx",
                      (ulong) &mem_root, (ulong) &thd->mem_root));
933 934 935 936
  thd->free_list= flist;	// Restore the old one
  thd->db= m_thd_db;		// Restore the original db pointer
  thd->mem_root= m_thd_root;
  m_thd= NULL;
937
  DBUG_VOID_RETURN;
938 939 940
}


941 942 943 944 945 946 947 948
int
sp_head::show_create_procedure(THD *thd)
{
  Protocol *protocol= thd->protocol;
  char buff[2048];
  String buffer(buff, sizeof(buff), system_charset_info);
  int res;
  List<Item> field_list;
949 950 951 952
  ulong old_sql_mode;
  sys_var *sql_mode_var;
  byte *sql_mode_str;
  ulong sql_mode_len;
953 954 955

  DBUG_ENTER("sp_head::show_create_procedure");
  DBUG_PRINT("info", ("procedure %s", m_name.str));
956 957 958
  LINT_INIT(sql_mode_str);
  LINT_INIT(sql_mode_len);
  
959 960 961 962 963 964
  old_sql_mode= thd->variables.sql_mode;
  thd->variables.sql_mode= m_sql_mode;
  sql_mode_var= find_sys_var("SQL_MODE", 8);
  if (sql_mode_var)
  {
    sql_mode_str= sql_mode_var->value_ptr(thd, OPT_SESSION, 0);
965
    sql_mode_len= strlen((char*) sql_mode_str);
966 967 968 969 970
  }

  field_list.push_back(new Item_empty_string("Procedure", NAME_LEN));
  if (sql_mode_var)
    field_list.push_back(new Item_empty_string("sql_mode", sql_mode_len));
971 972
  // 1024 is for not to confuse old clients
  field_list.push_back(new Item_empty_string("Create Procedure",
973
					     max(buffer.length(), 1024)));
974 975
  if (protocol->send_fields(&field_list, Protocol::SEND_NUM_ROWS |
                                         Protocol::SEND_EOF))
976 977 978 979
  {
    res= 1;
    goto done;
  }
980 981
  protocol->prepare_for_resend();
  protocol->store(m_name.str, m_name.length, system_charset_info);
982
  if (sql_mode_var)
983
    protocol->store((char*) sql_mode_str, sql_mode_len, system_charset_info);
984 985 986
  protocol->store(m_defstr.str, m_defstr.length, system_charset_info);
  res= protocol->write();
  send_eof(thd);
987 988 989

 done:
  thd->variables.sql_mode= old_sql_mode;
990 991 992
  DBUG_RETURN(res);
}

993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009

/*
  Add instruction to SP

  SYNOPSIS
    sp_head::add_instr()
    instr   Instruction
*/

void sp_head::add_instr(sp_instr *instr)
{
  instr->free_list= m_thd->free_list;
  m_thd->free_list= 0;
  insert_dynamic(&m_instr, (gptr)&instr);
}


1010 1011 1012 1013 1014 1015 1016 1017
int
sp_head::show_create_function(THD *thd)
{
  Protocol *protocol= thd->protocol;
  char buff[2048];
  String buffer(buff, sizeof(buff), system_charset_info);
  int res;
  List<Item> field_list;
1018 1019 1020 1021
  ulong old_sql_mode;
  sys_var *sql_mode_var;
  byte *sql_mode_str;
  ulong sql_mode_len;
1022 1023
  DBUG_ENTER("sp_head::show_create_function");
  DBUG_PRINT("info", ("procedure %s", m_name.str));
1024 1025
  LINT_INIT(sql_mode_str);
  LINT_INIT(sql_mode_len);
1026

1027 1028 1029 1030 1031 1032
  old_sql_mode= thd->variables.sql_mode;
  thd->variables.sql_mode= m_sql_mode;
  sql_mode_var= find_sys_var("SQL_MODE", 8);
  if (sql_mode_var)
  {
    sql_mode_str= sql_mode_var->value_ptr(thd, OPT_SESSION, 0);
1033
    sql_mode_len= strlen((char*) sql_mode_str);
1034 1035
  }

1036
  field_list.push_back(new Item_empty_string("Function",NAME_LEN));
1037 1038
  if (sql_mode_var)
    field_list.push_back(new Item_empty_string("sql_mode", sql_mode_len));
1039 1040
  field_list.push_back(new Item_empty_string("Create Function",
					     max(buffer.length(),1024)));
1041 1042
  if (protocol->send_fields(&field_list,
                            Protocol::SEND_NUM_ROWS | Protocol::SEND_EOF))
1043 1044 1045 1046
  {
    res= 1;
    goto done;
  }
1047 1048
  protocol->prepare_for_resend();
  protocol->store(m_name.str, m_name.length, system_charset_info);
1049
  if (sql_mode_var)
1050
    protocol->store((char*) sql_mode_str, sql_mode_len, system_charset_info);
1051 1052 1053
  protocol->store(m_defstr.str, m_defstr.length, system_charset_info);
  res= protocol->write();
  send_eof(thd);
1054 1055 1056

 done:
  thd->variables.sql_mode= old_sql_mode;
1057 1058
  DBUG_RETURN(res);
}
1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110

void
sp_head::optimize()
{
  List<sp_instr> bp;
  sp_instr *i;
  uint src, dst;

  opt_mark(0);

  bp.empty();
  src= dst= 0;
  while ((i= get_instr(src)))
  {
    if (! i->marked)
    {
      delete i;
      src+= 1;
    }
    else
    {
      if (src != dst)
      {
	sp_instr *ibp;
	List_iterator_fast<sp_instr> li(bp);

	set_dynamic(&m_instr, (gptr)&i, dst);
	while ((ibp= li++))
	{
	  sp_instr_jump *ji= static_cast<sp_instr_jump *>(ibp);
	  if (ji->m_dest == src)
	    ji->m_dest= dst;
	}
      }
      i->opt_move(dst, &bp);
      src+= 1;
      dst+= 1;
    }
  }
  m_instr.elements= dst;
  bp.empty();
}

void
sp_head::opt_mark(uint ip)
{
  sp_instr *i;

  while ((i= get_instr(ip)) && !i->marked)
    ip= i->opt_mark(this);
}

1111
// ------------------------------------------------------------------
1112 1113 1114 1115

//
// sp_instr_stmt
//
1116 1117 1118 1119 1120 1121
sp_instr_stmt::~sp_instr_stmt()
{
  if (m_lex)
    delete m_lex;
}

1122
int
1123
sp_instr_stmt::execute(THD *thd, uint *nextp)
1124
{
1125 1126
  char *query;
  uint32 query_length;
1127
  DBUG_ENTER("sp_instr_stmt::execute");
1128
  DBUG_PRINT("info", ("command: %d", m_lex->sql_command));
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
  int res;

  query= thd->query;
  query_length= thd->query_length;
  if (!(res= alloc_query(thd, m_query.str, m_query.length+1)))
  {
    if (query_cache_send_result_to_client(thd,
					  thd->query, thd->query_length) <= 0)
    {
      res= exec_stmt(thd, m_lex);
      query_cache_end_of_result(thd);
    }
    thd->query= query;
    thd->query_length= query_length;
  }
1144 1145 1146 1147
  *nextp = m_ip+1;
  DBUG_RETURN(res);
}

1148 1149 1150 1151 1152
void
sp_instr_stmt::print(String *str)
{
  str->reserve(12);
  str->append("stmt ");
1153
  str->qs_append((uint)m_lex->sql_command);
1154 1155 1156
}


1157 1158 1159
int
sp_instr_stmt::exec_stmt(THD *thd, LEX *lex)
{
1160
  LEX *olex;			// The other lex
1161
  int res;
1162

1163
  olex= thd->lex;		// Save the other lex
1164
  thd->lex= lex;		// Use my own lex
1165 1166
  thd->lex->thd = thd;		// QQ Not reentrant!
  thd->lex->unit.thd= thd;	// QQ Not reentrant
1167
  thd->free_list= NULL;
1168 1169

  VOID(pthread_mutex_lock(&LOCK_thread_count));
1170
  thd->query_id= query_id++;
1171
  VOID(pthread_mutex_unlock(&LOCK_thread_count));
1172

1173
  reset_stmt_for_execute(thd, lex);
1174

1175
  res= mysql_execute_command(thd);
1176

1177
  lex->unit.cleanup();
1178 1179 1180 1181 1182
  if (thd->lock || thd->open_tables || thd->derived_tables)
  {
    thd->proc_info="closing tables";
    close_thread_tables(thd);			/* Free tables */
  }
1183

1184
  thd->lex= olex;		// Restore the other lex
1185

1186
  return res;
1187 1188 1189 1190 1191 1192
}

//
// sp_instr_set
//
int
1193
sp_instr_set::execute(THD *thd, uint *nextp)
1194
{
1195 1196
  DBUG_ENTER("sp_instr_set::execute");
  DBUG_PRINT("info", ("offset: %u", m_offset));
1197 1198
  Item *it;
  int res;
1199

1200 1201 1202
  if (tables &&
      ((res= check_table_access(thd, SELECT_ACL, tables, 0)) ||
       (res= open_and_lock_tables(thd, tables))))
1203
    DBUG_RETURN(res);
1204 1205 1206 1207 1208 1209 1210 1211 1212

  it= sp_eval_func_item(thd, m_value, m_type);
  if (! it)
    res= -1;
  else
  {
    res= 0;
    thd->spcont->set_item(m_offset, it);
  }
1213
  *nextp = m_ip+1;
1214
  if (tables && (thd->lock || thd->open_tables || thd->derived_tables))
1215 1216
    close_thread_tables(thd);
  DBUG_RETURN(res);
1217 1218
}

1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
void
sp_instr_set::print(String *str)
{
  str->reserve(12);
  str->append("set ");
  str->qs_append(m_offset);
  str->append(' ');
  m_value->print(str);
}

1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282
//
// sp_instr_set_user_var
//
int
sp_instr_set_user_var::execute(THD *thd, uint *nextp)
{
  int res= 0;

  DBUG_ENTER("sp_instr_set_user_var::execute");
  /*
    It is ok to pass 0 as 3rd argument to fix_fields() since
    Item_func_set_user_var::fix_fields() won't use it.
    QQ: Still unsure what should we return in case of error 1 or -1 ?
  */
  if (!m_set_var_item.fixed && m_set_var_item.fix_fields(thd, 0, 0) ||
      m_set_var_item.check() || m_set_var_item.update())
    res= -1;
  *nextp= m_ip + 1;
  DBUG_RETURN(res);
}

void
sp_instr_set_user_var::print(String *str)
{
  m_set_var_item.print_as_stmt(str);
}

//
// sp_instr_set_trigger_field
//
int
sp_instr_set_trigger_field::execute(THD *thd, uint *nextp)
{
  int res= 0;

  DBUG_ENTER("sp_instr_set_trigger_field::execute");
  /* QQ: Still unsure what should we return in case of error 1 or -1 ? */
  if (!value->fixed && value->fix_fields(thd, 0, &value) ||
      trigger_field.fix_fields(thd, 0, 0) ||
      (value->save_in_field(trigger_field.field, 0) < 0))
    res= -1;
  *nextp= m_ip + 1;
  DBUG_RETURN(res);
}

void
sp_instr_set_trigger_field::print(String *str)
{
  str->append("set ", 4);
  trigger_field.print(str);
  str->append(":=", 2);
  value->print(str);
}

1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295
//
// sp_instr_jump
//
int
sp_instr_jump::execute(THD *thd, uint *nextp)
{
  DBUG_ENTER("sp_instr_jump::execute");
  DBUG_PRINT("info", ("destination: %u", m_dest));

  *nextp= m_dest;
  DBUG_RETURN(0);
}

1296 1297 1298 1299 1300 1301 1302 1303
void
sp_instr_jump::print(String *str)
{
  str->reserve(12);
  str->append("jump ");
  str->qs_append(m_dest);
}

1304 1305 1306
uint
sp_instr_jump::opt_mark(sp_head *sp)
{
1307
  m_dest= opt_shortcut_jump(sp, this);
1308 1309
  if (m_dest != m_ip+1)		/* Jumping to following instruction? */
    marked= 1;
1310 1311 1312 1313 1314
  m_optdest= sp->get_instr(m_dest);
  return m_dest;
}

uint
1315
sp_instr_jump::opt_shortcut_jump(sp_head *sp, sp_instr *start)
1316 1317 1318 1319 1320 1321
{
  uint dest= m_dest;
  sp_instr *i;

  while ((i= sp->get_instr(dest)))
  {
1322
    uint ndest;
1323

1324 1325 1326
    if (start == i)
      break;
    ndest= i->opt_shortcut_jump(sp, start);
1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343
    if (ndest == dest)
      break;
    dest= ndest;
  }
  return dest;
}

void
sp_instr_jump::opt_move(uint dst, List<sp_instr> *bp)
{
  if (m_dest > m_ip)
    bp->push_back(this);	// Forward
  else if (m_optdest)
    m_dest= m_optdest->m_ip;	// Backward
  m_ip= dst;
}

1344 1345 1346 1347 1348 1349
//
// sp_instr_jump_if
//
int
sp_instr_jump_if::execute(THD *thd, uint *nextp)
{
1350 1351
  DBUG_ENTER("sp_instr_jump_if::execute");
  DBUG_PRINT("info", ("destination: %u", m_dest));
1352 1353
  Item *it;
  int res;
1354

1355 1356 1357
  if (tables &&
      ((res= check_table_access(thd, SELECT_ACL, tables, 0)) ||
       (res= open_and_lock_tables(thd, tables))))
1358
    DBUG_RETURN(res);
1359 1360 1361 1362

  it= sp_eval_func_item(thd, m_expr, MYSQL_TYPE_TINY);
  if (!it)
    res= -1;
1363
  else
1364 1365 1366 1367 1368 1369 1370
  {
    res= 0;
    if (it->val_int())
      *nextp = m_dest;
    else
      *nextp = m_ip+1;
  }
1371
  if (tables && (thd->lock || thd->open_tables || thd->derived_tables))
1372 1373
    close_thread_tables(thd);
  DBUG_RETURN(res);
1374 1375
}

1376 1377 1378 1379 1380 1381 1382 1383 1384 1385
void
sp_instr_jump_if::print(String *str)
{
  str->reserve(12);
  str->append("jump_if ");
  str->qs_append(m_dest);
  str->append(' ');
  m_expr->print(str);
}

1386 1387 1388 1389 1390 1391 1392 1393
uint
sp_instr_jump_if::opt_mark(sp_head *sp)
{
  sp_instr *i;

  marked= 1;
  if ((i= sp->get_instr(m_dest)))
  {
1394
    m_dest= i->opt_shortcut_jump(sp, this);
1395 1396 1397 1398 1399 1400
    m_optdest= sp->get_instr(m_dest);
  }
  sp->opt_mark(m_dest);
  return m_ip+1;
}

1401 1402 1403 1404 1405 1406
//
// sp_instr_jump_if_not
//
int
sp_instr_jump_if_not::execute(THD *thd, uint *nextp)
{
1407 1408
  DBUG_ENTER("sp_instr_jump_if_not::execute");
  DBUG_PRINT("info", ("destination: %u", m_dest));
1409 1410
  Item *it;
  int res;
1411

1412 1413 1414
  if (tables &&
      ((res= check_table_access(thd, SELECT_ACL, tables, 0)) ||
       (res= open_and_lock_tables(thd, tables))))
1415
    DBUG_RETURN(res);
1416 1417 1418 1419

  it= sp_eval_func_item(thd, m_expr, MYSQL_TYPE_TINY);
  if (! it)
    res= -1;
1420
  else
1421 1422 1423 1424 1425 1426 1427
  {
    res= 0;
    if (! it->val_int())
      *nextp = m_dest;
    else
      *nextp = m_ip+1;
  }
1428
  if (tables && (thd->lock || thd->open_tables || thd->derived_tables))
1429 1430
    close_thread_tables(thd);
  DBUG_RETURN(res);
1431
}
1432

1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
void
sp_instr_jump_if_not::print(String *str)
{
  str->reserve(16);
  str->append("jump_if_not ");
  str->qs_append(m_dest);
  str->append(' ');
  m_expr->print(str);
}

1443 1444 1445 1446 1447 1448 1449 1450
uint
sp_instr_jump_if_not::opt_mark(sp_head *sp)
{
  sp_instr *i;

  marked= 1;
  if ((i= sp->get_instr(m_dest)))
  {
1451
    m_dest= i->opt_shortcut_jump(sp, this);
1452 1453 1454 1455 1456 1457
    m_optdest= sp->get_instr(m_dest);
  }
  sp->opt_mark(m_dest);
  return m_ip+1;
}

1458
//
1459
// sp_instr_freturn
1460 1461
//
int
1462
sp_instr_freturn::execute(THD *thd, uint *nextp)
1463
{
1464
  DBUG_ENTER("sp_instr_freturn::execute");
1465 1466
  Item *it;
  int res;
1467

1468 1469 1470
  if (tables &&
      ((res= check_table_access(thd, SELECT_ACL, tables, 0)) ||
       (res= open_and_lock_tables(thd, tables))))
1471
    DBUG_RETURN(res);
1472 1473 1474 1475 1476 1477 1478 1479 1480

  it= sp_eval_func_item(thd, m_value, m_type);
  if (! it)
    res= -1;
  else
  {
    res= 0;
    thd->spcont->set_result(it);
  }
1481
  *nextp= UINT_MAX;
1482
  DBUG_RETURN(res);
1483
}
1484

1485 1486 1487 1488 1489
void
sp_instr_freturn::print(String *str)
{
  str->reserve(12);
  str->append("freturn ");
1490
  str->qs_append((uint)m_type);
1491 1492 1493 1494
  str->append(' ');
  m_value->print(str);
}

1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
//
// sp_instr_hpush_jump
//
int
sp_instr_hpush_jump::execute(THD *thd, uint *nextp)
{
  DBUG_ENTER("sp_instr_hpush_jump::execute");
  List_iterator_fast<sp_cond_type_t> li(m_cond);
  sp_cond_type_t *p;

  while ((p= li++))
    thd->spcont->push_handler(p, m_handler, m_type, m_frame);

  *nextp= m_dest;
  DBUG_RETURN(0);
}

1512 1513 1514 1515 1516
void
sp_instr_hpush_jump::print(String *str)
{
  str->reserve(32);
  str->append("hpush_jump ");
1517 1518
  str->qs_append(m_dest);
  str->append(" t=");
1519
  str->qs_append(m_type);
1520
  str->append(" f=");
1521
  str->qs_append(m_frame);
1522
  str->append(" h=");
1523 1524 1525
  str->qs_append(m_handler);
}

1526 1527 1528 1529 1530 1531 1532 1533
uint
sp_instr_hpush_jump::opt_mark(sp_head *sp)
{
  sp_instr *i;

  marked= 1;
  if ((i= sp->get_instr(m_dest)))
  {
1534
    m_dest= i->opt_shortcut_jump(sp, this);
1535 1536 1537 1538 1539 1540
    m_optdest= sp->get_instr(m_dest);
  }
  sp->opt_mark(m_dest);
  return m_ip+1;
}

1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
//
// sp_instr_hpop
//
int
sp_instr_hpop::execute(THD *thd, uint *nextp)
{
  DBUG_ENTER("sp_instr_hpop::execute");
  thd->spcont->pop_handlers(m_count);
  *nextp= m_ip+1;
  DBUG_RETURN(0);
}

1553 1554 1555 1556 1557 1558 1559 1560
void
sp_instr_hpop::print(String *str)
{
  str->reserve(12);
  str->append("hpop ");
  str->qs_append(m_count);
}

1561 1562 1563 1564 1565 1566 1567
void
sp_instr_hpop::backpatch(uint dest, sp_pcontext *dst_ctx)
{
  m_count= m_ctx->diff_handlers(dst_ctx);
}


1568 1569 1570 1571 1572 1573 1574
//
// sp_instr_hreturn
//
int
sp_instr_hreturn::execute(THD *thd, uint *nextp)
{
  DBUG_ENTER("sp_instr_hreturn::execute");
1575 1576 1577 1578 1579 1580 1581 1582
  if (m_dest)
    *nextp= m_dest;
  else
  {
    thd->spcont->restore_variables(m_frame);
    *nextp= thd->spcont->pop_hstack();
  }
  thd->spcont->in_handler= FALSE;
1583 1584
  DBUG_RETURN(0);
}
1585

1586 1587 1588
void
sp_instr_hreturn::print(String *str)
{
1589
  str->reserve(16);
1590 1591
  str->append("hreturn ");
  str->qs_append(m_frame);
1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605
  if (m_dest)
    str->qs_append(m_dest);
}

uint
sp_instr_hreturn::opt_mark(sp_head *sp)
{
  if (m_dest)
    return sp_instr_jump::opt_mark(sp);
  else
  {
    marked= 1;
    return UINT_MAX;
  }
1606 1607
}

1608

1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626
//
// sp_instr_cpush
//
int
sp_instr_cpush::execute(THD *thd, uint *nextp)
{
  DBUG_ENTER("sp_instr_cpush::execute");
  thd->spcont->push_cursor(m_lex);
  *nextp= m_ip+1;
  DBUG_RETURN(0);
}

sp_instr_cpush::~sp_instr_cpush()
{
  if (m_lex)
    delete m_lex;
}

1627 1628 1629 1630 1631 1632
void
sp_instr_cpush::print(String *str)
{
  str->append("cpush");
}

1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
//
// sp_instr_cpop
//
int
sp_instr_cpop::execute(THD *thd, uint *nextp)
{
  DBUG_ENTER("sp_instr_cpop::execute");
  thd->spcont->pop_cursors(m_count);
  *nextp= m_ip+1;
  DBUG_RETURN(0);
}

1645 1646 1647 1648 1649 1650 1651 1652
void
sp_instr_cpop::print(String *str)
{
  str->reserve(12);
  str->append("cpop ");
  str->qs_append(m_count);
}

1653 1654 1655 1656 1657 1658
void
sp_instr_cpop::backpatch(uint dest, sp_pcontext *dst_ctx)
{
  m_count= m_ctx->diff_cursors(dst_ctx);
}

1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678
//
// sp_instr_copen
//
int
sp_instr_copen::execute(THD *thd, uint *nextp)
{
  sp_cursor *c= thd->spcont->get_cursor(m_cursor);
  int res;
  DBUG_ENTER("sp_instr_copen::execute");

  if (! c)
    res= -1;
  else
  {
    LEX *lex= c->pre_open(thd);

    if (! lex)
      res= -1;
    else
      res= exec_stmt(thd, lex);
1679
    c->post_open(thd, (lex ? TRUE : FALSE));
1680 1681 1682 1683 1684 1685
  }

  *nextp= m_ip+1;
  DBUG_RETURN(res);
}

1686 1687 1688 1689 1690 1691 1692 1693
void
sp_instr_copen::print(String *str)
{
  str->reserve(12);
  str->append("copen ");
  str->qs_append(m_cursor);
}

1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711
//
// sp_instr_cclose
//
int
sp_instr_cclose::execute(THD *thd, uint *nextp)
{
  sp_cursor *c= thd->spcont->get_cursor(m_cursor);
  int res;
  DBUG_ENTER("sp_instr_cclose::execute");

  if (! c)
    res= -1;
  else
    res= c->close(thd);
  *nextp= m_ip+1;
  DBUG_RETURN(res);
}

1712 1713 1714 1715 1716 1717 1718 1719
void
sp_instr_cclose::print(String *str)
{
  str->reserve(12);
  str->append("cclose ");
  str->qs_append(m_cursor);
}

1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
//
// sp_instr_cfetch
//
int
sp_instr_cfetch::execute(THD *thd, uint *nextp)
{
  sp_cursor *c= thd->spcont->get_cursor(m_cursor);
  int res;
  DBUG_ENTER("sp_instr_cfetch::execute");

  if (! c)
    res= -1;
  else
    res= c->fetch(thd, &m_varlist);
  *nextp= m_ip+1;
  DBUG_RETURN(res);
}
1737

1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
void
sp_instr_cfetch::print(String *str)
{
  List_iterator_fast<struct sp_pvar> li(m_varlist);
  sp_pvar_t *pv;

  str->reserve(12);
  str->append("cfetch ");
  str->qs_append(m_cursor);
  while ((pv= li++))
  {
    str->reserve(8);
    str->append(' ');
    str->qs_append(pv->offset);
  }
}

//
// sp_instr_error
//
int
sp_instr_error::execute(THD *thd, uint *nextp)
{
  DBUG_ENTER("sp_instr_error::execute");

bell@sanja.is.com.ua's avatar
bell@sanja.is.com.ua committed
1763
  my_message(m_errcode, ER(m_errcode), MYF(0));
1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
  *nextp= m_ip+1;
  DBUG_RETURN(-1);
}

void
sp_instr_error::print(String *str)
{
  str->reserve(12);
  str->append("error ");
  str->qs_append(m_errcode);
}

1776 1777
/* ------------------------------------------------------------------ */

1778 1779 1780 1781

//
// Security context swapping
//
1782

1783
#ifndef NO_EMBEDDED_ACCESS_CHECKS
1784 1785 1786
void
sp_change_security_context(THD *thd, sp_head *sp, st_sp_security_context *ctxp)
{
1787
  ctxp->changed= (sp->m_chistics->suid != SP_IS_NOT_SUID &&
1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832
		   (strcmp(sp->m_definer_user.str, thd->priv_user) ||
		    strcmp(sp->m_definer_host.str, thd->priv_host)));

  if (ctxp->changed)
  {
    ctxp->master_access= thd->master_access;
    ctxp->db_access= thd->db_access;
    ctxp->priv_user= thd->priv_user;
    strncpy(ctxp->priv_host, thd->priv_host, sizeof(ctxp->priv_host));
    ctxp->user= thd->user;
    ctxp->host= thd->host;
    ctxp->ip= thd->ip;

    /* Change thise just to do the acl_getroot_no_password */
    thd->user= sp->m_definer_user.str;
    thd->host= thd->ip = sp->m_definer_host.str;

    if (acl_getroot_no_password(thd))
    {			// Failed, run as invoker for now
      ctxp->changed= FALSE;
      thd->master_access= ctxp->master_access;
      thd->db_access= ctxp->db_access;
      thd->priv_user= ctxp->priv_user;
      strncpy(thd->priv_host, ctxp->priv_host, sizeof(thd->priv_host));
    }

    /* Restore these immiediately */
    thd->user= ctxp->user;
    thd->host= ctxp->host;
    thd->ip= ctxp->ip;
  }
}

void
sp_restore_security_context(THD *thd, sp_head *sp, st_sp_security_context *ctxp)
{
  if (ctxp->changed)
  {
    ctxp->changed= FALSE;
    thd->master_access= ctxp->master_access;
    thd->db_access= ctxp->db_access;
    thd->priv_user= ctxp->priv_user;
    strncpy(thd->priv_host, ctxp->priv_host, sizeof(thd->priv_host));
  }
}
1833 1834

#endif /* NO_EMBEDDED_ACCESS_CHECKS */
1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073

/*
 *  Table merge hash table
 *
 */
typedef struct st_sp_table
{
  LEX_STRING qname;
  bool temp;
  TABLE_LIST *table;
} SP_TABLE;

byte *
sp_table_key(const byte *ptr, uint *plen, my_bool first)
{
  SP_TABLE *tab= (SP_TABLE *)ptr;
  *plen= tab->qname.length;
  return (byte *)tab->qname.str;
}

/*
 *  Merge the table list into the hash table.
 *  If the optional lex is provided, it's used to check and set
 *  the flag for creation of a temporary table.
 */
bool
sp_merge_table_list(THD *thd, HASH *h, TABLE_LIST *table,
		    LEX *lex_for_tmp_check)
{
  for (; table ; table= table->next_global)
    if (!table->derived &&
	(!table->select_lex ||
	 !(table->select_lex->options & OPTION_SCHEMA_TABLE)))
    {
      char tname[64+1+64+1+64+1];	// db.table.alias\0
      uint tlen, alen;
      SP_TABLE *tab;

      tlen= table->db_length;
      memcpy(tname, table->db, tlen);
      tname[tlen++]= '.';
      memcpy(tname+tlen, table->table_name, table->table_name_length);
      tlen+= table->table_name_length;
      tname[tlen++]= '.';
      alen= strlen(table->alias);
      memcpy(tname+tlen, table->alias, alen);
      tlen+= alen;
      tname[tlen]= '\0';

      if ((tab= (SP_TABLE *)hash_search(h, (byte *)tname, tlen)))
      {
	if (tab->table->lock_type < table->lock_type)
	  tab->table= table;	// Use the table with the highest lock type
      }
      else
      {
	if (!(tab= (SP_TABLE *)thd->calloc(sizeof(SP_TABLE))))
	  return FALSE;
	tab->qname.length= tlen;
	tab->qname.str= (char *)thd->strmake(tname, tab->qname.length);
	if (!tab->qname.str)
	  return FALSE;
	if (lex_for_tmp_check &&
	    lex_for_tmp_check->sql_command == SQLCOM_CREATE_TABLE &&
	    lex_for_tmp_check->query_tables == table &&
	    lex_for_tmp_check->create_info.options & HA_LEX_CREATE_TMP_TABLE)
	  tab->temp= TRUE;
	tab->table= table;
	my_hash_insert(h, (byte *)tab);
      }
    }
  return TRUE;
}

void
sp_merge_routine_tables(THD *thd, LEX *lex)
{
  uint i;

  for (i= 0 ; i < lex->spfuns.records ; i++)
  {
    sp_head *sp;
    LEX_STRING *ls= (LEX_STRING *)hash_element(&lex->spfuns, i);
    sp_name name(*ls);

    name.m_qname= *ls;
    if ((sp= sp_cache_lookup(&thd->sp_func_cache, &name)))
      sp_merge_table_hash(&lex->sptabs, &sp->m_sptabs);
  }
  for (i= 0 ; i < lex->spprocs.records ; i++)
  {
    sp_head *sp;
    LEX_STRING *ls= (LEX_STRING *)hash_element(&lex->spprocs, i);
    sp_name name(*ls);

    name.m_qname= *ls;
    if ((sp= sp_cache_lookup(&thd->sp_proc_cache, &name)))
      sp_merge_table_hash(&lex->sptabs, &sp->m_sptabs);
  }
}

void
sp_merge_table_hash(HASH *hdst, HASH *hsrc)
{
  for (uint i=0 ; i < hsrc->records ; i++)
  {
    SP_TABLE *tabdst;
    SP_TABLE *tabsrc= (SP_TABLE *)hash_element(hsrc, i);

    if (! (tabdst= (SP_TABLE *)hash_search(hdst,
					   tabsrc->qname.str,
					   tabsrc->qname.length)))
    {
      my_hash_insert(hdst, (byte *)tabsrc);
    }
    else
    {
      if (tabdst->table->lock_type < tabsrc->table->lock_type)
	tabdst->table= tabsrc->table; // Use the highest lock type
    }
  }
}

TABLE_LIST *
sp_hash_to_table_list(THD *thd, HASH *h)
{
  uint i;
  TABLE_LIST *tables= NULL;
  DBUG_ENTER("sp_hash_to_table_list");

  for (i=0 ; i < h->records ; i++)
  {
    SP_TABLE *stab= (SP_TABLE *)hash_element(h, i);
    if (stab->temp)
      continue;
    TABLE_LIST *table, *otable= stab->table;

    if (! (table= (TABLE_LIST *)thd->calloc(sizeof(TABLE_LIST))))
      return NULL;
    table->db= otable->db;
    table->db_length= otable->db_length;
    table->alias= otable->alias;
    table->table_name= otable->table_name;
    table->table_name_length= otable->table_name_length;
    table->lock_type= otable->lock_type;
    table->updating= otable->updating;
    table->force_index= otable->force_index;
    table->ignore_leaves= otable->ignore_leaves;
    table->derived= otable->derived;
    table->schema_table= otable->schema_table;
    table->select_lex= otable->select_lex;
    table->cacheable_table= otable->cacheable_table;
    table->use_index= otable->use_index;
    table->ignore_index= otable->ignore_index;
    table->option= otable->option;

    table->next_global= tables;
    tables= table;
  }
  DBUG_RETURN(tables);
}

bool
sp_open_and_lock_tables(THD *thd, TABLE_LIST *tables)
{
  DBUG_ENTER("sp_open_and_lock_tables");
  bool ret;

  thd->in_lock_tables= 1;
  thd->options|= OPTION_TABLE_LOCK;
  if (simple_open_n_lock_tables(thd, tables))
  {
    thd->options&= ~(ulong)(OPTION_TABLE_LOCK);
    ret= FALSE;
  }
  else
  {
#if 0
    // QQ What about this?
#ifdef HAVE_QUERY_CACHE
    if (thd->variables.query_cache_wlock_invalidate)
      query_cache.invalidate_locked_for_write(first_table); // QQ first_table?
#endif /* HAVE_QUERY_CACHE */
#endif
    thd->locked_tables= thd->lock;
    thd->lock= 0;
    ret= TRUE;
  }
  thd->in_lock_tables= 0;
  DBUG_RETURN(ret);
}

void
sp_unlock_tables(THD *thd)
{
  thd->lock= thd->locked_tables;
  thd->locked_tables= 0;
  close_thread_tables(thd);			// Free tables
  if (thd->options & OPTION_TABLE_LOCK)
  {
#if 0
    // QQ What about this?
    end_active_trans(thd);
#endif
    thd->options&= ~(ulong)(OPTION_TABLE_LOCK);
  }
  if (thd->global_read_lock)
    unlock_global_read_lock(thd);
}

/*
 * Simple function for adding an explicetly named (systems) table to
 * the global table list, e.g. "mysql", "proc".
 *
 */
TABLE_LIST *
sp_add_to_query_tables(THD *thd, LEX *lex,
		       const char *db, const char *name,
		       thr_lock_type locktype)
{
  TABLE_LIST *table;

  if (!(table= (TABLE_LIST *)thd->calloc(sizeof(TABLE_LIST))))
  {
    my_error(ER_OUTOFMEMORY, MYF(0), sizeof(TABLE_LIST));
    return NULL;
  }
  table->db_length= strlen(db);
  table->db= thd->strmake(db, table->db_length);
  table->table_name_length= strlen(name);
  table->table_name= thd->strmake(name, table->table_name_length);
  table->alias= thd->strdup(name);
  table->lock_type= locktype;
  table->select_lex= lex->current_select; // QQ?
  table->cacheable_table= 1;
  
  lex->add_to_query_tables(table);
  return table;
}