Add error stack traceback support for SQL-language functions.

diff --git a/src/backend/executor/functions.c b/src/backend/executor/functions.c
index bda57fa32147cc69c257957f6f576c4efe02abd0..c8df7ccb83ca96f076627038b4c10aba90953013 100644 (file)
--- a/src/backend/executor/functions.c
+++ b/src/backend/executor/functions.c
@@ -1,14 +1,14 @@
 /*-------------------------------------------------------------------------
  *
  * functions.c
- *   Routines to handle functions called from the executor
+ *   Execution of SQL-language functions
  *
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/executor/functions.c,v 1.68 2003/07/21 17:05:09 tgl Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/executor/functions.c,v 1.69 2003/07/28 18:33:18 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -54,7 +54,6 @@ typedef struct local_es
  * An SQLFunctionCache record is built during the first call,
  * and linked to from the fn_extra field of the FmgrInfo struct.
  */
-
 typedef struct
 {
    int         typlen;         /* length of the return type */
@@ -88,6 +87,7 @@ static void postquel_sub_params(SQLFunctionCachePtr fcache,
 static Datum postquel_execute(execution_state *es,
                 FunctionCallInfo fcinfo,
                 SQLFunctionCachePtr fcache);
+static void sql_exec_error_callback(void *arg);
 static void ShutdownSQLFunction(Datum arg);
 
 
@@ -323,15 +323,15 @@ postquel_getnext(execution_state *es)
 static void
 postquel_end(execution_state *es)
 {
+   /* mark status done to ensure we don't do ExecutorEnd twice */
+   es->status = F_EXEC_DONE;
+
    /* Utility commands don't need Executor. */
    if (es->qd->operation != CMD_UTILITY)
        ExecutorEnd(es->qd);
 
    FreeQueryDesc(es->qd);
-
    es->qd = NULL;
-
-   es->status = F_EXEC_DONE;
 }
 
 /* Build ParamListInfo array representing current arguments */
@@ -492,6 +492,7 @@ fmgr_sql(PG_FUNCTION_ARGS)
 {
    MemoryContext oldcontext;
    SQLFunctionCachePtr fcache;
+   ErrorContextCallback sqlerrcontext;
    execution_state *es;
    Datum       result = 0;
 
@@ -502,6 +503,14 @@ fmgr_sql(PG_FUNCTION_ARGS)
     */
    oldcontext = MemoryContextSwitchTo(fcinfo->flinfo->fn_mcxt);
 
+   /*
+    * Setup error traceback support for ereport()
+    */
+   sqlerrcontext.callback = sql_exec_error_callback;
+   sqlerrcontext.arg = fcinfo->flinfo;
+   sqlerrcontext.previous = error_context_stack;
+   error_context_stack = &sqlerrcontext;
+
    /*
     * Initialize fcache (build plans) if first time through.
     */
@@ -580,6 +589,8 @@ fmgr_sql(PG_FUNCTION_ARGS)
            }
        }
 
+       error_context_stack = sqlerrcontext.previous;
+
        MemoryContextSwitchTo(oldcontext);
 
        return result;
@@ -618,11 +629,74 @@ fmgr_sql(PG_FUNCTION_ARGS)
        }
    }
 
+   error_context_stack = sqlerrcontext.previous;
+
    MemoryContextSwitchTo(oldcontext);
 
    return result;
 }
 
+
+/*
+ * error context callback to let us supply a call-stack traceback
+ */
+static void
+sql_exec_error_callback(void *arg)
+{
+   FmgrInfo   *flinfo = (FmgrInfo *) arg;
+   SQLFunctionCachePtr fcache = (SQLFunctionCachePtr) flinfo->fn_extra;
+   char       *fn_name;
+
+   fn_name = get_func_name(flinfo->fn_oid);
+   /* safety check, shouldn't happen */
+   if (fn_name == NULL)
+       return;
+
+   /*
+    * Try to determine where in the function we failed.  If there is a
+    * query with non-null QueryDesc, finger it.  (We check this rather
+    * than looking for F_EXEC_RUN state, so that errors during ExecutorStart
+    * or ExecutorEnd are blamed on the appropriate query; see postquel_start
+    * and postquel_end.)
+    */
+   if (fcache)
+   {
+       execution_state *es;
+       int     query_num;
+
+       es = fcache->func_state;
+       query_num = 1;
+       while (es)
+       {
+           if (es->qd)
+           {
+               errcontext("SQL function \"%s\" query %d",
+                          fn_name, query_num);
+               break;
+           }
+           es = es->next;
+           query_num++;
+       }
+       if (es == NULL)
+       {
+           /*
+            * couldn't identify a running query; might be function entry,
+            * function exit, or between queries.
+            */
+           errcontext("SQL function \"%s\"", fn_name);
+       }
+   }
+   else
+   {
+       /* must have failed during init_sql_fcache() */
+       errcontext("SQL function \"%s\" during startup", fn_name);
+   }
+
+   /* free result of get_func_name (in case this is only a notice) */
+   pfree(fn_name);
+}
+
+
 /*
  * callback function in case a function-returning-set needs to be shut down
  * before it has been run to completion

diff --git a/src/backend/optimizer/util/clauses.c b/src/backend/optimizer/util/clauses.c
index 5df7e1c3cb30a8c37b5476ff46e4395612b22f59..6060f462e8f4c1219cc139a1947447f77817f482 100644 (file)
--- a/src/backend/optimizer/util/clauses.c
+++ b/src/backend/optimizer/util/clauses.c
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *   $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.147 2003/07/25 00:01:08 tgl Exp $
+ *   $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.148 2003/07/28 18:33:18 tgl Exp $
  *
  * HISTORY
  *   AUTHOR            DATE            MAJOR EVENT
@@ -70,6 +70,7 @@ static Node *substitute_actual_parameters(Node *expr, int nargs, List *args,
                                          int *usecounts);
 static Node *substitute_actual_parameters_mutator(Node *node,
                     substitute_actual_parameters_context *context);
+static void sql_inline_error_callback(void *arg);
 static Expr *evaluate_expr(Expr *expr, Oid result_type);
 
 
@@ -1730,6 +1731,7 @@ inline_function(Oid funcid, Oid result_type, List *args,
    bool        isNull;
    MemoryContext oldcxt;
    MemoryContext mycxt;
+   ErrorContextCallback sqlerrcontext;
    List       *raw_parsetree_list;
    List       *querytree_list;
    Query      *querytree;
@@ -1780,6 +1782,15 @@ inline_function(Oid funcid, Oid result_type, List *args,
        }
    }
 
+   /*
+    * Setup error traceback support for ereport().  This is so that we can
+    * finger the function that bad information came from.
+    */
+   sqlerrcontext.callback = sql_inline_error_callback;
+   sqlerrcontext.arg = funcform;
+   sqlerrcontext.previous = error_context_stack;
+   error_context_stack = &sqlerrcontext;
+
    /*
     * Make a temporary memory context, so that we don't leak all the
     * stuff that parsing might create.
@@ -1926,12 +1937,15 @@ inline_function(Oid funcid, Oid result_type, List *args,
    newexpr = eval_const_expressions_mutator(newexpr,
                                             lconso(funcid, active_fns));
 
+   error_context_stack = sqlerrcontext.previous;
+
    return (Expr *) newexpr;
 
    /* Here if func is not inlinable: release temp memory and return NULL */
 fail:
    MemoryContextSwitchTo(oldcxt);
    MemoryContextDelete(mycxt);
+   error_context_stack = sqlerrcontext.previous;
 
    return NULL;
 }
@@ -1978,6 +1992,18 @@ substitute_actual_parameters_mutator(Node *node,
                                   (void *) context);
 }
 
+/*
+ * error context callback to let us supply a call-stack traceback
+ */
+static void
+sql_inline_error_callback(void *arg)
+{
+   Form_pg_proc funcform = (Form_pg_proc) arg;
+
+   errcontext("SQL function \"%s\" during inlining",
+              NameStr(funcform->proname));
+}
+
 /*
  * evaluate_expr: pre-evaluate a constant expression
  *