*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.26 1999/05/10 00:46:07 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.27 1999/05/29 01:45:21 tgl Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
- *
- * Most of these routines call SearchSysCacheStruct() and thus simply
- * (1) allocate some space for the return struct and (2) call it.
- *
*-------------------------------------------------------------------------
*/
#include <string.h>
bool
op_class(Oid oprno, int32 opclass, Oid amopid)
{
- FormData_pg_amop amoptup;
-
- if (SearchSysCacheStruct(AMOPOPID, (char *) &amoptup,
- ObjectIdGetDatum(opclass),
- ObjectIdGetDatum(oprno),
- ObjectIdGetDatum(amopid),
- 0))
+ if (HeapTupleIsValid(SearchSysCacheTuple(AMOPOPID,
+ ObjectIdGetDatum(opclass),
+ ObjectIdGetDatum(oprno),
+ ObjectIdGetDatum(amopid),
+ 0)))
return true;
else
return false;
char *
get_attname(Oid relid, AttrNumber attnum)
{
- FormData_pg_attribute att_tup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(ATTNUM, (char *) &att_tup,
+ tp = SearchSysCacheTuple(ATTNUM,
ObjectIdGetDatum(relid),
UInt16GetDatum(attnum),
- 0, 0))
- return pstrdup(att_tup.attname.data);
+ 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp);
+ return pstrdup(att_tup->attname.data);
+ }
else
return NULL;
}
AttrNumber
get_attnum(Oid relid, char *attname)
{
- FormData_pg_attribute att_tup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(ATTNAME, (char *) &att_tup,
+ tp = SearchSysCacheTuple(ATTNAME,
ObjectIdGetDatum(relid),
PointerGetDatum(attname),
- 0, 0))
- return att_tup.attnum;
+ 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp);
+ return att_tup->attnum;
+ }
else
return InvalidAttrNumber;
}
Oid
get_atttype(Oid relid, AttrNumber attnum)
{
- Form_pg_attribute att_tup = (Form_pg_attribute) palloc(sizeof(*att_tup));
+ HeapTuple tp;
- if (SearchSysCacheStruct(ATTNUM, (char *) att_tup,
+ tp = SearchSysCacheTuple(ATTNUM,
ObjectIdGetDatum(relid),
UInt16GetDatum(attnum),
- 0, 0))
+ 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp);
return att_tup->atttypid;
+ }
else
- return (Oid) NULL;
+ return InvalidOid;
}
/* This routine uses the attname instead of the attnum because it
bool
get_attisset(Oid relid, char *attname)
{
- HeapTuple tuple;
- AttrNumber attno;
- Form_pg_attribute att_tup;
-
- attno = get_attnum(relid, attname);
-
- tuple = SearchSysCacheTuple(ATTNAME,
- ObjectIdGetDatum(relid),
- PointerGetDatum(attname),
- 0, 0);
- if (!HeapTupleIsValid(tuple))
- elog(ERROR, "get_attisset: no attribute %s in relation %u",
- attname, relid);
- if (heap_attisnull(tuple, attno))
- return false;
- else
+ HeapTuple tp;
+
+ tp = SearchSysCacheTuple(ATTNAME,
+ ObjectIdGetDatum(relid),
+ PointerGetDatum(attname),
+ 0, 0);
+ if (HeapTupleIsValid(tp))
{
- att_tup = (Form_pg_attribute) GETSTRUCT(tuple);
+ Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp);
return att_tup->attisset;
}
+ else
+ return false;
}
/*
int32
get_atttypmod(Oid relid, AttrNumber attnum)
{
- FormData_pg_attribute att_tup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(ATTNUM, (char *) &att_tup,
+ tp = SearchSysCacheTuple(ATTNUM,
ObjectIdGetDatum(relid),
- Int16GetDatum(attnum),
- 0, 0))
- return att_tup.atttypmod;
+ UInt16GetDatum(attnum),
+ 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_attribute att_tup = (Form_pg_attribute) GETSTRUCT(tp);
+ return att_tup->atttypmod;
+ }
else
return -1;
}
* get_opcode -
*
* Returns the regproc id of the routine used to implement an
- * operator given the operator uid.
+ * operator given the operator oid.
*
*/
RegProcedure
get_opcode(Oid opno)
{
- FormData_pg_operator optup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ tp = SearchSysCacheTuple(OPROID,
ObjectIdGetDatum(opno),
- 0, 0, 0))
- return optup.oprcode;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
+ return optup->oprcode;
+ }
else
return (RegProcedure) NULL;
}
* get_opname -
* returns the name of the operator with the given opno
*
- * Note: return the struct so that it gets copied.
+ * Note: returns a palloc'd copy of the string, or NULL if no such operator.
*/
char *
get_opname(Oid opno)
{
- FormData_pg_operator optup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ tp = SearchSysCacheTuple(OPROID,
ObjectIdGetDatum(opno),
- 0, 0, 0))
- return pstrdup(optup.oprname.data);
- else
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
{
- /* don't throw an error anymore; we want to continue... */
-#ifdef NOT_USED
- elog(ERROR, "can't look up operator %u\n", opno);
-#endif
- return NULL;
+ Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
+ return pstrdup(optup->oprname.data);
}
+ else
+ return NULL;
}
/*
bool
op_mergejoinable(Oid opno, Oid ltype, Oid rtype, Oid *leftOp, Oid *rightOp)
{
- FormData_pg_operator optup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ tp = SearchSysCacheTuple(OPROID,
ObjectIdGetDatum(opno),
- 0, 0, 0) &&
- optup.oprlsortop &&
- optup.oprrsortop &&
- optup.oprleft == ltype &&
- optup.oprright == rtype)
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
{
- *leftOp = ObjectIdGetDatum(optup.oprlsortop);
- *rightOp = ObjectIdGetDatum(optup.oprrsortop);
- return TRUE;
+ Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
+
+ if (optup->oprlsortop &&
+ optup->oprrsortop &&
+ optup->oprleft == ltype &&
+ optup->oprright == rtype)
+ {
+ *leftOp = ObjectIdGetDatum(optup->oprlsortop);
+ *rightOp = ObjectIdGetDatum(optup->oprrsortop);
+ return true;
+ }
}
- else
- return FALSE;
+ return false;
}
/*
Oid
op_hashjoinable(Oid opno, Oid ltype, Oid rtype)
{
- FormData_pg_operator optup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ tp = SearchSysCacheTuple(OPROID,
ObjectIdGetDatum(opno),
- 0, 0, 0) &&
- optup.oprcanhash &&
- optup.oprleft == ltype &&
- optup.oprright == rtype)
- return opno;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
+
+ if (optup->oprcanhash &&
+ optup->oprleft == ltype &&
+ optup->oprright == rtype)
+ return opno;
+ }
+ return InvalidOid;
+}
+
+HeapTuple
+get_operator_tuple(Oid opno)
+{
+ HeapTuple optup;
+
+ if ((optup = SearchSysCacheTuple(OPROID,
+ ObjectIdGetDatum(opno),
+ 0, 0, 0)))
+ return optup;
else
- return InvalidOid;
+ return (HeapTuple) NULL;
}
/*
Oid
get_commutator(Oid opno)
{
- FormData_pg_operator optup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ tp = SearchSysCacheTuple(OPROID,
ObjectIdGetDatum(opno),
- 0, 0, 0))
- return optup.oprcom;
- else
- return (Oid) NULL;
-}
-
-HeapTuple
-get_operator_tuple(Oid opno)
-{
- HeapTuple optup;
-
- if ((optup = SearchSysCacheTuple(OPROID,
- ObjectIdGetDatum(opno),
- 0, 0, 0)))
- return optup;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
+ return optup->oprcom;
+ }
else
- return (HeapTuple) NULL;
+ return InvalidOid;
}
/*
Oid
get_negator(Oid opno)
{
- FormData_pg_operator optup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ tp = SearchSysCacheTuple(OPROID,
ObjectIdGetDatum(opno),
- 0, 0, 0))
- return optup.oprnegate;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
+ return optup->oprnegate;
+ }
else
- return (Oid) NULL;
+ return InvalidOid;
}
/*
RegProcedure
get_oprrest(Oid opno)
{
- FormData_pg_operator optup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ tp = SearchSysCacheTuple(OPROID,
ObjectIdGetDatum(opno),
- 0, 0, 0))
- return optup.oprrest;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
+ return optup->oprrest;
+ }
else
return (RegProcedure) NULL;
}
RegProcedure
get_oprjoin(Oid opno)
{
- FormData_pg_operator optup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(OPROID, (char *) &optup,
+ tp = SearchSysCacheTuple(OPROID,
ObjectIdGetDatum(opno),
- 0, 0, 0))
- return optup.oprjoin;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_operator optup = (Form_pg_operator) GETSTRUCT(tp);
+ return optup->oprjoin;
+ }
else
return (RegProcedure) NULL;
}
int
get_relnatts(Oid relid)
{
- FormData_pg_class reltup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(RELOID, (char *) &reltup,
+ tp = SearchSysCacheTuple(RELOID,
ObjectIdGetDatum(relid),
- 0, 0, 0))
- return reltup.relnatts;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
+ return reltup->relnatts;
+ }
else
return InvalidAttrNumber;
}
char *
get_rel_name(Oid relid)
{
- FormData_pg_class reltup;
+ HeapTuple tp;
- if ((SearchSysCacheStruct(RELOID, (char *) &reltup,
- ObjectIdGetDatum(relid),
- 0, 0, 0)))
- return pstrdup(reltup.relname.data);
+ tp = SearchSysCacheTuple(RELOID,
+ ObjectIdGetDatum(relid),
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_class reltup = (Form_pg_class) GETSTRUCT(tp);
+ return pstrdup(reltup->relname.data);
+ }
else
return NULL;
}
int16
get_typlen(Oid typid)
{
- FormData_pg_type typtup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
+ tp = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(typid),
- 0, 0, 0))
- return typtup.typlen;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
+ return typtup->typlen;
+ }
else
- return (int16) NULL;
+ return 0;
}
/*
bool
get_typbyval(Oid typid)
{
- FormData_pg_type typtup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
+ tp = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(typid),
- 0, 0, 0))
- return (bool) typtup.typbyval;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
+ return (bool) typtup->typbyval;
+ }
else
return false;
}
-/*
- * get_typbyval -
- *
- * Given the type OID, determine whether the type is returned by value or
- * not. Returns 1 if by value, 0 if by reference.
- *
- */
#ifdef NOT_USED
char
get_typalign(Oid typid)
{
- FormData_pg_type typtup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
+ tp = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(typid),
- 0, 0, 0))
- return typtup.typalign;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
+ return typtup->typalign;
+ }
else
return 'i';
}
char
get_typtype(Oid typid)
{
- FormData_pg_type typtup;
+ HeapTuple tp;
- if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
+ tp = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(typid),
- 0, 0, 0))
- return typtup.typtype;
+ 0, 0, 0);
+ if (HeapTupleIsValid(tp))
+ {
+ Form_pg_type typtup = (Form_pg_type) GETSTRUCT(tp);
+ return typtup->typtype;
+ }
else
return '\0';
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.26 1999/05/25 22:42:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.27 1999/05/29 01:45:20 tgl Exp $
*
* NOTES
* These routines allow the parser/planner/executor to perform
#include "access/htup.h"
#include "catalog/catname.h"
#include "utils/catcache.h"
-#ifndef HAVE_MEMMOVE
-#include <regex/utils.h>
-#else
#include <string.h>
-#endif
/* ----------------
NULL}
};
-static struct catcache *SysCache[
- lengthof(cacheinfo)];
+static struct catcache *SysCache[lengthof(cacheinfo)];
static int32 SysCacheSize = lengthof(cacheinfo);
tp = SearchSysCacheTuple(cacheId, key1, key2, key3, key4);
if (!HeapTupleIsValid(tp))
return 0;
- memmove(returnStruct, (char *) GETSTRUCT(tp), cacheinfo[cacheId].size);
+ memcpy(returnStruct, (char *) GETSTRUCT(tp), cacheinfo[cacheId].size);
return 1;
}
/*
* SearchSysCacheGetAttribute
* Returns the attribute corresponding to 'attributeNumber' for
- * a given cached tuple.
+ * a given cached tuple. This routine usually needs to be used for
+ * attributes that might be NULL or might be at a variable offset
+ * in the tuple.
*
- * XXX This re-opens a relation, so this is slower.
+ * XXX This re-opens the relation, so this is slower than just pulling
+ * fixed-location fields out of the struct returned by SearchSysCacheTuple.
*
* [callers all assume this returns a (struct varlena *). -ay 10/94]
*/
: attributeLength; /* fixed length */
tmp = (char *) palloc(size);
- memmove(tmp, (void *) attributeValue, size);
+ memcpy(tmp, (void *) attributeValue, size);
returnValue = (void *) tmp;
}
* TypeDefaultRetrieve
*
* Given a type OID, return the typdefault field associated with that
- * type. The typdefault is returned as the car of a dotted pair which
- * is passed to TypeDefaultRetrieve by the calling routine.
- *
- * Returns a fixnum for types which are passed by value and a ppreserve'd
- * vectori for types which are not.
+ * type. The result is a Datum, and points to palloc'd storage for
+ * non-pass-by-value types.
*
* [identical to get_typdefault, expecting a (struct varlena *) as ret val.
* some day, either of the functions should be removed -ay 10/94]
void *
TypeDefaultRetrieve(Oid typId)
{
+ struct varlena *typDefault;
+ int32 dataSize;
HeapTuple typeTuple;
Form_pg_type type;
int32 typByVal,
typLen;
- struct varlena *typDefault;
- int32 dataSize;
void *returnValue;
- typeTuple = SearchSysCacheTuple(TYPOID,
- ObjectIdGetDatum(typId),
- 0, 0, 0);
+ /*
+ * First, see if there is a non-null typdefault field (usually there isn't)
+ */
+ typDefault = (struct varlena *)
+ SearchSysCacheGetAttribute(TYPOID,
+ Anum_pg_type_typdefault,
+ ObjectIdGetDatum(typId),
+ 0, 0, 0);
- if (!HeapTupleIsValid(typeTuple))
+ if (typDefault == NULL)
{
#ifdef CACHEDEBUG
- elog(DEBUG, "TypeDefaultRetrieve: Lookup in %s(%d) failed",
+ elog(DEBUG, "TypeDefaultRetrieve: No extractable typdefault in %s(%d)",
cacheinfo[TYPOID].name, TYPOID);
#endif /* defined(CACHEDEBUG) */
return NULL;
}
- type = (Form_pg_type) GETSTRUCT(typeTuple);
- typByVal = type->typbyval;
- typLen = type->typlen;
+ dataSize = VARSIZE(typDefault) - VARHDRSZ;
- typDefault = (struct varlena *)
- SearchSysCacheGetAttribute(TYPOID,
- Anum_pg_type_typdefault,
- ObjectIdGetDatum(typId),
- 0, 0, 0);
+ /*
+ * Need the type's length and byVal fields.
+ *
+ * XXX silly to repeat the syscache search that SearchSysCacheGetAttribute
+ * just did --- but at present this path isn't taken often enough to
+ * make it worth fixing.
+ */
+ typeTuple = SearchSysCacheTuple(TYPOID,
+ ObjectIdGetDatum(typId),
+ 0, 0, 0);
- if (typDefault == (struct varlena *) NULL)
+ if (!HeapTupleIsValid(typeTuple))
{
+ /* should never get here, really... */
#ifdef CACHEDEBUG
- elog(DEBUG, "TypeDefaultRetrieve: No extractable typdefault in %s(%d)",
+ elog(DEBUG, "TypeDefaultRetrieve: Lookup in %s(%d) failed",
cacheinfo[TYPOID].name, TYPOID);
#endif /* defined(CACHEDEBUG) */
return NULL;
}
- dataSize = VARSIZE(typDefault) - VARHDRSZ;
+ type = (Form_pg_type) GETSTRUCT(typeTuple);
+ typLen = type->typlen;
+ typByVal = type->typbyval;
if (typByVal)
{
int8 i8;
int16 i16;
- int32 i32;
+ int32 i32 = 0;
if (dataSize == typLen)
{
switch (typLen)
{
case sizeof(int8):
- memmove((char *) &i8, VARDATA(typDefault), sizeof(int8));
+ memcpy((char *) &i8, VARDATA(typDefault), sizeof(int8));
i32 = i8;
break;
case sizeof(int16):
- memmove((char *) &i16, VARDATA(typDefault), sizeof(int16));
+ memcpy((char *) &i16, VARDATA(typDefault), sizeof(int16));
i32 = i16;
break;
case sizeof(int32):
- memmove((char *) &i32, VARDATA(typDefault), sizeof(int32));
+ memcpy((char *) &i32, VARDATA(typDefault), sizeof(int32));
break;
}
returnValue = (void *) i32;
else
{
returnValue = (void *) palloc(VARSIZE(typDefault));
- memmove((char *) returnValue,
- (char *) typDefault,
- (int) VARSIZE(typDefault));
+ memcpy((char *) returnValue,
+ (char *) typDefault,
+ (int) VARSIZE(typDefault));
}
}
projects / postgresql / commitdiff