Add a hack so that get_type_io_data() can work from bootstrap.c's

internal TypInfo table in bootstrap mode.  This allows array_in and
array_out to be used during early bootstrap, which eliminates the
former obstacle to giving OUT parameters to built-in functions.

diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c
index 08189bf07b23622001130cbc620a3ba4ce3a0030..06d8a5ca4fc056de949b3e89adb53eb12149b726 100644 (file)
--- a/src/backend/bootstrap/bootstrap.c
+++ b/src/backend/bootstrap/bootstrap.c
@@ -8,7 +8,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/bootstrap/bootstrap.c,v 1.223 2006/07/31 20:09:00 tgl Exp $
+ *       $PostgreSQL: pgsql/src/backend/bootstrap/bootstrap.c,v 1.224 2006/08/15 22:36:17 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -590,6 +590,7 @@ boot_openrel(char *relname)
 
        if (Typ == NULL)
        {
+               /* We can now load the pg_type data */
                rel = heap_open(TypeRelationId, NoLock);
                scan = heap_beginscan(rel, SnapshotNow, 0, NULL);
                i = 0;
@@ -806,6 +807,10 @@ void
 InsertOneValue(char *value, int i)
 {
        Oid                     typoid;
+       int16           typlen;
+       bool            typbyval;
+       char            typalign;
+       char            typdelim;
        Oid                     typioparam;
        Oid                     typinput;
        Oid                     typoutput;
@@ -817,52 +822,19 @@ InsertOneValue(char *value, int i)
 
        if (Typ != NULL)
        {
-               struct typmap **app;
-               struct typmap *ap;
-
-               elog(DEBUG5, "Typ != NULL");
                typoid = boot_reldesc->rd_att->attrs[i]->atttypid;
-               app = Typ;
-               while (*app && (*app)->am_oid != typoid)
-                       ++app;
-               ap = *app;
-               if (ap == NULL)
-                       elog(ERROR, "could not find atttypid %u in Typ list", typoid);
-
-               /* XXX this logic should match getTypeIOParam() */
-               if (OidIsValid(ap->am_typ.typelem))
-                       typioparam = ap->am_typ.typelem;
-               else
-                       typioparam = typoid;
-
-               typinput = ap->am_typ.typinput;
-               typoutput = ap->am_typ.typoutput;
        }
        else
        {
-               int                     typeindex;
-
-               /* XXX why is typoid determined differently in this path? */
+               /* XXX why is typoid determined differently in this case? */
                typoid = attrtypes[i]->atttypid;
-               for (typeindex = 0; typeindex < n_types; typeindex++)
-               {
-                       if (TypInfo[typeindex].oid == typoid)
-                               break;
-               }
-               if (typeindex >= n_types)
-                       elog(ERROR, "type oid %u not found", typoid);
-               elog(DEBUG5, "Typ == NULL, typeindex = %u", typeindex);
-
-               /* XXX this logic should match getTypeIOParam() */
-               if (OidIsValid(TypInfo[typeindex].elem))
-                       typioparam = TypInfo[typeindex].elem;
-               else
-                       typioparam = typoid;
-
-               typinput = TypInfo[typeindex].inproc;
-               typoutput = TypInfo[typeindex].outproc;
        }
 
+       boot_get_type_io_data(typoid,
+                                                 &typlen, &typbyval, &typalign,
+                                                 &typdelim, &typioparam,
+                                                 &typinput, &typoutput);
+
        values[i] = OidInputFunctionCall(typinput, value, typioparam, -1);
        prt = OidOutputFunctionCall(typoutput, values[i]);
        elog(DEBUG4, "inserted -> %s", prt);
@@ -972,6 +944,83 @@ gettype(char *type)
        return 0;
 }
 
+/* ----------------
+ *             boot_get_type_io_data
+ *
+ * Obtain type I/O information at bootstrap time.  This intentionally has
+ * almost the same API as lsyscache.c's get_type_io_data, except that
+ * we only support obtaining the typinput and typoutput routines, not
+ * the binary I/O routines.  It is exported so that array_in and array_out
+ * can be made to work during early bootstrap.
+ * ----------------
+ */
+void
+boot_get_type_io_data(Oid typid,
+                                         int16 *typlen,
+                                         bool *typbyval,
+                                         char *typalign,
+                                         char *typdelim,
+                                         Oid *typioparam,
+                                         Oid *typinput,
+                                         Oid *typoutput)
+{
+       if (Typ != NULL)
+       {
+               /* We have the boot-time contents of pg_type, so use it */
+               struct typmap **app;
+               struct typmap *ap;
+
+               app = Typ;
+               while (*app && (*app)->am_oid != typid)
+                       ++app;
+               ap = *app;
+               if (ap == NULL)
+                       elog(ERROR, "type OID %u not found in Typ list", typid);
+
+               *typlen = ap->am_typ.typlen;
+               *typbyval = ap->am_typ.typbyval;
+               *typalign = ap->am_typ.typalign;
+               *typdelim = ap->am_typ.typdelim;
+
+               /* XXX this logic must match getTypeIOParam() */
+               if (OidIsValid(ap->am_typ.typelem))
+                       *typioparam = ap->am_typ.typelem;
+               else
+                       *typioparam = typid;
+
+               *typinput = ap->am_typ.typinput;
+               *typoutput = ap->am_typ.typoutput;
+       }
+       else
+       {
+               /* We don't have pg_type yet, so use the hard-wired TypInfo array */
+               int                     typeindex;
+
+               for (typeindex = 0; typeindex < n_types; typeindex++)
+               {
+                       if (TypInfo[typeindex].oid == typid)
+                               break;
+               }
+               if (typeindex >= n_types)
+                       elog(ERROR, "type OID %u not found in TypInfo", typid);
+
+               *typlen = TypInfo[typeindex].len;
+               *typbyval = TypInfo[typeindex].byval;
+               *typalign = TypInfo[typeindex].align;
+               /* We assume typdelim is ',' for all boot-time types */
+               *typdelim = ',';
+
+               /* XXX this logic must match getTypeIOParam() */
+               if (OidIsValid(TypInfo[typeindex].elem))
+                       *typioparam = TypInfo[typeindex].elem;
+               else
+                       *typioparam = typid;
+
+               *typinput = TypInfo[typeindex].inproc;
+               *typoutput = TypInfo[typeindex].outproc;
+       }
+}
+
 /* ----------------
  *             AllocateAttribute
  * ----------------

diff --git a/src/backend/utils/cache/lsyscache.c b/src/backend/utils/cache/lsyscache.c
index 93fa1f029f668312fe797f61a8f2bc496db94a71..769206e02c825bc82acd219be708ae90734fc308 100644 (file)
--- a/src/backend/utils/cache/lsyscache.c
+++ b/src/backend/utils/cache/lsyscache.c
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *       $PostgreSQL: pgsql/src/backend/utils/cache/lsyscache.c,v 1.135 2006/07/14 14:52:25 momjian Exp $
+ *       $PostgreSQL: pgsql/src/backend/utils/cache/lsyscache.c,v 1.136 2006/08/15 22:36:17 tgl Exp $
  *
  * NOTES
  *       Eventually, the index information should go through here, too.
@@ -16,6 +16,7 @@
 #include "postgres.h"
 
 #include "access/hash.h"
+#include "bootstrap/bootstrap.h"
 #include "catalog/pg_amop.h"
 #include "catalog/pg_amproc.h"
 #include "catalog/pg_namespace.h"
@@ -24,6 +25,7 @@
 #include "catalog/pg_proc.h"
 #include "catalog/pg_statistic.h"
 #include "catalog/pg_type.h"
+#include "miscadmin.h"
 #include "nodes/makefuncs.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
@@ -1350,7 +1352,7 @@ get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval,
  * This knowledge is intended to be centralized here --- direct references
  * to typelem elsewhere in the code are wrong, if they are associated with
  * I/O calls and not with actual subscripting operations!  (But see
- * bootstrap.c, which can't conveniently use this routine.)
+ * bootstrap.c's boot_get_type_io_data() if you need to change this.)
  *
  * As of PostgreSQL 8.1, output functions receive only the value itself
  * and not any auxiliary parameters, so the name of this routine is now
@@ -1392,6 +1394,38 @@ get_type_io_data(Oid typid,
        HeapTuple       typeTuple;
        Form_pg_type typeStruct;
 
+       /*
+        * In bootstrap mode, pass it off to bootstrap.c.  This hack allows
+        * us to use array_in and array_out during bootstrap.
+        */
+       if (IsBootstrapProcessingMode())
+       {
+               Oid     typinput;
+               Oid     typoutput;
+
+               boot_get_type_io_data(typid,
+                                                         typlen,
+                                                         typbyval,
+                                                         typalign,
+                                                         typdelim,
+                                                         typioparam,
+                                                         &typinput,
+                                                         &typoutput);
+               switch (which_func)
+               {
+                       case IOFunc_input:
+                               *func = typinput;
+                               break;
+                       case IOFunc_output:
+                               *func = typoutput;
+                               break;
+                       default:
+                               elog(ERROR, "binary I/O not supported during bootstrap");
+                               break;
+               }
+               return;
+       }
+
        typeTuple = SearchSysCache(TYPEOID,
                                                           ObjectIdGetDatum(typid),
                                                           0, 0, 0);

diff --git a/src/include/bootstrap/bootstrap.h b/src/include/bootstrap/bootstrap.h
index 807f27664643f3e5289b2ebd338a34d59d5a85ff..6713b6df6788c3265ba005469f5b1d1607293a90 100644 (file)
--- a/src/include/bootstrap/bootstrap.h
+++ b/src/include/bootstrap/bootstrap.h
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $PostgreSQL: pgsql/src/include/bootstrap/bootstrap.h,v 1.42 2006/07/13 16:49:19 momjian Exp $
+ * $PostgreSQL: pgsql/src/include/bootstrap/bootstrap.h,v 1.43 2006/08/15 22:36:17 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -50,6 +50,15 @@ extern char *CleanUpStr(char *s);
 extern int     EnterString(char *str);
 extern void build_indices(void);
 
+extern void boot_get_type_io_data(Oid typid,
+                                                                 int16 *typlen,
+                                                                 bool *typbyval,
+                                                                 char *typalign,
+                                                                 char *typdelim,
+                                                                 Oid *typioparam,
+                                                                 Oid *typinput,
+                                                                 Oid *typoutput);
+
 extern int     boot_yyparse(void);
 
 extern int     boot_yylex(void);