pl/python refactoring

diff --git a/src/pl/plpython/expected/plpython_do.out b/src/pl/plpython/expected/plpython_do.out
index 9de261a..a21b088 100644
*** a/src/pl/plpython/expected/plpython_do.out
--- b/src/pl/plpython/expected/plpython_do.out
*************** DO $$ plpy.notice("This is plpythonu.")
*** 2,6 ****
  NOTICE:  This is plpythonu.
  CONTEXT:  PL/Python anonymous code block
  DO $$ nonsense $$ LANGUAGE plpythonu;
! ERROR:  PL/Python: NameError: global name 'nonsense' is not defined
  CONTEXT:  PL/Python anonymous code block
--- 2,6 ----
  NOTICE:  This is plpythonu.
  CONTEXT:  PL/Python anonymous code block
  DO $$ nonsense $$ LANGUAGE plpythonu;
! ERROR:  NameError: global name 'nonsense' is not defined
  CONTEXT:  PL/Python anonymous code block
diff --git a/src/pl/plpython/expected/plpython_error.out b/src/pl/plpython/expected/plpython_error.out
index 1f24c13..70890a8 100644
*** a/src/pl/plpython/expected/plpython_error.out
--- b/src/pl/plpython/expected/plpython_error.out
*************** CREATE FUNCTION sql_syntax_error() RETUR
*** 8,19 ****
  'plpy.execute("syntax error")'
          LANGUAGE plpythonu;
  SELECT sql_syntax_error();
! WARNING:  PL/Python: plpy.SPIError: unrecognized error in PLy_spi_execute_query
  CONTEXT:  PL/Python function "sql_syntax_error"
! ERROR:  syntax error at or near "syntax"
! LINE 1: syntax error
!         ^
! QUERY:  syntax error
  CONTEXT:  PL/Python function "sql_syntax_error"
  /* check the handling of uncaught python exceptions
   */
--- 8,16 ----
  'plpy.execute("syntax error")'
          LANGUAGE plpythonu;
  SELECT sql_syntax_error();
! WARNING:  plpy.SPIError: unrecognized error in PLy_spi_execute_query
  CONTEXT:  PL/Python function "sql_syntax_error"
! ERROR:  plpy.SPIError: syntax error at or near "syntax"
  CONTEXT:  PL/Python function "sql_syntax_error"
  /* check the handling of uncaught python exceptions
   */
*************** CREATE FUNCTION exception_index_invalid(
*** 22,28 ****
  'return args[1]'
  	LANGUAGE plpythonu;
  SELECT exception_index_invalid('test');
! ERROR:  PL/Python: IndexError: list index out of range
  CONTEXT:  PL/Python function "exception_index_invalid"
  /* check handling of nested exceptions
   */
--- 19,25 ----
  'return args[1]'
  	LANGUAGE plpythonu;
  SELECT exception_index_invalid('test');
! ERROR:  IndexError: list index out of range
  CONTEXT:  PL/Python function "exception_index_invalid"
  /* check handling of nested exceptions
   */
*************** CREATE FUNCTION exception_index_invalid_
*** 32,44 ****
  return rv[0]'
  	LANGUAGE plpythonu;
  SELECT exception_index_invalid_nested();
! WARNING:  PL/Python: plpy.SPIError: unrecognized error in PLy_spi_execute_query
  CONTEXT:  PL/Python function "exception_index_invalid_nested"
! ERROR:  function test5(unknown) does not exist
! LINE 1: SELECT test5('foo')
!                ^
! HINT:  No function matches the given name and argument types. You might need to add explicit type casts.
! QUERY:  SELECT test5('foo')
  CONTEXT:  PL/Python function "exception_index_invalid_nested"
  /* a typo
   */
--- 29,37 ----
  return rv[0]'
  	LANGUAGE plpythonu;
  SELECT exception_index_invalid_nested();
! WARNING:  plpy.SPIError: unrecognized error in PLy_spi_execute_query
  CONTEXT:  PL/Python function "exception_index_invalid_nested"
! ERROR:  plpy.SPIError: function test5(unknown) does not exist
  CONTEXT:  PL/Python function "exception_index_invalid_nested"
  /* a typo
   */
*************** return None
*** 54,62 ****
  '
  	LANGUAGE plpythonu;
  SELECT invalid_type_uncaught('rick');
! WARNING:  PL/Python: plpy.SPIError: unrecognized error in PLy_spi_prepare
  CONTEXT:  PL/Python function "invalid_type_uncaught"
! ERROR:  type "test" does not exist
  CONTEXT:  PL/Python function "invalid_type_uncaught"
  /* for what it's worth catch the exception generated by
   * the typo, and return None
--- 47,55 ----
  '
  	LANGUAGE plpythonu;
  SELECT invalid_type_uncaught('rick');
! WARNING:  plpy.SPIError: unrecognized error in PLy_spi_prepare
  CONTEXT:  PL/Python function "invalid_type_uncaught"
! ERROR:  plpy.SPIError: type "test" does not exist
  CONTEXT:  PL/Python function "invalid_type_uncaught"
  /* for what it's worth catch the exception generated by
   * the typo, and return None
*************** return None
*** 77,86 ****
  '
  	LANGUAGE plpythonu;
  SELECT invalid_type_caught('rick');
! WARNING:  PL/Python: plpy.SPIError: unrecognized error in PLy_spi_prepare
  CONTEXT:  PL/Python function "invalid_type_caught"
! ERROR:  type "test" does not exist
  CONTEXT:  PL/Python function "invalid_type_caught"
  /* for what it's worth catch the exception generated by
   * the typo, and reraise it as a plain error
   */
--- 70,84 ----
  '
  	LANGUAGE plpythonu;
  SELECT invalid_type_caught('rick');
! WARNING:  plpy.SPIError: unrecognized error in PLy_spi_prepare
  CONTEXT:  PL/Python function "invalid_type_caught"
! NOTICE:  type "test" does not exist
  CONTEXT:  PL/Python function "invalid_type_caught"
+  invalid_type_caught 
+ ---------------------
+  
+ (1 row)
+ 
  /* for what it's worth catch the exception generated by
   * the typo, and reraise it as a plain error
   */
*************** return None
*** 99,107 ****
  '
  	LANGUAGE plpythonu;
  SELECT invalid_type_reraised('rick');
! WARNING:  PL/Python: plpy.SPIError: unrecognized error in PLy_spi_prepare
  CONTEXT:  PL/Python function "invalid_type_reraised"
! ERROR:  type "test" does not exist
  CONTEXT:  PL/Python function "invalid_type_reraised"
  /* no typo no messing about
   */
--- 97,105 ----
  '
  	LANGUAGE plpythonu;
  SELECT invalid_type_reraised('rick');
! WARNING:  plpy.SPIError: unrecognized error in PLy_spi_prepare
  CONTEXT:  PL/Python function "invalid_type_reraised"
! ERROR:  plpy.Error: type "test" does not exist
  CONTEXT:  PL/Python function "invalid_type_reraised"
  /* no typo no messing about
   */
diff --git a/src/pl/plpython/expected/plpython_test.out b/src/pl/plpython/expected/plpython_test.out
index a229b18..d92c987 100644
*** a/src/pl/plpython/expected/plpython_test.out
--- b/src/pl/plpython/expected/plpython_test.out
*************** select argument_test_one(users, fname, l
*** 35,40 ****
--- 35,53 ----
   willem doe => {fname: willem, lname: doe, userid: 3, username: w_doe}
  (3 rows)
  
+ -- check module contents
+ CREATE FUNCTION module_contents() RETURNS text AS
+ $$
+ contents = list(filter(lambda x: not x.startswith("__"), dir(plpy)))
+ contents.sort()
+ return ", ".join(contents)
+ $$ LANGUAGE plpythonu;
+ select module_contents();
+                                       module_contents                                      
+ -------------------------------------------------------------------------------------------
+  Error, Fatal, SPIError, debug, error, execute, fatal, info, log, notice, prepare, warning
+ (1 row)
+ 
  CREATE FUNCTION elog_test() RETURNS void
  AS $$
  plpy.debug('debug')
*************** NOTICE:  notice
*** 60,64 ****
  CONTEXT:  PL/Python function "elog_test"
  WARNING:  warning
  CONTEXT:  PL/Python function "elog_test"
! ERROR:  error
  CONTEXT:  PL/Python function "elog_test"
--- 73,77 ----
  CONTEXT:  PL/Python function "elog_test"
  WARNING:  warning
  CONTEXT:  PL/Python function "elog_test"
! ERROR:  plpy.Error: error
  CONTEXT:  PL/Python function "elog_test"
diff --git a/src/pl/plpython/expected/plpython_types.out b/src/pl/plpython/expected/plpython_types.out
index a165936..982005b 100644
*** a/src/pl/plpython/expected/plpython_types.out
--- b/src/pl/plpython/expected/plpython_types.out
*************** CREATE FUNCTION test_type_conversion_arr
*** 596,602 ****
  return 5
  $$ LANGUAGE plpythonu;
  SELECT * FROM test_type_conversion_array_error();
! ERROR:  PL/Python: return value of function with array return type is not a Python sequence
  CONTEXT:  while creating return value
  PL/Python function "test_type_conversion_array_error"
  --
--- 596,602 ----
  return 5
  $$ LANGUAGE plpythonu;
  SELECT * FROM test_type_conversion_array_error();
! ERROR:  return value of function with array return type is not a Python sequence
  CONTEXT:  while creating return value
  PL/Python function "test_type_conversion_array_error"
  --
diff --git a/src/pl/plpython/expected/plpython_types_3.out b/src/pl/plpython/expected/plpython_types_3.out
index 38ddf02..eeb23b7 100644
*** a/src/pl/plpython/expected/plpython_types_3.out
--- b/src/pl/plpython/expected/plpython_types_3.out
*************** CREATE FUNCTION test_type_conversion_arr
*** 596,602 ****
  return 5
  $$ LANGUAGE plpython3u;
  SELECT * FROM test_type_conversion_array_error();
! ERROR:  PL/Python: return value of function with array return type is not a Python sequence
  CONTEXT:  while creating return value
  PL/Python function "test_type_conversion_array_error"
  --
--- 596,602 ----
  return 5
  $$ LANGUAGE plpython3u;
  SELECT * FROM test_type_conversion_array_error();
! ERROR:  return value of function with array return type is not a Python sequence
  CONTEXT:  while creating return value
  PL/Python function "test_type_conversion_array_error"
  --
diff --git a/src/pl/plpython/plpython.c b/src/pl/plpython/plpython.c
index 1ae1239..67eb0f3 100644
*** a/src/pl/plpython/plpython.c
--- b/src/pl/plpython/plpython.c
*************** typedef struct PLyProcedure
*** 214,223 ****
  	PyObject   *code;			/* compiled procedure code */
  	PyObject   *statics;		/* data saved across calls, local scope */
  	PyObject   *globals;		/* data saved across calls, global scope */
- 	PyObject   *me;				/* PyCObject containing pointer to this
- 								 * PLyProcedure */
  } PLyProcedure;
  
  
  /* Python objects */
  typedef struct PLyPlanObject
--- 214,227 ----
  	PyObject   *code;			/* compiled procedure code */
  	PyObject   *statics;		/* data saved across calls, local scope */
  	PyObject   *globals;		/* data saved across calls, global scope */
  } PLyProcedure;
  
+ /* the procedure cache entry */
+ typedef struct PLyProcedureEntry
+ {
+ 	Oid				fn_oid;		/* hash key */
+ 	PLyProcedure	*proc;
+ } PLyProcedureEntry;
  
  /* Python objects */
  typedef struct PLyPlanObject
*************** static HeapTuple PLy_modify_tuple(PLyPro
*** 311,321 ****
  
  static PyObject *PLy_procedure_call(PLyProcedure *, char *, PyObject *);
  
! static PLyProcedure *PLy_procedure_get(FunctionCallInfo fcinfo,
! 				  Oid tgreloid);
  
! static PLyProcedure *PLy_procedure_create(HeapTuple procTup, Oid tgreloid,
! 					 char *key);
  
  static void PLy_procedure_compile(PLyProcedure *, const char *);
  static char *PLy_procedure_munge_source(const char *, const char *);
--- 315,324 ----
  
  static PyObject *PLy_procedure_call(PLyProcedure *, char *, PyObject *);
  
! static PLyProcedure *PLy_procedure_get(Oid fn_oid, bool is_trigger);
  
! static PLyProcedure *PLy_procedure_create(HeapTuple procTup,
! 										  Oid fn_oid, bool is_trigger);
  
  static void PLy_procedure_compile(PLyProcedure *, const char *);
  static char *PLy_procedure_munge_source(const char *, const char *);
*************** static HeapTuple PLyObject_ToTuple(PLyTy
*** 358,379 ****
   */
  static PLyProcedure *PLy_curr_procedure = NULL;
  
- /*
-  * When a callback from Python into PG incurs an error, we temporarily store
-  * the error information here, and return NULL to the Python interpreter.
-  * Any further callback attempts immediately fail, and when the Python
-  * interpreter returns to the calling function, we re-throw the error (even if
-  * Python thinks it trapped the error and doesn't return NULL).  Eventually
-  * this ought to be improved to let Python code really truly trap the error,
-  * but that's more of a change from the pre-8.0 semantics than I have time for
-  * now --- it will only be possible if the callback query is executed inside a
-  * subtransaction.
-  */
- static ErrorData *PLy_error_in_progress = NULL;
  
  static PyObject *PLy_interp_globals = NULL;
  static PyObject *PLy_interp_safe_globals = NULL;
! static PyObject *PLy_procedure_cache = NULL;
  
  /* Python exceptions */
  static PyObject *PLy_exc_error = NULL;
--- 361,371 ----
   */
  static PLyProcedure *PLy_curr_procedure = NULL;
  
  
  static PyObject *PLy_interp_globals = NULL;
  static PyObject *PLy_interp_safe_globals = NULL;
! static HTAB *PLy_procedure_cache = NULL;
! static HTAB *PLy_trigger_cache = NULL;
  
  /* Python exceptions */
  static PyObject *PLy_exc_error = NULL;
*************** plpython_call_handler(PG_FUNCTION_ARGS)
*** 444,450 ****
  {
  	Datum		retval;
  	PLyProcedure *save_curr_proc;
! 	PLyProcedure *volatile proc = NULL;
  	ErrorContextCallback plerrcontext;
  
  	if (SPI_connect() != SPI_OK_CONNECT)
--- 436,442 ----
  {
  	Datum		retval;
  	PLyProcedure *save_curr_proc;
! 	PLyProcedure *proc = NULL;
  	ErrorContextCallback plerrcontext;
  
  	if (SPI_connect() != SPI_OK_CONNECT)
*************** plpython_call_handler(PG_FUNCTION_ARGS)
*** 463,480 ****
  	{
  		if (CALLED_AS_TRIGGER(fcinfo))
  		{
- 			TriggerData *tdata = (TriggerData *) fcinfo->context;
  			HeapTuple	trv;
  
! 			proc = PLy_procedure_get(fcinfo,
! 									 RelationGetRelid(tdata->tg_relation));
  			PLy_curr_procedure = proc;
  			trv = PLy_trigger_handler(fcinfo, proc);
  			retval = PointerGetDatum(trv);
  		}
  		else
  		{
! 			proc = PLy_procedure_get(fcinfo, InvalidOid);
  			PLy_curr_procedure = proc;
  			retval = PLy_function_handler(fcinfo, proc);
  		}
--- 455,470 ----
  	{
  		if (CALLED_AS_TRIGGER(fcinfo))
  		{
  			HeapTuple	trv;
  
! 			proc = PLy_procedure_get(fcinfo->flinfo->fn_oid, true);
  			PLy_curr_procedure = proc;
  			trv = PLy_trigger_handler(fcinfo, proc);
  			retval = PointerGetDatum(trv);
  		}
  		else
  		{
! 			proc = PLy_procedure_get(fcinfo->flinfo->fn_oid, false);
  			PLy_curr_procedure = proc;
  			retval = PLy_function_handler(fcinfo, proc);
  		}
*************** plpython_call_handler(PG_FUNCTION_ARGS)
*** 482,492 ****
  	PG_CATCH();
  	{
  		PLy_curr_procedure = save_curr_proc;
- 		if (proc)
- 		{
- 			/* note: Py_DECREF needs braces around it, as of 2003/08 */
- 			Py_DECREF(proc->me);
- 		}
  		PyErr_Clear();
  		PG_RE_THROW();
  	}
--- 472,477 ----
*************** plpython_call_handler(PG_FUNCTION_ARGS)
*** 497,504 ****
  
  	PLy_curr_procedure = save_curr_proc;
  
- 	Py_DECREF(proc->me);
- 
  	return retval;
  }
  
--- 482,487 ----
*************** static HeapTuple
*** 573,580 ****
  PLy_trigger_handler(FunctionCallInfo fcinfo, PLyProcedure *proc)
  {
  	HeapTuple	rv = NULL;
! 	PyObject   *volatile plargs = NULL;
! 	PyObject   *volatile plrv = NULL;
  
  	PG_TRY();
  	{
--- 556,578 ----
  PLy_trigger_handler(FunctionCallInfo fcinfo, PLyProcedure *proc)
  {
  	HeapTuple	rv = NULL;
! 	PyObject	*volatile plargs = NULL;
! 	PyObject   	*volatile plrv = NULL;
! 	TriggerData	*tdata;
! 
! 	AssertMacro(CALLED_AS_TRIGGER(fcinfo));
! 	/*
! 	 * Input/output conversion for trigger tuples.	Use the result
! 	 * TypeInfo variable to store the tuple conversion info.  We do this
! 	 * over again on each call to cover the possibility that the
! 	 * relation's tupdesc changed since the trigger was last called.
! 	 * PLy_input_tuple_funcs and PLy_output_tuple_funcs are responsible
! 	 * for not doing repetitive work.
! 	 */
! 	tdata = (TriggerData *) fcinfo->context;
! 
! 	PLy_input_tuple_funcs(&(proc->result), tdata->tg_relation->rd_att);
! 	PLy_output_tuple_funcs(&(proc->result), tdata->tg_relation->rd_att);
  
  	PG_TRY();
  	{
*************** PLy_trigger_handler(FunctionCallInfo fci
*** 582,588 ****
  		plrv = PLy_procedure_call(proc, "TD", plargs);
  
  		Assert(plrv != NULL);
- 		Assert(!PLy_error_in_progress);
  
  		/*
  		 * Disconnect from SPI manager
--- 580,585 ----
*************** PLy_function_handler(FunctionCallInfo fc
*** 992,1005 ****
  			plargs = PLy_function_build_args(fcinfo, proc);
  			plrv = PLy_procedure_call(proc, "args", plargs);
  			if (!proc->is_setof)
! 
  				/*
  				 * SETOF function parameters will be deleted when last row is
  				 * returned
  				 */
  				PLy_function_delete_args(proc);
  			Assert(plrv != NULL);
- 			Assert(!PLy_error_in_progress);
  		}
  
  		/*
--- 989,1002 ----
  			plargs = PLy_function_build_args(fcinfo, proc);
  			plrv = PLy_procedure_call(proc, "args", plargs);
  			if (!proc->is_setof)
! 			{
  				/*
  				 * SETOF function parameters will be deleted when last row is
  				 * returned
  				 */
  				PLy_function_delete_args(proc);
+ 			}
  			Assert(plrv != NULL);
  		}
  
  		/*
*************** PLy_function_handler(FunctionCallInfo fc
*** 1149,1154 ****
--- 1146,1159 ----
  		Py_XDECREF(plargs);
  		Py_XDECREF(plrv);
  
+ 		/*
+ 		 * If there was an error the iterator might have not been exhausted
+ 		 * yet. Set it to NULL so the next invocation of the function will
+ 		 * start the iteration again.
+ 		 */
+ 		Py_XDECREF(proc->setof);
+ 		proc->setof = NULL;
+ 
  		PG_RE_THROW();
  	}
  	PG_END_TRY();
*************** PLy_procedure_call(PLyProcedure *proc, c
*** 1174,1192 ****
  	 * If there was an error in a PG callback, propagate that no matter what
  	 * Python claims about its success.
  	 */
- 	if (PLy_error_in_progress)
- 	{
- 		ErrorData  *edata = PLy_error_in_progress;
- 
- 		PLy_error_in_progress = NULL;
- 		ReThrowError(edata);
- 	}
  
! 	if (rv == NULL || PyErr_Occurred())
! 	{
! 		Py_XDECREF(rv);
  		PLy_elog(ERROR, NULL);
- 	}
  
  	return rv;
  }
--- 1179,1188 ----
  	 * If there was an error in a PG callback, propagate that no matter what
  	 * Python claims about its success.
  	 */
  
! 	/* if the Python code returned an error, propagate it */
! 	if (rv == NULL)
  		PLy_elog(ERROR, NULL);
  
  	return rv;
  }
*************** PLy_function_delete_args(PLyProcedure *p
*** 1286,1291 ****
--- 1282,1301 ----
  }
  
  
+ /* Decide if a cached PLyProcedure struct is still valid */
+ static bool
+ PLy_procedure_valid(PLyProcedure *proc, HeapTuple procTup)
+ {
+ 	Assert(proc != NULL);
+ 
+ 	/* If the pg_proc tuple has changed, it's not valid */
+ 	if (!(proc->fn_xmin == HeapTupleHeaderGetXmin(procTup->t_data) &&
+ 		  ItemPointerEquals(&proc->fn_tid, &procTup->t_self)))
+ 		return false;
+ 
+ 	return true;
+ }
+ 
  /*
   * PLyProcedure functions
   */
*************** PLy_function_delete_args(PLyProcedure *p
*** 1296,1368 ****
   * function calls.
   */
  static PLyProcedure *
! PLy_procedure_get(FunctionCallInfo fcinfo, Oid tgreloid)
  {
! 	Oid			fn_oid;
! 	HeapTuple	procTup;
! 	char		key[128];
! 	PyObject   *plproc;
! 	PLyProcedure *proc = NULL;
! 	int			rv;
  
- 	fn_oid = fcinfo->flinfo->fn_oid;
  	procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(fn_oid));
  	if (!HeapTupleIsValid(procTup))
  		elog(ERROR, "cache lookup failed for function %u", fn_oid);
  
! 	rv = snprintf(key, sizeof(key), "%u_%u", fn_oid, tgreloid);
! 	if (rv >= sizeof(key) || rv < 0)
! 		elog(ERROR, "key too long");
! 
! 	plproc = PyDict_GetItemString(PLy_procedure_cache, key);
  
! 	if (plproc != NULL)
  	{
! 		Py_INCREF(plproc);
! 		if (!PyCObject_Check(plproc))
! 			elog(FATAL, "expected a PyCObject, didn't get one");
! 
! 		proc = PyCObject_AsVoidPtr(plproc);
! 		if (!proc)
! 			PLy_elog(ERROR, "PyCObject_AsVoidPtr() failed");
! 		if (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) ||
! 			!ItemPointerEquals(&proc->fn_tid, &procTup->t_self))
  		{
! 			Py_DECREF(plproc);
! 			proc = NULL;
  		}
  	}
  
! 	if (proc == NULL)
! 		proc = PLy_procedure_create(procTup, tgreloid, key);
  
! 	if (OidIsValid(tgreloid))
  	{
  		/*
! 		 * Input/output conversion for trigger tuples.	Use the result
! 		 * TypeInfo variable to store the tuple conversion info.  We do this
! 		 * over again on each call to cover the possibility that the
! 		 * relation's tupdesc changed since the trigger was last called.
! 		 * PLy_input_tuple_funcs and PLy_output_tuple_funcs are responsible
! 		 * for not doing repetitive work.
  		 */
! 		TriggerData *tdata = (TriggerData *) fcinfo->context;
  
! 		Assert(CALLED_AS_TRIGGER(fcinfo));
! 		PLy_input_tuple_funcs(&(proc->result), tdata->tg_relation->rd_att);
! 		PLy_output_tuple_funcs(&(proc->result), tdata->tg_relation->rd_att);
  	}
  
! 	ReleaseSysCache(procTup);
  
! 	return proc;
  }
  
  static PLyProcedure *
! PLy_procedure_create(HeapTuple procTup, Oid tgreloid, char *key)
  {
  	char		procName[NAMEDATALEN + 256];
  	Form_pg_proc procStruct;
--- 1306,1492 ----
   * function calls.
   */
  static PLyProcedure *
! PLy_procedure_get(Oid fn_oid, bool is_trigger)
  {
! 	HeapTuple			procTup;
! 	PLyProcedureEntry	*entry;
! 	bool				found;
  
  	procTup = SearchSysCache1(PROCOID, ObjectIdGetDatum(fn_oid));
  	if (!HeapTupleIsValid(procTup))
  		elog(ERROR, "cache lookup failed for function %u", fn_oid);
  
! 	/* Look for the function in the corresponding cache */
! 	if (is_trigger)
! 		entry = hash_search(PLy_trigger_cache,
! 							&fn_oid, HASH_ENTER, &found);
! 	else
! 		entry = hash_search(PLy_procedure_cache,
! 							&fn_oid, HASH_ENTER, &found);
  
! 	PG_TRY();
  	{
! 		if (!found)
  		{
! 			/* Haven't found it, create a new cache entry */
! 			entry->proc = PLy_procedure_create(procTup, fn_oid, is_trigger);
  		}
+ 		else if (!PLy_procedure_valid(entry->proc, procTup))
+ 		{
+ 			/* Found it, but it's invalid, free and reuse the cache entry */
+ 			PLy_procedure_delete(entry->proc);
+ 			PLy_free(entry->proc);
+ 			entry->proc = PLy_procedure_create(procTup, fn_oid, is_trigger);
+ 		}
+ 		/* Found it and it's valid, it's fine to use it */
+ 	}
+ 	PG_CATCH();
+ 	{
+ 		/* Do not leave an uninitialised entry in the cache */
+ 		if (is_trigger)
+ 			hash_search(PLy_trigger_cache,
+ 						&fn_oid, HASH_REMOVE, NULL);
+ 		else
+ 			hash_search(PLy_procedure_cache,
+ 						&fn_oid, HASH_REMOVE, NULL);
+ 		PG_RE_THROW();
  	}
+ 	PG_END_TRY();
  
! 	ReleaseSysCache(procTup);
  
! 	return entry->proc;
! }
! 
! /* Set up output conversion functions for a procedure */
! static void
! PLy_procedure_output_conversion(PLyProcedure *proc, Form_pg_proc procStruct)
! {
! 	HeapTuple	rvTypeTup;
! 	Form_pg_type rvTypeStruct;
! 
! 	/* Get the return type */
! 	rvTypeTup = SearchSysCache1(TYPEOID,
! 								ObjectIdGetDatum(procStruct->prorettype));
! 	if (!HeapTupleIsValid(rvTypeTup))
! 		elog(ERROR, "cache lookup failed for type %u",
! 			 procStruct->prorettype);
! 	rvTypeStruct = (Form_pg_type) GETSTRUCT(rvTypeTup);
! 
! 	/* Disallow pseudotype result, except for void */
! 	if (rvTypeStruct->typtype == TYPTYPE_PSEUDO &&
! 		procStruct->prorettype != VOIDOID)
! 	{
! 		if (procStruct->prorettype == TRIGGEROID)
! 			ereport(ERROR,
! 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 					 errmsg("trigger functions can only be called as triggers")));
! 		else
! 			ereport(ERROR,
! 					(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 					 errmsg("PL/Python functions cannot return type %s",
! 							format_type_be(procStruct->prorettype))));
! 	}
! 
! 	if (rvTypeStruct->typtype == TYPTYPE_COMPOSITE)
  	{
  		/*
! 		 * Tuple: set up later, during first call to
! 		 * PLy_function_handler
  		 */
! 		proc->result.out.d.typoid = procStruct->prorettype;
! 		proc->result.is_rowtype = 2;
! 	}
! 	else
! 	{
! 		/* Do the real work */
! 		PLy_output_datum_func(&proc->result, rvTypeTup);
! 	}
  
! 	ReleaseSysCache(rvTypeTup);
! }
! 
! /* Set up output conversion functions for a procedure */
! static void
! PLy_procedure_input_conversion(PLyProcedure *proc, HeapTuple procTup,
! 							   Form_pg_proc procStruct)
! {
! 	Oid		*types;
! 	char	**names,
! 			*modes;
! 	int		i,
! 			pos,
! 			total;
! 
! 	/* Extract argument type info from the pg_proc tuple */
! 	total = get_func_arg_info(procTup, &types, &names, &modes);
! 
! 	/* Count number of in+inout args into proc->nargs */
! 	if (modes == NULL)
! 		proc->nargs = total;
! 	else
! 	{
! 		/* proc->nargs was initialized to 0 above */
! 		for (i = 0; i < total; i++)
! 		{
! 			if (modes[i] != PROARGMODE_OUT &&
! 				modes[i] != PROARGMODE_TABLE)
! 				(proc->nargs)++;
! 		}
  	}
  
! 	proc->argnames = (char **) PLy_malloc0(sizeof(char *) * proc->nargs);
! 	for (i = pos = 0; i < total; i++)
! 	{
! 		HeapTuple	argTypeTup;
! 		Form_pg_type argTypeStruct;
  
! 		if (modes &&
! 			(modes[i] == PROARGMODE_OUT ||
! 			 modes[i] == PROARGMODE_TABLE))
! 			continue;	/* skip OUT arguments */
! 
! 		Assert(types[i] == procStruct->proargtypes.values[pos]);
! 
! 		argTypeTup = SearchSysCache1(TYPEOID,
! 									 ObjectIdGetDatum(types[i]));
! 		if (!HeapTupleIsValid(argTypeTup))
! 			elog(ERROR, "cache lookup failed for type %u", types[i]);
! 		argTypeStruct = (Form_pg_type) GETSTRUCT(argTypeTup);
! 
! 		/* Check argument type is OK, set up I/O function info */
! 		switch (argTypeStruct->typtype)
! 		{
! 			case TYPTYPE_PSEUDO:
! 				/* Disallow pseudotype argument */
! 				ereport(ERROR,
! 						(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 						 errmsg("PL/Python functions cannot accept type %s",
! 								format_type_be(types[i]))));
! 				break;
! 			case TYPTYPE_COMPOSITE:
! 				/* We'll set IO funcs at first call */
! 				proc->args[pos].is_rowtype = 2;
! 				break;
! 			default:
! 				PLy_input_datum_func(&(proc->args[pos]),
! 									 types[i],
! 									 argTypeTup);
! 				break;
! 		}
! 
! 		/* Get argument name */
! 		proc->argnames[pos] = names ? PLy_strdup(names[i]) : NULL;
! 
! 		ReleaseSysCache(argTypeTup);
! 
! 		pos++;
! 	}
  }
  
+ /* Create a new PLyProcedure structure */
  static PLyProcedure *
! PLy_procedure_create(HeapTuple procTup, Oid fn_oid, bool is_trigger)
  {
  	char		procName[NAMEDATALEN + 256];
  	Form_pg_proc procStruct;
*************** PLy_procedure_create(HeapTuple procTup,
*** 1373,1395 ****
  	int			i,
  				rv;
  
! 	procStruct = (Form_pg_proc) GETSTRUCT(procTup);
  
! 	if (OidIsValid(tgreloid))
! 		rv = snprintf(procName, sizeof(procName),
! 					  "__plpython_procedure_%s_%u_trigger_%u",
! 					  NameStr(procStruct->proname),
! 					  HeapTupleGetOid(procTup),
! 					  tgreloid);
! 	else
! 		rv = snprintf(procName, sizeof(procName),
! 					  "__plpython_procedure_%s_%u",
! 					  NameStr(procStruct->proname),
! 					  HeapTupleGetOid(procTup));
  	if (rv >= sizeof(procName) || rv < 0)
  		elog(ERROR, "procedure name would overrun buffer");
  
- 	proc = PLy_malloc(sizeof(PLyProcedure));
  	proc->proname = PLy_strdup(NameStr(procStruct->proname));
  	proc->pyname = PLy_strdup(procName);
  	proc->fn_xmin = HeapTupleHeaderGetXmin(procTup->t_data);
--- 1497,1512 ----
  	int			i,
  				rv;
  
! 	proc = PLy_malloc(sizeof(PLyProcedure));
  
! 	procStruct = (Form_pg_proc) GETSTRUCT(procTup);
! 	rv = snprintf(procName, sizeof(procName),
! 				  "__plpython_procedure_%s_%u",
! 				  NameStr(procStruct->proname),
! 				  fn_oid);
  	if (rv >= sizeof(procName) || rv < 0)
  		elog(ERROR, "procedure name would overrun buffer");
  
  	proc->proname = PLy_strdup(NameStr(procStruct->proname));
  	proc->pyname = PLy_strdup(procName);
  	proc->fn_xmin = HeapTupleHeaderGetXmin(procTup->t_data);
*************** PLy_procedure_create(HeapTuple procTup,
*** 1402,1408 ****
  		PLy_typeinfo_init(&proc->args[i]);
  	proc->nargs = 0;
  	proc->code = proc->statics = NULL;
! 	proc->globals = proc->me = NULL;
  	proc->is_setof = procStruct->proretset;
  	proc->setof = NULL;
  	proc->argnames = NULL;
--- 1519,1525 ----
  		PLy_typeinfo_init(&proc->args[i]);
  	proc->nargs = 0;
  	proc->code = proc->statics = NULL;
! 	proc->globals = NULL;
  	proc->is_setof = procStruct->proretset;
  	proc->setof = NULL;
  	proc->argnames = NULL;
*************** PLy_procedure_create(HeapTuple procTup,
*** 1413,1459 ****
  		 * get information required for output conversion of the return value,
  		 * but only if this isn't a trigger.
  		 */
! 		if (!OidIsValid(tgreloid))
! 		{
! 			HeapTuple	rvTypeTup;
! 			Form_pg_type rvTypeStruct;
! 
! 			rvTypeTup = SearchSysCache1(TYPEOID,
! 								   ObjectIdGetDatum(procStruct->prorettype));
! 			if (!HeapTupleIsValid(rvTypeTup))
! 				elog(ERROR, "cache lookup failed for type %u",
! 					 procStruct->prorettype);
! 			rvTypeStruct = (Form_pg_type) GETSTRUCT(rvTypeTup);
! 
! 			/* Disallow pseudotype result, except for void */
! 			if (rvTypeStruct->typtype == TYPTYPE_PSEUDO &&
! 				procStruct->prorettype != VOIDOID)
! 			{
! 				if (procStruct->prorettype == TRIGGEROID)
! 					ereport(ERROR,
! 							(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 							 errmsg("trigger functions can only be called as triggers")));
! 				else
! 					ereport(ERROR,
! 							(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 						  errmsg("PL/Python functions cannot return type %s",
! 								 format_type_be(procStruct->prorettype))));
! 			}
! 
! 			if (rvTypeStruct->typtype == TYPTYPE_COMPOSITE)
! 			{
! 				/*
! 				 * Tuple: set up later, during first call to
! 				 * PLy_function_handler
! 				 */
! 				proc->result.out.d.typoid = procStruct->prorettype;
! 				proc->result.is_rowtype = 2;
! 			}
! 			else
! 				PLy_output_datum_func(&proc->result, rvTypeTup);
! 
! 			ReleaseSysCache(rvTypeTup);
! 		}
  
  		/*
  		 * Now get information required for input conversion of the
--- 1530,1537 ----
  		 * get information required for output conversion of the return value,
  		 * but only if this isn't a trigger.
  		 */
! 		if (!is_trigger)
! 			PLy_procedure_output_conversion(proc, procStruct);
  
  		/*
  		 * Now get information required for input conversion of the
*************** PLy_procedure_create(HeapTuple procTup,
*** 1463,1541 ****
  		 * arguments.
  		 */
  		if (procStruct->pronargs)
! 		{
! 			Oid		   *types;
! 			char	  **names,
! 					   *modes;
! 			int			i,
! 						pos,
! 						total;
! 
! 			/* extract argument type info from the pg_proc tuple */
! 			total = get_func_arg_info(procTup, &types, &names, &modes);
! 
! 			/* count number of in+inout args into proc->nargs */
! 			if (modes == NULL)
! 				proc->nargs = total;
! 			else
! 			{
! 				/* proc->nargs was initialized to 0 above */
! 				for (i = 0; i < total; i++)
! 				{
! 					if (modes[i] != PROARGMODE_OUT &&
! 						modes[i] != PROARGMODE_TABLE)
! 						(proc->nargs)++;
! 				}
! 			}
! 
! 			proc->argnames = (char **) PLy_malloc0(sizeof(char *) * proc->nargs);
! 			for (i = pos = 0; i < total; i++)
! 			{
! 				HeapTuple	argTypeTup;
! 				Form_pg_type argTypeStruct;
! 
! 				if (modes &&
! 					(modes[i] == PROARGMODE_OUT ||
! 					 modes[i] == PROARGMODE_TABLE))
! 					continue;	/* skip OUT arguments */
! 
! 				Assert(types[i] == procStruct->proargtypes.values[pos]);
! 
! 				argTypeTup = SearchSysCache1(TYPEOID,
! 											 ObjectIdGetDatum(types[i]));
! 				if (!HeapTupleIsValid(argTypeTup))
! 					elog(ERROR, "cache lookup failed for type %u", types[i]);
! 				argTypeStruct = (Form_pg_type) GETSTRUCT(argTypeTup);
! 
! 				/* check argument type is OK, set up I/O function info */
! 				switch (argTypeStruct->typtype)
! 				{
! 					case TYPTYPE_PSEUDO:
! 						/* Disallow pseudotype argument */
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 						  errmsg("PL/Python functions cannot accept type %s",
! 								 format_type_be(types[i]))));
! 						break;
! 					case TYPTYPE_COMPOSITE:
! 						/* we'll set IO funcs at first call */
! 						proc->args[pos].is_rowtype = 2;
! 						break;
! 					default:
! 						PLy_input_datum_func(&(proc->args[pos]),
! 											 types[i],
! 											 argTypeTup);
! 						break;
! 				}
! 
! 				/* get argument name */
! 				proc->argnames[pos] = names ? PLy_strdup(names[i]) : NULL;
! 
! 				ReleaseSysCache(argTypeTup);
! 
! 				pos++;
! 			}
! 		}
  
  		/*
  		 * get the text of the function.
--- 1541,1547 ----
  		 * arguments.
  		 */
  		if (procStruct->pronargs)
! 			PLy_procedure_input_conversion(proc, procTup, procStruct);
  
  		/*
  		 * get the text of the function.
*************** PLy_procedure_create(HeapTuple procTup,
*** 1550,1560 ****
  
  		pfree(procSource);
  		procSource = NULL;
- 
- 		proc->me = PyCObject_FromVoidPtr(proc, NULL);
- 		if (!proc->me)
- 			PLy_elog(ERROR, "PyCObject_FromVoidPtr() failed");
- 		PyDict_SetItemString(PLy_procedure_cache, key, proc->me);
  	}
  	PG_CATCH();
  	{
--- 1556,1561 ----
*************** PLy_procedure_create(HeapTuple procTup,
*** 1569,1574 ****
--- 1570,1576 ----
  	return proc;
  }
  
+ /* Insert the procedure into the Python interpreter */
  static void
  PLy_procedure_compile(PLyProcedure *proc, const char *src)
  {
*************** PLy_procedure_compile(PLyProcedure *proc
*** 1589,1597 ****
  	 */
  	msrc = PLy_procedure_munge_source(proc->pyname, src);
  	crv = PyRun_String(msrc, Py_file_input, proc->globals, NULL);
! 	free(msrc);
  
! 	if (crv != NULL && (!PyErr_Occurred()))
  	{
  		int			clen;
  		char		call[NAMEDATALEN + 256];
--- 1591,1599 ----
  	 */
  	msrc = PLy_procedure_munge_source(proc->pyname, src);
  	crv = PyRun_String(msrc, Py_file_input, proc->globals, NULL);
! 	pfree(msrc);
  
! 	if (crv != NULL)
  	{
  		int			clen;
  		char		call[NAMEDATALEN + 256];
*************** PLy_procedure_compile(PLyProcedure *proc
*** 1605,1617 ****
  		if (clen < 0 || clen >= sizeof(call))
  			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, "could not compile PL/Python function \"%s\"", proc->proname);
  }
  
  static char *
--- 1607,1621 ----
  		if (clen < 0 || clen >= sizeof(call))
  			elog(ERROR, "string would overflow buffer");
  		proc->code = Py_CompileString(call, "<string>", Py_eval_input);
! 		if (proc->code != NULL)
  			return;
  	}
  
! 	if (proc->proname)
! 		PLy_elog(ERROR, "could not compile PL/Python function \"%s\"",
! 				 proc->proname);
! 	else
! 		PLy_elog(ERROR, "could not compile anonymous PL/Python code block");
  }
  
  static char *
*************** PLy_procedure_munge_source(const char *n
*** 1628,1634 ****
  	 */
  	mlen = (strlen(src) * 2) + strlen(name) + 16;
  
! 	mrc = PLy_malloc(mlen);
  	plen = snprintf(mrc, mlen, "def %s():\n\t", name);
  	Assert(plen >= 0 && plen < mlen);
  
--- 1632,1638 ----
  	 */
  	mlen = (strlen(src) * 2) + strlen(name) + 16;
  
! 	mrc = palloc(mlen);
  	plen = snprintf(mrc, mlen, "def %s():\n\t", name);
  	Assert(plen >= 0 && plen < mlen);
  
*************** PLy_procedure_delete(PLyProcedure *proc)
*** 1667,1673 ****
  	Py_XDECREF(proc->code);
  	Py_XDECREF(proc->statics);
  	Py_XDECREF(proc->globals);
- 	Py_XDECREF(proc->me);
  	if (proc->proname)
  		PLy_free(proc->proname);
  	if (proc->pyname)
--- 1671,1676 ----
*************** PLy_procedure_delete(PLyProcedure *proc)
*** 1686,1692 ****
  	}
  	if (proc->argnames)
  		PLy_free(proc->argnames);
- 	PLy_free(proc);
  }
  
  /*
--- 1689,1694 ----
*************** PLyMapping_ToTuple(PLyTypeInfo *info, Py
*** 2289,2294 ****
--- 2291,2299 ----
  		PyObject   *volatile value;
  		PLyObToDatum *att;
  
+ 		if (desc->attrs[i]->attisdropped)
+ 			continue;
+ 
  		key = NameStr(desc->attrs[i]->attname);
  		value = NULL;
  		att = &info->out.r.atts[i];
*************** PLySequence_ToTuple(PLyTypeInfo *info, P
*** 2339,2355 ****
  	HeapTuple	tuple;
  	Datum	   *values;
  	bool	   *nulls;
  	volatile int i;
  
  	Assert(PySequence_Check(sequence));
- 
  	/*
  	 * Check that sequence length is exactly same as PG tuple's. We actually
  	 * can ignore exceeding items or assume missing ones as null but to avoid
  	 * plpython developer's errors we are strict here
  	 */
  	desc = lookup_rowtype_tupdesc(info->out.d.typoid, -1);
! 	if (PySequence_Length(sequence) != desc->natts)
  		ereport(ERROR,
  				(errcode(ERRCODE_DATATYPE_MISMATCH),
  				 errmsg("length of returned sequence did not match number of columns in row")));
--- 2344,2366 ----
  	HeapTuple	tuple;
  	Datum	   *values;
  	bool	   *nulls;
+ 	int			idx;
  	volatile int i;
  
  	Assert(PySequence_Check(sequence));
  	/*
  	 * Check that sequence length is exactly same as PG tuple's. We actually
  	 * can ignore exceeding items or assume missing ones as null but to avoid
  	 * plpython developer's errors we are strict here
  	 */
  	desc = lookup_rowtype_tupdesc(info->out.d.typoid, -1);
! 	idx = 0;
! 	for (i = 0; i < desc->natts; ++i)
! 	{
! 		if (!desc->attrs[i]->attisdropped)
! 			idx++;
! 	}
! 	if (PySequence_Length(sequence) != idx)
  		ereport(ERROR,
  				(errcode(ERRCODE_DATATYPE_MISMATCH),
  				 errmsg("length of returned sequence did not match number of columns in row")));
*************** PLySequence_ToTuple(PLyTypeInfo *info, P
*** 2361,2376 ****
  	/* Build tuple */
  	values = palloc(sizeof(Datum) * desc->natts);
  	nulls = palloc(sizeof(bool) * desc->natts);
  	for (i = 0; i < desc->natts; ++i)
  	{
  		PyObject   *volatile value;
  		PLyObToDatum *att;
  
  		value = NULL;
  		att = &info->out.r.atts[i];
  		PG_TRY();
  		{
! 			value = PySequence_GetItem(sequence, i);
  			Assert(value);
  			if (value == Py_None)
  			{
--- 2372,2391 ----
  	/* Build tuple */
  	values = palloc(sizeof(Datum) * desc->natts);
  	nulls = palloc(sizeof(bool) * desc->natts);
+ 	idx = 0;
  	for (i = 0; i < desc->natts; ++i)
  	{
  		PyObject   *volatile value;
  		PLyObToDatum *att;
  
+ 		if (desc->attrs[i]->attisdropped)
+ 			continue;
+ 
  		value = NULL;
  		att = &info->out.r.atts[i];
  		PG_TRY();
  		{
! 			value = PySequence_GetItem(sequence, idx);
  			Assert(value);
  			if (value == Py_None)
  			{
*************** PLySequence_ToTuple(PLyTypeInfo *info, P
*** 2392,2397 ****
--- 2407,2414 ----
  			PG_RE_THROW();
  		}
  		PG_END_TRY();
+ 
+ 		idx++;
  	}
  
  	tuple = heap_form_tuple(desc, values, nulls);
*************** PLyObject_ToTuple(PLyTypeInfo *info, PyO
*** 2426,2431 ****
--- 2443,2451 ----
  		PyObject   *volatile value;
  		PLyObToDatum *att;
  
+ 		if (desc->attrs[i]->attisdropped)
+ 			continue;
+ 
  		key = NameStr(desc->attrs[i]->attname);
  		value = NULL;
  		att = &info->out.r.atts[i];
*************** static PyModuleDef PLy_module = {
*** 2628,2633 ****
--- 2648,2657 ----
  	NULL,						/* m_doc */
  	-1,							/* m_size */
  	PLy_methods,				/* m_methods */
+ 	NULL,                       /* m_reload */
+ 	NULL,                       /* m_traverse */
+ 	NULL,                       /* m_clear */
+ 	NULL                        /* m_free */
  };
  #endif
  
*************** PLy_plan_new(void)
*** 2637,2648 ****
  {
  	PLyPlanObject *ob;
  
! 	if ((ob = PyObject_NEW(PLyPlanObject, &PLy_PlanType)) == NULL)
  		return NULL;
  
  	ob->plan = NULL;
  	ob->nargs = 0;
  	ob->types = NULL;
  	ob->args = NULL;
  
  	return (PyObject *) ob;
--- 2661,2673 ----
  {
  	PLyPlanObject *ob;
  
! 	if ((ob = PyObject_New(PLyPlanObject, &PLy_PlanType)) == NULL)
  		return NULL;
  
  	ob->plan = NULL;
  	ob->nargs = 0;
  	ob->types = NULL;
+ 	ob->values = NULL;
  	ob->args = NULL;
  
  	return (PyObject *) ob;
*************** PLy_plan_dealloc(PyObject *arg)
*** 2658,2663 ****
--- 2683,2690 ----
  		SPI_freeplan(ob->plan);
  	if (ob->types)
  		PLy_free(ob->types);
+ 	if (ob->values)
+ 		PLy_free(ob->values);
  	if (ob->args)
  	{
  		int			i;
*************** PLy_result_new(void)
*** 2693,2699 ****
  {
  	PLyResultObject *ob;
  
! 	if ((ob = PyObject_NEW(PLyResultObject, &PLy_ResultType)) == NULL)
  		return NULL;
  
  	/* ob->tuples = NULL; */
--- 2720,2726 ----
  {
  	PLyResultObject *ob;
  
! 	if ((ob = PyObject_New(PLyResultObject, &PLy_ResultType)) == NULL)
  		return NULL;
  
  	/* ob->tuples = NULL; */
*************** PLy_spi_prepare(PyObject *self, PyObject
*** 2799,2823 ****
  	PyObject   *volatile optr = NULL;
  	char	   *query;
  	void	   *tmpplan;
! 	volatile MemoryContext oldcontext;
  
! 	/* Can't execute more if we have an unhandled error */
! 	if (PLy_error_in_progress)
! 	{
! 		PLy_exception_set(PLy_exc_error, "transaction aborted");
! 		return NULL;
! 	}
  
  	if (!PyArg_ParseTuple(args, "s|O", &query, &list))
  	{
- 		PLy_exception_set(PLy_exc_spi_error,
- 						  "invalid arguments for plpy.prepare");
  		return NULL;
  	}
  
  	if (list && (!PySequence_Check(list)))
  	{
! 		PLy_exception_set(PLy_exc_spi_error,
  					   "second argument of plpy.prepare must be a sequence");
  		return NULL;
  	}
--- 2826,2843 ----
  	PyObject   *volatile optr = NULL;
  	char	   *query;
  	void	   *tmpplan;
! 	int			nargs;
  
! 	MemoryContext volatile oldcontext = CurrentMemoryContext;
  
  	if (!PyArg_ParseTuple(args, "s|O", &query, &list))
  	{
  		return NULL;
  	}
  
  	if (list && (!PySequence_Check(list)))
  	{
! 		PLy_exception_set(PyExc_ValueError,
  					   "second argument of plpy.prepare must be a sequence");
  		return NULL;
  	}
*************** PLy_spi_prepare(PyObject *self, PyObject
*** 2825,2904 ****
  	if ((plan = (PLyPlanObject *) PLy_plan_new()) == NULL)
  		return NULL;
  
! 	oldcontext = CurrentMemoryContext;
  	PG_TRY();
  	{
! 		if (list != NULL)
! 		{
! 			int			nargs,
! 						i;
! 
! 			nargs = PySequence_Length(list);
! 			if (nargs > 0)
! 			{
! 				plan->nargs = nargs;
! 				plan->types = PLy_malloc(sizeof(Oid) * nargs);
! 				plan->values = PLy_malloc(sizeof(Datum) * nargs);
! 				plan->args = PLy_malloc(sizeof(PLyTypeInfo) * nargs);
  
! 				/*
! 				 * the other loop might throw an exception, if PLyTypeInfo
! 				 * member isn't properly initialized the Py_DECREF(plan) will
! 				 * go boom
! 				 */
! 				for (i = 0; i < nargs; i++)
! 				{
! 					PLy_typeinfo_init(&plan->args[i]);
! 					plan->values[i] = PointerGetDatum(NULL);
! 				}
  
! 				for (i = 0; i < nargs; i++)
! 				{
! 					char	   *sptr;
! 					HeapTuple	typeTup;
! 					Oid			typeId;
! 					int32		typmod;
! 					Form_pg_type typeStruct;
  
! 					optr = PySequence_GetItem(list, i);
! 					if (PyString_Check(optr))
! 						sptr = PyString_AsString(optr);
! 					else if (PyUnicode_Check(optr))
! 						sptr = PLyUnicode_AsString(optr);
! 					else
! 					{
! 						ereport(ERROR,
! 								(errmsg("plpy.prepare: type name at ordinal position %d is not a string", i)));
! 						sptr = NULL;	/* keep compiler quiet */
! 					}
  
! 					/********************************************************
! 					 * Resolve argument type names and then look them up by
! 					 * oid in the system cache, and remember the required
! 					 *information for input conversion.
! 					 ********************************************************/
  
! 					parseTypeString(sptr, &typeId, &typmod);
  
! 					typeTup = SearchSysCache1(TYPEOID,
! 											  ObjectIdGetDatum(typeId));
! 					if (!HeapTupleIsValid(typeTup))
! 						elog(ERROR, "cache lookup failed for type %u", typeId);
  
! 					Py_DECREF(optr);
! 					optr = NULL;	/* this is important */
  
! 					plan->types[i] = typeId;
! 					typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
! 					if (typeStruct->typtype != TYPTYPE_COMPOSITE)
! 						PLy_output_datum_func(&plan->args[i], typeTup);
! 					else
! 						ereport(ERROR,
! 								(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 								 errmsg("plpy.prepare does not support composite types")));
! 					ReleaseSysCache(typeTup);
! 				}
! 			}
  		}
  
  		pg_verifymbstr(query, strlen(query), false);
--- 2845,2921 ----
  	if ((plan = (PLyPlanObject *) PLy_plan_new()) == NULL)
  		return NULL;
  
! 	nargs = (list == NULL ? 0 : PySequence_Length(list));
! 
! 	plan->nargs = nargs;
! 	plan->types = PLy_malloc(sizeof(Oid) * nargs);
! 	plan->values = PLy_malloc(sizeof(Datum) * nargs);
! 	plan->args = PLy_malloc(sizeof(PLyTypeInfo) * nargs);
! 
  	PG_TRY();
  	{
! 		int	i;
  
! 		/*
! 		 * the other loop might throw an exception, if PLyTypeInfo
! 		 * member isn't properly initialized the Py_DECREF(plan) will
! 		 * go boom
! 		 */
! 		for (i = 0; i < nargs; i++)
! 		{
! 			PLy_typeinfo_init(&plan->args[i]);
! 			plan->values[i] = PointerGetDatum(NULL);
! 		}
  
! 		for (i = 0; i < nargs; i++)
! 		{
! 			char	   *sptr;
! 			HeapTuple	typeTup;
! 			Oid			typeId;
! 			int32		typmod;
! 			Form_pg_type typeStruct;
  
! 			optr = PySequence_GetItem(list, i);
! 			if (PyString_Check(optr))
! 				sptr = PyString_AsString(optr);
! 			else if (PyUnicode_Check(optr))
! 				sptr = PLyUnicode_AsString(optr);
! 			else
! 			{
! 				ereport(ERROR,
! 						(errmsg("plpy.prepare: type name at ordinal position %d is not a string", i)));
! 				sptr = NULL;	/* keep compiler quiet */
! 			}
  
! 			/********************************************************
! 			 * Resolve argument type names and then look them up by
! 			 * oid in the system cache, and remember the required
! 			 *information for input conversion.
! 			 ********************************************************/
  
! 			parseTypeString(sptr, &typeId, &typmod);
  
! 			typeTup = SearchSysCache1(TYPEOID,
! 									  ObjectIdGetDatum(typeId));
! 			if (!HeapTupleIsValid(typeTup))
! 				elog(ERROR, "cache lookup failed for type %u", typeId);
  
! 			Py_DECREF(optr);
! 			/*
! 			 * set optr to NULL, so we won't try to unref it again in
! 			 * case of an error
! 			 */
! 			optr = NULL;
  
! 			plan->types[i] = typeId;
! 			typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
! 			if (typeStruct->typtype != TYPTYPE_COMPOSITE)
! 				PLy_output_datum_func(&plan->args[i], typeTup);
! 			else
! 				ereport(ERROR,
! 						(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
! 						 errmsg("plpy.prepare does not support composite types")));
! 			ReleaseSysCache(typeTup);
  		}
  
  		pg_verifymbstr(query, strlen(query), false);
*************** PLy_spi_prepare(PyObject *self, PyObject
*** 2917,2935 ****
  	}
  	PG_CATCH();
  	{
  		MemoryContextSwitchTo(oldcontext);
! 		PLy_error_in_progress = CopyErrorData();
! 		FlushErrorState();
  		Py_DECREF(plan);
  		Py_XDECREF(optr);
  		if (!PyErr_Occurred())
  			PLy_exception_set(PLy_exc_spi_error,
  							  "unrecognized error in PLy_spi_prepare");
  		PLy_elog(WARNING, NULL);
  		return NULL;
  	}
  	PG_END_TRY();
  
  	return (PyObject *) plan;
  }
  
--- 2934,2955 ----
  	}
  	PG_CATCH();
  	{
+ 		ErrorData	*edata;
+ 
  		MemoryContextSwitchTo(oldcontext);
! 		edata = CopyErrorData();
  		Py_DECREF(plan);
  		Py_XDECREF(optr);
  		if (!PyErr_Occurred())
  			PLy_exception_set(PLy_exc_spi_error,
  							  "unrecognized error in PLy_spi_prepare");
  		PLy_elog(WARNING, NULL);
+ 		PLy_exception_set(PLy_exc_spi_error, edata->message);
  		return NULL;
  	}
  	PG_END_TRY();
  
+ 	Assert(plan->plan != NULL);
  	return (PyObject *) plan;
  }
  
*************** PLy_spi_execute(PyObject *self, PyObject
*** 2944,2956 ****
  	PyObject   *list = NULL;
  	long		limit = 0;
  
- 	/* Can't execute more if we have an unhandled error */
- 	if (PLy_error_in_progress)
- 	{
- 		PLy_exception_set(PLy_exc_error, "transaction aborted");
- 		return NULL;
- 	}
- 
  	if (PyArg_ParseTuple(args, "s|l", &query, &limit))
  		return PLy_spi_execute_query(query, limit);
  
--- 2964,2969 ----
*************** PLy_spi_execute(PyObject *self, PyObject
*** 2967,2983 ****
  static PyObject *
  PLy_spi_execute_plan(PyObject *ob, PyObject *list, long limit)
  {
! 	volatile int nargs;
! 	int			i,
! 				rv;
! 	PLyPlanObject *plan;
! 	volatile MemoryContext oldcontext;
  
  	if (list != NULL)
  	{
  		if (!PySequence_Check(list) || PyString_Check(list) || PyUnicode_Check(list))
  		{
! 			PLy_exception_set(PLy_exc_spi_error, "plpy.execute takes a sequence as its second argument");
  			return NULL;
  		}
  		nargs = PySequence_Length(list);
--- 2980,2996 ----
  static PyObject *
  PLy_spi_execute_plan(PyObject *ob, PyObject *list, long limit)
  {
! 	int 			volatile nargs;
! 	int				i, rv;
! 	PLyPlanObject	*plan;
! 	PyObject		*ret;
! 	MemoryContext volatile oldcontext = CurrentMemoryContext;
  
  	if (list != NULL)
  	{
  		if (!PySequence_Check(list) || PyString_Check(list) || PyUnicode_Check(list))
  		{
! 			PLy_exception_set(PyExc_ValueError, "plpy.execute takes a sequence as its second argument");
  			return NULL;
  		}
  		nargs = PySequence_Length(list);
*************** PLy_spi_execute_plan(PyObject *ob, PyObj
*** 2992,3003 ****
  		char	   *sv;
  		PyObject   *so = PyObject_Str(list);
  
! 		if (!so)
  			PLy_elog(ERROR, "could not execute plan");
  		sv = PyString_AsString(so);
! 		PLy_exception_set_plural(PLy_exc_spi_error,
! 							  "Expected sequence of %d argument, got %d: %s",
! 							 "Expected sequence of %d arguments, got %d: %s",
  								 plan->nargs,
  								 plan->nargs, nargs, sv);
  		Py_DECREF(so);
--- 3005,3016 ----
  		char	   *sv;
  		PyObject   *so = PyObject_Str(list);
  
! 		if (so == NULL)
  			PLy_elog(ERROR, "could not execute plan");
  		sv = PyString_AsString(so);
! 		PLy_exception_set_plural(PyExc_ValueError,
! 								 "Expected sequence of %d argument, got %d: %s",
! 								 "Expected sequence of %d arguments, got %d: %s",
  								 plan->nargs,
  								 plan->nargs, nargs, sv);
  		Py_DECREF(so);
*************** PLy_spi_execute_plan(PyObject *ob, PyObj
*** 3005,3015 ****
  		return NULL;
  	}
  
- 	oldcontext = CurrentMemoryContext;
  	PG_TRY();
  	{
! 		char	   *nulls = palloc(nargs * sizeof(char));
! 		volatile int j;
  
  		for (j = 0; j < nargs; j++)
  		{
--- 3018,3032 ----
  		return NULL;
  	}
  
  	PG_TRY();
  	{
! 		char	*nulls;
! 		int		volatile j;
! 
! 		if (nargs > 0)
! 			nulls = palloc(nargs * sizeof(char));
! 		else
! 			nulls = NULL;
  
  		for (j = 0; j < nargs; j++)
  		{
*************** PLy_spi_execute_plan(PyObject *ob, PyObj
*** 3049,3082 ****
  
  		rv = SPI_execute_plan(plan->plan, plan->values, nulls,
  							  PLy_curr_procedure->fn_readonly, limit);
  
- 		pfree(nulls);
  	}
  	PG_CATCH();
  	{
! 		int			k;
  
  		MemoryContextSwitchTo(oldcontext);
! 		PLy_error_in_progress = CopyErrorData();
  		FlushErrorState();
  
  		/*
  		 * cleanup plan->values array
  		 */
! 		for (k = 0; k < nargs; k++)
  		{
! 			if (!plan->args[k].out.d.typbyval &&
! 				(plan->values[k] != PointerGetDatum(NULL)))
  			{
! 				pfree(DatumGetPointer(plan->values[k]));
! 				plan->values[k] = PointerGetDatum(NULL);
  			}
  		}
  
  		if (!PyErr_Occurred())
! 			PLy_exception_set(PLy_exc_error,
  							  "unrecognized error in PLy_spi_execute_plan");
  		PLy_elog(WARNING, NULL);
  		return NULL;
  	}
  	PG_END_TRY();
--- 3066,3104 ----
  
  		rv = SPI_execute_plan(plan->plan, plan->values, nulls,
  							  PLy_curr_procedure->fn_readonly, limit);
+ 		ret = PLy_spi_execute_fetch_result(SPI_tuptable, SPI_processed, rv);
+ 
+ 		if (nargs > 0)
+ 			pfree(nulls);
+ 
  
  	}
  	PG_CATCH();
  	{
! 		ErrorData	*edata;
  
  		MemoryContextSwitchTo(oldcontext);
! 		edata = CopyErrorData();
  		FlushErrorState();
  
  		/*
  		 * cleanup plan->values array
  		 */
! 		for (i = 0; i < nargs; i++)
  		{
! 			if (!plan->args[i].out.d.typbyval &&
! 				(plan->values[i] != PointerGetDatum(NULL)))
  			{
! 				pfree(DatumGetPointer(plan->values[i]));
! 				plan->values[i] = PointerGetDatum(NULL);
  			}
  		}
  
  		if (!PyErr_Occurred())
! 			PLy_exception_set(PLy_exc_spi_error,
  							  "unrecognized error in PLy_spi_execute_plan");
  		PLy_elog(WARNING, NULL);
+ 		PLy_exception_set(PLy_exc_spi_error, edata->message);
  		return NULL;
  	}
  	PG_END_TRY();
*************** PLy_spi_execute_plan(PyObject *ob, PyObj
*** 3091,3128 ****
  		}
  	}
  
! 	if (rv < 0)
! 	{
! 		PLy_exception_set(PLy_exc_spi_error,
! 						  "SPI_execute_plan failed: %s",
! 						  SPI_result_code_string(rv));
! 		return NULL;
! 	}
! 
! 	return PLy_spi_execute_fetch_result(SPI_tuptable, SPI_processed, rv);
  }
  
  static PyObject *
  PLy_spi_execute_query(char *query, long limit)
  {
  	int			rv;
! 	volatile MemoryContext oldcontext;
  
- 	oldcontext = CurrentMemoryContext;
  	PG_TRY();
  	{
  		pg_verifymbstr(query, strlen(query), false);
  		rv = SPI_execute(query, PLy_curr_procedure->fn_readonly, limit);
  	}
  	PG_CATCH();
  	{
  		MemoryContextSwitchTo(oldcontext);
! 		PLy_error_in_progress = CopyErrorData();
  		FlushErrorState();
  		if (!PyErr_Occurred())
  			PLy_exception_set(PLy_exc_spi_error,
  							  "unrecognized error in PLy_spi_execute_query");
  		PLy_elog(WARNING, NULL);
  		return NULL;
  	}
  	PG_END_TRY();
--- 3113,3146 ----
  		}
  	}
  
! 	return ret;
  }
  
  static PyObject *
  PLy_spi_execute_query(char *query, long limit)
  {
  	int			rv;
! 	PyObject	*ret;
! 	MemoryContext volatile oldcontext = CurrentMemoryContext;
  
  	PG_TRY();
  	{
  		pg_verifymbstr(query, strlen(query), false);
  		rv = SPI_execute(query, PLy_curr_procedure->fn_readonly, limit);
+ 		ret = PLy_spi_execute_fetch_result(SPI_tuptable, SPI_processed, rv);
  	}
  	PG_CATCH();
  	{
+ 		ErrorData	*edata;
+ 
  		MemoryContextSwitchTo(oldcontext);
! 		edata = CopyErrorData();
  		FlushErrorState();
  		if (!PyErr_Occurred())
  			PLy_exception_set(PLy_exc_spi_error,
  							  "unrecognized error in PLy_spi_execute_query");
  		PLy_elog(WARNING, NULL);
+ 		PLy_exception_set(PLy_exc_spi_error, edata->message);
  		return NULL;
  	}
  	PG_END_TRY();
*************** PLy_spi_execute_query(char *query, long
*** 3135,3141 ****
  		return NULL;
  	}
  
! 	return PLy_spi_execute_fetch_result(SPI_tuptable, SPI_processed, rv);
  }
  
  static PyObject *
--- 3153,3159 ----
  		return NULL;
  	}
  
! 	return ret;
  }
  
  static PyObject *
*************** PLy_spi_execute_fetch_result(SPITupleTab
*** 3183,3190 ****
  		PG_CATCH();
  		{
  			MemoryContextSwitchTo(oldcontext);
- 			PLy_error_in_progress = CopyErrorData();
- 			FlushErrorState();
  			if (!PyErr_Occurred())
  				PLy_exception_set(PLy_exc_error,
  					   "unrecognized error in PLy_spi_execute_fetch_result");
--- 3201,3206 ----
*************** PLy_spi_execute_fetch_result(SPITupleTab
*** 3202,3207 ****
--- 3218,3263 ----
  	return (PyObject *) result;
  }
  
+ /*
+  * Exception support
+  */
+ 
+ /*
+  * Add an exception to the module. The first parameter is either the actual
+  * module (for Python 3) or the module dictionary
+  */
+ static void PLy_add_exception(PyObject *mod, const char *name, PyObject *exc)
+ {
+ #if PY_MAJOR_VERSION >= 3
+ 	Py_INCREF(exc);
+ 	PyModule_AddObject(mod, name, exc);
+ #else
+ 	PyDict_SetItemString(mod, name, exc);
+ #endif
+ }
+ 
+ /* Add exceptions to the plpy module */
+ static void
+ PLy_initialize_exceptions(PyObject *plpy)
+ {
+ 	PyObject	*mod;
+ 
+ #if PY_MAJOR_VERSION < 3
+ 	/* For Python <3 we add the exceptions to the module dictionary */
+ 	mod = PyModule_GetDict(plpy);
+ #else
+ 	/* In Python 3 you add them directly into the module */
+ 	mod = plpy;
+ #endif
+ 
+ 	PLy_exc_error = PyErr_NewException("plpy.Error", NULL, NULL);
+ 	PLy_exc_fatal = PyErr_NewException("plpy.Fatal", NULL, NULL);
+ 	PLy_exc_spi_error = PyErr_NewException("plpy.SPIError", NULL, NULL);
+ 
+ 	PLy_add_exception(mod, "Error", PLy_exc_error);
+ 	PLy_add_exception(mod, "Fatal", PLy_exc_fatal);
+ 	PLy_add_exception(mod, "SPIError", PLy_exc_spi_error);
+ }
  
  /*
   * language handler and interpreter initialization
*************** PLy_spi_execute_fetch_result(SPITupleTab
*** 3211,3217 ****
  static PyMODINIT_FUNC
  PyInit_plpy(void)
  {
! 	return PyModule_Create(&PLy_module);
  }
  #endif
  
--- 3267,3281 ----
  static PyMODINIT_FUNC
  PyInit_plpy(void)
  {
! 	PyObject	*m;
! 
! 	m = PyModule_Create(&PLy_module);
! 	if (m == NULL)
! 		return NULL;
! 
! 	PLy_initialize_exceptions(m);
! 
! 	return m;
  }
  #endif
  
*************** _PG_init(void)
*** 3229,3234 ****
--- 3293,3300 ----
  	/* Be sure we do initialization only once (should be redundant now) */
  	static bool inited = false;
  	const int **version_ptr;
+ 	HASHCTL		hash_ctl;
+ 
  
  	if (inited)
  		return;
*************** _PG_init(void)
*** 3260,3268 ****
  	PLy_init_plpy();
  	if (PyErr_Occurred())
  		PLy_elog(FATAL, "untrapped error in initialization");
! 	PLy_procedure_cache = PyDict_New();
! 	if (PLy_procedure_cache == NULL)
! 		PLy_elog(ERROR, "could not create procedure cache");
  
  	inited = true;
  }
--- 3326,3346 ----
  	PLy_init_plpy();
  	if (PyErr_Occurred())
  		PLy_elog(FATAL, "untrapped error in initialization");
! 
! 	memset(&hash_ctl, 0, sizeof(hash_ctl));
! 	hash_ctl.keysize = sizeof(Oid);
! 	hash_ctl.entrysize = sizeof(PLyProcedureEntry);
! 	hash_ctl.hash = oid_hash;
! 	PLy_procedure_cache = hash_create("PL/Python procedures", 32,
! 									  &hash_ctl, HASH_ELEM | HASH_FUNCTION);
! 
! 	memset(&hash_ctl, 0, sizeof(hash_ctl));
! 	hash_ctl.keysize = sizeof(Oid);
! 	hash_ctl.entrysize = sizeof(PLyProcedureEntry);
! 	hash_ctl.hash = oid_hash;
! 	PLy_trigger_cache = hash_create("PL/Python triggers",
! 									32, &hash_ctl,
! 									HASH_ELEM | HASH_FUNCTION);
  
  	inited = true;
  }
*************** PLy_init_plpy(void)
*** 3290,3297 ****
  	PyObject   *main_mod,
  			   *main_dict,
  			   *plpy_mod;
! 	PyObject   *plpy,
! 			   *plpy_dict;
  
  	/*
  	 * initialize plpy module
--- 3368,3374 ----
  	PyObject   *main_mod,
  			   *main_dict,
  			   *plpy_mod;
! 	PyObject   *plpy;
  
  	/*
  	 * initialize plpy module
*************** PLy_init_plpy(void)
*** 3305,3322 ****
  	plpy = PyModule_Create(&PLy_module);
  #else
  	plpy = Py_InitModule("plpy", PLy_methods);
  #endif
- 	plpy_dict = PyModule_GetDict(plpy);
  
  	/* PyDict_SetItemString(plpy, "PlanType", (PyObject *) &PLy_PlanType); */
  
- 	PLy_exc_error = PyErr_NewException("plpy.Error", NULL, NULL);
- 	PLy_exc_fatal = PyErr_NewException("plpy.Fatal", NULL, NULL);
- 	PLy_exc_spi_error = PyErr_NewException("plpy.SPIError", NULL, NULL);
- 	PyDict_SetItemString(plpy_dict, "Error", PLy_exc_error);
- 	PyDict_SetItemString(plpy_dict, "Fatal", PLy_exc_fatal);
- 	PyDict_SetItemString(plpy_dict, "SPIError", PLy_exc_spi_error);
- 
  	/*
  	 * initialize main module, and add plpy
  	 */
--- 3382,3393 ----
  	plpy = PyModule_Create(&PLy_module);
  #else
  	plpy = Py_InitModule("plpy", PLy_methods);
+ 	/* for Python 3 we initialized the exceptions in PyInit_plpy */
+ 	PLy_initialize_exceptions(plpy);
  #endif
  
  	/* PyDict_SetItemString(plpy, "PlanType", (PyObject *) &PLy_PlanType); */
  
  	/*
  	 * initialize main module, and add plpy
  	 */
*************** PLy_init_plpy(void)
*** 3331,3337 ****
  /* the python interface to the elog function
   * don't confuse these with PLy_elog
   */
! static PyObject *PLy_output(volatile int, PyObject *, PyObject *);
  
  static PyObject *
  PLy_debug(PyObject *self, PyObject *args)
--- 3402,3408 ----
  /* the python interface to the elog function
   * don't confuse these with PLy_elog
   */
! static PyObject *PLy_output(int, PyObject *, PyObject *);
  
  static PyObject *
  PLy_debug(PyObject *self, PyObject *args)
*************** PLy_fatal(PyObject *self, PyObject *args
*** 3379,3387 ****
  static PyObject *
  PLy_output(volatile int level, PyObject *self, PyObject *args)
  {
! 	PyObject   *volatile so;
! 	char	   *volatile sv;
! 	volatile MemoryContext oldcontext;
  
  	if (PyTuple_Size(args) == 1)
  	{
--- 3450,3458 ----
  static PyObject *
  PLy_output(volatile int level, PyObject *self, PyObject *args)
  {
! 	PyObject			*so;
! 	char				*sv;
! 	MemoryContext		 volatile oldcontext = CurrentMemoryContext;
  
  	if (PyTuple_Size(args) == 1)
  	{
*************** PLy_output(volatile int level, PyObject
*** 3402,3432 ****
  		sv = dgettext(TEXTDOMAIN, "could not parse error message in plpy.elog");
  	}
  
! 	oldcontext = CurrentMemoryContext;
  	PG_TRY();
  	{
- 		pg_verifymbstr(sv, strlen(sv), false);
  		elog(level, "%s", sv);
  	}
  	PG_CATCH();
  	{
! 		MemoryContextSwitchTo(oldcontext);
! 		PLy_error_in_progress = CopyErrorData();
! 		FlushErrorState();
  
! 		PyErr_SetString(PLy_exc_error, sv);
  
  		/*
! 		 * Note: If sv came from PyString_AsString(), it points into storage
! 		 * owned by so.  So free so after using sv.
! 		 */
  		Py_XDECREF(so);
  
! 		/*
! 		 * returning NULL here causes the python interpreter to bail. when
! 		 * control passes back to PLy_procedure_call, we check for PG
! 		 * exceptions and re-throw the error.
! 		 */
  		return NULL;
  	}
  	PG_END_TRY();
--- 3473,3500 ----
  		sv = dgettext(TEXTDOMAIN, "could not parse error message in plpy.elog");
  	}
  
! 	pg_verifymbstr(sv, strlen(sv), false);
  	PG_TRY();
  	{
  		elog(level, "%s", sv);
  	}
  	PG_CATCH();
  	{
! 		ErrorData  *edata;
  
!         /* Must reset elog.c's state */
!         MemoryContextSwitchTo(oldcontext);
!         edata = CopyErrorData();
!         FlushErrorState();
  
  		/*
!         * Note: If sv came from PyString_AsString(), it points into storage
!         * owned by so.  So free so after using sv.
!         */
  		Py_XDECREF(so);
  
! 		/* Make Python raise the exception */
! 		PLy_exception_set(PLy_exc_error, edata->message);
  		return NULL;
  	}
  	PG_END_TRY();
*************** PLy_elog(int elevel, const char *fmt,...
*** 3528,3538 ****
  	{
  		if (fmt)
  			ereport(elevel,
! 					(errmsg("PL/Python: %s", emsg.data),
  					 (xmsg) ? errdetail("%s", xmsg) : 0));
  		else
  			ereport(elevel,
! 					(errmsg("PL/Python: %s", xmsg)));
  	}
  	PG_CATCH();
  	{
--- 3596,3606 ----
  	{
  		if (fmt)
  			ereport(elevel,
! 					(errmsg("%s", emsg.data),
  					 (xmsg) ? errdetail("%s", xmsg) : 0));
  		else
  			ereport(elevel,
! 					(errmsg("%s", xmsg)));
  	}
  	PG_CATCH();
  	{
*************** PLy_traceback(int *xlevel)
*** 3635,3653 ****
  
  /* some dumb utility functions */
  static void *
! PLy_malloc(size_t bytes)
  {
! 	void	   *ptr = malloc(bytes);
! 
! 	if (ptr == NULL)
! 		ereport(FATAL,
! 				(errcode(ERRCODE_OUT_OF_MEMORY),
! 				 errmsg("out of memory")));
! 	return ptr;
  }
  
  static void *
! PLy_malloc0(size_t bytes)
  {
  	void	   *ptr = PLy_malloc(bytes);
  
--- 3703,3716 ----
  
  /* some dumb utility functions */
  static void *
! PLy_malloc(Size bytes)
  {
! 	/* We need our allocations to be long-lived, so use TopMemoryContext */
! 	return MemoryContextAlloc(TopMemoryContext, bytes);
  }
  
  static void *
! PLy_malloc0(Size bytes)
  {
  	void	   *ptr = PLy_malloc(bytes);
  
*************** PLy_strdup(const char *str)
*** 3672,3678 ****
  static void
  PLy_free(void *ptr)
  {
! 	free(ptr);
  }
  
  /*
--- 3735,3741 ----
  static void
  PLy_free(void *ptr)
  {
! 	pfree(ptr);
  }
  
  /*
diff --git a/src/pl/plpython/sql/plpython_test.sql b/src/pl/plpython/sql/plpython_test.sql
index 7cae124..298411a 100644
*** a/src/pl/plpython/sql/plpython_test.sql
--- b/src/pl/plpython/sql/plpython_test.sql
*************** return words'
*** 25,30 ****
--- 25,39 ----
  
  select argument_test_one(users, fname, lname) from users where lname = 'doe' order by 1;
  
+ -- check module contents
+ CREATE FUNCTION module_contents() RETURNS text AS
+ $$
+ contents = list(filter(lambda x: not x.startswith("__"), dir(plpy)))
+ contents.sort()
+ return ", ".join(contents)
+ $$ LANGUAGE plpythonu;
+ 
+ select module_contents();
  
  CREATE FUNCTION elog_test() RETURNS void
  AS $$