#include "postgres.h"
-#include "utils/elog.h"
-
/*
* This kludge is necessary because of the conflicting
* definitions of 'DEBUG' between postgres and perl.
* ENHANCEMENTS, OR MODIFICATIONS.
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plperl/plperl.c,v 1.36 2003/04/20 21:15:34 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plperl/plperl.c,v 1.37 2003/07/25 23:37:28 tgl Exp $
*
**********************************************************************/
/* postgreSQL stuff */
#include "executor/spi.h"
#include "commands/trigger.h"
-#include "utils/elog.h"
#include "fmgr.h"
#include "access/heapam.h"
#include "tcop/tcopprot.h"
plperl_interp = perl_alloc();
if (!plperl_interp)
- elog(ERROR, "plperl_init_interp(): could not allocate perl interpreter");
+ elog(ERROR, "could not allocate perl interpreter");
perl_construct(plperl_interp);
perl_parse(plperl_interp, plperl_init_shared_libs, 3, embedding, NULL);
* Connect to SPI manager
************************************************************/
if (SPI_connect() != SPI_OK_CONNECT)
- elog(ERROR, "plperl: cannot connect to SPI manager");
+ elog(ERROR, "could not connect to SPI manager");
/************************************************************
* Determine if called as function or trigger and
************************************************************/
if (CALLED_AS_TRIGGER(fcinfo))
{
- elog(ERROR, "plperl: can't use perl in triggers yet.");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("cannot use perl in triggers yet")));
/*
* retval = PointerGetDatum(plperl_trigger_handler(fcinfo));
PUTBACK;
FREETMPS;
LEAVE;
- elog(ERROR, "plperl: didn't get a return item from mksafefunc");
+ elog(ERROR, "didn't get a return item from mksafefunc");
}
if (SvTRUE(ERRSV))
* subref is our responsibility because it is not mortal
*/
SvREFCNT_dec(subref);
- elog(ERROR, "plperl_create_sub: didn't get a code ref");
+ elog(ERROR, "didn't get a code ref");
}
PUTBACK;
PUTBACK;
FREETMPS;
LEAVE;
- elog(ERROR, "plperl: didn't get a return item from function");
+ elog(ERROR, "didn't get a return item from function");
}
if (SvTRUE(ERRSV))
PUTBACK;
FREETMPS;
LEAVE;
- elog(ERROR, "plperl: error from function: %s", SvPV(ERRSV, PL_na));
+ elog(ERROR, "error from function: %s", SvPV(ERRSV, PL_na));
}
retval = newSVsv(POPs);
* because SPI_finish would free it).
************************************************************/
if (SPI_finish() != SPI_OK_FINISH)
- elog(ERROR, "plperl: SPI_finish() failed");
+ elog(ERROR, "SPI_finish() failed");
if (!(perlret && SvOK(perlret)))
{
ObjectIdGetDatum(fn_oid),
0, 0, 0);
if (!HeapTupleIsValid(procTup))
- elog(ERROR, "plperl: cache lookup for proc %u failed", fn_oid);
+ elog(ERROR, "cache lookup failed for function %u", fn_oid);
procStruct = (Form_pg_proc) GETSTRUCT(procTup);
/************************************************************
************************************************************/
prodesc = (plperl_proc_desc *) malloc(sizeof(plperl_proc_desc));
if (prodesc == NULL)
- elog(ERROR, "plperl: out of memory");
+ ereport(ERROR,
+ (errcode(ERRCODE_OUT_OF_MEMORY),
+ errmsg("out of memory")));
MemSet(prodesc, 0, sizeof(plperl_proc_desc));
prodesc->proname = strdup(internal_proname);
prodesc->fn_xmin = HeapTupleHeaderGetXmin(procTup->t_data);
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "plperl: cache lookup for language %u failed",
+ elog(ERROR, "cache lookup failed for language %u",
procStruct->prolang);
}
langStruct = (Form_pg_language) GETSTRUCT(langTup);
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "plperl: cache lookup for return type %u failed",
+ elog(ERROR, "cache lookup failed for type %u",
procStruct->prorettype);
}
typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "plperl functions cannot return type %s"
- "\n\texcept when used as triggers",
- format_type_be(procStruct->prorettype));
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("trigger functions may only be called as triggers")));
}
else
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "plperl functions cannot return type %s",
- format_type_be(procStruct->prorettype));
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("plperl functions cannot return type %s",
+ format_type_be(procStruct->prorettype))));
}
}
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "plperl: return types of tuples not supported yet");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("plperl functions cannot return tuples yet")));
}
perm_fmgr_info(typeStruct->typinput, &(prodesc->result_in_func));
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "plperl: cache lookup for argument type %u failed",
+ elog(ERROR, "cache lookup failed for type %u",
procStruct->proargtypes[i]);
}
typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "plperl functions cannot take type %s",
- format_type_be(procStruct->proargtypes[i]));
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("plperl functions cannot take type %s",
+ format_type_be(procStruct->proargtypes[i]))));
}
if (typeStruct->typrelid != InvalidOid)
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "plperl: cannot create internal procedure %s",
+ elog(ERROR, "could not create internal procedure \"%s\"",
internal_proname);
}
ObjectIdGetDatum(tupdesc->attrs[i]->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
- elog(ERROR, "plperl: Cache lookup for attribute '%s' type %u failed",
- attname, tupdesc->attrs[i]->atttypid);
+ elog(ERROR, "cache lookup failed for type %u",
+ tupdesc->attrs[i]->atttypid);
typoutput = ((Form_pg_type) GETSTRUCT(typeTup))->typoutput;
typelem = ((Form_pg_type) GETSTRUCT(typeTup))->typelem;
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/gram.y,v 1.44 2003/05/27 17:49:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/gram.y,v 1.45 2003/07/25 23:37:28 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
row->lineno = $1.lineno;
if ($2)
- elog(ERROR, "Rowtype variable cannot be CONSTANT");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("rowtype variable cannot be CONSTANT")));
if ($4)
- elog(ERROR, "Rowtype variable cannot be NOT NULL");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("rowtype variable cannot be NOT NULL")));
if ($5 != NULL)
- elog(ERROR, "Default value for rowtype variable is not supported");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("default value for rowtype variable is not supported")));
plpgsql_adddatum((PLpgSQL_datum *)row);
plpgsql_ns_additem(PLPGSQL_NSTYPE_ROW,
if (nsi == NULL)
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "function has no parameter %s", name);
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_PARAMETER),
+ errmsg("function has no parameter \"%s\"",
+ name)));
}
plpgsql_ns_setlocal(true);
new->row = (PLpgSQL_row *)$4;
break;
default:
- elog(ERROR, "unknown dtype %d in stmt_fors", $4->dtype);
+ elog(ERROR, "unrecognized dtype: %d",
+ $4->dtype);
}
new->query = $7;
new->body = $8;
new->row = (PLpgSQL_row *)$4;
break;
default:
- elog(ERROR, "unknown dtype %d in stmt_dynfors", $4->dtype);
+ elog(ERROR, "unrecognized dtype: %d",
+ $4->dtype);
}
new->query = $7;
new->body = $8;
if (tok != K_FOR)
{
plpgsql_error_lineno = $2;
- elog(ERROR, "syntax error at \"%s\" - expected FOR to open a reference cursor", yytext);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("syntax error at \"%s\"",
+ yytext),
+ errdetail("Expected FOR to open a reference cursor.")));
}
tok = yylex();
default:
plpgsql_error_lineno = $2;
- elog(ERROR, "syntax error at \"%s\"", yytext);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("syntax error at \"%s\"",
+ yytext)));
}
}
if (tok != '(')
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "cursor %s has arguments",
- $3->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("cursor \"%s\" has arguments",
+ $3->refname)));
}
/*
if (strncmp(cp, "SELECT", 6) != 0)
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "expected 'SELECT (', got '%s' (internal error)",
+ /* internal error */
+ elog(ERROR, "expected \"SELECT (\", got \"%s\"",
new->argquery->query);
}
cp += 6;
if (*cp != '(')
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "expected 'SELECT (', got '%s' (internal error)",
+ /* internal error */
+ elog(ERROR, "expected \"SELECT (\", got \"%s\"",
new->argquery->query);
}
*cp = ' ';
if (tok == '(')
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "cursor %s has no arguments", $3->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("cursor \"%s\" has no arguments",
+ $3->refname)));
}
if (tok != ';')
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "syntax error at \"%s\"", yytext);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("syntax error at \"%s\"",
+ yytext)));
}
}
}
if (((PLpgSQL_var *) yylval.variable)->datatype->typoid != REFCURSOROID)
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "%s must be of type cursor or refcursor",
- ((PLpgSQL_var *) yylval.variable)->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("\"%s\" must be of type cursor or refcursor",
+ ((PLpgSQL_var *) yylval.variable)->refname)));
}
$$ = (PLpgSQL_var *) yylval.variable;
}
if (((PLpgSQL_var *) yylval.variable)->datatype->typoid != REFCURSOROID)
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "%s must be of type refcursor",
- ((PLpgSQL_var *) yylval.variable)->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("\"%s\" must be of type refcursor",
+ ((PLpgSQL_var *) yylval.variable)->refname)));
}
$$ = yylval.variable->dno;
}
{
parenlevel--;
if (parenlevel < 0)
- elog(ERROR, "mismatched parentheses");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("mismatched parentheses")));
}
/*
* End of function definition is an error, and we don't expect to
{
plpgsql_error_lineno = lno;
if (parenlevel != 0)
- elog(ERROR, "mismatched parentheses");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("mismatched parentheses")));
if (isexpression)
- elog(ERROR, "missing %s at end of SQL expression",
- expected);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("missing \"%s\" at end of SQL expression",
+ expected)));
else
- elog(ERROR, "missing %s at end of SQL statement",
- expected);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("missing \"%s\" at end of SQL statement",
+ expected)));
break;
}
if (plpgsql_SpaceScanned)
{
plpgsql_error_lineno = lno;
if (parenlevel != 0)
- elog(ERROR, "mismatched parentheses");
- elog(ERROR, "incomplete datatype declaration");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("mismatched parentheses")));
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("incomplete datatype declaration")));
}
/* Possible followers for datatype in a declaration */
if (tok == K_NOT || tok == K_ASSIGN || tok == K_DEFAULT)
if (tok == 0)
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "unexpected end of file");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("unexpected end of function definition")));
}
if (tok == K_INTO)
{
if (have_into)
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "INTO specified more than once");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("INTO specified more than once")));
}
tok = yylex();
switch (tok)
default:
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "plpgsql: %s is not a variable",
- yytext);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("\"%s\" is not a variable",
+ yytext)));
}
}
have_nexttok = 1;
default:
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "plpgsql: %s is not a variable",
- yytext);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("\"%s\" is not a variable",
+ yytext)));
}
}
have_nexttok = 1;
if (((PLpgSQL_var *) datum)->isconst)
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "%s is declared CONSTANT",
- ((PLpgSQL_var *) datum)->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_ERROR_IN_ASSIGNMENT),
+ errmsg("\"%s\" is declared CONSTANT",
+ ((PLpgSQL_var *) datum)->refname)));
}
break;
case PLPGSQL_DTYPE_RECFIELD:
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_comp.c,v 1.59 2003/07/01 21:47:09 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_comp.c,v 1.60 2003/07/25 23:37:28 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
ObjectIdGetDatum(funcOid),
0, 0, 0);
if (!HeapTupleIsValid(procTup))
- elog(ERROR, "plpgsql: cache lookup for proc %u failed", funcOid);
+ elog(ERROR, "cache lookup failed for function %u", funcOid);
procStruct = (Form_pg_proc) GETSTRUCT(procTup);
/*
* Check for a polymorphic returntype. If found, use the actual
* returntype type from the caller's FuncExpr node, if we
* have one.
+ *
+ * Note: errcode is FEATURE_NOT_SUPPORTED because it should always
+ * work; if it doesn't we're in some context that fails to make
+ * the info available.
*/
rettypeid = procStruct->prorettype;
if (rettypeid == ANYARRAYOID || rettypeid == ANYELEMENTOID)
{
rettypeid = get_fn_expr_rettype(fcinfo->flinfo);
if (!OidIsValid(rettypeid))
- elog(ERROR, "could not determine actual return type "
- "for polymorphic function %s",
- plpgsql_error_funcname);
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("could not determine actual return type "
+ "for polymorphic function \"%s\"",
+ plpgsql_error_funcname)));
}
/*
ObjectIdGetDatum(rettypeid),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
- elog(ERROR, "cache lookup for return type %u failed",
- rettypeid);
+ elog(ERROR, "cache lookup failed for type %u", rettypeid);
typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
/* Disallow pseudotype result, except VOID or RECORD */
rettypeid == RECORDOID)
/* okay */ ;
else if (rettypeid == TRIGGEROID)
- elog(ERROR, "plpgsql functions cannot return type %s"
- "\n\texcept when used as triggers",
- format_type_be(rettypeid));
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("trigger functions may only be called as triggers")));
else
- elog(ERROR, "plpgsql functions cannot return type %s",
- format_type_be(rettypeid));
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("plpgsql functions cannot return type %s",
+ format_type_be(rettypeid))));
}
if (typeStruct->typrelid != InvalidOid ||
ObjectIdGetDatum(argtypeid),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
- elog(ERROR, "cache lookup for argument type %u failed",
- argtypeid);
+ elog(ERROR, "cache lookup failed for type %u", argtypeid);
typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
/* Disallow pseudotype argument */
/* (note we already replaced ANYARRAY/ANYELEMENT) */
if (typeStruct->typtype == 'p')
- elog(ERROR, "plpgsql functions cannot take type %s",
- format_type_be(argtypeid));
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("plpgsql functions cannot take type %s",
+ format_type_be(argtypeid))));
if (typeStruct->typrelid != InvalidOid)
{
break;
default:
- elog(ERROR, "unknown function type %u in plpgsql_compile()",
- functype);
+ elog(ERROR, "unrecognized function typecode: %u", functype);
break;
}
*/
parse_rc = plpgsql_yyparse();
if (parse_rc != 0)
- elog(ERROR, "plpgsql: parser returned %d ???", parse_rc);
+ elog(ERROR, "plpgsql parser returned %d", parse_rc);
plpgsql_scanner_finish();
return T_VARIABLE;
}
}
- elog(ERROR, "row %s doesn't have a field %s",
- cp[0], cp[1]);
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_COLUMN),
+ errmsg("row \"%s\" has no field \"%s\"",
+ cp[0], cp[1])));
}
default:
return T_VARIABLE;
}
}
- elog(ERROR, "row %s.%s doesn't have a field %s",
- cp[0], cp[1], cp[2]);
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_COLUMN),
+ errmsg("row \"%s.%s\" has no field \"%s\"",
+ cp[0], cp[1], cp[2])));
}
default:
ObjectIdGetDatum(attrStruct->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %u of %s.%s failed",
- attrStruct->atttypid, cp[0], cp[1]);
+ elog(ERROR, "cache lookup failed for type %u", attrStruct->atttypid);
/*
* Found that - build a compiler type struct and return it
ObjectIdGetDatum(attrStruct->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %u of %s.%s failed",
- attrStruct->atttypid, cp[0], cp[1]);
+ elog(ERROR, "cache lookup failed for type %u", attrStruct->atttypid);
/*
* Found that - build a compiler type struct and return it
/* Lookup the relation */
classOid = RelnameGetRelid(cp[0]);
if (!OidIsValid(classOid))
- elog(ERROR, "%s: no such class", cp[0]);
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_TABLE),
+ errmsg("relation \"%s\" does not exist", cp[0])));
/*
* Build and return the complete row definition
relvar = makeRangeVarFromNameList(stringToQualifiedNameList(cp, "plpgsql_parse_dblwordrowtype"));
classOid = RangeVarGetRelid(relvar, true);
if (!OidIsValid(classOid))
- elog(ERROR, "%s: no such class", cp);
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_TABLE),
+ errmsg("relation \"%s\" does not exist", cp)));
/*
* Build and return the complete row definition
classStruct->relkind != RELKIND_SEQUENCE &&
classStruct->relkind != RELKIND_VIEW &&
classStruct->relkind != RELKIND_COMPOSITE_TYPE)
- elog(ERROR, "%s isn't a table", relname);
+ ereport(ERROR,
+ (errcode(ERRCODE_WRONG_OBJECT_TYPE),
+ errmsg("relation \"%s\" is not a table", relname)));
/*
* Create a row datum entry and all the required variables that it
Int16GetDatum(i + 1),
0, 0);
if (!HeapTupleIsValid(attrtup))
- elog(ERROR, "cache lookup for attribute %d of class %s failed",
- i + 1, relname);
+ elog(ERROR, "cache lookup failed for attribute %d of relation %u",
+ i + 1, classOid);
attrStruct = (Form_pg_attribute) GETSTRUCT(attrtup);
attname = NameStr(attrStruct->attname);
ObjectIdGetDatum(attrStruct->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %u of %s.%s failed",
- attrStruct->atttypid, relname, attname);
+ elog(ERROR, "cache lookup failed for type %u",
+ attrStruct->atttypid);
/*
* Create the internal variable
plpgsql_yyerror(const char *s)
{
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "%s at or near \"%s\"", s, plpgsql_yytext);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ /* translator: first %s is a phrase like "syntax error" */
+ errmsg("%s at or near \"%s\"", s, plpgsql_yytext)));
}
{
argtypeid = get_fn_expr_argtype(flinfo, i);
if (!OidIsValid(argtypeid))
- elog(ERROR, "could not determine actual argument "
- "type for polymorphic function %s",
- NameStr(procStruct->proname));
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("could not determine actual argument "
+ "type for polymorphic function \"%s\"",
+ NameStr(procStruct->proname))));
}
hashkey->argtypes[i] = argtypeid;
HASH_ENTER,
&found);
if (hentry == NULL)
- elog(ERROR, "out of memory in plpgsql_HashTable");
+ ereport(ERROR,
+ (errcode(ERRCODE_OUT_OF_MEMORY),
+ errmsg("out of memory")));
if (found)
- elog(WARNING, "trying to insert a function that exists");
+ elog(WARNING, "trying to insert a function that already exists");
hentry->function = function;
/* prepare back link from function to hashtable key */
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.87 2003/06/29 00:33:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.88 2003/07/25 23:37:28 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
break;
default:
- elog(ERROR, "unknown dtype %d in plpgsql_exec_function()",
- func->datums[i]->dtype);
+ elog(ERROR, "unrecognized dtype: %d", func->datums[i]->dtype);
}
}
break;
default:
- elog(ERROR, "unknown dtype %d in plpgsql_exec_function()",
- func->datums[i]->dtype);
+ elog(ERROR, "unrecognized dtype: %d", func->datums[i]->dtype);
}
}
break;
default:
- elog(ERROR, "unknown dtype %d in plpgsql_exec_function()",
- func->datums[i]->dtype);
+ elog(ERROR, "unrecognized dtype: %d", func->datums[i]->dtype);
}
}
{
estate.err_stmt = NULL;
estate.err_text = "at END of toplevel PL block";
- elog(ERROR, "control reaches end of function without RETURN");
+ ereport(ERROR,
+ (errcode(ERRCODE_S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT),
+ errmsg("control reached end of function without RETURN")));
}
/*
/* Check caller can handle a set result */
if (!rsi || !IsA(rsi, ReturnSetInfo) ||
(rsi->allowedModes & SFRM_Materialize) == 0)
- elog(ERROR, "Set-valued function called in context that cannot accept a set");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("set-valued function called in context that cannot accept a set")));
rsi->returnMode = SFRM_Materialize;
/* If we produced any tuples, send back the result */
break;
default:
- elog(ERROR, "unknown dtype %d in plpgsql_exec_function()",
- func->datums[i]->dtype);
+ elog(ERROR, "unrecognized dtype: %d", func->datums[i]->dtype);
}
}
rec_old->tupdesc = trigdata->tg_relation->rd_att;
}
else
- elog(ERROR, "Unknown trigger action: not INSERT, DELETE, or UPDATE");
+ elog(ERROR, "unrecognized trigger action: not INSERT, DELETE, or UPDATE");
/*
* Assign the special tg_ variables
else if (TRIGGER_FIRED_BY_DELETE(trigdata->tg_event))
var->value = DirectFunctionCall1(textin, CStringGetDatum("DELETE"));
else
- elog(ERROR, "Unknown trigger action: not INSERT, DELETE, or UPDATE");
+ elog(ERROR, "unrecognized trigger action: not INSERT, DELETE, or UPDATE");
var = (PLpgSQL_var *) (estate.datums[func->tg_name_varno]);
var->isnull = false;
else if (TRIGGER_FIRED_AFTER(trigdata->tg_event))
var->value = DirectFunctionCall1(textin, CStringGetDatum("AFTER"));
else
- elog(ERROR, "Unknown trigger execution time: not BEFORE or AFTER");
+ elog(ERROR, "unrecognized trigger execution time: not BEFORE or AFTER");
var = (PLpgSQL_var *) (estate.datums[func->tg_level_varno]);
var->isnull = false;
else if (TRIGGER_FIRED_FOR_STATEMENT(trigdata->tg_event))
var->value = DirectFunctionCall1(textin, CStringGetDatum("STATEMENT"));
else
- elog(ERROR, "Unknown trigger event type: not ROW or STATEMENT");
+ elog(ERROR, "unrecognized trigger event type: not ROW or STATEMENT");
var = (PLpgSQL_var *) (estate.datums[func->tg_relid_varno]);
var->isnull = false;
break;
default:
- elog(ERROR, "unknown dtype %d in plpgsql_exec_trigger()",
- func->datums[i]->dtype);
+ elog(ERROR, "unrecognized dtype: %d", func->datums[i]->dtype);
}
}
{
estate.err_stmt = NULL;
estate.err_text = "at END of toplevel PL block";
- elog(ERROR, "control reaches end of trigger procedure without RETURN");
+ ereport(ERROR,
+ (errcode(ERRCODE_S_R_E_FUNCTION_EXECUTED_NO_RETURN_STATEMENT),
+ errmsg("control reached end of trigger procedure without RETURN")));
}
if (estate.retisset)
- elog(ERROR, "trigger procedure cannot return a set");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("trigger procedure cannot return a set")));
/*
* Check that the returned tuple structure has the same attributes,
{
if (!compatible_tupdesc(estate.rettupdesc,
trigdata->tg_relation->rd_att))
- elog(ERROR, "returned tuple structure doesn't match table of trigger event");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("returned tuple structure does not match table of trigger event")));
/* Copy tuple to upper executor memory */
rettup = SPI_copytuple((HeapTuple) (estate.retval));
}
var->value = (Datum) 0;
var->isnull = true;
if (var->notnull)
- elog(ERROR, "variable '%s' declared NOT NULL cannot default to NULL", var->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("variable \"%s\" declared NOT NULL cannot default to NULL",
+ var->refname)));
}
else
{
break;
default:
- elog(ERROR, "unknown dtype %d in exec_stmt_block()", estate->datums[n]->dtype);
+ elog(ERROR, "unrecognized dtype: %d",
+ estate->datums[n]->dtype);
}
}
return PLPGSQL_RC_RETURN;
default:
- elog(ERROR, "unknown rc %d from exec_stmt()", rc);
+ elog(ERROR, "unrecognized rc: %d", rc);
}
return PLPGSQL_RC_OK;
default:
estate->err_stmt = save_estmt;
- elog(ERROR, "unknown cmdtype %d in exec_stmt",
- stmt->cmd_type);
+ elog(ERROR, "unrecognized cmdtype: %d", stmt->cmd_type);
}
estate->err_stmt = save_estmt;
rc = exec_run_select(estate, expr, 0, NULL);
if (rc != SPI_OK_SELECT)
- elog(ERROR, "query \"%s\" didn't return data", expr->query);
+ ereport(ERROR,
+ (errcode(ERRCODE_WRONG_OBJECT_TYPE),
+ errmsg("query \"%s\" did not return data", expr->query)));
exec_set_found(estate, (estate->eval_processed != 0));
break;
default:
-
- elog(ERROR, "unknown attribute request %d in get_diagnostic",
+ elog(ERROR, "unrecognized attribute request: %d",
dtitem->item);
}
}
return PLPGSQL_RC_RETURN;
default:
- elog(ERROR, "unknown rc %d from exec_stmts()", rc);
+ elog(ERROR, "unrecognized rc: %d", rc);
}
}
return PLPGSQL_RC_RETURN;
default:
- elog(ERROR, "unknown rc %d from exec_stmts()", rc);
+ elog(ERROR, "unrecognized rc: %d", rc);
}
}
var->datatype->typelem,
var->datatype->atttypmod, &isnull);
if (isnull)
- elog(ERROR, "lower bound of FOR loop cannot be NULL");
+ ereport(ERROR,
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("lower bound of FOR loop cannot be NULL")));
var->value = value;
var->isnull = false;
exec_eval_cleanup(estate);
var->datatype->typelem,
var->datatype->atttypmod, &isnull);
if (isnull)
- elog(ERROR, "upper bound of FOR loop cannot be NULL");
+ ereport(ERROR,
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("upper bound of FOR loop cannot be NULL")));
exec_eval_cleanup(estate);
/*
else if (stmt->row != NULL)
row = (PLpgSQL_row *) (estate->datums[stmt->row->rowno]);
else
- elog(ERROR, "unsupported target in exec_stmt_fors()");
+ elog(ERROR, "unsupported target");
/*
* Open the implicit cursor for the statement and fetch the initial 10
else if (stmt->row != NULL)
row = (PLpgSQL_row *) (estate->datums[stmt->row->rowno]);
else
- elog(ERROR, "unsupported target in exec_stmt_select()");
+ elog(ERROR, "unsupported target");
/*
* Run the query
bool free_tuple = false;
if (!estate->retisset)
- elog(ERROR, "Cannot use RETURN NEXT in a non-SETOF function");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("cannot use RETURN NEXT in a non-SETOF function")));
if (estate->tuple_store == NULL)
exec_init_tuple_store(estate);
PLpgSQL_rec *rec = (PLpgSQL_rec *) (estate->datums[stmt->rec->recno]);
if (!HeapTupleIsValid(rec->tup))
- elog(ERROR, "record \"%s\" is unassigned yet", rec->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+ errmsg("record \"%s\" is not assigned yet",
+ rec->refname),
+ errdetail("The tuple structure of a not-yet-assigned record is indeterminate.")));
if (!compatible_tupdesc(tupdesc, rec->tupdesc))
- elog(ERROR, "Wrong record type supplied in RETURN NEXT");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("wrong record type supplied in RETURN NEXT")));
tuple = rec->tup;
}
else if (stmt->row)
int i;
if (natts != stmt->row->nfields)
- elog(ERROR, "Wrong record type supplied in RETURN NEXT");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("wrong record type supplied in RETURN NEXT")));
dvalues = (Datum *) palloc0(natts * sizeof(Datum));
nulls = (char *) palloc(natts * sizeof(char));
var = (PLpgSQL_var *) (estate->datums[stmt->row->varnos[i]]);
if (var->datatype->typoid != tupdesc->attrs[i]->atttypid)
- elog(ERROR, "Wrong record type supplied in RETURN NEXT");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("wrong record type supplied in RETURN NEXT")));
dvalues[i] = var->value;
if (!var->isnull)
nulls[i] = ' ';
char nullflag;
if (natts != 1)
- elog(ERROR, "Wrong result type supplied in RETURN NEXT");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("wrong result type supplied in RETURN NEXT")));
retval = exec_eval_expr(estate,
stmt->expr,
}
else
{
- elog(ERROR, "Blank RETURN NEXT not allowed");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("RETURN NEXT must have a parameter")));
tuple = NULL; /* keep compiler quiet */
}
if (!rsi || !IsA(rsi, ReturnSetInfo) ||
(rsi->allowedModes & SFRM_Materialize) == 0 ||
rsi->expectedDesc == NULL)
- elog(ERROR, "Set-valued function called in context that cannot accept a set");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("set-valued function called in context that cannot accept a set")));
estate->tuple_store_cxt = rsi->econtext->ecxt_per_query_memory;
}
/* ----------
- * exec_stmt_raise Build a message and throw it with
- * elog()
+ * exec_stmt_raise Build a message and throw it with elog()
* ----------
*/
static int
for (cp = stmt->message; *cp; cp++)
{
/*
- * Occurences of a single % are replaced by the next arguments
- * external representation. Double %'s are left as is so elog()
- * will also don't touch them.
+ * Occurences of a single % are replaced by the next argument's
+ * external representation. Double %'s are converted to one %.
*/
if ((c[0] = *cp) == '%')
{
cp++;
if (*cp == '%')
{
- plpgsql_dstring_append(&ds, c);
plpgsql_dstring_append(&ds, c);
continue;
}
cp--;
if (pidx >= stmt->nparams)
{
- plpgsql_dstring_append(&ds, c);
plpgsql_dstring_append(&ds, c);
continue;
}
ObjectIdGetDatum(paramtypeid),
0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %u failed",
+ elog(ERROR, "cache lookup failed for type %u",
paramtypeid);
typeStruct = (Form_pg_type) GETSTRUCT(typetup);
/*
* Occurrences of single ' are removed. double ' are reduced to
- * single ones.
+ * single ones. We must do this because the parameter stored
+ * by the grammar is the raw T_STRING input literal, rather than
+ * the de-lexed string as you might expect ...
*/
if (*cp == '\'')
{
break;
case SPI_OK_SELECT:
- elog(ERROR, "SELECT query has no destination for result data."
- "\n\tIf you want to discard the results, use PERFORM instead.");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("SELECT query has no destination for result data"),
+ errhint("If you want to discard the results, use PERFORM instead.")));
default:
elog(ERROR, "error executing query \"%s\"", expr->query);
*/
query = exec_eval_expr(estate, stmt->query, &isnull, &restype);
if (isnull)
- elog(ERROR, "cannot EXECUTE NULL query");
+ ereport(ERROR,
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("cannot EXECUTE a null querystring")));
/*
* Get the C-String representation.
ObjectIdGetDatum(restype),
0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %u failed", restype);
+ elog(ERROR, "cache lookup failed for type %u", restype);
typeStruct = (Form_pg_type) GETSTRUCT(typetup);
fmgr_info(typeStruct->typoutput, &finfo_output);
if (!isspace((unsigned char) *ptr))
break;
if (*ptr == 'S' || *ptr == 's')
- elog(ERROR, "EXECUTE of SELECT ... INTO is not implemented yet");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("EXECUTE of SELECT ... INTO is not implemented yet")));
break;
}
default:
- elog(ERROR, "unexpected error %d in EXECUTE of query '%s'",
+ elog(ERROR, "unexpected error %d in EXECUTE of query \"%s\"",
exec_res, querystr);
break;
}
else if (stmt->row != NULL)
row = (PLpgSQL_row *) (estate->datums[stmt->row->rowno]);
else
- elog(ERROR, "unsupported target in exec_stmt_dynfors()");
+ elog(ERROR, "unsupported target");
/*
* Evaluate the string expression after the EXECUTE keyword. It's
*/
query = exec_eval_expr(estate, stmt->query, &isnull, &restype);
if (isnull)
- elog(ERROR, "cannot EXECUTE NULL-query");
+ ereport(ERROR,
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("cannot EXECUTE a null querystring")));
/*
* Get the C-String representation.
ObjectIdGetDatum(restype),
0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %u failed", restype);
+ elog(ERROR, "cache lookup failed for type %u", restype);
typeStruct = (Form_pg_type) GETSTRUCT(typetup);
fmgr_info(typeStruct->typoutput, &finfo_output);
{
curname = DatumGetCString(DirectFunctionCall1(textout, curvar->value));
if (SPI_cursor_find(curname) != NULL)
- elog(ERROR, "cursor \"%s\" already in use", curname);
+ ereport(ERROR,
+ (errcode(ERRCODE_DUPLICATE_CURSOR),
+ errmsg("cursor \"%s\" already in use", curname)));
}
/* ----------
*/
queryD = exec_eval_expr(estate, stmt->dynquery, &isnull, &restype);
if (isnull)
- elog(ERROR, "cannot EXECUTE NULL query");
+ ereport(ERROR,
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("cannot EXECUTE a null querystring")));
/* ----------
* Get the C-String representation.
ObjectIdGetDatum(restype),
0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %u failed", restype);
+ elog(ERROR, "cache lookup failed for type %u", restype);
typeStruct = (Form_pg_type) GETSTRUCT(typetup);
fmgr_info(typeStruct->typoutput, &finfo_output);
querystr);
portal = SPI_cursor_open(curname, curplan, NULL, NULL);
if (portal == NULL)
- elog(ERROR, "Failed to open cursor");
+ elog(ERROR, "failed to open cursor");
pfree(querystr);
SPI_freeplan(curplan);
PLpgSQL_stmt_select set_args;
if (curvar->cursor_explicit_argrow < 0)
- elog(ERROR, "arguments given for cursor without arguments");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("arguments given for cursor without arguments")));
memset(&set_args, 0, sizeof(set_args));
set_args.cmd_type = PLPGSQL_STMT_SELECT;
else
{
if (curvar->cursor_explicit_argrow >= 0)
- elog(ERROR, "arguments required for cursor");
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("arguments required for cursor")));
}
query = curvar->cursor_explicit_expr;
*/
portal = SPI_cursor_open(curname, query->plan, values, nulls);
if (portal == NULL)
- elog(ERROR, "Failed to open cursor");
+ elog(ERROR, "failed to open cursor");
pfree(values);
pfree(nulls);
*/
curvar = (PLpgSQL_var *) (estate->datums[stmt->curvar]);
if (curvar->isnull)
- elog(ERROR, "cursor variable \"%s\" is NULL", curvar->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("cursor variable \"%s\" is NULL", curvar->refname)));
curname = DatumGetCString(DirectFunctionCall1(textout, curvar->value));
portal = SPI_cursor_find(curname);
if (portal == NULL)
- elog(ERROR, "cursor \"%s\" is invalid", curname);
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_CURSOR),
+ errmsg("cursor \"%s\" does not exist", curname)));
pfree(curname);
/* ----------
else if (stmt->row != NULL)
row = (PLpgSQL_row *) (estate->datums[stmt->row->rowno]);
else
- elog(ERROR, "unsupported target in exec_stmt_fetch()");
+ elog(ERROR, "unsupported target");
/* ----------
* Fetch 1 tuple from the cursor
*/
curvar = (PLpgSQL_var *) (estate->datums[stmt->curvar]);
if (curvar->isnull)
- elog(ERROR, "cursor variable \"%s\" is NULL", curvar->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("cursor variable \"%s\" is NULL", curvar->refname)));
curname = DatumGetCString(DirectFunctionCall1(textout, curvar->value));
portal = SPI_cursor_find(curname);
if (portal == NULL)
- elog(ERROR, "cursor \"%s\" is invalid", curname);
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_CURSOR),
+ errmsg("cursor \"%s\" does not exist", curname)));
pfree(curname);
/* ----------
isNull);
if (*isNull && var->notnull)
- elog(ERROR, "NULL assignment to variable '%s' declared NOT NULL", var->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
+ errmsg("NULL cannot be assigned to variable \"%s\" declared NOT NULL",
+ var->refname)));
/*
* If type is by-reference, make sure we have a freshly
* structure.
*/
if (!HeapTupleIsValid(rec->tup))
- elog(ERROR, "record \"%s\" is unassigned yet - don't know its tuple structure", rec->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+ errmsg("record \"%s\" is not assigned yet",
+ rec->refname),
+ errdetail("The tuple structure of a not-yet-assigned record is indeterminate.")));
/*
* Get the number of the records field to change and the
*/
fno = SPI_fnumber(rec->tupdesc, recfield->fieldname);
if (fno == SPI_ERROR_NOATTRIBUTE)
- elog(ERROR, "record \"%s\" has no field named \"%s\"", rec->refname, recfield->fieldname);
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_COLUMN),
+ errmsg("record \"%s\" has no field \"%s\"",
+ rec->refname, recfield->fieldname)));
fno--;
natts = rec->tupdesc->natts;
PLpgSQL_arrayelem *arrayelem = (PLpgSQL_arrayelem *) target;
if (nsubscripts >= MAXDIM)
- elog(ERROR, "Too many subscripts");
+ ereport(ERROR,
+ (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+ errmsg("number of array dimensions exceeds the maximum allowed, %d",
+ MAXDIM)));
subscripts[nsubscripts++] = arrayelem->subscript;
target = estate->datums[arrayelem->arrayparentno];
} while (target->dtype == PLPGSQL_DTYPE_ARRAYELEM);
getTypeInputInfo(arraytypeid, &arrayInputFn, &arrayelemtypeid);
if (!OidIsValid(arrayelemtypeid))
- elog(ERROR, "Subscripted item is not an array");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("subscripted object is not an array")));
/* Evaluate the subscripts, switch into left-to-right order */
havenullsubscript = false;
break;
default:
- elog(ERROR, "unknown dtype %d in exec_assign_value()",
- target->dtype);
+ elog(ERROR, "unrecognized dtype: %d", target->dtype);
}
}
*value = var->value;
*isnull = var->isnull;
if (expectedtypeid != InvalidOid && expectedtypeid != *typeid)
- elog(ERROR, "type of %s doesn't match that when preparing the plan",
- var->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("type of \"%s\" does not match that when preparing the plan",
+ var->refname)));
break;
case PLPGSQL_DTYPE_RECFIELD:
recfield = (PLpgSQL_recfield *) datum;
rec = (PLpgSQL_rec *) (estate->datums[recfield->recparentno]);
if (!HeapTupleIsValid(rec->tup))
- elog(ERROR, "record \"%s\" is unassigned yet", rec->refname);
+ ereport(ERROR,
+ (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
+ errmsg("record \"%s\" is not assigned yet",
+ rec->refname),
+ errdetail("The tuple structure of a not-yet-assigned record is indeterminate.")));
fno = SPI_fnumber(rec->tupdesc, recfield->fieldname);
if (fno == SPI_ERROR_NOATTRIBUTE)
- elog(ERROR, "record \"%s\" has no field named \"%s\"",
- rec->refname, recfield->fieldname);
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_COLUMN),
+ errmsg("record \"%s\" has no field \"%s\"",
+ rec->refname, recfield->fieldname)));
*typeid = SPI_gettypeid(rec->tupdesc, fno);
*value = SPI_getbinval(rec->tup, rec->tupdesc, fno, isnull);
if (expectedtypeid != InvalidOid && expectedtypeid != *typeid)
- elog(ERROR, "type of %s.%s doesn't match that when preparing the plan",
- rec->refname, recfield->fieldname);
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("type of \"%s.%s\" does not match that when preparing the plan",
+ rec->refname, recfield->fieldname)));
break;
case PLPGSQL_DTYPE_TRIGARG:
*isnull = false;
}
if (expectedtypeid != InvalidOid && expectedtypeid != *typeid)
- elog(ERROR, "type of tgargv[%d] doesn't match that when preparing the plan",
- tgargno);
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("type of tgargv[%d] does not match that when preparing the plan",
+ tgargno)));
break;
default:
- elog(ERROR, "unknown datum dtype %d in exec_eval_datum()",
- datum->dtype);
+ elog(ERROR, "unrecognized dtype: %d", datum->dtype);
}
}
rc = exec_run_select(estate, expr, 2, NULL);
if (rc != SPI_OK_SELECT)
- elog(ERROR, "query \"%s\" didn't return data", expr->query);
+ ereport(ERROR,
+ (errcode(ERRCODE_WRONG_OBJECT_TYPE),
+ errmsg("query \"%s\" did not return data", expr->query)));
/*
* If there are no rows selected, the result is NULL.
* Check that the expression returned one single Datum
*/
if (estate->eval_processed > 1)
- elog(ERROR, "query \"%s\" returned more than one row", expr->query);
+ ereport(ERROR,
+ (errcode(ERRCODE_CARDINALITY_VIOLATION),
+ errmsg("query \"%s\" returned more than one row",
+ expr->query)));
if (estate->eval_tuptable->tupdesc->natts != 1)
- elog(ERROR, "query \"%s\" returned %d columns", expr->query,
- estate->eval_tuptable->tupdesc->natts);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("query \"%s\" returned %d columns", expr->query,
+ estate->eval_tuptable->tupdesc->natts)));
/*
* Return the result and its type
*/
rc = SPI_execp(expr->plan, values, nulls, maxtuples);
if (rc != SPI_OK_SELECT)
- elog(ERROR, "query \"%s\" isn't a SELECT", expr->query);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("query \"%s\" is not a SELECT", expr->query)));
/* Save query results for eventual cleanup */
Assert(estate->eval_tuptable == NULL);
return;
}
- elog(ERROR, "unsupported target in exec_move_row()");
+ elog(ERROR, "unsupported target");
}
ObjectIdGetDatum(valtype),
0, 0, 0);
if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for type %u failed", valtype);
+ elog(ERROR, "cache lookup failed for type %u", valtype);
typeStruct = (Form_pg_type) GETSTRUCT(typetup);
fmgr_info(typeStruct->typoutput, &finfo_output);
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_funcs.c,v 1.26 2003/05/23 04:08:34 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_funcs.c,v 1.27 2003/07/25 23:37:29 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
}
}
- elog(ERROR, "there is no variable '%s' in the current block", oldname);
+ ereport(ERROR,
+ (errcode(ERRCODE_UNDEFINED_OBJECT),
+ errmsg("there is no variable \"%s\" in the current block",
+ oldname)));
}
*cp++ = *s++;
}
if (*s != '"') /* should not happen if lexer checked */
- elog(ERROR, "unterminated \" in name: %s", sstart);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("unterminated \" in name: %s", sstart)));
s++;
}
else
if (identctr < numidents)
output[identctr++] = curident;
else
- elog(ERROR, "Qualified identifier cannot be used here: %s",
- sstart);
+ ereport(ERROR,
+ (errcode(ERRCODE_SYNTAX_ERROR),
+ errmsg("qualified identifier cannot be used here: %s",
+ sstart)));
/* If not done, skip whitespace, dot, whitespace */
if (*s)
while (*s && isspace((unsigned char) *s))
s++;
if (*s++ != '.')
- elog(ERROR, "Expected dot between identifiers: %s", sstart);
+ elog(ERROR, "expected dot between identifiers: %s", sstart);
while (*s && isspace((unsigned char) *s))
s++;
if (*s == '\0')
- elog(ERROR, "Expected another identifier: %s", sstart);
+ elog(ERROR, "expected another identifier: %s", sstart);
}
}
if (identctr != numidents)
- elog(ERROR, "Improperly qualified identifier: %s",
+ elog(ERROR, "improperly qualified identifier: %s",
sstart);
}
dump_perform((PLpgSQL_stmt_perform *) stmt);
break;
default:
- elog(ERROR, "plpgsql_dump: unknown cmd_type %d\n", stmt->cmd_type);
+ elog(ERROR, "unknown cmd_type: %d", stmt->cmd_type);
break;
}
}
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_handler.c,v 1.13 2003/07/01 21:47:09 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_handler.c,v 1.14 2003/07/25 23:37:29 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
* Connect to SPI manager
*/
if (SPI_connect() != SPI_OK_CONNECT)
- elog(ERROR, "plpgsql: cannot connect to SPI manager");
+ elog(ERROR, "could not connect to SPI manager");
/* Find or compile the function */
func = plpgsql_compile(fcinfo);
* Disconnect from SPI manager
*/
if (SPI_finish() != SPI_OK_FINISH)
- elog(ERROR, "plpgsql: SPI_finish() failed");
+ elog(ERROR, "SPI_finish() failed");
return retval;
}
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/Attic/scan.l,v 1.28 2003/06/19 23:22:40 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/Attic/scan.l,v 1.29 2003/07/25 23:37:29 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
\". {
plpgsql_error_lineno = plpgsql_scanner_lineno();
- elog(ERROR, "unterminated quoted identifier");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("unterminated quoted identifier")));
}
/* ----------
<IN_COMMENT>. ;
<IN_COMMENT><<EOF>> {
plpgsql_error_lineno = start_lineno;
- elog(ERROR, "unterminated comment");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("unterminated comment")));
}
/* ----------
}
<IN_STRING><<EOF>> {
plpgsql_error_lineno = start_lineno;
- elog(ERROR, "unterminated string");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATATYPE_MISMATCH),
+ errmsg("unterminated string")));
}
<IN_STRING>[^'\\]* { }
plpgsql_push_back_token(int token)
{
if (have_pushback_token)
- elog(ERROR, "plpgsql_push_back_token: can't push back multiple tokens");
+ elog(ERROR, "cannot push back multiple tokens");
pushback_token = token;
have_pushback_token = true;
}
* MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpython/plpython.c,v 1.34 2003/06/25 01:18:58 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpython/plpython.c,v 1.35 2003/07/25 23:37:30 tgl Exp $
*
*********************************************************************
*/
PLy_init_all();
if (SPI_connect() != SPI_OK_CONNECT)
- elog(ERROR, "plpython: Unable to connect to SPI manager");
+ elog(ERROR, "could not connect to SPI manager");
CALL_LEVEL_INC();
is_trigger = CALLED_AS_TRIGGER(fcinfo);
* Disconnect from SPI manager
*/
if (SPI_finish() != SPI_OK_FINISH)
- elog(ERROR, "plpython: SPI_finish failed");
+ elog(ERROR, "SPI_finish failed");
if (plrv == NULL)
- elog(FATAL, "Aiieee, PLy_procedure_call returned NULL");
+ elog(FATAL, "PLy_procedure_call returned NULL");
if (PLy_restart_in_progress)
- elog(FATAL, "Aiieee, restart in progress not expected");
+ elog(FATAL, "restart in progress not expected");
/*
* return of None means we're happy with the tuple
char *srv;
if (!PyString_Check(plrv))
- elog(ERROR, "plpython: Expected trigger to return None or a String");
+ elog(ERROR, "expected trigger to return None or a String");
srv = PyString_AsString(plrv);
if (strcasecmp(srv, "SKIP") == 0)
(TRIGGER_FIRED_BY_UPDATE(tdata->tg_event)))
rv = PLy_modify_tuple(proc, plargs, tdata, rv);
else
- elog(WARNING, "plpython: Ignoring modified tuple in DELETE trigger");
+ elog(WARNING, "ignoring modified tuple in DELETE trigger");
}
else if (strcasecmp(srv, "OK"))
{
* surprising thing since i've written no documentation, so
* accept a belated OK
*/
- elog(ERROR, "plpython: Expected return to be 'SKIP' or 'MODIFY'");
+ elog(ERROR, "expected return to be \"SKIP\" or \"MODIFY\"");
}
}
}
if ((plntup = PyDict_GetItemString(pltd, "new")) == NULL)
- elog(ERROR, "plpython: TD[\"new\"] deleted, unable to modify tuple");
+ elog(ERROR, "TD[\"new\"] deleted, unable to modify tuple");
if (!PyDict_Check(plntup))
- elog(ERROR, "plpython: TD[\"new\"] is not a dictionary object");
+ elog(ERROR, "TD[\"new\"] is not a dictionary object");
Py_INCREF(plntup);
plkeys = PyDict_Keys(plntup);
natts = PyList_Size(plkeys);
if (natts != proc->result.out.r.natts)
- elog(ERROR, "plpython: TD[\"new\"] has an incorrect number of keys.");
+ elog(ERROR, "TD[\"new\"] has an incorrect number of keys");
modattrs = palloc(natts * sizeof(int));
modvalues = palloc(natts * sizeof(Datum));
platt = PyList_GetItem(plkeys, j);
if (!PyString_Check(platt))
- elog(ERROR, "plpython: attribute is not a string");
+ elog(ERROR, "attribute is not a string");
attn = modattrs[j] = SPI_fnumber(tupdesc, PyString_AsString(platt));
if (attn == SPI_ERROR_NOATTRIBUTE)
- elog(ERROR, "plpython: invalid attribute `%s' in tuple.",
+ elog(ERROR, "invalid attribute \"%s\" in tuple",
PyString_AsString(platt));
atti = attn - 1;
plval = PyDict_GetItem(plntup, platt);
if (plval == NULL)
- elog(FATAL, "plpython: interpreter is probably corrupted");
+ elog(FATAL, "python interpreter is probably corrupted");
Py_INCREF(plval);
pfree(modnulls);
if (rtup == NULL)
- elog(ERROR, "plpython: SPI_modifytuple failed -- error %d", SPI_result);
+ elog(ERROR, "SPI_modifytuple failed -- error %d", SPI_result);
Py_DECREF(plntup);
Py_DECREF(plkeys);
pltdata = PyDict_New();
if (!pltdata)
- PLy_elog(ERROR, "Unable to build arguments for trigger procedure");
+ PLy_elog(ERROR, "could not build arguments for trigger procedure");
pltname = PyString_FromString(tdata->tg_trigger->tgname);
PyDict_SetItemString(pltdata, "name", pltname);
* it).
*/
if (SPI_finish() != SPI_OK_FINISH)
- elog(ERROR, "plpython: SPI_finish failed");
+ elog(ERROR, "SPI_finish failed");
if (plrv == NULL)
{
- elog(FATAL, "Aiieee, PLy_procedure_call returned NULL");
+ elog(FATAL, "PLy_procedure_call returned NULL");
#ifdef NOT_USED
if (!PLy_restart_in_progress)
- PLy_elog(ERROR, "plpython: Function \"%s\" failed.", proc->proname);
+ PLy_elog(ERROR, "function \"%s\" failed", proc->proname);
/*
* FIXME is this dead code? i'm pretty sure it is for unnested
{
Py_XDECREF(rv);
if (!PLy_restart_in_progress)
- PLy_elog(ERROR, "Call of function `%s' failed.", proc->proname);
+ PLy_elog(ERROR, "function \"%s\" failed", proc->proname);
RAISE_EXC(1);
}
ObjectIdGetDatum(fn_oid),
0, 0, 0);
if (!HeapTupleIsValid(procTup))
- elog(ERROR, "plpython: cache lookup for procedure %u failed", fn_oid);
+ elog(ERROR, "cache lookup failed for function %u", fn_oid);
rv = snprintf(key, sizeof(key), "%u%s",
fn_oid,
is_trigger ? "_trigger" : "");
if ((rv >= sizeof(key)) || (rv < 0))
- elog(FATAL, "plpython: Buffer overrun in %s:%d", __FILE__, __LINE__);
+ elog(ERROR, "key too long");
plproc = PyDict_GetItemString(PLy_procedure_cache, key);
{
Py_INCREF(plproc);
if (!PyCObject_Check(plproc))
- elog(FATAL, "plpython: Expected a PyCObject, didn't get one");
+ elog(FATAL, "expected a PyCObject, didn't get one");
mark();
proc = PyCObject_AsVoidPtr(plproc);
if (proc->me != plproc)
- elog(FATAL, "plpython: Aiieee, proc->me != plproc");
+ elog(FATAL, "proc->me != plproc");
/* did we find an up-to-date cache entry? */
if (proc->fn_xmin != HeapTupleHeaderGetXmin(procTup->t_data) ||
proc->fn_cmin != HeapTupleHeaderGetCmin(procTup->t_data))
fcinfo->flinfo->fn_oid,
is_trigger ? "_trigger" : "");
if ((rv >= sizeof(procName)) || (rv < 0))
- elog(FATAL, "plpython: Procedure name would overrun buffer");
+ elog(ERROR, "procedure name would overrun buffer");
proc = PLy_malloc(sizeof(PLyProcedure));
proc->proname = PLy_malloc(strlen(NameStr(procStruct->proname)) + 1);
{
HeapTuple rvTypeTup;
Form_pg_type rvTypeStruct;
- Datum rvDatum;
- rvDatum = ObjectIdGetDatum(procStruct->prorettype);
- rvTypeTup = SearchSysCache(TYPEOID, rvDatum, 0, 0, 0);
+ rvTypeTup = SearchSysCache(TYPEOID,
+ ObjectIdGetDatum(procStruct->prorettype),
+ 0, 0, 0);
if (!HeapTupleIsValid(rvTypeTup))
- elog(ERROR, "plpython: cache lookup for type \"%u\" failed",
+ elog(ERROR, "cache lookup failed for type %u",
procStruct->prorettype);
rvTypeStruct = (Form_pg_type) GETSTRUCT(rvTypeTup);
if (rvTypeStruct->typrelid == InvalidOid)
PLy_output_datum_func(&proc->result, rvTypeStruct);
else
- elog(ERROR, "plpython: tuple return types not supported, yet");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("tuple return types are not supported yet")));
ReleaseSysCache(rvTypeTup);
}
{
HeapTuple argTypeTup;
Form_pg_type argTypeStruct;
- Datum argDatum;
- argDatum = ObjectIdGetDatum(procStruct->proargtypes[i]);
- argTypeTup = SearchSysCache(TYPEOID, argDatum, 0, 0, 0);
+ argTypeTup = SearchSysCache(TYPEOID,
+ ObjectIdGetDatum(procStruct->proargtypes[i]),
+ 0, 0, 0);
if (!HeapTupleIsValid(argTypeTup))
- elog(ERROR, "plpython: cache lookup for type \"%u\" failed",
+ elog(ERROR, "cache lookup failed for type %u",
procStruct->proargtypes[i]);
argTypeStruct = (Form_pg_type) GETSTRUCT(argTypeTup);
*/
clen = snprintf(call, sizeof(call), "%s()", proc->pyname);
if ((clen < 0) || (clen >= sizeof(call)))
- elog(ERROR, "plpython: string would overflow buffer.");
+ elog(ERROR, "string would overflow buffer");
proc->code = Py_CompileString(call, "<string>", Py_eval_input);
if ((proc->code != NULL) && (!PyErr_Occurred()))
return;
else
Py_XDECREF(crv);
- PLy_elog(ERROR, "Unable to compile function %s", proc->proname);
+ PLy_elog(ERROR, "could not compile function \"%s\"", proc->proname);
}
char *
mrc = PLy_malloc(mlen);
plen = snprintf(mrc, mlen, "def %s():\n\t", name);
- if ((plen < 0) || (plen >= mlen))
- elog(FATAL, "Aiieee, impossible buffer overrun (or snprintf failure)");
+ Assert(plen >= 0 && plen < mlen);
sp = src;
mp = mrc + plen;
*mp = '\0';
if (mp > (mrc + mlen))
- elog(FATAL, "plpython: Buffer overrun in PLy_munge_source");
+ elog(FATAL, "buffer overrun in PLy_munge_source");
return mrc;
}
PLy_input_tuple_funcs(PLyTypeInfo * arg, TupleDesc desc)
{
int i;
- Datum datum;
enter();
if (arg->is_rel == 0)
- elog(FATAL, "plpython: PLyTypeInfo struct is initialized for a Datum");
+ elog(ERROR, "PLyTypeInfo struct is initialized for a Datum");
arg->is_rel = 1;
arg->in.r.natts = desc->natts;
HeapTuple typeTup;
Form_pg_type typeStruct;
- datum = ObjectIdGetDatum(desc->attrs[i]->atttypid);
- typeTup = SearchSysCache(TYPEOID, datum, 0, 0, 0);
+ typeTup = SearchSysCache(TYPEOID,
+ ObjectIdGetDatum(desc->attrs[i]->atttypid),
+ 0, 0, 0);
if (!HeapTupleIsValid(typeTup))
- {
- char *attname = NameStr(desc->attrs[i]->attname);
-
- elog(ERROR, "plpython: Cache lookup for attribute `%s' type `%u' failed",
- attname, desc->attrs[i]->atttypid);
- }
-
+ elog(ERROR, "cache lookup failed for type %u",
+ desc->attrs[i]->atttypid);
typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
PLy_input_datum_func2(&(arg->in.r.atts[i]),
PLy_output_tuple_funcs(PLyTypeInfo * arg, TupleDesc desc)
{
int i;
- Datum datum;
enter();
if (arg->is_rel == 0)
- elog(FATAL, "plpython: PLyTypeInfo struct is initialized for a Datum");
+ elog(ERROR, "PLyTypeInfo struct is initialized for a Datum");
arg->is_rel = 1;
arg->out.r.natts = desc->natts;
HeapTuple typeTup;
Form_pg_type typeStruct;
- datum = ObjectIdGetDatum(desc->attrs[i]->atttypid);
- typeTup = SearchSysCache(TYPEOID, datum, 0, 0, 0);
+ typeTup = SearchSysCache(TYPEOID,
+ ObjectIdGetDatum(desc->attrs[i]->atttypid),
+ 0, 0, 0);
if (!HeapTupleIsValid(typeTup))
- {
- char *attname = NameStr(desc->attrs[i]->attname);
-
- elog(ERROR, "plpython: Cache lookup for attribute `%s' type `%u' failed",
- attname, desc->attrs[i]->atttypid);
- }
-
+ elog(ERROR, "cache lookup failed for type %u",
+ desc->attrs[i]->atttypid);
typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
PLy_output_datum_func2(&(arg->out.r.atts[i]), typeStruct);
enter();
if (arg->is_rel == 1)
- elog(FATAL, "plpython: PLyTypeInfo struct is initialized for a Tuple");
+ elog(ERROR, "PLyTypeInfo struct is initialized for a Tuple");
arg->is_rel = 0;
PLy_output_datum_func2(&(arg->out.d), typeStruct);
}
enter();
if (arg->is_rel == 1)
- elog(FATAL, "plpython: PLyTypeInfo struct is initialized for Tuple");
+ elog(ERROR, "PLyTypeInfo struct is initialized for Tuple");
arg->is_rel = 0;
PLy_input_datum_func2(&(arg->in.d), typeOid, typeStruct);
}
enter();
if (info->is_rel != 1)
- elog(FATAL, "plpython: PLyTypeInfo structure describes a datum.");
+ elog(ERROR, "PLyTypeInfo structure describes a datum");
dict = PyDict_New();
if (dict == NULL)
- PLy_elog(ERROR, "Unable to create tuple dictionary.");
+ PLy_elog(ERROR, "could not create tuple dictionary");
SAVE_EXC();
if (TRAP_EXC())
Py_XDECREF(optr);
if (!PyErr_Occurred())
PyErr_SetString(PLy_exc_spi_error,
- "Unknown error in PLy_spi_prepare.");
+ "Unknown error in PLy_spi_prepare");
+ /* XXX this oughta be replaced with errcontext mechanism */
PLy_elog(WARNING, "in function %s:", PLy_procedure_name(PLy_last_procedure));
RERAISE_EXC();
}
RESTORE_EXC();
if ((!PLy_restart_in_progress) && (!PyErr_Occurred()))
PyErr_SetString(PLy_exc_spi_error,
- "Unknown error in PLy_spi_execute_query.");
+ "Unknown error in PLy_spi_execute_query");
PLy_elog(WARNING, "in function %s:", PLy_procedure_name(PLy_last_procedure));
RERAISE_EXC();
}
enter();
if (init_active)
- elog(FATAL, "plpython: Initialization of language module failed.");
+ elog(FATAL, "initialization of language module failed");
init_active = 1;
Py_Initialize();
PLy_init_interp();
PLy_init_plpy();
if (PyErr_Occurred())
- PLy_elog(FATAL, "Untrapped error in initialization.");
+ PLy_elog(FATAL, "untrapped error in initialization");
PLy_procedure_cache = PyDict_New();
if (PLy_procedure_cache == NULL)
- PLy_elog(ERROR, "Unable to create procedure cache.");
+ PLy_elog(ERROR, "could not create procedure cache");
PLy_first_call = 0;
mainmod = PyImport_AddModule("__main__");
if ((mainmod == NULL) || (PyErr_Occurred()))
- PLy_elog(ERROR, "Unable to import '__main__' module.");
+ PLy_elog(ERROR, "could not import \"__main__\" module.");
Py_INCREF(mainmod);
PLy_interp_globals = PyModule_GetDict(mainmod);
PLy_interp_safe_globals = PyDict_New();
PyDict_SetItemString(PLy_interp_globals, "GD", PLy_interp_safe_globals);
Py_DECREF(mainmod);
if ((PLy_interp_globals == NULL) || (PyErr_Occurred()))
- PLy_elog(ERROR, "Unable to initialize globals.");
+ PLy_elog(ERROR, "could not initialize globals");
}
void
plpy_mod = PyImport_AddModule("plpy");
PyDict_SetItemString(main_dict, "plpy", plpy_mod);
if (PyErr_Occurred())
- elog(ERROR, "Unable to init plpy.");
+ elog(ERROR, "could not init plpy");
}
/* the python interface to the elog function
enter();
if (args == NULL)
- elog(WARNING, "plpython, args is NULL in %s", __FUNCTION__);
+ elog(WARNING, "args is NULL");
so = PyObject_Str(args);
if ((so == NULL) || ((sv = PyString_AsString(so)) == NULL))
* postgresql log, no? whatever, this shouldn't happen so die
* hideously.
*/
- elog(FATAL, "plpython: Aiieee, elog threw an unknown exception!");
+ elog(FATAL, "elog threw an unknown exception");
RERAISE_EXC();
}
*/
PLy_restart_in_progress += 1;
PLy_free(emsg);
- PLy_free(xmsg);
+ if (xmsg)
+ PLy_free(xmsg);
RERAISE_EXC();
}
+ ereport(elevel,
+ (errmsg("plpython: %s", emsg),
+ (xmsg) ? errdetail("%s", xmsg) : 0));
+
+ PLy_free(emsg);
if (xmsg)
- {
- elog(elevel, "plpython: %s\n%s", emsg, xmsg);
PLy_free(xmsg);
- }
- else
- elog(elevel, "plpython: %s", emsg);
- PLy_free(emsg);
leave();
void *ptr = malloc(bytes);
if (ptr == NULL)
- elog(FATAL, "plpython: Memory exhausted.");
+ ereport(FATAL,
+ (errcode(ERRCODE_OUT_OF_MEMORY),
+ errmsg("out of memory")));
return ptr;
}
void *nptr = realloc(optr, bytes);
if (nptr == NULL)
- elog(FATAL, "plpython: Memory exhausted.");
+ ereport(FATAL,
+ (errcode(ERRCODE_OUT_OF_MEMORY),
+ errmsg("out of memory")));
return nptr;
}
-/* $Header: /cvsroot/pgsql/src/pl/plpython/Attic/plpython.h,v 1.7 2003/05/27 17:49:47 momjian Exp $ */
+/* $Header: /cvsroot/pgsql/src/pl/plpython/Attic/plpython.h,v 1.8 2003/07/25 23:37:30 tgl Exp $ */
#ifndef PLPYTHON_H
#define PLPYTHON_H
#if DEBUG_LEVEL
#define CALL_LEVEL_INC() do { PLy_call_level += 1; \
- elog(DEBUG4, "Level: %d", PLy_call_level); } while (0)
-#define CALL_LEVEL_DEC() do { elog(DEBUG4, "Level: %d", PLy_call_level); \
+ elog(DEBUG4, "level: %d", PLy_call_level); } while (0)
+#define CALL_LEVEL_DEC() do { elog(DEBUG4, "level: %d", PLy_call_level); \
PLy_call_level -= 1; } while (0)
#else
#define CALL_LEVEL_INC() do { PLy_call_level += 1; } while (0)
* ENHANCEMENTS, OR MODIFICATIONS.
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.71 2003/05/27 17:49:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.72 2003/07/25 23:37:31 tgl Exp $
*
**********************************************************************/
* stdout and stderr on DeleteInterp
************************************************************/
if ((pltcl_hold_interp = Tcl_CreateInterp()) == NULL)
- {
- elog(ERROR, "pltcl: internal error - cannot create 'hold' "
- "interpreter");
- }
+ elog(ERROR, "could not create \"hold\" interpreter");
/************************************************************
* Create the two interpreters
************************************************************/
if ((pltcl_norm_interp =
Tcl_CreateSlave(pltcl_hold_interp, "norm", 0)) == NULL)
- {
- elog(ERROR,
- "pltcl: internal error - cannot create 'normal' interpreter");
- }
+ elog(ERROR, "could not create \"normal\" interpreter");
pltcl_init_interp(pltcl_norm_interp);
if ((pltcl_safe_interp =
Tcl_CreateSlave(pltcl_hold_interp, "safe", 1)) == NULL)
- {
- elog(ERROR,
- "pltcl: internal error - cannot create 'safe' interpreter");
- }
+ elog(ERROR, "could not create \"safe\" interpreter");
pltcl_init_interp(pltcl_safe_interp);
/************************************************************
* Try to load the unknown procedure from pltcl_modules
************************************************************/
if (SPI_connect() != SPI_OK_CONNECT)
- elog(ERROR, "pltcl_init_interp(): SPI_connect failed");
+ elog(ERROR, "SPI_connect failed");
pltcl_init_load_unknown(interp);
if (SPI_finish() != SPI_OK_FINISH)
- elog(ERROR, "pltcl_init_interp(): SPI_finish failed");
+ elog(ERROR, "SPI_finish failed");
}
"where relname = 'pltcl_modules'", 1);
SPI_freetuptable(SPI_tuptable);
if (spi_rc != SPI_OK_SELECT)
- elog(ERROR, "pltcl_init_load_unknown(): select from pg_class failed");
+ elog(ERROR, "select from pg_class failed");
if (SPI_processed == 0)
return;
"where modname = 'unknown' "
"order by modseq", 0);
if (spi_rc != SPI_OK_SELECT)
- {
- elog(ERROR, "pltcl_init_load_unknown(): select from pltcl_modules "
- "failed");
- }
+ elog(ERROR, "select from pltcl_modules failed");
/************************************************************
* If there's nothing, module unknown doesn't exist
{
Tcl_DStringFree(&unknown_src);
SPI_freetuptable(SPI_tuptable);
- elog(WARNING, "pltcl: Module unknown not found in pltcl_modules");
+ elog(WARNING, "module \"unknown\" not found in pltcl_modules");
return;
}
* Connect to SPI manager
************************************************************/
if (SPI_connect() != SPI_OK_CONNECT)
- elog(ERROR, "pltcl: cannot connect to SPI manager");
+ elog(ERROR, "could not connect to SPI manager");
/************************************************************
* Keep track about the nesting of Tcl-SPI-Tcl-... calls
************************************************************/
if (--pltcl_call_level == 0)
pltcl_restart_in_progress = 0;
UTF_BEGIN;
- elog(ERROR, "pltcl: %s\n%s", interp->result,
- UTF_U2E(Tcl_GetVar(interp, "errorInfo",
- TCL_GLOBAL_ONLY)));
+ ereport(ERROR,
+ (errmsg("pltcl: %s", interp->result),
+ errdetail("%s",
+ UTF_U2E(Tcl_GetVar(interp, "errorInfo",
+ TCL_GLOBAL_ONLY)))));
UTF_END;
}
if (--pltcl_call_level == 0)
* the result type in that case.
************************************************************/
if (SPI_finish() != SPI_OK_FINISH)
- elog(ERROR, "pltcl: SPI_finish() failed");
+ elog(ERROR, "SPI_finish() failed");
if (fcinfo->isnull)
retval = (Datum) 0;
if (--pltcl_call_level == 0)
pltcl_restart_in_progress = 0;
UTF_BEGIN;
- elog(ERROR, "pltcl: %s\n%s", interp->result,
- UTF_U2E(Tcl_GetVar(interp, "errorInfo",
- TCL_GLOBAL_ONLY)));
+ ereport(ERROR,
+ (errmsg("pltcl: %s", interp->result),
+ errdetail("%s",
+ UTF_U2E(Tcl_GetVar(interp, "errorInfo",
+ TCL_GLOBAL_ONLY)))));
UTF_END;
}
if (--pltcl_call_level == 0)
break;
default:
- elog(ERROR, "pltcl: unsupported TCL return code %d", tcl_rc);
+ elog(ERROR, "unsupported TCL return code: %d", tcl_rc);
}
/************************************************************
* the magic strings OK or SKIP or a list from array get
************************************************************/
if (SPI_finish() != SPI_OK_FINISH)
- elog(ERROR, "pltcl: SPI_finish() failed");
+ elog(ERROR, "SPI_finish() failed");
if (strcmp(interp->result, "OK") == 0)
return rettup;
************************************************************/
if (Tcl_SplitList(interp, interp->result,
&ret_numvals, &ret_values) != TCL_OK)
- {
- elog(WARNING, "pltcl: cannot split return value from trigger");
- elog(ERROR, "pltcl: %s", interp->result);
- }
+ elog(ERROR, "could not split return value from trigger: %s",
+ interp->result);
if (ret_numvals % 2 != 0)
{
ckfree((char *) ret_values);
- elog(ERROR, "pltcl: invalid return list from trigger - must have even # of elements");
+ elog(ERROR, "invalid return list from trigger - must have even # of elements");
}
modattrs = (int *) palloc(tupdesc->natts * sizeof(int));
************************************************************/
attnum = SPI_fnumber(tupdesc, ret_values[i++]);
if (attnum == SPI_ERROR_NOATTRIBUTE)
- elog(ERROR, "pltcl: invalid attribute '%s'", ret_values[--i]);
+ elog(ERROR, "invalid attribute \"%s\"",
+ ret_values[--i]);
if (attnum <= 0)
- elog(ERROR, "pltcl: cannot set system attribute '%s'", ret_values[--i]);
+ elog(ERROR, "cannot set system attribute \"%s\"",
+ ret_values[--i]);
/************************************************************
* Lookup the attribute type in the syscache
ObjectIdGetDatum(tupdesc->attrs[attnum - 1]->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
- {
- elog(ERROR, "pltcl: Cache lookup for attribute '%s' type %u failed",
- ret_values[--i],
+ elog(ERROR, "cache lookup failed for type %u",
tupdesc->attrs[attnum - 1]->atttypid);
- }
typinput = ((Form_pg_type) GETSTRUCT(typeTup))->typinput;
typelem = ((Form_pg_type) GETSTRUCT(typeTup))->typelem;
ReleaseSysCache(typeTup);
pfree(modnulls);
if (rettup == NULL)
- elog(ERROR, "pltcl: SPI_modifytuple() failed - RC = %d\n", SPI_result);
+ elog(ERROR, "SPI_modifytuple() failed - RC = %d", SPI_result);
ckfree((char *) ret_values);
memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
ObjectIdGetDatum(fn_oid),
0, 0, 0);
if (!HeapTupleIsValid(procTup))
- elog(ERROR, "pltcl: cache lookup for proc %u failed", fn_oid);
+ elog(ERROR, "cache lookup failed for function %u", fn_oid);
procStruct = (Form_pg_proc) GETSTRUCT(procTup);
/************************************************************
************************************************************/
prodesc = (pltcl_proc_desc *) malloc(sizeof(pltcl_proc_desc));
if (prodesc == NULL)
- elog(ERROR, "pltcl: out of memory");
+ ereport(ERROR,
+ (errcode(ERRCODE_OUT_OF_MEMORY),
+ errmsg("out of memory")));
MemSet(prodesc, 0, sizeof(pltcl_proc_desc));
prodesc->proname = strdup(internal_proname);
prodesc->fn_xmin = HeapTupleHeaderGetXmin(procTup->t_data);
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "pltcl: cache lookup for language %u failed",
+ elog(ERROR, "cache lookup failed for language %u",
procStruct->prolang);
}
langStruct = (Form_pg_language) GETSTRUCT(langTup);
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "pltcl: cache lookup for return type %u failed",
+ elog(ERROR, "cache lookup failed for type %u",
procStruct->prorettype);
}
typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "pltcl functions cannot return type %s"
- "\n\texcept when used as triggers",
- format_type_be(procStruct->prorettype));
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("trigger functions may only be called as triggers")));
}
else
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "pltcl functions cannot return type %s",
- format_type_be(procStruct->prorettype));
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("pltcl functions cannot return type %s",
+ format_type_be(procStruct->prorettype))));
}
}
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "pltcl: return types of tuples not supported yet");
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("pltcl functions cannot return tuples yet")));
}
perm_fmgr_info(typeStruct->typinput, &(prodesc->result_in_func));
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "pltcl: cache lookup for argument type %u failed",
+ elog(ERROR, "cache lookup failed for type %u",
procStruct->proargtypes[i]);
}
typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "pltcl functions cannot take type %s",
- format_type_be(procStruct->proargtypes[i]));
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("pltcl functions cannot take type %s",
+ format_type_be(procStruct->proargtypes[i]))));
}
if (typeStruct->typrelid != InvalidOid)
{
free(prodesc->proname);
free(prodesc);
- elog(ERROR, "pltcl: cannot create internal procedure %s - %s",
+ elog(ERROR, "could not create internal procedure \"%s\": %s",
internal_proname, interp->result);
}
if (plan == NULL)
{
- char buf[128];
- char *reason;
-
memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
-
- switch (SPI_result)
- {
- case SPI_ERROR_ARGUMENT:
- reason = "SPI_ERROR_ARGUMENT";
- break;
-
- case SPI_ERROR_UNCONNECTED:
- reason = "SPI_ERROR_UNCONNECTED";
- break;
-
- case SPI_ERROR_COPY:
- reason = "SPI_ERROR_COPY";
- break;
-
- case SPI_ERROR_CURSOR:
- reason = "SPI_ERROR_CURSOR";
- break;
-
- case SPI_ERROR_TRANSACTION:
- reason = "SPI_ERROR_TRANSACTION";
- break;
-
- case SPI_ERROR_OPUNKNOWN:
- reason = "SPI_ERROR_OPUNKNOWN";
- break;
-
- default:
- snprintf(buf, sizeof(buf), "unknown RC %d", SPI_result);
- reason = buf;
- break;
-
- }
-
- elog(ERROR, "pltcl: SPI_prepare() failed - %s", reason);
+ elog(ERROR, "SPI_prepare() failed");
}
/************************************************************
qdesc->plan = SPI_saveplan(plan);
if (qdesc->plan == NULL)
{
- char buf[128];
- char *reason;
-
memcpy(&Warn_restart, &save_restart, sizeof(Warn_restart));
-
- switch (SPI_result)
- {
- case SPI_ERROR_ARGUMENT:
- reason = "SPI_ERROR_ARGUMENT";
- break;
-
- case SPI_ERROR_UNCONNECTED:
- reason = "SPI_ERROR_UNCONNECTED";
- break;
-
- default:
- snprintf(buf, sizeof(buf), "unknown RC %d", SPI_result);
- reason = buf;
- break;
-
- }
-
- elog(ERROR, "pltcl: SPI_saveplan() failed - %s", reason);
+ elog(ERROR, "SPI_saveplan() failed");
}
/* Release the procCxt copy to avoid within-function memory leak */
SPI_freeplan(plan);
ObjectIdGetDatum(tupdesc->attrs[i]->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
- {
- elog(ERROR, "pltcl: Cache lookup for attribute '%s' type %u failed",
- attname, tupdesc->attrs[i]->atttypid);
- }
+ elog(ERROR, "cache lookup failed for type %u",
+ tupdesc->attrs[i]->atttypid);
typoutput = ((Form_pg_type) GETSTRUCT(typeTup))->typoutput;
typelem = ((Form_pg_type) GETSTRUCT(typeTup))->typelem;
ObjectIdGetDatum(tupdesc->attrs[i]->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
- {
- elog(ERROR, "pltcl: Cache lookup for attribute '%s' type %u failed",
- attname, tupdesc->attrs[i]->atttypid);
- }
+ elog(ERROR, "cache lookup failed for type %u",
+ tupdesc->attrs[i]->atttypid);
typoutput = ((Form_pg_type) GETSTRUCT(typeTup))->typoutput;
typelem = ((Form_pg_type) GETSTRUCT(typeTup))->typelem;
projects / postgresql / commitdiff