sp_head.h 29.6 KB
Newer Older
1 2 3 4 5
/* -*- 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
6
   the Free Software Foundation; version 2 of the License.
7 8 9 10 11 12 13 14 15 16 17 18 19

   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_

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

#include <stddef.h>

26 27 28 29
// 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
30
#define TYPE_ENUM_TRIGGER   3
31

32 33 34
Item_result
sp_map_result_type(enum enum_field_types type);

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

38 39
uint
sp_get_flags_for_command(LEX *lex);
40

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

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

  LEX_STRING m_db;
  LEX_STRING m_name;
  LEX_STRING m_qname;
55 56 57 58 59 60 61
  /*
    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;
62 63 64 65

  sp_name(LEX_STRING db, LEX_STRING name)
    : m_db(db), m_name(name)
  {
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
    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;
82 83 84 85 86
  }

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

87 88 89 90 91
  void set_routine_type(char type)
  {
    m_sroutines_key.str[0]= type;
  }

92 93 94 95
  ~sp_name()
  {}
};

96

97
bool
98
check_routine_name(LEX_STRING name);
99

serg@serg.mylan's avatar
serg@serg.mylan committed
100
class sp_head :private Query_arena
101 102 103 104
{
  sp_head(const sp_head &);	/* Prevent use of these */
  void operator=(sp_head &);

105
  MEM_ROOT main_mem_root;
106
public:
107
  /* Possible values of m_flags */
108
  enum {
109 110 111
    HAS_RETURN= 1,              // For FUNCTIONs only: is set if has RETURN
    MULTI_RESULTS= 8,           // Is set if a procedure with SELECT(s)
    CONTAINS_DYNAMIC_SQL= 16,   // Is set if a procedure with PREPARE/EXECUTE
112
    IS_INVOKED= 32,             // Is set if this sp_head is being used
113 114
    HAS_SET_AUTOCOMMIT_STMT= 64,// Is set if a procedure with 'set autocommit'
    /* Is set if a procedure with COMMIT (implicit or explicit) | ROLLBACK */
115 116 117
    HAS_COMMIT_OR_ROLLBACK= 128,
    HAS_SQLCOM_RESET= 2048,
    HAS_SQLCOM_FLUSH= 4096
118
  };
119

120 121
  /* TYPE_ENUM_FUNCTION, TYPE_ENUM_PROCEDURE or TYPE_ENUM_TRIGGER */
  int m_type;
122
  uint m_flags;                 // Boolean attributes of a stored routine
123 124 125

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

126
  uchar *m_tmp_query;		// Temporary pointer to sub query string
127
  uint m_old_cmq;		// Old CLIENT_MULTI_QUERIES value
128
  st_sp_chistics *m_chistics;
129
  ulong m_sql_mode;		// For SHOW CREATE and execution
130 131
  LEX_STRING m_qname;		// db.name
  LEX_STRING m_db;
132 133 134 135
  LEX_STRING m_name;
  LEX_STRING m_params;
  LEX_STRING m_body;
  LEX_STRING m_defstr;
136 137
  LEX_STRING m_definer_user;
  LEX_STRING m_definer_host;
138 139
  longlong m_created;
  longlong m_modified;
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
  /* 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;
166
  /*
167 168 169 170 171
    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.
172
  */
173
  HASH m_sroutines;
174
  // Pointers set during parsing
175
  uchar *m_param_begin, *m_param_end, *m_body_begin;
176

177 178 179 180 181
  /*
    Security context for stored routine which should be run under
    definer privileges.
  */
  Security_context m_security_ctx;
182

183 184 185
  static void *
  operator new(size_t size);

186
  static void
187 188
  operator delete(void *ptr, size_t size);

189 190 191 192
  sp_head();

  // Initialize after we have reset mem_root
  void
193 194
  init(LEX *lex);

195 196 197 198
  /* Copy sp name from parser. */
  void
  init_sp_name(THD *thd, sp_name *spname);

199 200
  // Initialize strings after parsing header
  void
201
  init_strings(THD *thd, LEX *lex);
202

203 204
  int
  create(THD *thd);
205

206 207
  virtual ~sp_head();

208 209 210 211
  // Free memory
  void
  destroy();

212 213 214 215
  bool
  execute_trigger(THD *thd, const char *db, const char *table,
                  GRANT_INFO *grant_onfo);

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

219
  bool
220
  execute_procedure(THD *thd, List<Item> *args);
221

222 223 224 225 226 227
  int
  show_create_procedure(THD *thd);

  int
  show_create_function(THD *thd);

228 229
  void
  add_instr(sp_instr *instr);
230 231 232 233 234 235 236

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

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

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

246 247 248 249 250 251 252 253 254
  // 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);

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

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

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

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

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

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

283 284
  char *create_string(THD *thd, ulong *lenp);

285 286 287 288 289 290
  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);
291

292
  void set_info(longlong created, longlong modified,
293
		st_sp_chistics *chistics, ulong sql_mode);
294

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

298 299 300
  void reset_thd_mem_root(THD *thd);

  void restore_thd_mem_root(THD *thd);
301

302 303 304
  /**
    Optimize the code.
  */
305
  void optimize();
306 307 308 309 310 311 312 313 314

  /**
    Helper used during flow analysis during code optimization.
    See the implementation of <code>opt_mark()</code>.
    @param ip the instruction to add to the leads list
    @param leads the list of remaining paths to explore in the graph that
    represents the code, during flow analysis.
  */
  void add_mark_lead(uint ip, List<sp_instr> *leads);
315

316
  void recursion_level_error(THD *thd);
317

318 319 320 321 322 323 324 325 326 327 328
  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;
  }
329

330 331
  /* Add tables used by routine to the table list. */
  bool add_used_tables_to_table_list(THD *thd,
332 333
                                     TABLE_LIST ***query_tables_last_ptr,
                                     TABLE_LIST *belong_to_view);
334

335 336 337 338 339 340 341 342 343 344 345
  /*
    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);
346 347
    else if (m_flags & HAS_SET_AUTOCOMMIT_STMT)
      my_error(ER_SP_CANT_SET_AUTOCOMMIT, MYF(0));
348
    else if (m_flags & HAS_COMMIT_OR_ROLLBACK)
349
      my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
350 351 352 353 354
    else if (m_flags & HAS_SQLCOM_RESET)
      my_error(ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0), "RESET");
    else if (m_flags & HAS_SQLCOM_FLUSH)
      my_error(ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0), "FLUSH");

355
    return test(m_flags &
356 357
		(CONTAINS_DYNAMIC_SQL|MULTI_RESULTS|HAS_SET_AUTOCOMMIT_STMT|
                 HAS_COMMIT_OR_ROLLBACK|HAS_SQLCOM_RESET|HAS_SQLCOM_FLUSH));
358
  }
pem@mysql.com's avatar
pem@mysql.com committed
359 360 361 362 363 364

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


365 366
private:

monty@mysql.com's avatar
monty@mysql.com committed
367
  MEM_ROOT *m_thd_root;		// Temp. store for thd's mem_root
368
  THD *m_thd;			// Set if we have reset mem_root
369

370
  sp_pcontext *m_pcont;		// Parse context
371
  List<LEX> m_lex;		// Temp. store for the other lex
372
  DYNAMIC_ARRAY m_instr;	// The "instructions"
373 374 375 376 377
  typedef struct
  {
    struct sp_label *lab;
    sp_instr *instr;
  } bp_t;
378
  List<bp_t> m_backpatch;	// Instructions needing backpatching
379
  /*
380
    We need a special list for backpatching of instructions with a continue
381 382
    destination (in the case of a continue handler catching an error in
    the test), since it would otherwise interfere with the normal backpatch
383
    mechanism - e.g. jump_if_not instructions have two different destinations
384 385 386 387
    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.
   */
388
  List<sp_instr_opt_meta> m_cont_backpatch;
389 390
  uint m_cont_level;            // The current cont. backpatch level

391 392 393
  /*
    Multi-set representing optimized list of tables to be locked by this
    routine. Does not include tables which are used by invoked routines.
394 395 396 397

    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.
398 399
  */
  HASH m_sptabs;
400

401
  bool
402 403
  execute(THD *thd);

404 405 406 407 408 409
  /**
    Perform a forward flow analysis in the generated code.
    Mark reachable instructions, for the optimizer.
  */
  void opt_mark();

410 411 412 413 414
  /*
    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);
415 416 417
}; // class sp_head : public Sql_alloc


418 419 420 421
//
// "Instructions"...
//

422
class sp_instr :public Query_arena, public Sql_alloc
423 424 425 426 427 428
{
  sp_instr(const sp_instr &);	/* Prevent use of these */
  void operator=(sp_instr &);

public:

429 430
  uint marked;
  uint m_ip;			// My index
431
  sp_pcontext *m_ctx;		// My parse context
432

433
  // Should give each a name or type code for debugging purposes?
434
  sp_instr(uint ip, sp_pcontext *ctx)
435
    :Query_arena(0, INITIALIZED_FOR_SP), marked(0), m_ip(ip), m_ctx(ctx)
436 437 438
  {}

  virtual ~sp_instr()
439
  { free_items(); }
440

441 442 443 444 445 446 447 448 449

  /*
    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
450 451 452 453 454 455 456
                    one). Note that this parameter is undefined in case of
                    errors, use get_cont_dest() to find the continuation
                    instruction for CONTINUE error handlers.

     RETURN
       0      on success,
       other  if some error occurred
457
  */
458

459 460
  virtual int execute(THD *thd, uint *nextp) = 0;

461 462 463 464 465 466 467 468 469
  /**
    Execute <code>open_and_lock_tables()</code> for this statement.
    Open and lock the tables used by this statement, as a pre-requisite
    to execute the core logic of this instruction with
    <code>exec_core()</code>.
    @param thd the current thread
    @param tables the list of tables to open and lock
    @return zero on success, non zero on failure.
  */
470
  int exec_open_and_lock_tables(THD *thd, TABLE_LIST *tables);
471 472 473

  /**
    Get the continuation destination of this instruction.
474
    @return the continuation destination
475
  */
476
  virtual uint get_cont_dest();
477

478 479 480 481 482 483 484
  /*
    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
485
    sp_lex_keeper class and its descendants (there are none currently).
486 487 488
  */
  virtual int exec_core(THD *thd, uint *nextp);

489
  virtual void print(String *str) = 0;
490

491
  virtual void backpatch(uint dest, sp_pcontext *dst_ctx)
492
  {}
493

494 495
  /*
    Mark this instruction as reachable during optimization and return the
496 497
    index to the next instruction. Jump instruction will add their
    destination to the leads list.
498
  */
499
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads)
500 501 502 503 504
  {
    marked= 1;
    return m_ip+1;
  }

505 506 507 508 509 510
  /*
    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.
  */
511
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
512 513 514 515
  {
    return m_ip;
  }

516 517 518 519 520 521
  /*
    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'.
  */
522 523 524 525
  virtual void opt_move(uint dst, List<sp_instr> *ibp)
  {
    m_ip= dst;
  }
526

527 528 529
}; // class sp_instr : public Sql_alloc


530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549
/*
  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)
550 551
    : m_lex(lex), m_lex_resp(lex_resp), 
      lex_query_tables_own_last(NULL)
552 553 554 555 556 557
  {
    lex->sp_lex_in_use= TRUE;
  }
  virtual ~sp_lex_keeper()
  {
    if (m_lex_resp)
558 559
    {
      lex_end(m_lex);
560
      delete m_lex;
561
    }
562 563 564 565 566 567 568 569 570 571 572 573 574 575 576
  }

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

577 578 579 580
  void disable_query_cache()
  {
    m_lex->safe_to_cache_query= 0;
  }
581 582 583 584 585 586 587 588
private:

  LEX *m_lex;
  /*
    Indicates whenever this sp_lex_keeper instance responsible
    for LEX deletion.
  */
  bool m_lex_resp;
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607

  /*
    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;
608 609 610
};


611 612 613 614 615 616 617 618 619 620
//
// 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:

621 622
  LEX_STRING m_query;		// For thd->query

623 624
  sp_instr_stmt(uint ip, sp_pcontext *ctx, LEX *lex)
    : sp_instr(ip, ctx), m_lex_keeper(lex, TRUE)
625 626 627 628
  {
    m_query.str= 0;
    m_query.length= 0;
  }
629

630 631
  virtual ~sp_instr_stmt()
  {};
632

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

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

637
  virtual void print(String *str);
638

639 640
private:

641
  sp_lex_keeper m_lex_keeper;
642 643 644 645 646 647 648 649 650 651 652

}; // 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:

653
  sp_instr_set(uint ip, sp_pcontext *ctx,
654
	       uint offset, Item *val, enum enum_field_types type_arg,
655
               LEX *lex, bool lex_resp)
656
    : sp_instr(ip, ctx), m_offset(offset), m_value(val), m_type(type_arg),
657
      m_lex_keeper(lex, lex_resp)
658 659 660 661 662
  {}

  virtual ~sp_instr_set()
  {}

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

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

667 668
  virtual void print(String *str);

669 670
private:

671
  uint m_offset;		// Frame offset
672 673
  Item *m_value;
  enum enum_field_types m_type;	// The declared type
674
  sp_lex_keeper m_lex_keeper;
675 676 677

}; // class sp_instr_set : public sp_instr

678

679 680 681 682 683 684 685 686 687 688
/*
  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:

689
  sp_instr_set_trigger_field(uint ip, sp_pcontext *ctx,
690 691
                             Item_trigger_field *trg_fld,
                             Item *val, LEX *lex)
692
    : sp_instr(ip, ctx),
693
      trigger_field(trg_fld),
694
      value(val), m_lex_keeper(lex, TRUE)
695 696 697 698 699 700 701
  {}

  virtual ~sp_instr_set_trigger_field()
  {}

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

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

704 705
  virtual void print(String *str);

706
private:
707
  Item_trigger_field *trigger_field;
708
  Item *value;
709
  sp_lex_keeper m_lex_keeper;
710 711 712
}; // class sp_instr_trigger_field : public sp_instr


713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
/*
  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;

742
  virtual uint get_cont_dest();
743

744 745 746 747 748 749 750 751
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
752 753 754 755 756 757
{
  sp_instr_jump(const sp_instr_jump &);	/* Prevent use of these */
  void operator=(sp_instr_jump &);

public:

758
  sp_instr_jump(uint ip, sp_pcontext *ctx)
759
    : sp_instr_opt_meta(ip, ctx)
760 761
  {}

762
  sp_instr_jump(uint ip, sp_pcontext *ctx, uint dest)
763
    : sp_instr_opt_meta(ip, ctx, dest)
764 765 766 767 768
  {}

  virtual ~sp_instr_jump()
  {}

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

771 772
  virtual void print(String *str);

773
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);
774

775
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start);
776 777 778

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

779
  virtual void backpatch(uint dest, sp_pcontext *dst_ctx)
780
  {
781 782
    if (m_dest == 0)		// Don't reset
      m_dest= dest;
783 784
  }

785 786 787
  /*
    Update the destination; used by the optimizer.
  */
788
  virtual void set_destination(uint old_dest, uint new_dest)
789
  {
790 791
    if (m_dest == old_dest)
      m_dest= new_dest;
792 793
  }

794
}; // class sp_instr_jump : public sp_instr_opt_meta
795 796 797 798 799 800 801 802 803


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:

804
  sp_instr_jump_if_not(uint ip, sp_pcontext *ctx, Item *i, LEX *lex)
805 806
    : sp_instr_jump(ip, ctx), m_expr(i),
      m_lex_keeper(lex, TRUE)
807 808
  {}

809
  sp_instr_jump_if_not(uint ip, sp_pcontext *ctx, Item *i, uint dest, LEX *lex)
810 811
    : sp_instr_jump(ip, ctx, dest), m_expr(i),
      m_lex_keeper(lex, TRUE)
812 813 814 815 816 817 818
  {}

  virtual ~sp_instr_jump_if_not()
  {}

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

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

821 822
  virtual void print(String *str);

823
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);
824

825
  /* Override sp_instr_jump's shortcut; we stop here */
826
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
827 828 829 830
  {
    return m_ip;
  }

831 832 833 834 835 836 837 838 839
  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;
  }

840 841 842
private:

  Item *m_expr;			// The condition
843
  sp_lex_keeper m_lex_keeper;
844 845 846

}; // class sp_instr_jump_if_not : public sp_instr_jump

847

848
class sp_instr_freturn : public sp_instr
849
{
850 851
  sp_instr_freturn(const sp_instr_freturn &);	/* Prevent use of these */
  void operator=(sp_instr_freturn &);
852 853 854

public:

855
  sp_instr_freturn(uint ip, sp_pcontext *ctx,
856 857 858
		   Item *val, enum enum_field_types type_arg, LEX *lex)
    : sp_instr(ip, ctx), m_value(val), m_type(type_arg),
      m_lex_keeper(lex, TRUE)
859 860
  {}

861
  virtual ~sp_instr_freturn()
862 863 864 865
  {}

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

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

868 869
  virtual void print(String *str);

870
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads)
871 872 873 874 875
  {
    marked= 1;
    return UINT_MAX;
  }

876 877 878 879
protected:

  Item *m_value;
  enum enum_field_types m_type;
880
  sp_lex_keeper m_lex_keeper;
881

882 883 884 885 886 887 888 889 890 891
}; // 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:

892 893
  sp_instr_hpush_jump(uint ip, sp_pcontext *ctx, int htype, uint fp)
    : sp_instr_jump(ip, ctx), m_type(htype), m_frame(fp)
894 895 896 897 898 899 900 901 902 903 904
  {
    m_cond.empty();
  }

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

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

905 906
  virtual void print(String *str);

907
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);
908

909
  /* Override sp_instr_jump's shortcut; we stop here. */
910
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
911 912 913 914
  {
    return m_ip;
  }

915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
  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:

936 937
  sp_instr_hpop(uint ip, sp_pcontext *ctx, uint count)
    : sp_instr(ip, ctx), m_count(count)
938 939 940 941 942 943 944
  {}

  virtual ~sp_instr_hpop()
  {}

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

945 946
  virtual void print(String *str);

947 948 949 950 951 952 953
private:

  uint m_count;

}; // class sp_instr_hpop : public sp_instr


954
class sp_instr_hreturn : public sp_instr_jump
955 956 957 958 959 960
{
  sp_instr_hreturn(const sp_instr_hreturn &);	/* Prevent use of these */
  void operator=(sp_instr_hreturn &);

public:

961
  sp_instr_hreturn(uint ip, sp_pcontext *ctx, uint fp)
962
    : sp_instr_jump(ip, ctx), m_frame(fp)
963 964 965 966 967 968 969
  {}

  virtual ~sp_instr_hreturn()
  {}

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

970 971
  virtual void print(String *str);

972
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);
973

974 975 976 977
private:

  uint m_frame;

978
}; // class sp_instr_hreturn : public sp_instr_jump
979

980

981
/* This is DECLARE CURSOR */
982 983 984 985 986 987 988
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
989 990
  sp_instr_cpush(uint ip, sp_pcontext *ctx, LEX *lex, uint offset)
    : sp_instr(ip, ctx), m_lex_keeper(lex, TRUE), m_cursor(offset)
991 992
  {}

993 994
  virtual ~sp_instr_cpush()
  {}
995 996 997

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

998 999
  virtual void print(String *str);

1000 1001 1002 1003 1004 1005
  /*
    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 */ }
1006 1007
private:

1008
  sp_lex_keeper m_lex_keeper;
pem@mysql.com's avatar
pem@mysql.com committed
1009
  uint m_cursor;                /* Frame offset (for debugging) */
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020

}; // 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:

1021 1022
  sp_instr_cpop(uint ip, sp_pcontext *ctx, uint count)
    : sp_instr(ip, ctx), m_count(count)
1023 1024 1025 1026 1027 1028 1029
  {}

  virtual ~sp_instr_cpop()
  {}

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

1030 1031
  virtual void print(String *str);

1032 1033 1034 1035 1036 1037 1038
private:

  uint m_count;

}; // class sp_instr_cpop : public sp_instr


1039
class sp_instr_copen : public sp_instr
1040 1041 1042 1043 1044 1045
{
  sp_instr_copen(const sp_instr_copen &); /* Prevent use of these */
  void operator=(sp_instr_copen &);

public:

1046
  sp_instr_copen(uint ip, sp_pcontext *ctx, uint c)
1047
    : sp_instr(ip, ctx), m_cursor(c)
1048 1049 1050 1051 1052 1053 1054
  {}

  virtual ~sp_instr_copen()
  {}

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

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

1057 1058
  virtual void print(String *str);

1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
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:

1073 1074
  sp_instr_cclose(uint ip, sp_pcontext *ctx, uint c)
    : sp_instr(ip, ctx), m_cursor(c)
1075 1076 1077 1078 1079 1080 1081
  {}

  virtual ~sp_instr_cclose()
  {}

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

1082 1083
  virtual void print(String *str);

1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
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:

1098 1099
  sp_instr_cfetch(uint ip, sp_pcontext *ctx, uint c)
    : sp_instr(ip, ctx), m_cursor(c)
1100 1101 1102 1103 1104 1105 1106 1107 1108
  {
    m_varlist.empty();
  }

  virtual ~sp_instr_cfetch()
  {}

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

1109 1110
  virtual void print(String *str);

1111
  void add_to_varlist(struct sp_variable *var)
1112 1113 1114 1115 1116 1117 1118
  {
    m_varlist.push_back(var);
  }

private:

  uint m_cursor;
1119
  List<struct sp_variable> m_varlist;
1120 1121 1122 1123

}; // class sp_instr_cfetch : public sp_instr


1124 1125 1126 1127 1128 1129 1130
class sp_instr_error : public sp_instr
{
  sp_instr_error(const sp_instr_error &); /* Prevent use of these */
  void operator=(sp_instr_error &);

public:

1131 1132
  sp_instr_error(uint ip, sp_pcontext *ctx, int errcode)
    : sp_instr(ip, ctx), m_errcode(errcode)
1133 1134 1135 1136 1137 1138 1139 1140 1141
  {}

  virtual ~sp_instr_error()
  {}

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

  virtual void print(String *str);

1142
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads)
1143 1144 1145 1146 1147
  {
    marked= 1;
    return UINT_MAX;
  }

1148 1149 1150 1151 1152 1153 1154
private:

  int m_errcode;

}; // class sp_instr_error : public sp_instr


1155
class sp_instr_set_case_expr : public sp_instr_opt_meta
1156 1157 1158 1159 1160
{
public:

  sp_instr_set_case_expr(uint ip, sp_pcontext *ctx, uint case_expr_id,
                         Item *case_expr, LEX *lex)
1161 1162 1163 1164 1165 1166
    : 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()
1167 1168 1169 1170 1171 1172 1173 1174
  {}

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

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

  virtual void print(String *str);

1175
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);
1176 1177 1178 1179 1180 1181 1182 1183 1184

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

1185 1186 1187 1188 1189 1190
private:

  uint m_case_expr_id;
  Item *m_case_expr;
  sp_lex_keeper m_lex_keeper;

1191
}; // class sp_instr_set_case_expr : public sp_instr_opt_meta
1192 1193


1194
#ifndef NO_EMBEDDED_ACCESS_CHECKS
1195 1196
bool
sp_change_security_context(THD *thd, sp_head *sp,
1197
                           Security_context **backup);
1198
void
1199
sp_restore_security_context(THD *thd, Security_context *backup);
1200 1201 1202 1203

bool
set_routine_security_ctx(THD *thd, sp_head *sp, bool is_proc,
                         Security_context **save_ctx);
1204
#endif /* NO_EMBEDDED_ACCESS_CHECKS */
1205

1206 1207 1208 1209
TABLE_LIST *
sp_add_to_query_tables(THD *thd, LEX *lex,
		       const char *db, const char *name,
		       thr_lock_type locktype);
1210 1211
Item *
sp_prepare_func_item(THD* thd, Item **it_addr);
1212

1213
bool
1214
sp_eval_expr(THD *thd, Field *result_field, Item **expr_item_ptr);
1215

1216
#endif /* _SP_HEAD_H_ */