src/pl/plpgsql/src/plpgsql.h

   1 /**********************************************************************
   2  * plpgsql.h            - Definitions for the PL/pgSQL
   3  *                        procedural language
   4  *
   5  * IDENTIFICATION
   6  *        $PostgreSQL: pgsql/src/pl/plpgsql/src/plpgsql.h,v 1.56 2004/09/16 16:58:44 tgl Exp $
   7  *
   8  *        This software is copyrighted by Jan Wieck - Hamburg.
   9  *
  10  *        The author hereby grants permission  to  use,  copy,  modify,
  11  *        distribute,  and      license this software and its documentation
  12  *        for any purpose, provided that existing copyright notices are
  13  *        retained      in      all  copies  and  that  this notice is included
  14  *        verbatim in any distributions. No written agreement, license,
  15  *        or  royalty  fee      is required for any of the authorized uses.
  16  *        Modifications to this software may be  copyrighted  by  their
  17  *        author  and  need  not  follow  the licensing terms described
  18  *        here, provided that the new terms are  clearly  indicated  on
  19  *        the first page of each file where they apply.
  20  *
  21  *        IN NO EVENT SHALL THE AUTHOR OR DISTRIBUTORS BE LIABLE TO ANY
  22  *        PARTY  FOR  DIRECT,   INDIRECT,       SPECIAL,   INCIDENTAL,   OR
  23  *        CONSEQUENTIAL   DAMAGES  ARISING      OUT  OF  THE  USE  OF  THIS
  24  *        SOFTWARE, ITS DOCUMENTATION, OR ANY DERIVATIVES THEREOF, EVEN
  25  *        IF  THE  AUTHOR  HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH
  26  *        DAMAGE.
  27  *
  28  *        THE  AUTHOR  AND      DISTRIBUTORS  SPECIFICALLY       DISCLAIM       ANY
  29  *        WARRANTIES,  INCLUDING,  BUT  NOT  LIMITED  TO,  THE  IMPLIED
  30  *        WARRANTIES  OF  MERCHANTABILITY,      FITNESS  FOR  A  PARTICULAR
  31  *        PURPOSE,      AND NON-INFRINGEMENT.  THIS SOFTWARE IS PROVIDED ON
  32  *        AN "AS IS" BASIS, AND THE AUTHOR      AND  DISTRIBUTORS  HAVE  NO
  33  *        OBLIGATION   TO       PROVIDE   MAINTENANCE,   SUPPORT,  UPDATES,
  34  *        ENHANCEMENTS, OR MODIFICATIONS.
  35  *
  36  **********************************************************************/
  37 #ifndef PLPGSQL_H
  38 #define PLPGSQL_H
  39
  40 #include "postgres.h"
  41
  42 #include "fmgr.h"
  43 #include "miscadmin.h"
  44 #include "executor/spi.h"
  45 #include "commands/trigger.h"
  46 #include "utils/tuplestore.h"
  47
  48 /**********************************************************************
  49  * Definitions
  50  **********************************************************************/
  51
  52 /* ----------
  53  * Compilers namestack item types
  54  * ----------
  55  */
  56 enum
  57 {
  58         PLPGSQL_NSTYPE_LABEL,
  59         PLPGSQL_NSTYPE_VAR,
  60         PLPGSQL_NSTYPE_ROW,
  61         PLPGSQL_NSTYPE_REC
  62 };
  63
  64 /* ----------
  65  * Datum array node types
  66  * ----------
  67  */
  68 enum
  69 {
  70         PLPGSQL_DTYPE_VAR,
  71         PLPGSQL_DTYPE_ROW,
  72         PLPGSQL_DTYPE_REC,
  73         PLPGSQL_DTYPE_RECFIELD,
  74         PLPGSQL_DTYPE_ARRAYELEM,
  75         PLPGSQL_DTYPE_EXPR,
  76         PLPGSQL_DTYPE_TRIGARG
  77 };
  78
  79 /* ----------
  80  * Variants distinguished in PLpgSQL_type structs
  81  * ----------
  82  */
  83 enum
  84 {
  85         PLPGSQL_TTYPE_SCALAR,           /* scalar types and domains */
  86         PLPGSQL_TTYPE_ROW,                      /* composite types */
  87         PLPGSQL_TTYPE_REC,                      /* RECORD pseudotype */
  88         PLPGSQL_TTYPE_PSEUDO            /* other pseudotypes */
  89 };
  90
  91 /* ----------
  92  * Execution tree node types
  93  * ----------
  94  */
  95 enum
  96 {
  97         PLPGSQL_STMT_BLOCK,
  98         PLPGSQL_STMT_ASSIGN,
  99         PLPGSQL_STMT_IF,
 100         PLPGSQL_STMT_LOOP,
 101         PLPGSQL_STMT_WHILE,
 102         PLPGSQL_STMT_FORI,
 103         PLPGSQL_STMT_FORS,
 104         PLPGSQL_STMT_SELECT,
 105         PLPGSQL_STMT_EXIT,
 106         PLPGSQL_STMT_RETURN,
 107         PLPGSQL_STMT_RETURN_NEXT,
 108         PLPGSQL_STMT_RAISE,
 109         PLPGSQL_STMT_EXECSQL,
 110         PLPGSQL_STMT_DYNEXECUTE,
 111         PLPGSQL_STMT_DYNFORS,
 112         PLPGSQL_STMT_GETDIAG,
 113         PLPGSQL_STMT_OPEN,
 114         PLPGSQL_STMT_FETCH,
 115         PLPGSQL_STMT_CLOSE,
 116         PLPGSQL_STMT_PERFORM
 117 };
 118
 119
 120 /* ----------
 121  * Execution node return codes
 122  * ----------
 123  */
 124 enum
 125 {
 126         PLPGSQL_RC_OK,
 127         PLPGSQL_RC_EXIT,
 128         PLPGSQL_RC_RETURN
 129 };
 130
 131 /* ----------
 132  * GET DIAGNOSTICS system attrs
 133  * ----------
 134  */
 135 enum
 136 {
 137         PLPGSQL_GETDIAG_ROW_COUNT,
 138         PLPGSQL_GETDIAG_RESULT_OID
 139 };
 140
 141
 142 /**********************************************************************
 143  * Node and structure definitions
 144  **********************************************************************/
 145
 146
 147 typedef struct
 148 {                                                               /* Dynamic string control structure */
 149         int                     alloc;
 150         int                     used;
 151         char       *value;
 152 } PLpgSQL_dstring;
 153
 154
 155 typedef struct
 156 {                                                               /* Postgres data type */
 157         char       *typname;            /* (simple) name of the type */
 158         Oid                     typoid;                 /* OID of the data type */
 159         int                     ttype;                  /* PLPGSQL_TTYPE_ code */
 160         int16           typlen;                 /* stuff copied from its pg_type entry */
 161         bool            typbyval;
 162         Oid                     typrelid;
 163         Oid                     typioparam;
 164         FmgrInfo        typinput;               /* lookup info for typinput function */
 165         int32           atttypmod;              /* typmod (taken from someplace else) */
 166 } PLpgSQL_type;
 167
 168
 169 /*
 170  * PLpgSQL_datum is the common supertype for PLpgSQL_expr, PLpgSQL_var,
 171  * PLpgSQL_row, PLpgSQL_rec, PLpgSQL_recfield, PLpgSQL_arrayelem, and
 172  * PLpgSQL_trigarg
 173  */
 174 typedef struct
 175 {                                                               /* Generic datum array item             */
 176         int                     dtype;
 177         int                     dno;
 178 } PLpgSQL_datum;
 179
 180 /*
 181  * The variants PLpgSQL_var, PLpgSQL_row, and PLpgSQL_rec share these
 182  * fields
 183  */
 184 typedef struct
 185 {                                                               /* Scalar or composite variable */
 186         int                     dtype;
 187         int                     dno;
 188         char       *refname;
 189         int                     lineno;
 190 } PLpgSQL_variable;
 191
 192 typedef struct PLpgSQL_expr
 193 {                                                               /* SQL Query to plan and execute        */
 194         int                     dtype;
 195         int                     exprno;
 196         char       *query;
 197         void       *plan;
 198         Oid                *plan_argtypes;
 199         /* fields for "simple expression" fast-path execution: */
 200         Expr       *expr_simple_expr;           /* NULL means not a simple expr */
 201         Oid                     expr_simple_type;
 202         /* if expr is simple AND in use in current xact, these fields are set: */
 203         ExprState  *expr_simple_state;
 204         struct PLpgSQL_expr *expr_simple_next;
 205         /* params to pass to expr */
 206         int                     nparams;
 207         int                     params[1];              /* VARIABLE SIZE ARRAY ... must be last */
 208 } PLpgSQL_expr;
 209
 210
 211 typedef struct
 212 {                                                               /* Scalar variable */
 213         int                     dtype;
 214         int                     varno;
 215         char       *refname;
 216         int                     lineno;
 217
 218         PLpgSQL_type *datatype;
 219         int                     isconst;
 220         int                     notnull;
 221         PLpgSQL_expr *default_val;
 222         PLpgSQL_expr *cursor_explicit_expr;
 223         int                     cursor_explicit_argrow;
 224
 225         Datum           value;
 226         bool            isnull;
 227         bool            freeval;
 228 } PLpgSQL_var;
 229
 230
 231 typedef struct
 232 {                                                               /* Row variable */
 233         int                     dtype;
 234         int                     rowno;
 235         char       *refname;
 236         int                     lineno;
 237
 238         TupleDesc       rowtupdesc;
 239
 240         /*
 241          * Note: TupleDesc is only set up for named rowtypes, else it is NULL.
 242          *
 243          * Note: if the underlying rowtype contains a dropped column, the
 244          * corresponding fieldnames[] entry will be NULL, and there is no
 245          * corresponding var (varnos[] will be -1).
 246          */
 247         int                     nfields;
 248         char      **fieldnames;
 249         int                *varnos;
 250 } PLpgSQL_row;
 251
 252
 253 typedef struct
 254 {                                                               /* Record variable (non-fixed structure) */
 255         int                     dtype;
 256         int                     recno;
 257         char       *refname;
 258         int                     lineno;
 259
 260         HeapTuple       tup;
 261         TupleDesc       tupdesc;
 262         bool            freetup;
 263         bool            freetupdesc;
 264 } PLpgSQL_rec;
 265
 266
 267 typedef struct
 268 {                                                               /* Field in record */
 269         int                     dtype;
 270         int                     rfno;
 271         char       *fieldname;
 272         int                     recparentno;    /* dno of parent record */
 273 } PLpgSQL_recfield;
 274
 275
 276 typedef struct
 277 {                                                               /* Element of array variable */
 278         int                     dtype;
 279         int                     dno;
 280         PLpgSQL_expr *subscript;
 281         int                     arrayparentno;  /* dno of parent array variable */
 282 } PLpgSQL_arrayelem;
 283
 284
 285 typedef struct
 286 {                                                               /* Positional argument to trigger       */
 287         int                     dtype;
 288         int                     dno;
 289         PLpgSQL_expr *argnum;
 290 } PLpgSQL_trigarg;
 291
 292
 293 typedef struct
 294 {                                                               /* Item in the compilers namestack      */
 295         int                     itemtype;
 296         int                     itemno;
 297         char            name[1];
 298 } PLpgSQL_nsitem;
 299
 300
 301 typedef struct PLpgSQL_ns
 302 {                                                               /* Compiler namestack level             */
 303         int                     items_alloc;
 304         int                     items_used;
 305         PLpgSQL_nsitem **items;
 306         struct PLpgSQL_ns *upper;
 307 } PLpgSQL_ns;
 308
 309
 310 typedef struct
 311 {                                                               /* Generic execution node               */
 312         int                     cmd_type;
 313         int                     lineno;
 314 } PLpgSQL_stmt;
 315
 316
 317 typedef struct
 318 {                                                               /* List of execution nodes              */
 319         int                     stmts_alloc;    /* XXX this oughta just be a List ... */
 320         int                     stmts_used;
 321         PLpgSQL_stmt **stmts;
 322 } PLpgSQL_stmts;
 323
 324
 325 typedef struct PLpgSQL_condition
 326 {                                                               /* One EXCEPTION condition name */
 327         int                     sqlerrstate;    /* SQLSTATE code */
 328         char       *condname;           /* condition name (for debugging) */
 329         struct PLpgSQL_condition *next;
 330 } PLpgSQL_condition;
 331
 332 typedef struct
 333 {                                                               /* One EXCEPTION ... WHEN clause */
 334         int                     lineno;
 335         PLpgSQL_condition *conditions;
 336         PLpgSQL_stmts *action;
 337 } PLpgSQL_exception;
 338
 339
 340 typedef struct
 341 {                                                               /* List of WHEN clauses                 */
 342         int                     exceptions_alloc;               /* XXX this oughta just be a List
 343                                                                                  * ... */
 344         int                     exceptions_used;
 345         PLpgSQL_exception **exceptions;
 346 } PLpgSQL_exceptions;
 347
 348
 349 typedef struct
 350 {                                                               /* Block of statements                  */
 351         int                     cmd_type;
 352         int                     lineno;
 353         char       *label;
 354         PLpgSQL_stmts *body;
 355         PLpgSQL_exceptions *exceptions;
 356         int                     n_initvars;
 357         int                *initvarnos;
 358 } PLpgSQL_stmt_block;
 359
 360
 361 typedef struct
 362 {                                                               /* Assign statement                     */
 363         int                     cmd_type;
 364         int                     lineno;
 365         int                     varno;
 366         PLpgSQL_expr *expr;
 367 } PLpgSQL_stmt_assign;
 368
 369 typedef struct
 370 {                                                               /* PERFORM statement            */
 371         int                     cmd_type;
 372         int                     lineno;
 373         PLpgSQL_expr *expr;
 374 } PLpgSQL_stmt_perform;
 375
 376 typedef struct
 377 {                                                               /* Get Diagnostics item         */
 378         int                     item;                   /* id for diagnostic value desired */
 379         int                     target;                 /* where to assign it */
 380 } PLpgSQL_diag_item;
 381
 382 typedef struct
 383 {                                                               /* Get Diagnostics statement            */
 384         int                     cmd_type;
 385         int                     lineno;
 386         int                     ndtitems;
 387         PLpgSQL_diag_item *dtitems;
 388 } PLpgSQL_stmt_getdiag;
 389
 390
 391 typedef struct
 392 {                                                               /* IF statement                         */
 393         int                     cmd_type;
 394         int                     lineno;
 395         PLpgSQL_expr *cond;
 396         PLpgSQL_stmts *true_body;
 397         PLpgSQL_stmts *false_body;
 398 } PLpgSQL_stmt_if;
 399
 400
 401 typedef struct
 402 {                                                               /* Unconditional LOOP statement         */
 403         int                     cmd_type;
 404         int                     lineno;
 405         char       *label;
 406         PLpgSQL_stmts *body;
 407 } PLpgSQL_stmt_loop;
 408
 409
 410 typedef struct
 411 {                                                               /* WHILE cond LOOP statement            */
 412         int                     cmd_type;
 413         int                     lineno;
 414         char       *label;
 415         PLpgSQL_expr *cond;
 416         PLpgSQL_stmts *body;
 417 } PLpgSQL_stmt_while;
 418
 419
 420 typedef struct
 421 {                                                               /* FOR statement with integer loopvar   */
 422         int                     cmd_type;
 423         int                     lineno;
 424         char       *label;
 425         PLpgSQL_var *var;
 426         PLpgSQL_expr *lower;
 427         PLpgSQL_expr *upper;
 428         int                     reverse;
 429         PLpgSQL_stmts *body;
 430 } PLpgSQL_stmt_fori;
 431
 432
 433 typedef struct
 434 {                                                               /* FOR statement running over SELECT    */
 435         int                     cmd_type;
 436         int                     lineno;
 437         char       *label;
 438         PLpgSQL_rec *rec;
 439         PLpgSQL_row *row;
 440         PLpgSQL_expr *query;
 441         PLpgSQL_stmts *body;
 442 } PLpgSQL_stmt_fors;
 443
 444
 445 typedef struct
 446 {                                                               /* FOR statement running over EXECUTE   */
 447         int                     cmd_type;
 448         int                     lineno;
 449         char       *label;
 450         PLpgSQL_rec *rec;
 451         PLpgSQL_row *row;
 452         PLpgSQL_expr *query;
 453         PLpgSQL_stmts *body;
 454 } PLpgSQL_stmt_dynfors;
 455
 456
 457 typedef struct
 458 {                                                               /* SELECT ... INTO statement            */
 459         int                     cmd_type;
 460         int                     lineno;
 461         PLpgSQL_rec *rec;
 462         PLpgSQL_row *row;
 463         PLpgSQL_expr *query;
 464 } PLpgSQL_stmt_select;
 465
 466
 467 typedef struct
 468 {                                                               /* OPEN a curvar                                        */
 469         int                     cmd_type;
 470         int                     lineno;
 471         int                     curvar;
 472         PLpgSQL_row *returntype;
 473         PLpgSQL_expr *argquery;
 474         PLpgSQL_expr *query;
 475         PLpgSQL_expr *dynquery;
 476 } PLpgSQL_stmt_open;
 477
 478
 479 typedef struct
 480 {                                                               /* FETCH curvar INTO statement          */
 481         int                     cmd_type;
 482         int                     lineno;
 483         PLpgSQL_rec *rec;
 484         PLpgSQL_row *row;
 485         int                     curvar;
 486 } PLpgSQL_stmt_fetch;
 487
 488
 489 typedef struct
 490 {                                                               /* CLOSE curvar                                         */
 491         int                     cmd_type;
 492         int                     lineno;
 493         int                     curvar;
 494 } PLpgSQL_stmt_close;
 495
 496
 497 typedef struct
 498 {                                                               /* EXIT statement                       */
 499         int                     cmd_type;
 500         int                     lineno;
 501         char       *label;
 502         PLpgSQL_expr *cond;
 503 } PLpgSQL_stmt_exit;
 504
 505
 506 typedef struct
 507 {                                                               /* RETURN statement                     */
 508         int                     cmd_type;
 509         int                     lineno;
 510         PLpgSQL_expr *expr;
 511         int                     retrecno;
 512         int                     retrowno;
 513 } PLpgSQL_stmt_return;
 514
 515 typedef struct
 516 {                                                               /* RETURN NEXT statement */
 517         int                     cmd_type;
 518         int                     lineno;
 519         PLpgSQL_rec *rec;
 520         PLpgSQL_row *row;
 521         PLpgSQL_expr *expr;
 522 } PLpgSQL_stmt_return_next;
 523
 524 typedef struct
 525 {                                                               /* RAISE statement                      */
 526         int                     cmd_type;
 527         int                     lineno;
 528         int                     elog_level;
 529         char       *message;
 530         int                     nparams;
 531         int                *params;
 532 } PLpgSQL_stmt_raise;
 533
 534
 535 typedef struct
 536 {                                                               /* Generic SQL statement to execute */
 537         int                     cmd_type;
 538         int                     lineno;
 539         PLpgSQL_expr *sqlstmt;
 540 } PLpgSQL_stmt_execsql;
 541
 542
 543 typedef struct
 544 {                                                               /* Dynamic SQL string to execute */
 545         int                     cmd_type;
 546         int                     lineno;
 547         PLpgSQL_expr *query;
 548 } PLpgSQL_stmt_dynexecute;
 549
 550
 551 typedef struct PLpgSQL_func_hashkey
 552 {                                                               /* Hash lookup key for functions */
 553         Oid                     funcOid;
 554
 555         /*
 556          * For a trigger function, the OID of the relation triggered on is
 557          * part of the hashkey --- we want to compile the trigger separately
 558          * for each relation it is used with, in case the rowtype is
 559          * different.  Zero if not called as a trigger.
 560          */
 561         Oid                     trigrelOid;
 562
 563         /*
 564          * We include actual argument types in the hash key to support
 565          * polymorphic PLpgSQL functions.  Be careful that extra positions are
 566          * zeroed!
 567          */
 568         Oid                     argtypes[FUNC_MAX_ARGS];
 569 } PLpgSQL_func_hashkey;
 570
 571
 572 typedef struct PLpgSQL_function
 573 {                                                               /* Complete compiled function     */
 574         char       *fn_name;
 575         Oid                     fn_oid;
 576         TransactionId fn_xmin;
 577         CommandId       fn_cmin;
 578         int                     fn_functype;
 579         PLpgSQL_func_hashkey *fn_hashkey;       /* back-link to hashtable key */
 580
 581         Oid                     fn_rettype;
 582         int                     fn_rettyplen;
 583         bool            fn_retbyval;
 584         FmgrInfo        fn_retinput;
 585         Oid                     fn_rettypioparam;
 586         bool            fn_retistuple;
 587         bool            fn_retset;
 588         bool            fn_readonly;
 589
 590         int                     fn_nargs;
 591         int                     fn_argvarnos[FUNC_MAX_ARGS];
 592         int                     found_varno;
 593         int                     new_varno;
 594         int                     old_varno;
 595         int                     tg_name_varno;
 596         int                     tg_when_varno;
 597         int                     tg_level_varno;
 598         int                     tg_op_varno;
 599         int                     tg_relid_varno;
 600         int                     tg_relname_varno;
 601         int                     tg_nargs_varno;
 602
 603         int                     ndatums;
 604         PLpgSQL_datum **datums;
 605         PLpgSQL_stmt_block *action;
 606 } PLpgSQL_function;
 607
 608
 609 typedef struct
 610 {                                                               /* Runtime execution data       */
 611         Datum           retval;
 612         bool            retisnull;
 613         Oid                     rettype;                /* type of current retval */
 614
 615         Oid                     fn_rettype;             /* info about declared function rettype */
 616         bool            retistuple;
 617         bool            retisset;
 618
 619         bool            readonly_func;
 620
 621         TupleDesc       rettupdesc;
 622         char       *exitlabel;
 623
 624         Tuplestorestate *tuple_store;           /* SRFs accumulate results here */
 625         MemoryContext tuple_store_cxt;
 626         ReturnSetInfo *rsi;
 627
 628         int                     trig_nargs;
 629         Datum      *trig_argv;
 630
 631         int                     found_varno;
 632         int                     ndatums;
 633         PLpgSQL_datum **datums;
 634
 635         /* temporary state for results from evaluation of query or expr */
 636         SPITupleTable *eval_tuptable;
 637         uint32          eval_processed;
 638         Oid                     eval_lastoid;
 639         ExprContext *eval_econtext;
 640
 641         /* status information for error context reporting */
 642         PLpgSQL_function *err_func; /* current func */
 643         PLpgSQL_stmt *err_stmt;         /* current stmt */
 644         const char *err_text;           /* additional state info */
 645 } PLpgSQL_execstate;
 646
 647
 648 /**********************************************************************
 649  * Global variable declarations
 650  **********************************************************************/
 651
 652 extern int      plpgsql_DumpExecTree;
 653 extern int      plpgsql_SpaceScanned;
 654 extern int      plpgsql_nDatums;
 655 extern PLpgSQL_datum **plpgsql_Datums;
 656
 657 extern int      plpgsql_error_lineno;
 658 extern char *plpgsql_error_funcname;
 659
 660 /* linkage to the real yytext variable */
 661 extern char *plpgsql_base_yytext;
 662
 663 #define plpgsql_yytext plpgsql_base_yytext
 664
 665 extern PLpgSQL_function *plpgsql_curr_compile;
 666
 667 /**********************************************************************
 668  * Function declarations
 669  **********************************************************************/
 670
 671 /* ----------
 672  * Functions in pl_comp.c
 673  * ----------
 674  */
 675 extern PLpgSQL_function *plpgsql_compile(FunctionCallInfo fcinfo,
 676                                 bool forValidator);
 677 extern int      plpgsql_parse_word(char *word);
 678 extern int      plpgsql_parse_dblword(char *word);
 679 extern int      plpgsql_parse_tripword(char *word);
 680 extern int      plpgsql_parse_wordtype(char *word);
 681 extern int      plpgsql_parse_dblwordtype(char *word);
 682 extern int      plpgsql_parse_tripwordtype(char *word);
 683 extern int      plpgsql_parse_wordrowtype(char *word);
 684 extern int      plpgsql_parse_dblwordrowtype(char *word);
 685 extern PLpgSQL_type *plpgsql_parse_datatype(const char *string);
 686 extern PLpgSQL_type *plpgsql_build_datatype(Oid typeOid, int32 typmod);
 687 extern PLpgSQL_variable *plpgsql_build_variable(char *refname, int lineno,
 688                                            PLpgSQL_type *dtype,
 689                                            bool add2namespace);
 690 extern PLpgSQL_condition *plpgsql_parse_err_condition(char *condname);
 691 extern void plpgsql_adddatum(PLpgSQL_datum *new);
 692 extern int      plpgsql_add_initdatums(int **varnos);
 693 extern void plpgsql_HashTableInit(void);
 694
 695 /* ----------
 696  * Functions in pl_handler.c
 697  * ----------
 698  */
 699 extern void plpgsql_init(void);
 700 extern Datum plpgsql_call_handler(PG_FUNCTION_ARGS);
 701 extern Datum plpgsql_validator(PG_FUNCTION_ARGS);
 702
 703 /* ----------
 704  * Functions in pl_exec.c
 705  * ----------
 706  */
 707 extern Datum plpgsql_exec_function(PLpgSQL_function *func,
 708                                           FunctionCallInfo fcinfo);
 709 extern HeapTuple plpgsql_exec_trigger(PLpgSQL_function *func,
 710                                          TriggerData *trigdata);
 711 extern void plpgsql_xact_cb(XactEvent event, void *arg);
 712
 713 /* ----------
 714  * Functions for the dynamic string handling in pl_funcs.c
 715  * ----------
 716  */
 717 extern void plpgsql_dstring_init(PLpgSQL_dstring *ds);
 718 extern void plpgsql_dstring_free(PLpgSQL_dstring *ds);
 719 extern void plpgsql_dstring_append(PLpgSQL_dstring *ds, const char *str);
 720 extern char *plpgsql_dstring_get(PLpgSQL_dstring *ds);
 721
 722 /* ----------
 723  * Functions for the namestack handling in pl_funcs.c
 724  * ----------
 725  */
 726 extern void plpgsql_ns_init(void);
 727 extern bool plpgsql_ns_setlocal(bool flag);
 728 extern void plpgsql_ns_push(char *label);
 729 extern void plpgsql_ns_pop(void);
 730 extern void plpgsql_ns_additem(int itemtype, int itemno, char *name);
 731 extern PLpgSQL_nsitem *plpgsql_ns_lookup(char *name, char *nsname);
 732 extern void plpgsql_ns_rename(char *oldname, char *newname);
 733
 734 /* ----------
 735  * Other functions in pl_funcs.c
 736  * ----------
 737  */
 738 extern void plpgsql_convert_ident(const char *s, char **output, int numidents);
 739 extern const char *plpgsql_stmt_typename(PLpgSQL_stmt *stmt);
 740 extern void plpgsql_dumptree(PLpgSQL_function *func);
 741
 742 /* ----------
 743  * Externs in gram.y and scan.l
 744  * ----------
 745  */
 746 extern PLpgSQL_expr *plpgsql_read_expression(int until, const char *expected);
 747 extern int      plpgsql_yyparse(void);
 748 extern int      plpgsql_base_yylex(void);
 749 extern int      plpgsql_yylex(void);
 750 extern void plpgsql_push_back_token(int token);
 751 extern void plpgsql_yyerror(const char *message);
 752 extern int      plpgsql_scanner_lineno(void);
 753 extern void plpgsql_scanner_init(const char *str, int functype);
 754 extern void plpgsql_scanner_finish(void);
 755 extern char *plpgsql_get_string_value(void);
 756
 757 #endif   /* PLPGSQL_H */