sp_head.h 28 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/* -*- C++ -*- */
/* 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 */

#ifndef _SP_HEAD_H_
#define _SP_HEAD_H_

21
#ifdef USE_PRAGMA_INTERFACE
22 23 24 25 26
#pragma interface			/* gcc class implementation */
#endif

#include <stddef.h>

27 28 29 30
// Values for the type enum. This reflects the order of the enum declaration
// in the CREATE TABLE command.
#define TYPE_ENUM_FUNCTION  1
#define TYPE_ENUM_PROCEDURE 2
31
#define TYPE_ENUM_TRIGGER   3
32

33 34 35
Item_result
sp_map_result_type(enum enum_field_types type);

36 37 38
Item::Type
sp_map_item_type(enum enum_field_types type);

39 40
uint
sp_get_flags_for_command(LEX *lex);
41

42
struct sp_label;
43
class sp_instr;
44
class sp_instr_opt_meta;
45
class sp_instr_jump_if_not;
46
struct sp_cond_type;
47
struct sp_variable;
48

49 50 51 52 53 54 55
class sp_name : public Sql_alloc
{
public:

  LEX_STRING m_db;
  LEX_STRING m_name;
  LEX_STRING m_qname;
56 57 58 59 60 61 62
  /*
    Key representing routine in the set of stored routines used by statement.
    Consists of 1-byte routine type and m_qname (which usually refences to
    same buffer). Note that one must complete initialization of the key by
    calling set_routine_type().
  */
  LEX_STRING m_sroutines_key;
63 64 65 66

  sp_name(LEX_STRING name)
    : m_name(name)
  {
67 68
    m_db.str= m_qname.str= m_sroutines_key.str= 0;
    m_db.length= m_qname.length= m_sroutines_key.length= 0;
69 70 71 72 73
  }

  sp_name(LEX_STRING db, LEX_STRING name)
    : m_db(db), m_name(name)
  {
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
    m_qname.str= m_sroutines_key.str= 0;
    m_qname.length= m_sroutines_key.length= 0;
  }

  /*
    Creates temporary sp_name object from key, used mainly
    for SP-cache lookups.
  */
  sp_name(char *key, uint key_len)
  {
    m_sroutines_key.str= key;
    m_sroutines_key.length= key_len;
    m_name.str= m_qname.str= key + 1;
    m_name.length= m_qname.length= key_len - 1;
    m_db.str= 0;
    m_db.length= 0;
90 91 92 93 94
  }

  // Init. the qualified name from the db and name.
  void init_qname(THD *thd);	// thd for memroot allocation

95 96 97 98 99
  void set_routine_type(char type)
  {
    m_sroutines_key.str[0]= type;
  }

100 101 102 103
  ~sp_name()
  {}
};

104 105 106
sp_name *
sp_name_current_db_new(THD *thd, LEX_STRING name);

107
bool
108
check_routine_name(LEX_STRING name);
109

serg@serg.mylan's avatar
serg@serg.mylan committed
110
class sp_head :private Query_arena
111 112 113 114
{
  sp_head(const sp_head &);	/* Prevent use of these */
  void operator=(sp_head &);

115
  MEM_ROOT main_mem_root;
116
public:
117
  /* Possible values of m_flags */
118
  enum {
119 120 121 122 123
    HAS_RETURN= 1,              // For FUNCTIONs only: is set if has RETURN
    IN_SIMPLE_CASE= 2,          // Is set if parsing a simple CASE
    IN_HANDLER= 4,              // Is set if the parser is in a handler body
    MULTI_RESULTS= 8,           // Is set if a procedure with SELECT(s)
    CONTAINS_DYNAMIC_SQL= 16,   // Is set if a procedure with PREPARE/EXECUTE
124
    IS_INVOKED= 32,             // Is set if this sp_head is being used
125 126 127
    HAS_SET_AUTOCOMMIT_STMT= 64,// Is set if a procedure with 'set autocommit'
    /* Is set if a procedure with COMMIT (implicit or explicit) | ROLLBACK */
    HAS_COMMIT_OR_ROLLBACK= 128
128
  };
129

130 131
  /* TYPE_ENUM_FUNCTION, TYPE_ENUM_PROCEDURE or TYPE_ENUM_TRIGGER */
  int m_type;
132
  uint m_flags;                 // Boolean attributes of a stored routine
133 134 135

  create_field m_return_field_def; /* This is used for FUNCTIONs only. */

136
  uchar *m_tmp_query;		// Temporary pointer to sub query string
137
  uint m_old_cmq;		// Old CLIENT_MULTI_QUERIES value
138
  st_sp_chistics *m_chistics;
139
  ulong m_sql_mode;		// For SHOW CREATE and execution
140 141
  LEX_STRING m_qname;		// db.name
  LEX_STRING m_db;
142 143 144 145
  LEX_STRING m_name;
  LEX_STRING m_params;
  LEX_STRING m_body;
  LEX_STRING m_defstr;
146 147
  LEX_STRING m_definer_user;
  LEX_STRING m_definer_host;
148 149
  longlong m_created;
  longlong m_modified;
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
  /* Recursion level of the current SP instance. The levels are numbered from 0 */
  ulong m_recursion_level;
  /*
    A list of diferent recursion level instances for the same procedure.
    For every recursion level we have a sp_head instance. This instances
    connected in the list. The list ordered by increasing recursion level
    (m_recursion_level).
  */
  sp_head *m_next_cached_sp;
  /*
    Pointer to the first element of the above list
  */
  sp_head *m_first_instance;
  /*
    Pointer to the first free (non-INVOKED) routine in the list of
    cached instances for this SP. This pointer is set only for the first
    SP in the list of instences (see above m_first_cached_sp pointer).
    The pointer equal to 0 if we have no free instances.
    For non-first instance value of this pointer meanless (point to itself);
  */
  sp_head *m_first_free_instance;
  /*
    Pointer to the last element in the list of instances of the SP.
    For non-first instance value of this pointer meanless (point to itself);
  */
  sp_head *m_last_cached_sp;
176
  /*
177 178 179 180 181
    Set containing names of stored routines used by this routine.
    Note that unlike elements of similar set for statement elements of this
    set are not linked in one list. Because of this we are able save memory
    by using for this set same objects that are used in 'sroutines' sets
    for statements of which this stored routine consists.
182
  */
183
  HASH m_sroutines;
184
  // Pointers set during parsing
185
  uchar *m_param_begin, *m_param_end, *m_body_begin;
186

187 188 189 190 191
  /*
    Security context for stored routine which should be run under
    definer privileges.
  */
  Security_context m_security_ctx;
192

193 194 195
  static void *
  operator new(size_t size);

196
  static void
197 198
  operator delete(void *ptr, size_t size);

199 200 201 202
  sp_head();

  // Initialize after we have reset mem_root
  void
203 204 205 206
  init(LEX *lex);

  // Initialize strings after parsing header
  void
207
  init_strings(THD *thd, LEX *lex, sp_name *name);
208

209 210
  int
  create(THD *thd);
211

212 213
  virtual ~sp_head();

214 215 216 217
  // Free memory
  void
  destroy();

218 219
  bool
  execute_function(THD *thd, Item **args, uint argcount, Field *return_fld);
220

221
  bool
222
  execute_procedure(THD *thd, List<Item> *args);
223

224 225 226 227 228 229
  int
  show_create_procedure(THD *thd);

  int
  show_create_function(THD *thd);

230 231
  void
  add_instr(sp_instr *instr);
232 233 234 235 236 237 238

  inline uint
  instructions()
  {
    return m_instr.elements;
  }

239 240 241 242 243 244 245 246 247
  inline sp_instr *
  last_instruction()
  {
    sp_instr *i;

    get_dynamic(&m_instr, (gptr)&i, m_instr.elements-1);
    return i;
  }

248 249 250 251 252 253 254 255 256
  // Resets lex in 'thd' and keeps a copy of the old one.
  void
  reset_lex(THD *thd);

  // Restores lex in 'thd' from our copy, but keeps some status from the
  // one in 'thd', like ptr, tables, fields, etc.
  void
  restore_lex(THD *thd);

257
  // Put the instruction on the backpatch list, associated with the label.
258
  void
259
  push_backpatch(sp_instr *, struct sp_label *);
260

261 262
  // Update all instruction with this label in the backpatch list to
  // the current position.
263
  void
264
  backpatch(struct sp_label *);
265

266 267
  // Start a new cont. backpatch level. If 'i' is NULL, the level is just incr.
  void
268
  new_cont_backpatch(sp_instr_opt_meta *i);
269 270 271

  // Add an instruction to the current level
  void
272
  add_cont_backpatch(sp_instr_opt_meta *i);
273 274 275 276 277

  // Backpatch (and pop) the current level to the current position.
  void
  do_cont_backpatch();

278 279 280
  char *name(uint *lenp = 0) const
  {
    if (lenp)
281 282
      *lenp= m_name.length;
    return m_name.str;
283 284
  }

285 286
  char *create_string(THD *thd, ulong *lenp);

287 288 289 290 291 292
  Field *create_result_field(uint field_max_length, const char *field_name,
                             TABLE *table);

  bool fill_field_definition(THD *thd, LEX *lex,
                             enum enum_field_types field_type,
                             create_field *field_def);
293

294
  void set_info(longlong created, longlong modified,
295
		st_sp_chistics *chistics, ulong sql_mode);
296

297
  void set_definer(const char *definer, uint definerlen);
298
  void set_definer(const LEX_STRING *user_name, const LEX_STRING *host_name);
299

300 301 302
  void reset_thd_mem_root(THD *thd);

  void restore_thd_mem_root(THD *thd);
303

304 305 306
  void optimize();
  void opt_mark(uint ip);

307
  void recursion_level_error(THD *thd);
308

309 310 311 312 313 314 315 316 317 318 319
  inline sp_instr *
  get_instr(uint i)
  {
    sp_instr *ip;

    if (i < m_instr.elements)
      get_dynamic(&m_instr, (gptr)&ip, i);
    else
      ip= NULL;
    return ip;
  }
320

321 322
  /* Add tables used by routine to the table list. */
  bool add_used_tables_to_table_list(THD *thd,
323 324
                                     TABLE_LIST ***query_tables_last_ptr,
                                     TABLE_LIST *belong_to_view);
325

326 327 328 329 330 331 332 333 334 335 336
  /*
    Check if this stored routine contains statements disallowed
    in a stored function or trigger, and set an appropriate error message
    if this is the case.
  */
  bool is_not_allowed_in_function(const char *where)
  {
    if (m_flags & CONTAINS_DYNAMIC_SQL)
      my_error(ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0), "Dynamic SQL");
    else if (m_flags & MULTI_RESULTS)
      my_error(ER_SP_NO_RETSET, MYF(0), where);
337 338
    else if (m_flags & HAS_SET_AUTOCOMMIT_STMT)
      my_error(ER_SP_CANT_SET_AUTOCOMMIT, MYF(0));
339 340 341 342 343 344
    else if (m_type != TYPE_ENUM_PROCEDURE &&
             (m_flags & sp_head::HAS_COMMIT_OR_ROLLBACK))
    {
      my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
      return TRUE;
    }
345 346
    return test(m_flags &
		(CONTAINS_DYNAMIC_SQL|MULTI_RESULTS|HAS_SET_AUTOCOMMIT_STMT));
347
  }
pem@mysql.com's avatar
pem@mysql.com committed
348 349 350 351 352 353

#ifndef DBUG_OFF
  int show_routine_code(THD *thd);
#endif


354 355
private:

monty@mysql.com's avatar
monty@mysql.com committed
356
  MEM_ROOT *m_thd_root;		// Temp. store for thd's mem_root
357
  THD *m_thd;			// Set if we have reset mem_root
358
  char *m_thd_db;		// Original thd->db pointer
359

360
  sp_pcontext *m_pcont;		// Parse context
361
  List<LEX> m_lex;		// Temp. store for the other lex
362
  DYNAMIC_ARRAY m_instr;	// The "instructions"
363 364 365 366 367
  typedef struct
  {
    struct sp_label *lab;
    sp_instr *instr;
  } bp_t;
368
  List<bp_t> m_backpatch;	// Instructions needing backpatching
369
  /*
370
    We need a special list for backpatching of instructions with a continue
371 372
    destination (in the case of a continue handler catching an error in
    the test), since it would otherwise interfere with the normal backpatch
373
    mechanism - e.g. jump_if_not instructions have two different destinations
374 375 376 377
    which are to be patched differently.
    Since these occur in a more restricted way (always the same "level" in
    the code), we don't need the label.
   */
378
  List<sp_instr_opt_meta> m_cont_backpatch;
379 380
  uint m_cont_level;            // The current cont. backpatch level

381 382 383
  /*
    Multi-set representing optimized list of tables to be locked by this
    routine. Does not include tables which are used by invoked routines.
384 385 386 387

    Note: for prelocking-free SPs this multiset is constructed too.
    We do so because the same instance of sp_head may be called both
    in prelocked mode and in non-prelocked mode.
388 389
  */
  HASH m_sptabs;
390

391
  bool
392 393
  execute(THD *thd);

394 395 396 397 398
  /*
    Merge the list of tables used by query into the multi-set of tables used
    by routine.
  */
  bool merge_table_list(THD *thd, TABLE_LIST *table, LEX *lex_for_tmp_check);
399 400 401
}; // class sp_head : public Sql_alloc


402 403 404 405
//
// "Instructions"...
//

406
class sp_instr :public Query_arena, public Sql_alloc
407 408 409 410 411 412
{
  sp_instr(const sp_instr &);	/* Prevent use of these */
  void operator=(sp_instr &);

public:

413 414
  uint marked;
  uint m_ip;			// My index
415
  sp_pcontext *m_ctx;		// My parse context
416

417
  // Should give each a name or type code for debugging purposes?
418
  sp_instr(uint ip, sp_pcontext *ctx)
419
    :Query_arena(0, INITIALIZED_FOR_SP), marked(0), m_ip(ip), m_ctx(ctx)
420 421 422
  {}

  virtual ~sp_instr()
423
  { free_items(); }
424

425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440

  /*
    Execute this instruction

    SYNOPSIS
       execute()
         thd        Thread handle
         nextp  OUT index of the next instruction to execute. (For most
                    instructions this will be the instruction following this
                    one).
 
     RETURN 
       0      on success, 
       other  if some error occured
  */
  
441 442
  virtual int execute(THD *thd, uint *nextp) = 0;

443 444 445 446 447 448 449
  /*
    Execute core function of instruction after all preparations (e.g.
    setting of proper LEX, saving part of the thread context have been
    done).

    Should be implemented for instructions using expressions or whole
    statements (thus having to have own LEX). Used in concert with
450
    sp_lex_keeper class and its descendants (there are none currently).
451 452 453
  */
  virtual int exec_core(THD *thd, uint *nextp);

454
  virtual void print(String *str) = 0;
455

456
  virtual void backpatch(uint dest, sp_pcontext *dst_ctx)
457
  {}
458

459 460 461 462 463
  /*
    Mark this instruction as reachable during optimization and return the
    index to the next instruction. Jump instruction will mark their
    destination too recursively.
  */
464 465 466 467 468 469
  virtual uint opt_mark(sp_head *sp)
  {
    marked= 1;
    return m_ip+1;
  }

470 471 472 473 474 475
  /*
    Short-cut jumps to jumps during optimization. This is used by the
    jump instructions' opt_mark() methods. 'start' is the starting point,
    used to prevent the mark sweep from looping for ever. Return the
    end destination.
  */
476
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
477 478 479 480
  {
    return m_ip;
  }

481 482 483 484 485 486
  /*
    Inform the instruction that it has been moved during optimization.
    Most instructions will simply update its index, but jump instructions
    must also take care of their destination pointers. Forward jumps get
    pushed to the backpatch list 'ibp'.
  */
487 488 489 490
  virtual void opt_move(uint dst, List<sp_instr> *ibp)
  {
    m_ip= dst;
  }
491

492 493 494
}; // class sp_instr : public Sql_alloc


495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
/*
  Auxilary class to which instructions delegate responsibility
  for handling LEX and preparations before executing statement
  or calculating complex expression.

  Exist mainly to avoid having double hierarchy between instruction
  classes.

  TODO: Add ability to not store LEX and do any preparations if
        expression used is simple.
*/

class sp_lex_keeper
{
  /* Prevent use of these */
  sp_lex_keeper(const sp_lex_keeper &);
  void operator=(sp_lex_keeper &);
public:

  sp_lex_keeper(LEX *lex, bool lex_resp)
515 516
    : m_lex(lex), m_lex_resp(lex_resp), 
      lex_query_tables_own_last(NULL)
517 518 519 520 521 522
  {
    lex->sp_lex_in_use= TRUE;
  }
  virtual ~sp_lex_keeper()
  {
    if (m_lex_resp)
523 524
    {
      lex_end(m_lex);
525
      delete m_lex;
526
    }
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
  }

  /*
    Prepare execution of instruction using LEX, if requested check whenever
    we have read access to tables used and open/lock them, call instruction's
    exec_core() method, perform cleanup afterwards.
  */
  int reset_lex_and_exec_core(THD *thd, uint *nextp, bool open_tables,
                              sp_instr* instr);

  inline uint sql_command() const
  {
    return (uint)m_lex->sql_command;
  }

542 543 544 545
  void disable_query_cache()
  {
    m_lex->safe_to_cache_query= 0;
  }
546 547 548 549 550 551 552 553
private:

  LEX *m_lex;
  /*
    Indicates whenever this sp_lex_keeper instance responsible
    for LEX deletion.
  */
  bool m_lex_resp;
554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572

  /*
    Support for being able to execute this statement in two modes:
    a) inside prelocked mode set by the calling procedure or its ancestor.
    b) outside of prelocked mode, when this statement enters/leaves
       prelocked mode itself.
  */
  
  /*
    List of additional tables this statement needs to lock when it
    enters/leaves prelocked mode on its own.
  */
  TABLE_LIST *prelocking_tables;

  /*
    The value m_lex->query_tables_own_last should be set to this when the
    statement enters/leaves prelocked mode on its own.
  */
  TABLE_LIST **lex_query_tables_own_last;
573 574 575
};


576 577 578 579 580 581 582 583 584 585
//
// Call out to some prepared SQL statement.
//
class sp_instr_stmt : public sp_instr
{
  sp_instr_stmt(const sp_instr_stmt &);	/* Prevent use of these */
  void operator=(sp_instr_stmt &);

public:

586 587
  LEX_STRING m_query;		// For thd->query

588 589
  sp_instr_stmt(uint ip, sp_pcontext *ctx, LEX *lex)
    : sp_instr(ip, ctx), m_lex_keeper(lex, TRUE)
590 591 592 593
  {
    m_query.str= 0;
    m_query.length= 0;
  }
594

595 596
  virtual ~sp_instr_stmt()
  {};
597

598
  virtual int execute(THD *thd, uint *nextp);
599

600
  virtual int exec_core(THD *thd, uint *nextp);
601

602
  virtual void print(String *str);
603

604 605
private:

606
  sp_lex_keeper m_lex_keeper;
607 608 609 610 611 612 613 614 615 616 617

}; // class sp_instr_stmt : public sp_instr


class sp_instr_set : public sp_instr
{
  sp_instr_set(const sp_instr_set &);	/* Prevent use of these */
  void operator=(sp_instr_set &);

public:

618
  sp_instr_set(uint ip, sp_pcontext *ctx,
619 620 621 622
	       uint offset, Item *val, enum enum_field_types type,
               LEX *lex, bool lex_resp)
    : sp_instr(ip, ctx), m_offset(offset), m_value(val), m_type(type),
      m_lex_keeper(lex, lex_resp)
623 624 625 626 627
  {}

  virtual ~sp_instr_set()
  {}

628
  virtual int execute(THD *thd, uint *nextp);
629

630 631
  virtual int exec_core(THD *thd, uint *nextp);

632 633
  virtual void print(String *str);

634 635
private:

636
  uint m_offset;		// Frame offset
637 638
  Item *m_value;
  enum enum_field_types m_type;	// The declared type
639
  sp_lex_keeper m_lex_keeper;
640 641 642

}; // class sp_instr_set : public sp_instr

643

644 645 646 647 648 649 650 651 652 653
/*
  Set NEW/OLD row field value instruction. Used in triggers.
*/
class sp_instr_set_trigger_field : public sp_instr
{
  sp_instr_set_trigger_field(const sp_instr_set_trigger_field &);
  void operator=(sp_instr_set_trigger_field &);

public:

654
  sp_instr_set_trigger_field(uint ip, sp_pcontext *ctx,
655 656
                             Item_trigger_field *trg_fld,
                             Item *val, LEX *lex)
657
    : sp_instr(ip, ctx),
658
      trigger_field(trg_fld),
659
      value(val), m_lex_keeper(lex, TRUE)
660 661 662 663 664 665 666
  {}

  virtual ~sp_instr_set_trigger_field()
  {}

  virtual int execute(THD *thd, uint *nextp);

667 668
  virtual int exec_core(THD *thd, uint *nextp);

669 670
  virtual void print(String *str);

671
private:
672
  Item_trigger_field *trigger_field;
673
  Item *value;
674
  sp_lex_keeper m_lex_keeper;
675 676 677
}; // class sp_instr_trigger_field : public sp_instr


678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
/*
  An abstract class for all instructions with destinations that
  needs to be updated by the optimizer.
  Even if not all subclasses will use both the normal destination and
  the continuation destination, we put them both here for simplicity.
 */
class sp_instr_opt_meta : public sp_instr
{
public:

  uint m_dest;			// Where we will go
  uint m_cont_dest;             // Where continue handlers will go

  sp_instr_opt_meta(uint ip, sp_pcontext *ctx)
    : sp_instr(ip, ctx),
      m_dest(0), m_cont_dest(0), m_optdest(0), m_cont_optdest(0)
  {}

  sp_instr_opt_meta(uint ip, sp_pcontext *ctx, uint dest)
    : sp_instr(ip, ctx),
      m_dest(dest), m_cont_dest(0), m_optdest(0), m_cont_optdest(0)
  {}

  virtual ~sp_instr_opt_meta()
  {}

  virtual void set_destination(uint old_dest, uint new_dest)
    = 0;

protected:

  sp_instr *m_optdest;		// Used during optimization
  sp_instr *m_cont_optdest;     // Used during optimization

}; // class sp_instr_opt_meta : public sp_instr

class sp_instr_jump : public sp_instr_opt_meta
715 716 717 718 719 720
{
  sp_instr_jump(const sp_instr_jump &);	/* Prevent use of these */
  void operator=(sp_instr_jump &);

public:

721
  sp_instr_jump(uint ip, sp_pcontext *ctx)
722
    : sp_instr_opt_meta(ip, ctx)
723 724
  {}

725
  sp_instr_jump(uint ip, sp_pcontext *ctx, uint dest)
726
    : sp_instr_opt_meta(ip, ctx, dest)
727 728 729 730 731
  {}

  virtual ~sp_instr_jump()
  {}

732
  virtual int execute(THD *thd, uint *nextp);
733

734 735
  virtual void print(String *str);

736 737
  virtual uint opt_mark(sp_head *sp);

738
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start);
739 740 741

  virtual void opt_move(uint dst, List<sp_instr> *ibp);

742
  virtual void backpatch(uint dest, sp_pcontext *dst_ctx)
743
  {
744 745
    if (m_dest == 0)		// Don't reset
      m_dest= dest;
746 747
  }

748 749 750
  /*
    Update the destination; used by the optimizer.
  */
751
  virtual void set_destination(uint old_dest, uint new_dest)
752
  {
753 754
    if (m_dest == old_dest)
      m_dest= new_dest;
755 756
  }

757
}; // class sp_instr_jump : public sp_instr_opt_meta
758 759 760 761 762 763 764 765 766


class sp_instr_jump_if_not : public sp_instr_jump
{
  sp_instr_jump_if_not(const sp_instr_jump_if_not &); /* Prevent use of these */
  void operator=(sp_instr_jump_if_not &);

public:

767
  sp_instr_jump_if_not(uint ip, sp_pcontext *ctx, Item *i, LEX *lex)
768 769
    : sp_instr_jump(ip, ctx), m_expr(i),
      m_lex_keeper(lex, TRUE)
770 771
  {}

772
  sp_instr_jump_if_not(uint ip, sp_pcontext *ctx, Item *i, uint dest, LEX *lex)
773 774
    : sp_instr_jump(ip, ctx, dest), m_expr(i),
      m_lex_keeper(lex, TRUE)
775 776 777 778 779 780 781
  {}

  virtual ~sp_instr_jump_if_not()
  {}

  virtual int execute(THD *thd, uint *nextp);

782 783
  virtual int exec_core(THD *thd, uint *nextp);

784 785
  virtual void print(String *str);

786 787
  virtual uint opt_mark(sp_head *sp);

788
  /* Override sp_instr_jump's shortcut; we stop here */
789
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
790 791 792 793
  {
    return m_ip;
  }

794 795 796 797 798 799 800 801 802
  virtual void opt_move(uint dst, List<sp_instr> *ibp);

  virtual void set_destination(uint old_dest, uint new_dest)
  {
    sp_instr_jump::set_destination(old_dest, new_dest);
    if (m_cont_dest == old_dest)
      m_cont_dest= new_dest;
  }

803 804 805
private:

  Item *m_expr;			// The condition
806
  sp_lex_keeper m_lex_keeper;
807 808 809

}; // class sp_instr_jump_if_not : public sp_instr_jump

810

811
class sp_instr_freturn : public sp_instr
812
{
813 814
  sp_instr_freturn(const sp_instr_freturn &);	/* Prevent use of these */
  void operator=(sp_instr_freturn &);
815 816 817

public:

818
  sp_instr_freturn(uint ip, sp_pcontext *ctx,
819 820
		   Item *val, enum enum_field_types type, LEX *lex)
    : sp_instr(ip, ctx), m_value(val), m_type(type), m_lex_keeper(lex, TRUE)
821 822
  {}

823
  virtual ~sp_instr_freturn()
824 825 826 827
  {}

  virtual int execute(THD *thd, uint *nextp);

828 829
  virtual int exec_core(THD *thd, uint *nextp);

830 831
  virtual void print(String *str);

832 833 834 835 836 837
  virtual uint opt_mark(sp_head *sp)
  {
    marked= 1;
    return UINT_MAX;
  }

838 839 840 841
protected:

  Item *m_value;
  enum enum_field_types m_type;
842
  sp_lex_keeper m_lex_keeper;
843

844 845 846 847 848 849 850 851 852 853
}; // class sp_instr_freturn : public sp_instr


class sp_instr_hpush_jump : public sp_instr_jump
{
  sp_instr_hpush_jump(const sp_instr_hpush_jump &); /* Prevent use of these */
  void operator=(sp_instr_hpush_jump &);

public:

854 855
  sp_instr_hpush_jump(uint ip, sp_pcontext *ctx, int htype, uint fp)
    : sp_instr_jump(ip, ctx), m_type(htype), m_frame(fp)
856 857 858 859 860 861 862 863 864 865 866
  {
    m_cond.empty();
  }

  virtual ~sp_instr_hpush_jump()
  {
    m_cond.empty();
  }

  virtual int execute(THD *thd, uint *nextp);

867 868
  virtual void print(String *str);

869 870
  virtual uint opt_mark(sp_head *sp);

871
  /* Override sp_instr_jump's shortcut; we stop here. */
872
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
873 874 875 876
  {
    return m_ip;
  }

877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897
  inline void add_condition(struct sp_cond_type *cond)
  {
    m_cond.push_front(cond);
  }

private:

  int m_type;			// Handler type
  uint m_frame;
  List<struct sp_cond_type> m_cond;

}; // class sp_instr_hpush_jump : public sp_instr_jump


class sp_instr_hpop : public sp_instr
{
  sp_instr_hpop(const sp_instr_hpop &);	/* Prevent use of these */
  void operator=(sp_instr_hpop &);

public:

898 899
  sp_instr_hpop(uint ip, sp_pcontext *ctx, uint count)
    : sp_instr(ip, ctx), m_count(count)
900 901 902 903 904 905 906
  {}

  virtual ~sp_instr_hpop()
  {}

  virtual int execute(THD *thd, uint *nextp);

907 908
  virtual void print(String *str);

909 910 911 912 913 914 915
private:

  uint m_count;

}; // class sp_instr_hpop : public sp_instr


916
class sp_instr_hreturn : public sp_instr_jump
917 918 919 920 921 922
{
  sp_instr_hreturn(const sp_instr_hreturn &);	/* Prevent use of these */
  void operator=(sp_instr_hreturn &);

public:

923
  sp_instr_hreturn(uint ip, sp_pcontext *ctx, uint fp)
924
    : sp_instr_jump(ip, ctx), m_frame(fp)
925 926 927 928 929 930 931
  {}

  virtual ~sp_instr_hreturn()
  {}

  virtual int execute(THD *thd, uint *nextp);

932 933
  virtual void print(String *str);

934
  virtual uint opt_mark(sp_head *sp);
935

936 937 938 939
private:

  uint m_frame;

940
}; // class sp_instr_hreturn : public sp_instr_jump
941

942

943
/* This is DECLARE CURSOR */
944 945 946 947 948 949 950
class sp_instr_cpush : public sp_instr
{
  sp_instr_cpush(const sp_instr_cpush &); /* Prevent use of these */
  void operator=(sp_instr_cpush &);

public:

pem@mysql.com's avatar
pem@mysql.com committed
951 952
  sp_instr_cpush(uint ip, sp_pcontext *ctx, LEX *lex, uint offset)
    : sp_instr(ip, ctx), m_lex_keeper(lex, TRUE), m_cursor(offset)
953 954
  {}

955 956
  virtual ~sp_instr_cpush()
  {}
957 958 959

  virtual int execute(THD *thd, uint *nextp);

960 961
  virtual void print(String *str);

962 963 964 965 966 967
  /*
    This call is used to cleanup the instruction when a sensitive
    cursor is closed. For now stored procedures always use materialized
    cursors and the call is not used.
  */
  virtual void cleanup_stmt() { /* no op */ }
968 969
private:

970
  sp_lex_keeper m_lex_keeper;
pem@mysql.com's avatar
pem@mysql.com committed
971
  uint m_cursor;                /* Frame offset (for debugging) */
972 973 974 975 976 977 978 979 980 981 982

}; // class sp_instr_cpush : public sp_instr


class sp_instr_cpop : public sp_instr
{
  sp_instr_cpop(const sp_instr_cpop &); /* Prevent use of these */
  void operator=(sp_instr_cpop &);

public:

983 984
  sp_instr_cpop(uint ip, sp_pcontext *ctx, uint count)
    : sp_instr(ip, ctx), m_count(count)
985 986 987 988 989 990 991
  {}

  virtual ~sp_instr_cpop()
  {}

  virtual int execute(THD *thd, uint *nextp);

992 993
  virtual void print(String *str);

994 995 996 997 998 999 1000
private:

  uint m_count;

}; // class sp_instr_cpop : public sp_instr


1001
class sp_instr_copen : public sp_instr
1002 1003 1004 1005 1006 1007
{
  sp_instr_copen(const sp_instr_copen &); /* Prevent use of these */
  void operator=(sp_instr_copen &);

public:

1008
  sp_instr_copen(uint ip, sp_pcontext *ctx, uint c)
1009
    : sp_instr(ip, ctx), m_cursor(c)
1010 1011 1012 1013 1014 1015 1016
  {}

  virtual ~sp_instr_copen()
  {}

  virtual int execute(THD *thd, uint *nextp);

1017 1018
  virtual int exec_core(THD *thd, uint *nextp);

1019 1020
  virtual void print(String *str);

1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034
private:

  uint m_cursor;		// Stack index

}; // class sp_instr_copen : public sp_instr_stmt


class sp_instr_cclose : public sp_instr
{
  sp_instr_cclose(const sp_instr_cclose &); /* Prevent use of these */
  void operator=(sp_instr_cclose &);

public:

1035 1036
  sp_instr_cclose(uint ip, sp_pcontext *ctx, uint c)
    : sp_instr(ip, ctx), m_cursor(c)
1037 1038 1039 1040 1041 1042 1043
  {}

  virtual ~sp_instr_cclose()
  {}

  virtual int execute(THD *thd, uint *nextp);

1044 1045
  virtual void print(String *str);

1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
private:

  uint m_cursor;

}; // class sp_instr_cclose : public sp_instr


class sp_instr_cfetch : public sp_instr
{
  sp_instr_cfetch(const sp_instr_cfetch &); /* Prevent use of these */
  void operator=(sp_instr_cfetch &);

public:

1060 1061
  sp_instr_cfetch(uint ip, sp_pcontext *ctx, uint c)
    : sp_instr(ip, ctx), m_cursor(c)
1062 1063 1064 1065 1066 1067 1068 1069 1070
  {
    m_varlist.empty();
  }

  virtual ~sp_instr_cfetch()
  {}

  virtual int execute(THD *thd, uint *nextp);

1071 1072
  virtual void print(String *str);

1073
  void add_to_varlist(struct sp_variable *var)
1074 1075 1076 1077 1078 1079 1080
  {
    m_varlist.push_back(var);
  }

private:

  uint m_cursor;
1081
  List<struct sp_variable> m_varlist;
1082 1083 1084 1085

}; // class sp_instr_cfetch : public sp_instr


1086 1087 1088 1089 1090 1091 1092
class sp_instr_error : public sp_instr
{
  sp_instr_error(const sp_instr_error &); /* Prevent use of these */
  void operator=(sp_instr_error &);

public:

1093 1094
  sp_instr_error(uint ip, sp_pcontext *ctx, int errcode)
    : sp_instr(ip, ctx), m_errcode(errcode)
1095 1096 1097 1098 1099 1100 1101 1102 1103
  {}

  virtual ~sp_instr_error()
  {}

  virtual int execute(THD *thd, uint *nextp);

  virtual void print(String *str);

1104 1105 1106 1107 1108 1109
  virtual uint opt_mark(sp_head *sp)
  {
    marked= 1;
    return UINT_MAX;
  }

1110 1111 1112 1113 1114 1115 1116
private:

  int m_errcode;

}; // class sp_instr_error : public sp_instr


1117
class sp_instr_set_case_expr : public sp_instr_opt_meta
1118 1119 1120 1121 1122
{
public:

  sp_instr_set_case_expr(uint ip, sp_pcontext *ctx, uint case_expr_id,
                         Item *case_expr, LEX *lex)
1123 1124 1125 1126 1127 1128
    : sp_instr_opt_meta(ip, ctx),
      m_case_expr_id(case_expr_id), m_case_expr(case_expr),
      m_lex_keeper(lex, TRUE)
  {}

  virtual ~sp_instr_set_case_expr()
1129 1130 1131 1132 1133 1134 1135 1136
  {}

  virtual int execute(THD *thd, uint *nextp);

  virtual int exec_core(THD *thd, uint *nextp);

  virtual void print(String *str);

1137 1138 1139 1140 1141 1142 1143 1144 1145 1146
  virtual uint opt_mark(sp_head *sp);

  virtual void opt_move(uint dst, List<sp_instr> *ibp);

  virtual void set_destination(uint old_dest, uint new_dest)
  {
    if (m_cont_dest == old_dest)
      m_cont_dest= new_dest;
  }

1147 1148 1149 1150 1151 1152
private:

  uint m_case_expr_id;
  Item *m_case_expr;
  sp_lex_keeper m_lex_keeper;

1153
}; // class sp_instr_set_case_expr : public sp_instr_opt_meta
1154 1155


1156
#ifndef NO_EMBEDDED_ACCESS_CHECKS
1157 1158
bool
sp_change_security_context(THD *thd, sp_head *sp,
1159
                           Security_context **backup);
1160
void
1161
sp_restore_security_context(THD *thd, Security_context *backup);
1162
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
1163

1164 1165 1166 1167
TABLE_LIST *
sp_add_to_query_tables(THD *thd, LEX *lex,
		       const char *db, const char *name,
		       thr_lock_type locktype);
1168 1169
Item *
sp_prepare_func_item(THD* thd, Item **it_addr);
1170

1171
bool
1172
sp_eval_expr(THD *thd, Field *result_field, Item **expr_item_ptr);
1173

1174
#endif /* _SP_HEAD_H_ */