Postgres95 1.01 Distribution - Virgin SourcesPG95-1_01

1 files changed, 353 insertions, 0 deletions

diff --git a/src/backend/tcop/fastpath.c b/src/backend/tcop/fastpath.c
new file mode 100644
index 00000000000..39014fe0db1
--- /dev/null
+++ b/src/backend/tcop/fastpath.c
@@ -0,0 +1,353 @@
+/*-------------------------------------------------------------------------
+ *
+ * fastpath.c--
+ *    routines to handle function requests from the frontend
+ *
+ * Copyright (c) 1994, Regents of the University of California
+ *
+ *
+ * IDENTIFICATION
+ *    $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.1.1.1 1996/07/09 06:21:59 scrappy Exp $
+ *
+ * NOTES
+ *    This cruft is the server side of PQfn.
+ *
+ *    - jolly 07/11/95:
+ *
+ *    no longer rely on return sizes provided by the frontend.  Always
+ *    use the true lengths for the catalogs.  Assume that the frontend 
+ *    has allocated enough space to handle the result value returned.
+ *    
+ *    trust that the user knows what he is doing with the args.  If the 
+ *    sys catalog says it is a varlena, assume that the user is only sending
+ *    down VARDATA and that the argsize is the VARSIZE.  If the arg is
+ *    fixed len, assume that the argsize given by the user is correct.
+ *  
+ *    if the function returns by value, then only send 4 bytes value 
+ *    back to the frontend.  If the return returns by reference, 
+ *    send down only the data portion and set the return size appropriately.
+ * 
+ *   OLD COMMENTS FOLLOW
+ *
+ *    The VAR_LENGTH_{ARGS,RESULT} stuff is limited to MAX_STRING_LENGTH
+ *    (see src/backend/tmp/fastpath.h) for no obvious reason.  Since its
+ *    primary use (for us) is for Inversion path names, it should probably
+ *    be increased to 256 (MAXPATHLEN for Inversion, hidden in pg_type
+ *    as well as utils/adt/filename.c).
+ *
+ *    Quoth PMA on 08/15/93:
+ *
+ *    This code has been almost completely rewritten with an eye to
+ *    keeping it as compatible as possible with the previous (broken)
+ *    implementation.
+ *
+ *    The previous implementation would assume (1) that any value of
+ *    length <= 4 bytes was passed-by-value, and that any other value
+ *    was a struct varlena (by-reference).  There was NO way to pass a
+ *    fixed-length by-reference argument (like char16) or a struct
+ *    varlena of size <= 4 bytes.
+ *	
+ *    The new implementation checks the catalogs to determine whether
+ *    a value is by-value (type "0" is null-delimited character string,
+ *    as it is for, e.g., the parser).  The only other item obtained
+ *    from the catalogs is whether or not the value should be placed in
+ *    a struct varlena or not.  Otherwise, the size given by the
+ *    frontend is assumed to be correct (probably a bad decision, but
+ *    we do strange things in the name of compatibility).
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "tcop/tcopdebug.h"
+
+#include "utils/palloc.h"
+#include "fmgr.h"
+#include "utils/elog.h"
+#include "utils/builtins.h"	/* for oideq */
+#include "tcop/fastpath.h"
+#include "libpq/libpq.h"
+
+#include "access/xact.h"	/* for TransactionId/CommandId protos */
+
+#include "utils/syscache.h"
+#include "catalog/pg_proc.h"
+#include "catalog/pg_type.h"
+
+
+/* ----------------
+ *	SendFunctionResult
+ * ----------------
+ */
+static void
+SendFunctionResult(Oid fid,	/* function id */
+		   char *retval, /* actual return value */
+		   bool retbyval,
+		   int retlen	/* the length according to the catalogs */
+		   )
+{
+    pq_putnchar("V", 1);
+    
+    if (retlen != 0) { 
+	pq_putnchar("G", 1);
+	if (retbyval) {		/* by-value */
+	    pq_putint(retlen, 4);
+	    pq_putint((int)retval, retlen); 
+	} else {		/* by-reference ... */
+	    if (retlen < 0) {		/* ... varlena */
+		pq_putint(VARSIZE(retval) - VARHDRSZ, 4);
+		pq_putnchar(VARDATA(retval), VARSIZE(retval) - VARHDRSZ);
+	    } else {			/* ... fixed */
+		pq_putint(retlen, 4);
+		pq_putnchar(retval, retlen);
+	    }
+	}
+    }
+
+    pq_putnchar("0", 1);
+    pq_flush();
+}
+
+/*
+ * This structure saves enough state so that one can avoid having to
+ * do catalog lookups over and over again.  (Each RPC can require up
+ * to MAXFMGRARGS+2 lookups, which is quite tedious.)
+ *
+ * The previous incarnation of this code just assumed that any argument
+ * of size <= 4 was by value; this is not correct.  There is no cheap
+ * way to determine function argument length etc.; one must simply pay
+ * the price of catalog lookups.
+ */
+struct fp_info {
+    Oid		funcid;
+    int			nargs;
+    bool		argbyval[MAXFMGRARGS];
+    int32		arglen[MAXFMGRARGS];	/* signed (for varlena) */
+    bool		retbyval;
+    int32		retlen;			/* signed (for varlena) */
+    TransactionId	xid;
+    CommandId		cid;
+};
+
+/*
+ * We implement one-back caching here.  If we need to do more, we can.
+ * Most routines in tight loops (like PQfswrite -> F_LOWRITE) will do
+ * the same thing repeatedly.
+ */
+static struct fp_info last_fp = { InvalidOid };
+
+/*
+ * valid_fp_info
+ *
+ * RETURNS:
+ *	1 if the state in 'fip' is valid
+ *	0 otherwise
+ *
+ * "valid" means:
+ * The saved state was either uninitialized, for another function,
+ * or from a previous command.  (Commands can do updates, which
+ * may invalidate catalog entries for subsequent commands.  This
+ * is overly pessimistic but since there is no smarter invalidation
+ * scheme...).
+ */
+static int
+valid_fp_info(Oid func_id, struct fp_info *fip)
+{
+    Assert(OidIsValid(func_id));
+    Assert(fip != (struct fp_info *) NULL);
+    
+    return(OidIsValid(fip->funcid) &&
+	   oideq(func_id, fip->funcid) &&
+	   TransactionIdIsCurrentTransactionId(fip->xid) &&
+	   CommandIdIsCurrentCommandId(fip->cid));
+}
+
+/*
+ * update_fp_info
+ *
+ * Performs catalog lookups to load a struct fp_info 'fip' for the
+ * function 'func_id'.
+ *
+ * RETURNS:
+ *	The correct information in 'fip'.  Sets 'fip->funcid' to
+ *	InvalidOid if an exception occurs.
+ */
+static void
+update_fp_info(Oid func_id, struct fp_info *fip)
+{
+    Oid		*argtypes;	/* an oid8 */
+    Oid		rettype;
+    HeapTuple		func_htp, type_htp;
+    TypeTupleForm	tp;
+    Form_pg_proc	pp;
+    int			i;
+    
+    Assert(OidIsValid(func_id));
+    Assert(fip != (struct fp_info *) NULL);
+
+    /*
+     * Since the validity of this structure is determined by whether
+     * the funcid is OK, we clear the funcid here.  It must not be
+     * set to the correct value until we are about to return with
+     * a good struct fp_info, since we can be interrupted (i.e., with
+     * an elog(WARN, ...)) at any time.
+     */
+    memset((char *) fip, 0, (int) sizeof(struct fp_info));
+    fip->funcid = InvalidOid;
+
+    func_htp = SearchSysCacheTuple(PROOID, ObjectIdGetDatum(func_id),
+				   0,0,0);
+    if (!HeapTupleIsValid(func_htp)) {
+	elog(WARN, "update_fp_info: cache lookup for function %d failed",
+	     func_id);
+    }
+    pp = (Form_pg_proc) GETSTRUCT(func_htp);
+    fip->nargs = pp->pronargs;
+    rettype = pp->prorettype;
+    argtypes = pp->proargtypes;
+
+    for (i = 0; i < fip->nargs; ++i) {
+	if (OidIsValid(argtypes[i])) {
+	    type_htp = SearchSysCacheTuple(TYPOID, 
+					   ObjectIdGetDatum(argtypes[i]),
+					   0,0,0);
+	    if (!HeapTupleIsValid(type_htp)) {
+		elog(WARN, "update_fp_info: bad argument type %d for %d",
+		     argtypes[i], func_id);
+	    }
+	    tp = (TypeTupleForm) GETSTRUCT(type_htp);
+	    fip->argbyval[i] = tp->typbyval;
+	    fip->arglen[i] = tp->typlen;
+	} /* else it had better be VAR_LENGTH_ARG */
+    }
+
+    if (OidIsValid(rettype)) {
+	type_htp = SearchSysCacheTuple(TYPOID, ObjectIdGetDatum(rettype),
+				       0,0,0);
+	if (!HeapTupleIsValid(type_htp)) {
+	    elog(WARN, "update_fp_info: bad return type %d for %d",
+		 rettype, func_id);
+	}
+	tp = (TypeTupleForm) GETSTRUCT(type_htp);
+	fip->retbyval = tp->typbyval;
+	fip->retlen = tp->typlen;
+    } /* else it had better by VAR_LENGTH_RESULT */
+
+    fip->xid = GetCurrentTransactionId();
+    fip->cid = GetCurrentCommandId();
+
+    /*
+     * This must be last!
+     */
+    fip->funcid = func_id;
+}
+	
+
+/*
+ * HandleFunctionRequest
+ *
+ * Server side of PQfn (fastpath function calls from the frontend).
+ * This corresponds to the libpq protocol symbol "F".
+ *
+ * RETURNS:
+ *	nothing of significance.
+ *	All errors result in elog(WARN,...).
+ */
+int
+HandleFunctionRequest()
+{
+    Oid		fid;
+    int		argsize;
+    int		nargs;
+    char	*arg[8];
+    char	*retval;
+    int			i;
+    uint32		palloced;
+    char		*p;
+    struct fp_info	*fip;
+
+    fid = (Oid) pq_getint(4);	/* function oid */
+    nargs = pq_getint(4);	/* # of arguments */
+
+    /*
+     * This is where the one-back caching is done.
+     * If you want to save more state, make this a loop around an array.
+     */
+    fip = &last_fp;
+    if (!valid_fp_info(fid, fip)) {
+	update_fp_info(fid, fip);
+    }
+
+    if (fip->nargs != nargs) {
+	elog(WARN, "HandleFunctionRequest: actual arguments (%d) != registered arguments (%d)",
+	     nargs, fip->nargs);
+    }
+
+    /*
+     *  Copy arguments into arg vector.  If we palloc() an argument, we need
+     *  to remember, so that we pfree() it after the call.
+     */
+    palloced = 0x0;
+    for (i = 0; i < 8; ++i) {
+	if (i >= nargs) {
+	    arg[i] = (char *) NULL;
+	} else {
+	    argsize = pq_getint(4);
+	    
+	    Assert(argsize > 0);
+	    if (fip->argbyval[i]) {		/* by-value */
+		Assert(argsize <= 4);
+		arg[i] = (char *) pq_getint(argsize);
+	    } else {			/* by-reference ... */
+		if (fip->arglen[i] < 0) {		/* ... varlena */
+		    if (!(p = palloc(argsize + VARHDRSZ))) {
+			elog(WARN, "HandleFunctionRequest: palloc failed");
+		    }
+		    VARSIZE(p) = argsize + VARHDRSZ;
+		    pq_getnchar(VARDATA(p), 0, argsize);
+		} else {				/* ... fixed */
+			/* XXX cross our fingers and trust "argsize" */
+			if (!(p = palloc(argsize))) {
+			    elog(WARN, "HandleFunctionRequest: palloc failed");
+			}
+			pq_getnchar(p, 0, argsize);
+		    }
+		palloced |= (1 << i);
+		arg[i] = p;
+	    }
+	}
+    }
+
+#ifndef NO_FASTPATH
+    retval = fmgr(fid,
+		  arg[0], arg[1], arg[2], arg[3],
+		  arg[4], arg[5], arg[6], arg[7]);
+
+#else
+    retval = NULL;
+#endif /* NO_FASTPATH */
+
+    /* free palloc'ed arguments */
+    for (i = 0; i < nargs; ++i) {
+	if (palloced & (1 << i))
+	    pfree(arg[i]);
+    }
+
+    /*
+     *  If this is an ordinary query (not a retrieve portal p ...), then
+     *  we return the data to the user.  If the return value was palloc'ed,
+     *  then it must also be freed.
+     */
+#ifndef NO_FASTPATH
+    SendFunctionResult(fid, retval, fip->retbyval, fip->retlen);
+#else
+    SendFunctionResult(fid, retval, fip->retbyval, 0);
+#endif /* NO_FASTPATH */
+
+    if (!fip->retbyval)
+	pfree(retval);
+
+    
+    
+    return(0);
+}