* MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/pl/plpython/plpython.c,v 1.68 2005/12/29 21:47:32 neilc Exp $
+ * $PostgreSQL: pgsql/src/pl/plpython/plpython.c,v 1.69 2006/01/09 02:47:09 neilc Exp $
*
*********************************************************************
*/
} PLyTypeInfo;
-/* cached procedure data
- */
+/* cached procedure data */
typedef struct PLyProcedure
{
char *proname; /* SQL name of procedure */
} PLyProcedure;
-/* Python objects.
- */
+/* Python objects */
typedef struct PLyPlanObject
{
PyObject_HEAD
} PLyResultObject;
-/* function declarations
- */
+/* function declarations */
/* Two exported functions: first is the magic telling Postgresql
* what function call interface it implements. Second allows
PG_FUNCTION_INFO_V1(plpython_call_handler);
-/* most of the remaining of the declarations, all static
- */
+/* most of the remaining of the declarations, all static */
/* these should only be called once at the first call
* of plpython_call_handler. initialize the python interpreter
static void PLy_init_interp(void);
static void PLy_init_plpy(void);
-/* call PyErr_SetString with a vprint interface
- */
+/* call PyErr_SetString with a vprint interface */
static void
PLy_exception_set(PyObject *, const char *,...)
__attribute__((format(printf, 2, 3)));
-/* Get the innermost python procedure called from the backend.
- */
+/* Get the innermost python procedure called from the backend */
static char *PLy_procedure_name(PLyProcedure *);
-/* some utility functions
- */
+/* some utility functions */
static void PLy_elog(int, const char *,...);
static char *PLy_traceback(int *);
static char *PLy_vprintf(const char *fmt, va_list ap);
static char *PLy_strdup(const char *);
static void PLy_free(void *);
-/* sub handlers for functions and triggers
- */
+/* sub handlers for functions and triggers */
static Datum PLy_function_handler(FunctionCallInfo fcinfo, PLyProcedure *);
static HeapTuple PLy_trigger_handler(FunctionCallInfo fcinfo, PLyProcedure *);
static void PLy_output_tuple_funcs(PLyTypeInfo *, TupleDesc);
static void PLy_input_tuple_funcs(PLyTypeInfo *, TupleDesc);
-/* conversion functions
- */
+/* conversion functions */
static PyObject *PLyDict_FromTuple(PLyTypeInfo *, HeapTuple, TupleDesc);
static PyObject *PLyBool_FromString(const char *);
static PyObject *PLyFloat_FromString(const char *);
static PyObject *PLyString_FromString(const char *);
-/* global data
- */
+/* global data */
static bool PLy_first_call = true;
/*
static PyObject *PLy_interp_safe_globals = NULL;
static PyObject *PLy_procedure_cache = NULL;
-/* Python exceptions
- */
+/* Python exceptions */
static PyObject *PLy_exc_error = NULL;
static PyObject *PLy_exc_fatal = NULL;
static PyObject *PLy_exc_spi_error = NULL;
-/* some globals for the python module
- */
+/* some globals for the python module */
static char PLy_plan_doc[] = {
"Store a PostgreSQL plan"
};
char *srv;
if (!PyString_Check(plrv))
- elog(ERROR, "expected trigger to return None or a String");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_EXCEPTION),
+ errmsg("unexpected return value from trigger procedure"),
+ errdetail("expected None or a String")));
srv = PyString_AsString(plrv);
if (pg_strcasecmp(srv, "SKIP") == 0)
else if (pg_strcasecmp(srv, "OK") != 0)
{
/*
- * hmmm, perhaps they only read the pltcl page, not a
- * surprising thing since i've written no documentation, so
- * accept a belated OK
+ * accept "OK" as an alternative to None; otherwise,
+ * raise an error
*/
- elog(ERROR, "expected return to be \"SKIP\" or \"MODIFY\"");
+ ereport(ERROR,
+ (errcode(ERRCODE_DATA_EXCEPTION),
+ errmsg("unexpected return value from trigger procedure"),
+ errdetail("expected None, \"OK\", \"SKIP\", or \"MODIFY\"")));
}
}
}
}
else
{
- modvalues[i] = (Datum) 0;
+ modvalues[i] = PointerGetDatum(NULL);
modnulls[i] = 'n';
}
-/* function handler and friends
- */
+/* function handler and friends */
static Datum
PLy_function_handler(FunctionCallInfo fcinfo, PLyProcedure * proc)
{
if (plrv == Py_None)
{
fcinfo->isnull = true;
- rv = (Datum) NULL;
+ rv = PointerGetDatum(NULL);
}
else
{
ObjectIdGetDatum(proc->result.out.d.typioparam),
Int32GetDatum(-1));
}
-
}
PG_CATCH();
{
proc->globals = PyDict_Copy(PLy_interp_globals);
/*
- * SD is private preserved data between calls GD is global data shared by
- * all functions
+ * SD is private preserved data between calls. GD is global data
+ * shared by all functions
*/
proc->statics = PyDict_New();
PyDict_SetItemString(proc->globals, "SD", proc->statics);
}
}
-/* assumes that a bool is always returned as a 't' or 'f'
- */
+/* assumes that a bool is always returned as a 't' or 'f' */
static PyObject *
PLyBool_FromString(const char *src)
{
return dict;
}
-/* initialization, some python variables function declared here
- */
+/* initialization, some python variables function declared here */
-/* interface to postgresql elog
- */
+/* interface to postgresql elog */
static PyObject *PLy_debug(PyObject *, PyObject *);
static PyObject *PLy_log(PyObject *, PyObject *);
static PyObject *PLy_info(PyObject *, PyObject *);
static PyObject *PLy_error(PyObject *, PyObject *);
static PyObject *PLy_fatal(PyObject *, PyObject *);
-/* PLyPlanObject, PLyResultObject and SPI interface
- */
+/* PLyPlanObject, PLyResultObject and SPI interface */
#define is_PLyPlanObject(x) ((x)->ob_type == &PLy_PlanType)
static PyObject *PLy_plan_new(void);
static void PLy_plan_dealloc(PyObject *);
};
-/* plan object methods
- */
+/* plan object methods */
static PyObject *
PLy_plan_new(void)
{
-/* result object methods
- */
+/* result object methods */
static PyObject *
PLy_result_new(void)
return rv;
}
-/* SPI interface
- */
+/* SPI interface */
static PyObject *
PLy_spi_prepare(PyObject * self, PyObject * args)
{
for (i = 0; i < nargs; i++)
{
PLy_typeinfo_init(&plan->args[i]);
- plan->values[i] = (Datum) NULL;
+ plan->values[i] = PointerGetDatum(NULL);
}
for (i = 0; i < nargs; i++)
else
{
Py_DECREF(elem);
- plan->values[i] = (Datum) 0;
+ plan->values[i] = PointerGetDatum(NULL);
nulls[i] = 'n';
}
}
for (i = 0; i < nargs; i++)
{
if (!plan->args[i].out.d.typbyval &&
- (plan->values[i] != (Datum) NULL))
+ (plan->values[i] != PointerGetDatum(NULL)))
{
pfree(DatumGetPointer(plan->values[i]));
- plan->values[i] = (Datum) NULL;
+ plan->values[i] = PointerGetDatum(NULL);
}
}
for (i = 0; i < nargs; i++)
{
if (!plan->args[i].out.d.typbyval &&
- (plan->values[i] != (Datum) NULL))
+ (plan->values[i] != PointerGetDatum(NULL)))
{
pfree(DatumGetPointer(plan->values[i]));
- plan->values[i] = (Datum) NULL;
+ plan->values[i] = PointerGetDatum(NULL);
}
}
/*
- * Get the last procedure name called by the backend ( the innermost,
- * If a plpython procedure call calls the backend and the backend calls
- * another plpython procedure )
+ * Get the name of the last procedure called by the backend (the
+ * innermost, if a plpython procedure call calls the backend and the
+ * backend calls another plpython procedure).
*
* NB: this returns the SQL name, not the internal Python procedure name
*/
-
static char *
PLy_procedure_name(PLyProcedure * proc)
{
return NULL;
}
-/* python module code
- */
-
-
-/* some dumb utility functions
- */
+/* python module code */
+/* some dumb utility functions */
static void *
PLy_malloc(size_t bytes)
{
return result;
}
-/* define this away
- */
+/* define this away */
static void
PLy_free(void *ptr)
{
projects / postgresql / commitdiff