Allow pltcl args to spi_prepare and plpython args to plpy.prepare to be standard...

diff --git a/doc/src/sgml/pltcl.sgml b/doc/src/sgml/pltcl.sgml
index 41a93fbd95110d6434cbceebf6446f6168bddb43..6ae266a5b72190b82ee390262c552dca04ba234d 100644 (file)
--- a/doc/src/sgml/pltcl.sgml
+++ b/doc/src/sgml/pltcl.sgml
@@ -1,4 +1,4 @@
-<!-- $PostgreSQL: pgsql/doc/src/sgml/pltcl.sgml,v 2.45 2007/02/01 00:28:17 momjian Exp $ -->
+<!-- $PostgreSQL: pgsql/doc/src/sgml/pltcl.sgml,v 2.46 2007/02/21 03:27:31 adunstan Exp $ -->
 
  <chapter id="pltcl">
   <title>PL/Tcl - Tcl Procedural Language</title>
@@ -331,9 +331,6 @@ spi_exec -array C "SELECT * FROM pg_class" {
         If the query uses parameters, the names of the parameter types
         must be given as a Tcl list.  (Write an empty list for
         <replaceable>typelist</replaceable> if no parameters are used.)
-        Presently, the parameter types must be identified by the internal
-        type names shown in the system table <literal>pg_type</>; for example <literal>int4</> not
-        <literal>integer</>.
        </para>
        <para>
         The return value from <function>spi_prepare</function> is a query ID

diff --git a/src/pl/plpython/plpython.c b/src/pl/plpython/plpython.c
index 90a3f87b150c884df27a63238a0e711aa4ae4ccb..78c9f6c66e0e0057b3e8987620b9e10ec5d51186 100644 (file)
--- a/src/pl/plpython/plpython.c
+++ b/src/pl/plpython/plpython.c
@@ -1,7 +1,7 @@
 /**********************************************************************
  * plpython.c - python as a procedural language for PostgreSQL
  *
- *     $PostgreSQL: pgsql/src/pl/plpython/plpython.c,v 1.95 2007/02/09 03:35:35 tgl Exp $
+ *     $PostgreSQL: pgsql/src/pl/plpython/plpython.c,v 1.96 2007/02/21 03:27:32 adunstan Exp $
  *
  *********************************************************************
  */
@@ -2309,27 +2309,34 @@ PLy_spi_prepare(PyObject * self, PyObject * args)
                                for (i = 0; i < nargs; i++)
                                {
                                        char       *sptr;
-                                       List       *names;
                                        HeapTuple       typeTup;
+                                       Oid         typeId;
+                                       int32       typmod;
                                        Form_pg_type typeStruct;
 
                                        optr = PySequence_GetItem(list, i);
                                        if (!PyString_Check(optr))
                                                elog(ERROR, "Type names must be strings.");
                                        sptr = PyString_AsString(optr);
+                                       
+                                       /********************************************************
+                                        * 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 = SearchSysCache(TYPEOID,
+                                                                                        ObjectIdGetDatum(typeId),
+                                                                                        0,0,0);
+                                       if (!HeapTupleIsValid(typeTup))
+                                               elog(ERROR, "cache lookup failed for type %u", typeId);
 
-                                       /*
-                                        * Parse possibly-qualified type name and look it up in
-                                        * pg_type
-                                        */
-                                       names = stringToQualifiedNameList(sptr,
-                                                                                                         "PLy_spi_prepare");
-                                       typeTup = typenameType(NULL,
-                                                                                  makeTypeNameFromNameList(names));
                                        Py_DECREF(optr);
                                        optr = NULL;    /* this is important */
 
-                                       plan->types[i] = HeapTupleGetOid(typeTup);
+                                       plan->types[i] = typeId;
                                        typeStruct = (Form_pg_type) GETSTRUCT(typeTup);
                                        if (typeStruct->typtype != 'c')
                                                PLy_output_datum_func(&plan->args[i], typeTup);

diff --git a/src/pl/tcl/pltcl.c b/src/pl/tcl/pltcl.c
index 0477fa8c56c0e79c0e6d80d4cbe3f487e7c65e7f..2cd26d06412cd94f76112e2056224030ad4c3c01 100644 (file)
--- a/src/pl/tcl/pltcl.c
+++ b/src/pl/tcl/pltcl.c
@@ -2,7 +2,7 @@
  * pltcl.c             - PostgreSQL support for Tcl as
  *                               procedural language (PL)
  *
- *       $PostgreSQL: pgsql/src/pl/tcl/pltcl.c,v 1.110 2007/02/09 03:35:35 tgl Exp $
+ *       $PostgreSQL: pgsql/src/pl/tcl/pltcl.c,v 1.111 2007/02/21 03:27:32 adunstan Exp $
  *
  **********************************************************************/
 
@@ -1808,23 +1808,22 @@ pltcl_SPI_prepare(ClientData cdata, Tcl_Interp *interp,
        PG_TRY();
        {
                /************************************************************
-                * Lookup the argument types by name in the system cache
-                * and remember the required information for input conversion
+                * Resolve argument type names and then look them up by oid 
+         * in the system cache, and remember the required information 
+         * for input conversion.
                 ************************************************************/
                for (i = 0; i < nargs; i++)
                {
-                       List       *names;
-                       HeapTuple       typeTup;
+                       Oid         typId, typInput, typIOParam;
+            int32       typmod;
 
-                       /* Parse possibly-qualified type name and look it up in pg_type */
-                       names = stringToQualifiedNameList(args[i],
-                                                                                         "pltcl_SPI_prepare");
-                       typeTup = typenameType(NULL, makeTypeNameFromNameList(names));
-                       qdesc->argtypes[i] = HeapTupleGetOid(typeTup);
-                       perm_fmgr_info(((Form_pg_type) GETSTRUCT(typeTup))->typinput,
-                                                  &(qdesc->arginfuncs[i]));
-                       qdesc->argtypioparams[i] = getTypeIOParam(typeTup);
-                       ReleaseSysCache(typeTup);
+                       parseTypeString(args[i], &typId, &typmod);
+
+                       getTypeInputInfo(typId, &typInput, &typIOParam);
+
+                       qdesc->argtypes[i] = typId;
+                       perm_fmgr_info(typInput, &(qdesc->arginfuncs[i]));
+                       qdesc->argtypioparams[i] = typIOParam;
                }
 
                /************************************************************