sp_head.h 30.7 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
unknown's avatar
unknown committed
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
  bool       m_explicit_name;                   /**< Prepend the db name? */
63

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

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

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

94 95 96 97
  ~sp_name()
  {}
};

98

99
bool
100
check_routine_name(LEX_STRING *ident);
101

unknown's avatar
unknown committed
102
class sp_head :private Query_arena
103 104 105 106
{
  sp_head(const sp_head &);	/* Prevent use of these */
  void operator=(sp_head &);

107
  MEM_ROOT main_mem_root;
108
public:
109
  /* Possible values of m_flags */
110
  enum {
111 112 113
    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
114
    IS_INVOKED= 32,             // Is set if this sp_head is being used
115 116
    HAS_SET_AUTOCOMMIT_STMT= 64,// Is set if a procedure with 'set autocommit'
    /* Is set if a procedure with COMMIT (implicit or explicit) | ROLLBACK */
unknown's avatar
unknown committed
117
    HAS_COMMIT_OR_ROLLBACK= 128,
118
    LOG_SLOW_STATEMENTS= 256,   // Used by events
unknown's avatar
unknown committed
119
    LOG_GENERAL_LOG= 512,        // Used by events
unknown's avatar
unknown committed
120
    BINLOG_ROW_BASED_IF_MIXED= 1024,
121 122
    HAS_SQLCOM_RESET= 2048,
    HAS_SQLCOM_FLUSH= 4096
123
  };
124

125 126
  /* TYPE_ENUM_FUNCTION, TYPE_ENUM_PROCEDURE or TYPE_ENUM_TRIGGER */
  int m_type;
127
  uint m_flags;                 // Boolean attributes of a stored routine
128

unknown's avatar
unknown committed
129
  Create_field m_return_field_def; /* This is used for FUNCTIONs only. */
130

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

private:
183
  const char *m_body_begin;
184

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

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

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

198 199 200 201
  sp_head();

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

204 205 206 207
  /* Copy sp name from parser. */
  void
  init_sp_name(THD *thd, sp_name *spname);

208 209
  // Initialize strings after parsing header
  void
210
  init_strings(THD *thd, LEX *lex);
unknown's avatar
unknown committed
211

212 213
  int
  create(THD *thd);
214

215 216
  virtual ~sp_head();

217 218 219 220
  // Free memory
  void
  destroy();

221
  bool
222 223 224 225
  execute_trigger(THD *thd,
                  const LEX_STRING *db_name,
                  const LEX_STRING *table_name,
                  GRANT_INFO *grant_info);
226

227 228
  bool
  execute_function(THD *thd, Item **args, uint argcount, Field *return_fld);
229

230
  bool
231
  execute_procedure(THD *thd, List<Item> *args);
232

unknown's avatar
unknown committed
233 234
  bool
  show_create_routine(THD *thd, int type);
unknown's avatar
unknown committed
235

236 237
  void
  add_instr(sp_instr *instr);
238 239 240 241 242 243 244

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

245 246 247 248 249
  inline sp_instr *
  last_instruction()
  {
    sp_instr *i;

250
    get_dynamic(&m_instr, (uchar*)&i, m_instr.elements-1);
251 252 253
    return i;
  }

254 255 256 257 258 259 260 261 262
  // 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);

263
  // Put the instruction on the backpatch list, associated with the label.
264
  void
265
  push_backpatch(sp_instr *, struct sp_label *);
266

267 268
  // Update all instruction with this label in the backpatch list to
  // the current position.
269
  void
270
  backpatch(struct sp_label *);
271

272 273
  // Start a new cont. backpatch level. If 'i' is NULL, the level is just incr.
  void
274
  new_cont_backpatch(sp_instr_opt_meta *i);
275 276 277

  // Add an instruction to the current level
  void
278
  add_cont_backpatch(sp_instr_opt_meta *i);
279 280 281 282 283

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

284 285 286
  char *name(uint *lenp = 0) const
  {
    if (lenp)
287 288
      *lenp= m_name.length;
    return m_name.str;
289 290
  }

291 292
  char *create_string(THD *thd, ulong *lenp);

293 294 295 296 297
  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,
unknown's avatar
unknown committed
298
                             Create_field *field_def);
299

300
  void set_info(longlong created, longlong modified,
301
		st_sp_chistics *chistics, ulong sql_mode);
302

303 304
  void set_body_begin_ptr(Lex_input_stream *lip, const char *begin_ptr);

unknown's avatar
unknown committed
305
  void set_definer(const char *definer, uint definerlen);
306
  void set_definer(const LEX_STRING *user_name, const LEX_STRING *host_name);
307

308 309 310
  void reset_thd_mem_root(THD *thd);

  void restore_thd_mem_root(THD *thd);
311

312 313 314
  /**
    Optimize the code.
  */
315
  void optimize();
316 317 318 319 320 321 322 323 324

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

unknown's avatar
unknown committed
326
  void recursion_level_error(THD *thd);
327

328 329 330 331 332 333
  inline sp_instr *
  get_instr(uint i)
  {
    sp_instr *ip;

    if (i < m_instr.elements)
334
      get_dynamic(&m_instr, (uchar*)&ip, i);
335 336 337 338
    else
      ip= NULL;
    return ip;
  }
unknown's avatar
unknown committed
339

340 341
  /* Add tables used by routine to the table list. */
  bool add_used_tables_to_table_list(THD *thd,
342 343
                                     TABLE_LIST ***query_tables_last_ptr,
                                     TABLE_LIST *belong_to_view);
344

345 346 347 348 349 350 351 352 353 354 355
  /*
    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);
356 357
    else if (m_flags & HAS_SET_AUTOCOMMIT_STMT)
      my_error(ER_SP_CANT_SET_AUTOCOMMIT, MYF(0));
358
    else if (m_flags & HAS_COMMIT_OR_ROLLBACK)
359
      my_error(ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG, MYF(0));
360 361 362 363 364
    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");

365
    return test(m_flags &
366 367
		(CONTAINS_DYNAMIC_SQL|MULTI_RESULTS|HAS_SET_AUTOCOMMIT_STMT|
                 HAS_COMMIT_OR_ROLLBACK|HAS_SQLCOM_RESET|HAS_SQLCOM_FLUSH));
368
  }
unknown's avatar
unknown committed
369 370 371 372 373

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

unknown's avatar
unknown committed
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
  /*
    This method is intended for attributes of a routine which need
    to propagate upwards to the LEX of the caller (when a property of a
    sp_head needs to "taint" the caller).
  */
  void propagate_attributes(LEX *lex)
  {
    /*
      If this routine needs row-based binary logging, the entire top statement
      too (we cannot switch from statement-based to row-based only for this
      routine, as in statement-based the top-statement may be binlogged and
      the substatements not).
    */
    if (m_flags & BINLOG_ROW_BASED_IF_MIXED)
      lex->binlog_row_based_if_mixed= TRUE;
  }

unknown's avatar
unknown committed
391

392 393
private:

unknown's avatar
unknown committed
394
  MEM_ROOT *m_thd_root;		// Temp. store for thd's mem_root
395
  THD *m_thd;			// Set if we have reset mem_root
396

397
  sp_pcontext *m_pcont;		// Parse context
398
  List<LEX> m_lex;		// Temp. store for the other lex
399
  DYNAMIC_ARRAY m_instr;	// The "instructions"
400 401 402 403 404
  typedef struct
  {
    struct sp_label *lab;
    sp_instr *instr;
  } bp_t;
405
  List<bp_t> m_backpatch;	// Instructions needing backpatching
406
  /*
407
    We need a special list for backpatching of instructions with a continue
408 409
    destination (in the case of a continue handler catching an error in
    the test), since it would otherwise interfere with the normal backpatch
410
    mechanism - e.g. jump_if_not instructions have two different destinations
411 412 413 414
    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.
   */
415
  List<sp_instr_opt_meta> m_cont_backpatch;
416 417
  uint m_cont_level;            // The current cont. backpatch level

418 419 420
  /*
    Multi-set representing optimized list of tables to be locked by this
    routine. Does not include tables which are used by invoked routines.
421 422 423 424

    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.
425 426
  */
  HASH m_sptabs;
427

428
  bool
429 430
  execute(THD *thd);

431 432 433 434 435 436
  /**
    Perform a forward flow analysis in the generated code.
    Mark reachable instructions, for the optimizer.
  */
  void opt_mark();

437 438 439 440 441
  /*
    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);
442 443 444
}; // class sp_head : public Sql_alloc


445 446 447 448
//
// "Instructions"...
//

449
class sp_instr :public Query_arena, public Sql_alloc
450 451 452 453 454 455
{
  sp_instr(const sp_instr &);	/* Prevent use of these */
  void operator=(sp_instr &);

public:

456 457
  uint marked;
  uint m_ip;			// My index
458
  sp_pcontext *m_ctx;		// My parse context
459

460
  // Should give each a name or type code for debugging purposes?
461
  sp_instr(uint ip, sp_pcontext *ctx)
462
    :Query_arena(0, INITIALIZED_FOR_SP), marked(0), m_ip(ip), m_ctx(ctx)
463 464 465
  {}

  virtual ~sp_instr()
466
  { free_items(); }
467

468 469 470 471 472 473 474 475 476

  /*
    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
477 478 479 480 481 482 483
                    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
484
  */
485

486 487
  virtual int execute(THD *thd, uint *nextp) = 0;

488 489 490 491 492 493 494 495 496
  /**
    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.
  */
497
  int exec_open_and_lock_tables(THD *thd, TABLE_LIST *tables);
498 499 500

  /**
    Get the continuation destination of this instruction.
501
    @return the continuation destination
502
  */
503
  virtual uint get_cont_dest();
504

505 506 507 508 509 510 511
  /*
    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
512
    sp_lex_keeper class and its descendants (there are none currently).
513 514 515
  */
  virtual int exec_core(THD *thd, uint *nextp);

516
  virtual void print(String *str) = 0;
517

518
  virtual void backpatch(uint dest, sp_pcontext *dst_ctx)
519
  {}
520

521 522
  /*
    Mark this instruction as reachable during optimization and return the
523 524
    index to the next instruction. Jump instruction will add their
    destination to the leads list.
525
  */
526
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads)
527 528 529 530 531
  {
    marked= 1;
    return m_ip+1;
  }

532 533 534 535 536 537
  /*
    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.
  */
538
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
539 540 541 542
  {
    return m_ip;
  }

543 544 545 546 547 548
  /*
    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'.
  */
549 550 551 552
  virtual void opt_move(uint dst, List<sp_instr> *ibp)
  {
    m_ip= dst;
  }
553

554 555 556
}; // class sp_instr : public Sql_alloc


557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576
/*
  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)
577 578
    : m_lex(lex), m_lex_resp(lex_resp), 
      lex_query_tables_own_last(NULL)
579 580 581 582 583 584
  {
    lex->sp_lex_in_use= TRUE;
  }
  virtual ~sp_lex_keeper()
  {
    if (m_lex_resp)
585 586
    {
      lex_end(m_lex);
587
      delete m_lex;
588
    }
589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
  }

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

604 605 606 607
  void disable_query_cache()
  {
    m_lex->safe_to_cache_query= 0;
  }
608 609 610 611 612 613 614 615
private:

  LEX *m_lex;
  /*
    Indicates whenever this sp_lex_keeper instance responsible
    for LEX deletion.
  */
  bool m_lex_resp;
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634

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


638 639 640 641 642 643 644 645 646 647
//
// 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:

648 649
  LEX_STRING m_query;		// For thd->query

650 651
  sp_instr_stmt(uint ip, sp_pcontext *ctx, LEX *lex)
    : sp_instr(ip, ctx), m_lex_keeper(lex, TRUE)
652 653 654 655
  {
    m_query.str= 0;
    m_query.length= 0;
  }
656

657 658
  virtual ~sp_instr_stmt()
  {};
659

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

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

664
  virtual void print(String *str);
665

666 667
private:

668
  sp_lex_keeper m_lex_keeper;
669 670 671 672 673 674 675 676 677 678 679

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

680
  sp_instr_set(uint ip, sp_pcontext *ctx,
681
	       uint offset, Item *val, enum enum_field_types type_arg,
682
               LEX *lex, bool lex_resp)
683
    : sp_instr(ip, ctx), m_offset(offset), m_value(val), m_type(type_arg),
684
      m_lex_keeper(lex, lex_resp)
685 686 687 688 689
  {}

  virtual ~sp_instr_set()
  {}

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

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

694 695
  virtual void print(String *str);

696 697
private:

698
  uint m_offset;		// Frame offset
699 700
  Item *m_value;
  enum enum_field_types m_type;	// The declared type
701
  sp_lex_keeper m_lex_keeper;
702 703 704

}; // class sp_instr_set : public sp_instr

705

706 707 708 709 710 711 712 713 714 715
/*
  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:

unknown's avatar
unknown committed
716
  sp_instr_set_trigger_field(uint ip, sp_pcontext *ctx,
717 718
                             Item_trigger_field *trg_fld,
                             Item *val, LEX *lex)
unknown's avatar
unknown committed
719
    : sp_instr(ip, ctx),
720
      trigger_field(trg_fld),
721
      value(val), m_lex_keeper(lex, TRUE)
722 723 724 725 726 727 728
  {}

  virtual ~sp_instr_set_trigger_field()
  {}

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

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

731 732
  virtual void print(String *str);

733
private:
734
  Item_trigger_field *trigger_field;
735
  Item *value;
736
  sp_lex_keeper m_lex_keeper;
737 738 739
}; // class sp_instr_trigger_field : public sp_instr


740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
/*
  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;

769
  virtual uint get_cont_dest();
770

771 772 773 774 775 776 777 778
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
779 780 781 782 783 784
{
  sp_instr_jump(const sp_instr_jump &);	/* Prevent use of these */
  void operator=(sp_instr_jump &);

public:

785
  sp_instr_jump(uint ip, sp_pcontext *ctx)
786
    : sp_instr_opt_meta(ip, ctx)
787 788
  {}

789
  sp_instr_jump(uint ip, sp_pcontext *ctx, uint dest)
790
    : sp_instr_opt_meta(ip, ctx, dest)
791 792 793 794 795
  {}

  virtual ~sp_instr_jump()
  {}

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

798 799
  virtual void print(String *str);

800
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);
801

802
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start);
803 804 805

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

806
  virtual void backpatch(uint dest, sp_pcontext *dst_ctx)
807
  {
808 809
    if (m_dest == 0)		// Don't reset
      m_dest= dest;
810 811
  }

812 813 814
  /*
    Update the destination; used by the optimizer.
  */
815
  virtual void set_destination(uint old_dest, uint new_dest)
816
  {
817 818
    if (m_dest == old_dest)
      m_dest= new_dest;
819 820
  }

821
}; // class sp_instr_jump : public sp_instr_opt_meta
822 823 824 825 826 827 828 829 830


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:

831
  sp_instr_jump_if_not(uint ip, sp_pcontext *ctx, Item *i, LEX *lex)
832 833
    : sp_instr_jump(ip, ctx), m_expr(i),
      m_lex_keeper(lex, TRUE)
834 835
  {}

836
  sp_instr_jump_if_not(uint ip, sp_pcontext *ctx, Item *i, uint dest, LEX *lex)
837 838
    : sp_instr_jump(ip, ctx, dest), m_expr(i),
      m_lex_keeper(lex, TRUE)
839 840 841 842 843 844 845
  {}

  virtual ~sp_instr_jump_if_not()
  {}

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

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

848 849
  virtual void print(String *str);

850
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);
851

852
  /* Override sp_instr_jump's shortcut; we stop here */
853
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
854 855 856 857
  {
    return m_ip;
  }

858 859 860 861 862 863 864 865 866
  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;
  }

867 868 869
private:

  Item *m_expr;			// The condition
870
  sp_lex_keeper m_lex_keeper;
871 872 873

}; // class sp_instr_jump_if_not : public sp_instr_jump

874

875
class sp_instr_freturn : public sp_instr
876
{
877 878
  sp_instr_freturn(const sp_instr_freturn &);	/* Prevent use of these */
  void operator=(sp_instr_freturn &);
879 880 881

public:

882
  sp_instr_freturn(uint ip, sp_pcontext *ctx,
883 884 885
		   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)
886 887
  {}

888
  virtual ~sp_instr_freturn()
889 890 891 892
  {}

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

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

895 896
  virtual void print(String *str);

897
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads)
898 899 900 901 902
  {
    marked= 1;
    return UINT_MAX;
  }

903 904 905 906
protected:

  Item *m_value;
  enum enum_field_types m_type;
907
  sp_lex_keeper m_lex_keeper;
908

909 910 911 912 913 914 915 916 917 918
}; // 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:

919 920
  sp_instr_hpush_jump(uint ip, sp_pcontext *ctx, int htype, uint fp)
    : sp_instr_jump(ip, ctx), m_type(htype), m_frame(fp)
921 922 923 924 925 926 927 928 929 930 931
  {
    m_cond.empty();
  }

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

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

932 933
  virtual void print(String *str);

934
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);
935

936
  /* Override sp_instr_jump's shortcut; we stop here. */
937
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
938 939 940 941
  {
    return m_ip;
  }

942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
  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:

963 964
  sp_instr_hpop(uint ip, sp_pcontext *ctx, uint count)
    : sp_instr(ip, ctx), m_count(count)
965 966 967 968 969 970 971
  {}

  virtual ~sp_instr_hpop()
  {}

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

972 973
  virtual void print(String *str);

974 975 976 977 978 979 980
private:

  uint m_count;

}; // class sp_instr_hpop : public sp_instr


981
class sp_instr_hreturn : public sp_instr_jump
982 983 984 985 986 987
{
  sp_instr_hreturn(const sp_instr_hreturn &);	/* Prevent use of these */
  void operator=(sp_instr_hreturn &);

public:

988
  sp_instr_hreturn(uint ip, sp_pcontext *ctx, uint fp)
989
    : sp_instr_jump(ip, ctx), m_frame(fp)
990 991 992 993 994 995 996
  {}

  virtual ~sp_instr_hreturn()
  {}

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

997 998
  virtual void print(String *str);

999 1000 1001 1002 1003 1004
  /* This instruction will not be short cut optimized. */
  virtual uint opt_shortcut_jump(sp_head *sp, sp_instr *start)
  {
    return m_ip;
  }

1005
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);
1006

1007 1008 1009 1010
private:

  uint m_frame;

1011
}; // class sp_instr_hreturn : public sp_instr_jump
1012

1013

1014
/* This is DECLARE CURSOR */
1015 1016 1017 1018 1019 1020 1021
class sp_instr_cpush : public sp_instr
{
  sp_instr_cpush(const sp_instr_cpush &); /* Prevent use of these */
  void operator=(sp_instr_cpush &);

public:

unknown's avatar
unknown committed
1022 1023
  sp_instr_cpush(uint ip, sp_pcontext *ctx, LEX *lex, uint offset)
    : sp_instr(ip, ctx), m_lex_keeper(lex, TRUE), m_cursor(offset)
1024 1025
  {}

1026 1027
  virtual ~sp_instr_cpush()
  {}
1028 1029 1030

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

1031 1032
  virtual void print(String *str);

1033 1034 1035 1036 1037 1038
  /*
    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 */ }
1039 1040
private:

1041
  sp_lex_keeper m_lex_keeper;
unknown's avatar
unknown committed
1042
  uint m_cursor;                /* Frame offset (for debugging) */
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053

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

1054 1055
  sp_instr_cpop(uint ip, sp_pcontext *ctx, uint count)
    : sp_instr(ip, ctx), m_count(count)
1056 1057 1058 1059 1060 1061 1062
  {}

  virtual ~sp_instr_cpop()
  {}

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

1063 1064
  virtual void print(String *str);

1065 1066 1067 1068 1069 1070 1071
private:

  uint m_count;

}; // class sp_instr_cpop : public sp_instr


1072
class sp_instr_copen : public sp_instr
1073 1074 1075 1076 1077 1078
{
  sp_instr_copen(const sp_instr_copen &); /* Prevent use of these */
  void operator=(sp_instr_copen &);

public:

1079
  sp_instr_copen(uint ip, sp_pcontext *ctx, uint c)
1080
    : sp_instr(ip, ctx), m_cursor(c)
1081 1082 1083 1084 1085 1086 1087
  {}

  virtual ~sp_instr_copen()
  {}

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

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

1090 1091
  virtual void print(String *str);

1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
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:

1106 1107
  sp_instr_cclose(uint ip, sp_pcontext *ctx, uint c)
    : sp_instr(ip, ctx), m_cursor(c)
1108 1109 1110 1111 1112 1113 1114
  {}

  virtual ~sp_instr_cclose()
  {}

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

1115 1116
  virtual void print(String *str);

1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
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:

1131 1132
  sp_instr_cfetch(uint ip, sp_pcontext *ctx, uint c)
    : sp_instr(ip, ctx), m_cursor(c)
1133 1134 1135 1136 1137 1138 1139 1140 1141
  {
    m_varlist.empty();
  }

  virtual ~sp_instr_cfetch()
  {}

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

1142 1143
  virtual void print(String *str);

1144
  void add_to_varlist(struct sp_variable *var)
1145 1146 1147 1148 1149 1150 1151
  {
    m_varlist.push_back(var);
  }

private:

  uint m_cursor;
1152
  List<struct sp_variable> m_varlist;
1153 1154 1155 1156

}; // class sp_instr_cfetch : public sp_instr


1157 1158 1159 1160 1161 1162 1163
class sp_instr_error : public sp_instr
{
  sp_instr_error(const sp_instr_error &); /* Prevent use of these */
  void operator=(sp_instr_error &);

public:

1164 1165
  sp_instr_error(uint ip, sp_pcontext *ctx, int errcode)
    : sp_instr(ip, ctx), m_errcode(errcode)
1166 1167 1168 1169 1170 1171 1172 1173 1174
  {}

  virtual ~sp_instr_error()
  {}

  virtual int execute(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
  {
    marked= 1;
    return UINT_MAX;
  }

1181 1182 1183 1184 1185 1186 1187
private:

  int m_errcode;

}; // class sp_instr_error : public sp_instr


1188
class sp_instr_set_case_expr : public sp_instr_opt_meta
1189 1190 1191 1192 1193
{
public:

  sp_instr_set_case_expr(uint ip, sp_pcontext *ctx, uint case_expr_id,
                         Item *case_expr, LEX *lex)
1194 1195 1196 1197 1198 1199
    : 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()
1200 1201 1202 1203 1204 1205 1206 1207
  {}

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

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

  virtual void print(String *str);

1208
  virtual uint opt_mark(sp_head *sp, List<sp_instr> *leads);
1209 1210 1211 1212 1213 1214 1215 1216 1217

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

1218 1219 1220 1221 1222 1223
private:

  uint m_case_expr_id;
  Item *m_case_expr;
  sp_lex_keeper m_lex_keeper;

1224
}; // class sp_instr_set_case_expr : public sp_instr_opt_meta
1225 1226


1227
#ifndef NO_EMBEDDED_ACCESS_CHECKS
1228 1229
bool
sp_change_security_context(THD *thd, sp_head *sp,
1230
                           Security_context **backup);
1231
void
1232
sp_restore_security_context(THD *thd, Security_context *backup);
1233 1234 1235 1236

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

1239 1240 1241 1242
TABLE_LIST *
sp_add_to_query_tables(THD *thd, LEX *lex,
		       const char *db, const char *name,
		       thr_lock_type locktype);
1243 1244
Item *
sp_prepare_func_item(THD* thd, Item **it_addr);
1245

1246
bool
1247
sp_eval_expr(THD *thd, Field *result_field, Item **expr_item_ptr);
1248

1249
#endif /* _SP_HEAD_H_ */