Make all system indexes unique.
Make all cache loads use system indexes.
Rename *rel to *relid in inheritance tables.
Rename cache names to be clearer.
<synopsis>
int PgConnection::ExecTuplesOk(const char *query)
</synopsis>
- Returns TRUE if the command query succeeds and there are tuples to be retrieved.
+ Returns TRUE if the command query succeeds.
</para>
</listitem>
<listitem>
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.50 1999/11/07 23:07:46 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/printtup.c,v 1.51 1999/11/22 17:55:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
HeapTuple typeTuple;
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(type),
0, 0, 0);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.56 1999/11/07 23:07:47 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/common/tupdesc.c,v 1.57 1999/11/22 17:55:52 momjian Exp $
*
* NOTES
* some of the executor utility code such as "ExecTypeFromTL" should be
* -cim 6/14/90
* ----------------
*/
- tuple = SearchSysCacheTuple(TYPOID,
+ tuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(typeid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.37 1999/10/23 03:13:20 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/Attic/istrat.c,v 1.38 1999/11/22 17:55:53 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (!IsBootstrapProcessingMode())
{
- tuple = SearchSysCacheTuple(OPROID,
+ tuple = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(operatorObjectId),
0, 0, 0);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.50 1999/08/09 01:39:19 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/nbtree/nbtinsert.c,v 1.51 1999/11/22 17:55:54 momjian Exp $
*
*-------------------------------------------------------------------------
*/
buf = _bt_getbuf(rel, blkno, BT_WRITE);
goto l1;/* continue from the begin */
}
- elog(ERROR, "Cannot insert a duplicate key into a unique index");
+ elog(ERROR, "Cannot insert a duplicate key into unique index %s", RelationGetRelationName(rel));
}
/* htup null so no buffer to release */
/* get next offnum */
# Makefile for catalog
#
# IDENTIFICATION
-# $Header: /cvsroot/pgsql/src/backend/catalog/Makefile,v 1.17 1999/03/27 17:25:09 tgl Exp $
+# $Header: /cvsroot/pgsql/src/backend/catalog/Makefile,v 1.18 1999/11/22 17:55:56 momjian Exp $
#
#-------------------------------------------------------------------------
pg_rewrite.h pg_listener.h pg_description.h indexing.h \
)
-global1.bki.source: $(GENBKI) $(GLOBALBKI_SRCS)
+global1.bki.source: $(GENBKI) $(GLOBALBKI_SRCS) \
+ $(addprefix ../../include/catalog/, indexing.h)
ifneq ($(PORTNAME), win)
sh $(SHOPTS) $(GENBKI) $(BKIOPTS) $(GLOBALBKI_SRCS) > $@ 2>global1.description
else
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.29 1999/11/07 23:08:00 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.30 1999/11/22 17:55:56 momjian Exp $
*
* NOTES
* See acl.h.
int32 result;
Relation relation;
- tuple = SearchSysCacheTuple(USENAME,
+ tuple = SearchSysCacheTuple(USERNAME,
PointerGetDatum(usename),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
AclId user_id,
owner_id = 0;
- tuple = SearchSysCacheTuple(USENAME,
+ tuple = SearchSysCacheTuple(USERNAME,
PointerGetDatum(usename),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
0, 0, 0);
switch (cacheid)
{
- case OPROID:
+ case OPEROID:
if (!HeapTupleIsValid(tuple))
elog(ERROR, "pg_ownercheck: operator %ld not found",
PointerGetDatum(value));
owner_id = ((Form_pg_operator) GETSTRUCT(tuple))->oprowner;
break;
- case PRONAME:
+ case PROCNAME:
if (!HeapTupleIsValid(tuple))
elog(ERROR, "pg_ownercheck: function \"%s\" not found",
value);
value);
owner_id = ((Form_pg_class) GETSTRUCT(tuple))->relowner;
break;
- case TYPNAME:
+ case TYPENAME:
if (!HeapTupleIsValid(tuple))
elog(ERROR, "pg_ownercheck: type \"%s\" not found",
value);
AclId user_id,
owner_id;
- tuple = SearchSysCacheTuple(USENAME,
+ tuple = SearchSysCacheTuple(USERNAME,
PointerGetDatum(usename),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
return 1;
}
- tuple = SearchSysCacheTuple(PRONAME,
+ tuple = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(funcname),
Int32GetDatum(nargs),
PointerGetDatum(arglist),
AclId user_id,
owner_id;
- tuple = SearchSysCacheTuple(USENAME,
+ tuple = SearchSysCacheTuple(USERNAME,
PointerGetDatum(usename),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.25 1999/07/17 20:16:48 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/catalog.c,v 1.26 1999/11/22 17:55:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
for (i = 0; i < natts;)
{
- tuple = SearchSysCacheTuple(TYPOID,
+ tuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum((*attributeP)->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.108 1999/11/16 04:13:55 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.109 1999/11/22 17:55:57 momjian Exp $
*
*
* INTERFACE ROUTINES
tuple = heap_getnext(scan, 0);
if (HeapTupleIsValid(tuple))
{
- Oid subclass = ((Form_pg_inherits) GETSTRUCT(tuple))->inhrel;
+ Oid subclass = ((Form_pg_inherits) GETSTRUCT(tuple))->inhrelid;
heap_endscan(scan);
heap_close(catalogRelation, RowExclusiveLock);
* so we can trash it. First we remove dead INHERITS tuples.
* ----------------
*/
- entry.sk_attno = Anum_pg_inherits_inhrel;
+ entry.sk_attno = Anum_pg_inherits_inhrelid;
scan = heap_beginscan(catalogRelation,
false,
catalogRelation = heap_openr(InheritancePrecidenceListRelationName,
RowExclusiveLock);
- entry.sk_attno = Anum_pg_ipl_iplrel;
+ entry.sk_attno = Anum_pg_ipl_iplrelid;
scan = heap_beginscan(catalogRelation,
false,
{
funcInfo = &fInfo;
FIsetnArgs(funcInfo, numberOfAttributes);
- procTuple = SearchSysCacheTuple(PROOID, ObjectIdGetDatum(procId),
+ procTuple = SearchSysCacheTuple(PROCOID, ObjectIdGetDatum(procId),
0, 0, 0);
if (!HeapTupleIsValid(procTuple))
elog(ERROR, "RelationTruncateIndexes: index procedure not found");
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.96 1999/11/21 20:01:10 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.97 1999/11/22 17:55:57 momjian Exp $
*
*
* INTERFACE ROUTINES
funcname = FIgetname(funcInfo);
nargs = FIgetnArgs(funcInfo);
argtypes = FIgetArglist(funcInfo);
- tuple = SearchSysCacheTuple(PRONAME,
+ tuple = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(funcname),
Int32GetDatum(nargs),
PointerGetDatum(argtypes),
/*
* Look up the return type in pg_type for the type length.
*/
- tuple = SearchSysCacheTuple(TYPOID,
+ tuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(retType),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
{
HeapTuple tup;
- tup = SearchSysCacheTuple(TYPNAME,
+ tup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(IndexKeyType->name),
0, 0, 0);
if (!HeapTupleIsValid(tup))
{
HeapTuple proc_tup;
- proc_tup = SearchSysCacheTuple(PRONAME,
+ proc_tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(FIgetname(funcInfo)),
Int32GetDatum(FIgetnArgs(funcInfo)),
PointerGetDatum(FIgetArglist(funcInfo)),
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.50 1999/11/01 04:00:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.51 1999/11/22 17:55:57 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/syscache.h"
/*
- * Names of indices on the following system catalogs:
- *
- * pg_attribute
- * pg_proc
- * pg_type
- * pg_naming
- * pg_class
- * pg_attrdef
- * pg_relcheck
- * pg_trigger
+ * Names of indices - they match all system caches
*/
-char *Name_pg_amop_indices[Num_pg_amop_indices] = {AccessMethodOpidIndex,
- AccessMethodStrategyIndex};
-char *Name_pg_attr_indices[Num_pg_attr_indices] = {AttributeNameIndex,
- AttributeNumIndex, AttributeRelidIndex};
-char *Name_pg_index_indices[Num_pg_index_indices] = {IndexRelidIndex};
-char *Name_pg_proc_indices[Num_pg_proc_indices] = {ProcedureNameIndex,
- ProcedureOidIndex};
-char *Name_pg_type_indices[Num_pg_type_indices] = {TypeNameIndex,
- TypeOidIndex};
-char *Name_pg_class_indices[Num_pg_class_indices] = {ClassNameIndex,
- ClassOidIndex};
-char *Name_pg_attrdef_indices[Num_pg_attrdef_indices] = {AttrDefaultIndex};
-char *Name_pg_relcheck_indices[Num_pg_relcheck_indices] = {RelCheckIndex};
-char *Name_pg_trigger_indices[Num_pg_trigger_indices] = {TriggerRelidIndex,
- TriggerConstrNameIndex, TriggerConstrRelidIndex};
-char *Name_pg_description_indices[Num_pg_description_indices] = {DescriptionObjIndex};
+char *Name_pg_aggregate_indices[Num_pg_aggregate_indices] =
+ {AggregateNameTypeIndex};
+char *Name_pg_am_indices[Num_pg_am_indices] =
+ {AmNameIndex};
+char *Name_pg_amop_indices[Num_pg_amop_indices] =
+ {AccessMethodOpidIndex, AccessMethodStrategyIndex};
+char *Name_pg_attr_indices[Num_pg_attr_indices] =
+ {AttributeRelidNameIndex, AttributeRelidNumIndex};
+char *Name_pg_attrdef_indices[Num_pg_attrdef_indices] =
+ {AttrDefaultIndex};
+char *Name_pg_class_indices[Num_pg_class_indices] =
+ {ClassNameIndex, ClassOidIndex};
+char *Name_pg_group_indices[Num_pg_group_indices] =
+ {GroupNameIndex, GroupSysidIndex};
+char *Name_pg_index_indices[Num_pg_index_indices] =
+ {IndexRelidIndex};
+char *Name_pg_inherits_indices[Num_pg_inherits_indices] =
+ {InheritsRelidSeqnoIndex};
+char *Name_pg_language_indices[Num_pg_language_indices] =
+ {LanguageOidIndex, LanguageNameIndex};
+char *Name_pg_listener_indices[Num_pg_listener_indices] =
+ {ListenerRelnamePidIndex};
+char *Name_pg_opclass_indices[Num_pg_opclass_indices] =
+ {OpclassNameIndex, OpclassDeftypeIndex};
+char *Name_pg_operator_indices[Num_pg_operator_indices] =
+ {OperatorOidIndex, OperatorNameIndex};
+char *Name_pg_proc_indices[Num_pg_proc_indices] =
+ {ProcedureOidIndex, ProcedureNameIndex};
+char *Name_pg_relcheck_indices[Num_pg_relcheck_indices] =
+ {RelCheckIndex};
+char *Name_pg_rewrite_indices[Num_pg_rewrite_indices] =
+ {RewriteOidIndex, RewriteRulenameIndex};
+char *Name_pg_shadow_indices[Num_pg_shadow_indices] =
+ {ShadowNameIndex, ShadowSysidIndex};
+char *Name_pg_trigger_indices[Num_pg_trigger_indices] =
+ {TriggerRelidIndex, TriggerConstrNameIndex, TriggerConstrRelidIndex};
+char *Name_pg_type_indices[Num_pg_type_indices] =
+ {TypeNameIndex, TypeOidIndex};
+char *Name_pg_description_indices[Num_pg_description_indices] =
+ {DescriptionObjIndex};
* (that is, functional or normal) and what arguments the cache lookup
* requires. Each routine returns the heap tuple that qualifies.
*/
+
+
+HeapTuple
+AggregateNameTypeIndexScan(Relation heapRelation, char *aggName, Oid aggType)
+{
+ Relation idesc;
+ ScanKeyData skey[2];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_NAMEEQ,
+ PointerGetDatum(aggName));
+
+ ScanKeyEntryInitialize(&skey[1],
+ (bits16) 0x0,
+ (AttrNumber) 2,
+ (RegProcedure) F_OIDEQ,
+ ObjectIdGetDatum(aggType));
+
+ idesc = index_openr(AggregateNameTypeIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 2);
+
+ index_close(idesc);
+ return tuple;
+}
+
+
+HeapTuple
+AmNameIndexScan(Relation heapRelation, char *amName)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_NAMEEQ,
+ PointerGetDatum(amName));
+
+ idesc = index_openr(AmNameIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+ return tuple;
+}
+
+
HeapTuple
AccessMethodOpidIndexScan(Relation heapRelation,
Oid claid,
return tuple;
}
-
+
+
HeapTuple
-AttributeNameIndexScan(Relation heapRelation,
+AttributeRelidNameIndexScan(Relation heapRelation,
Oid relid,
char *attname)
{
(RegProcedure) F_NAMEEQ,
NameGetDatum(attname));
- idesc = index_openr(AttributeNameIndex);
+ idesc = index_openr(AttributeRelidNameIndex);
tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 2);
index_close(idesc);
HeapTuple
-AttributeNumIndexScan(Relation heapRelation,
+AttributeRelidNumIndexScan(Relation heapRelation,
Oid relid,
AttrNumber attnum)
{
(RegProcedure) F_INT2EQ,
Int16GetDatum(attnum));
- idesc = index_openr(AttributeNumIndex);
+ idesc = index_openr(AttributeRelidNumIndex);
tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 2);
index_close(idesc);
return tuple;
}
+
+HeapTuple
+OpclassDeftypeIndexScan(Relation heapRelation, Oid defType)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_OIDEQ,
+ ObjectIdGetDatum(defType));
+
+ idesc = index_openr(OpclassDeftypeIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+
+ return tuple;
+}
+
+
+HeapTuple
+OpclassNameIndexScan(Relation heapRelation, char *opcName)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_NAMEEQ,
+ PointerGetDatum(opcName));
+
+ idesc = index_openr(OpclassNameIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+ return tuple;
+}
+
+
+HeapTuple
+GroupNameIndexScan(Relation heapRelation, char *groName)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_NAMEEQ,
+ PointerGetDatum(groName));
+
+ idesc = index_openr(GroupNameIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+ return tuple;
+}
+
+
+HeapTuple
+GroupSysidIndexScan(Relation heapRelation, int4 sysId)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_INT4EQ,
+ Int32GetDatum(sysId));
+
+ idesc = index_openr(GroupSysidIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+ return tuple;
+}
+
+
HeapTuple
IndexRelidIndexScan(Relation heapRelation, Oid relid)
{
}
+HeapTuple
+InheritsRelidSeqnoIndexScan(Relation heapRelation,
+ Oid relid,
+ int4 seqno)
+{
+ Relation idesc;
+ ScanKeyData skey[2];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_OIDEQ,
+ ObjectIdGetDatum(relid));
+
+ ScanKeyEntryInitialize(&skey[1],
+ (bits16) 0x0,
+ (AttrNumber) 2,
+ (RegProcedure) F_INT4EQ,
+ Int32GetDatum(seqno));
+
+ idesc = index_openr(InheritsRelidSeqnoIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 2);
+
+ index_close(idesc);
+
+ return tuple;
+}
+
+
+HeapTuple
+LanguageNameIndexScan(Relation heapRelation, char *lanName)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_NAMEEQ,
+ PointerGetDatum(lanName));
+
+ idesc = index_openr(LanguageNameIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+ return tuple;
+}
+
HeapTuple
-ProcedureOidIndexScan(Relation heapRelation, Oid procId)
+LanguageOidIndexScan(Relation heapRelation, Oid lanId)
{
Relation idesc;
ScanKeyData skey[1];
(bits16) 0x0,
(AttrNumber) 1,
(RegProcedure) F_OIDEQ,
- ObjectIdGetDatum(procId));
+ ObjectIdGetDatum(lanId));
- idesc = index_openr(ProcedureOidIndex);
+ idesc = index_openr(LanguageOidIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+
+ return tuple;
+}
+
+
+HeapTuple
+ListenerRelnamePidIndexScan(Relation heapRelation, char *relName, int4 pid)
+{
+ Relation idesc;
+ ScanKeyData skey[2];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_NAMEEQ,
+ PointerGetDatum(relName));
+
+ ScanKeyEntryInitialize(&skey[1],
+ (bits16) 0x0,
+ (AttrNumber) 2,
+ (RegProcedure) F_INT4EQ,
+ Int32GetDatum(pid));
+
+ idesc = index_openr(ListenerRelnamePidIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 2);
+
+ index_close(idesc);
+ return tuple;
+}
+
+
+HeapTuple
+OperatorNameIndexScan(Relation heapRelation,
+ char *oprName,
+ Oid oprLeft,
+ Oid oprRight,
+ char oprKind)
+{
+ Relation idesc;
+ ScanKeyData skey[4];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_NAMEEQ,
+ PointerGetDatum(oprName));
+
+ ScanKeyEntryInitialize(&skey[1],
+ (bits16) 0x0,
+ (AttrNumber) 2,
+ (RegProcedure) F_OIDEQ,
+ ObjectIdGetDatum(oprLeft));
+
+ ScanKeyEntryInitialize(&skey[2],
+ (bits16) 0x0,
+ (AttrNumber) 3,
+ (RegProcedure) F_OIDEQ,
+ ObjectIdGetDatum(oprRight));
+
+ ScanKeyEntryInitialize(&skey[3],
+ (bits16) 0x0,
+ (AttrNumber) 4,
+ (RegProcedure) F_CHAREQ,
+ CharGetDatum(oprKind));
+
+ idesc = index_openr(OperatorNameIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 4);
+
+ index_close(idesc);
+
+ return tuple;
+}
+
+
+HeapTuple
+OperatorOidIndexScan(Relation heapRelation, Oid oprId)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_OIDEQ,
+ ObjectIdGetDatum(oprId));
+
+ idesc = index_openr(OperatorOidIndex);
tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
index_close(idesc);
HeapTuple
-TypeOidIndexScan(Relation heapRelation, Oid typeId)
+ProcedureOidIndexScan(Relation heapRelation, Oid procId)
{
Relation idesc;
ScanKeyData skey[1];
(bits16) 0x0,
(AttrNumber) 1,
(RegProcedure) F_OIDEQ,
- ObjectIdGetDatum(typeId));
+ ObjectIdGetDatum(procId));
- idesc = index_openr(TypeOidIndex);
+ idesc = index_openr(ProcedureOidIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+
+ return tuple;
+}
+
+
+HeapTuple
+ClassNameIndexScan(Relation heapRelation, char *relName)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_NAMEEQ,
+ PointerGetDatum(relName));
+
+ idesc = index_openr(ClassNameIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+ return tuple;
+}
+
+
+HeapTuple
+ClassOidIndexScan(Relation heapRelation, Oid relId)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_OIDEQ,
+ ObjectIdGetDatum(relId));
+
+ idesc = index_openr(ClassOidIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+
+ return tuple;
+}
+
+
+HeapTuple
+RewriteRulenameIndexScan(Relation heapRelation, char *ruleName)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_NAMEEQ,
+ PointerGetDatum(ruleName));
+
+ idesc = index_openr(RewriteRulenameIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+ return tuple;
+}
+
+
+HeapTuple
+RewriteOidIndexScan(Relation heapRelation, Oid rewriteId)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_OIDEQ,
+ ObjectIdGetDatum(rewriteId));
+
+ idesc = index_openr(RewriteOidIndex);
tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
index_close(idesc);
HeapTuple
-ClassNameIndexScan(Relation heapRelation, char *relName)
+TypeOidIndexScan(Relation heapRelation, Oid typeId)
+{
+ Relation idesc;
+ ScanKeyData skey[1];
+ HeapTuple tuple;
+
+ ScanKeyEntryInitialize(&skey[0],
+ (bits16) 0x0,
+ (AttrNumber) 1,
+ (RegProcedure) F_OIDEQ,
+ ObjectIdGetDatum(typeId));
+
+ idesc = index_openr(TypeOidIndex);
+ tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
+
+ index_close(idesc);
+
+ return tuple;
+}
+
+
+HeapTuple
+ShadowNameIndexScan(Relation heapRelation, char *useName)
{
Relation idesc;
ScanKeyData skey[1];
(bits16) 0x0,
(AttrNumber) 1,
(RegProcedure) F_NAMEEQ,
- PointerGetDatum(relName));
+ PointerGetDatum(useName));
- idesc = index_openr(ClassNameIndex);
+ idesc = index_openr(ShadowNameIndex);
tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
index_close(idesc);
HeapTuple
-ClassOidIndexScan(Relation heapRelation, Oid relId)
+ShadowSysidIndexScan(Relation heapRelation, int4 sysId)
{
Relation idesc;
ScanKeyData skey[1];
HeapTuple tuple;
-
+
ScanKeyEntryInitialize(&skey[0],
(bits16) 0x0,
(AttrNumber) 1,
- (RegProcedure) F_OIDEQ,
- ObjectIdGetDatum(relId));
+ (RegProcedure) F_INT4EQ,
+ Int32GetDatum(sysId));
- idesc = index_openr(ClassOidIndex);
+ idesc = index_openr(ShadowSysidIndex);
tuple = CatalogIndexFetchTuple(heapRelation, idesc, skey, 1);
index_close(idesc);
-
return tuple;
}
+
+
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.25 1999/09/18 19:06:33 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_aggregate.c,v 1.26 1999/11/22 17:55:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/catname.h"
+#include "catalog/indexing.h"
#include "catalog/pg_aggregate.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
if (!aggtransfn1Name && !aggtransfn2Name)
elog(ERROR, "AggregateCreate: aggregate must have at least one transition function");
- tup = SearchSysCacheTuple(TYPNAME,
+ tup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(aggbasetypeName),
0, 0, 0);
if (!HeapTupleIsValid(tup))
if (aggtransfn1Name)
{
- tup = SearchSysCacheTuple(TYPNAME,
+ tup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(aggtransfn1typeName),
0, 0, 0);
if (!HeapTupleIsValid(tup))
fnArgs[0] = xret1;
fnArgs[1] = xbase;
- tup = SearchSysCacheTuple(PRONAME,
+ tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(aggtransfn1Name),
Int32GetDatum(2),
PointerGetDatum(fnArgs),
if (aggtransfn2Name)
{
- tup = SearchSysCacheTuple(TYPNAME,
+ tup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(aggtransfn2typeName),
0, 0, 0);
if (!HeapTupleIsValid(tup))
fnArgs[0] = xret2;
fnArgs[1] = 0;
- tup = SearchSysCacheTuple(PRONAME,
+ tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(aggtransfn2Name),
Int32GetDatum(1),
PointerGetDatum(fnArgs),
{
fnArgs[0] = xret1;
fnArgs[1] = xret2;
- tup = SearchSysCacheTuple(PRONAME,
+ tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(aggfinalfnName),
Int32GetDatum(2),
PointerGetDatum(fnArgs),
elog(ERROR, "AggregateCreate: heap_formtuple failed");
if (!OidIsValid(heap_insert(aggdesc, tup)))
elog(ERROR, "AggregateCreate: heap_insert failed");
+
+ if (RelationGetForm(aggdesc)->relhasindex)
+ {
+ Relation idescs[Num_pg_aggregate_indices];
+
+ CatalogOpenIndices(Num_pg_aggregate_indices, Name_pg_aggregate_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_aggregate_indices, aggdesc, tup);
+ CatalogCloseIndices(Num_pg_aggregate_indices, idescs);
+ }
+
heap_close(aggdesc, RowExclusiveLock);
}
heap_close(aggRel, AccessShareLock);
- tup = SearchSysCacheTuple(TYPOID,
+ tup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(transtype),
0, 0, 0);
if (!HeapTupleIsValid(tup))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.42 1999/09/18 19:06:33 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_operator.c,v 1.43 1999/11/22 17:55:58 momjian Exp $
*
* NOTES
* these routines moved here from commands/define.c and somewhat cleaned up.
#include "access/heapam.h"
#include "catalog/catname.h"
+#include "catalog/indexing.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
heap_insert(pg_operator_desc, tup);
operatorObjectId = tup->t_data->t_oid;
+ if (RelationGetForm(pg_operator_desc)->relhasindex)
+ {
+ Relation idescs[Num_pg_operator_indices];
+
+ CatalogOpenIndices(Num_pg_operator_indices, Name_pg_operator_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_operator_indices, pg_operator_desc, tup);
+ CatalogCloseIndices(Num_pg_operator_indices, idescs);
+ }
+
/* ----------------
* free the tuple and return the operator oid
* ----------------
typeId[1] = rightTypeId;
nargs = 2;
}
- tup = SearchSysCacheTuple(PRONAME,
+ tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(procedureName),
Int32GetDatum(nargs),
PointerGetDatum(typeId),
typeId[2] = INT2OID; /* attribute number */
typeId[3] = 0; /* value - can be any type */
typeId[4] = INT4OID; /* flags - left or right selectivity */
- tup = SearchSysCacheTuple(PRONAME,
+ tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(restrictionName),
Int32GetDatum(5),
PointerGetDatum(typeId),
typeId[3] = OIDOID; /* relation OID 2 */
typeId[4] = INT2OID; /* attribute number 2 */
- tup = SearchSysCacheTuple(PRONAME,
+ tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(joinName),
Int32GetDatum(5),
PointerGetDatum(typeId),
/*
* If we are adding to an operator shell, get its t_self
*/
-
if (operatorObjectId)
{
opKey[0].sk_argument = PointerGetDatum(operatorName);
heap_insert(pg_operator_desc, tup);
operatorObjectId = tup->t_data->t_oid;
+
+ }
+
+ if (RelationGetForm(pg_operator_desc)->relhasindex)
+ {
+ Relation idescs[Num_pg_operator_indices];
+
+ CatalogOpenIndices(Num_pg_operator_indices, Name_pg_operator_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_operator_indices, pg_operator_desc, tup);
+ CatalogCloseIndices(Num_pg_operator_indices, idescs);
}
heap_close(pg_operator_desc, RowExclusiveLock);
setheapoverride(true);
heap_replace(pg_operator_desc, &tup->t_self, tup, NULL);
setheapoverride(false);
-
+
+ if (RelationGetForm(pg_operator_desc)->relhasindex)
+ {
+ Relation idescs[Num_pg_operator_indices];
+
+ CatalogOpenIndices(Num_pg_operator_indices, Name_pg_operator_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_operator_indices, pg_operator_desc, tup);
+ CatalogCloseIndices(Num_pg_operator_indices, idescs);
+ }
}
}
heap_endscan(pg_operator_scan);
heap_replace(pg_operator_desc, &tup->t_self, tup, NULL);
setheapoverride(false);
+ if (RelationGetForm(pg_operator_desc)->relhasindex)
+ {
+ Relation idescs[Num_pg_operator_indices];
+
+ CatalogOpenIndices(Num_pg_operator_indices, Name_pg_operator_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_operator_indices, pg_operator_desc, tup);
+ CatalogCloseIndices(Num_pg_operator_indices, idescs);
+ }
+
values[Anum_pg_operator_oprcom - 1] = (Datum) NULL;
replaces[Anum_pg_operator_oprcom - 1] = ' ';
}
setheapoverride(true);
heap_replace(pg_operator_desc, &tup->t_self, tup, NULL);
setheapoverride(false);
+
+ if (RelationGetForm(pg_operator_desc)->relhasindex)
+ {
+ Relation idescs[Num_pg_operator_indices];
+
+ CatalogOpenIndices(Num_pg_operator_indices, Name_pg_operator_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_operator_indices, pg_operator_desc, tup);
+ CatalogCloseIndices(Num_pg_operator_indices, idescs);
+ }
}
heap_endscan(pg_operator_scan);
+
heap_close(pg_operator_desc, RowExclusiveLock);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.35 1999/09/30 10:31:42 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.36 1999/11/22 17:55:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
typev[parameterCount++] = toid;
}
- tup = SearchSysCacheTuple(PRONAME,
+ tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(procedureName),
UInt16GetDatum(parameterCount),
PointerGetDatum(typev),
}
}
- tup = SearchSysCacheTuple(LANNAME,
+ tup = SearchSysCacheTuple(LANGNAME,
PointerGetDatum(languageName),
0, 0, 0);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.41 1999/09/18 19:06:34 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_type.c,v 1.42 1999/11/22 17:55:58 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
MemSet(argList, 0, 8 * sizeof(Oid));
- tup = SearchSysCacheTuple(PRONAME,
+ tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(procname),
Int32GetDatum(1),
PointerGetDatum(argList),
nargs = 3;
argList[2] = INT4OID;
}
- tup = SearchSysCacheTuple(PRONAME,
+ tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(procname),
Int32GetDatum(nargs),
PointerGetDatum(argList),
pg_type_desc = heap_openr(TypeRelationName, RowExclusiveLock);
- oldtup = SearchSysCacheTupleCopy(TYPNAME,
+ oldtup = SearchSysCacheTupleCopy(TYPENAME,
PointerGetDatum(oldTypeName),
0, 0, 0);
elog(ERROR, "TypeRename: type %s not defined", oldTypeName);
}
- newtup = SearchSysCacheTuple(TYPNAME,
+ newtup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(newTypeName),
0, 0, 0);
if (HeapTupleIsValid(newtup))
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.54 1999/09/18 19:06:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.55 1999/11/22 17:55:59 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/catname.h"
+#include "catalog/indexing.h"
#include "catalog/pg_listener.h"
#include "commands/async.h"
#include "lib/dllist.h"
if (listenerPID == MyProcPid)
{
-
/*
* Self-notify: no need to bother with table update.
* Indeed, we *must not* clear the notification field in
*/
if (kill(listenerPID, SIGUSR2) < 0)
{
-
/*
* Get rid of pg_listener entry if it refers to a PID
* that no longer exists. Presumably, that backend
rTuple = heap_modifytuple(lTuple, lRel,
value, nulls, repl);
heap_replace(lRel, &lTuple->t_self, rTuple, NULL);
+ if (RelationGetForm(lRel)->relhasindex)
+ {
+ Relation idescs[Num_pg_listener_indices];
+
+ CatalogOpenIndices(Num_pg_listener_indices, Name_pg_listener_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_listener_indices, lRel, rTuple);
+ CatalogCloseIndices(Num_pg_listener_indices, idescs);
+ }
}
}
}
/* Rewrite the tuple with 0 in notification column */
rTuple = heap_modifytuple(lTuple, lRel, value, nulls, repl);
heap_replace(lRel, &lTuple->t_self, rTuple, NULL);
+ if (RelationGetForm(lRel)->relhasindex)
+ {
+ Relation idescs[Num_pg_listener_indices];
+
+ CatalogOpenIndices(Num_pg_listener_indices, Name_pg_listener_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_listener_indices, lRel, rTuple);
+ CatalogCloseIndices(Num_pg_listener_indices, idescs);
+ }
}
}
heap_endscan(sRel);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.46 1999/11/07 23:08:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.47 1999/11/22 17:56:00 momjian Exp $
*
*-------------------------------------------------------------------------
*/
FIgetnArgs(finfo) = natts;
FIgetProcOid(finfo) = Old_pg_index_Form->indproc;
- pg_proc_Tuple = SearchSysCacheTuple(PROOID,
+ pg_proc_Tuple = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(Old_pg_index_Form->indproc),
0, 0, 0);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.56 1999/11/07 23:08:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.57 1999/11/22 17:56:00 momjian Exp $
*
* NOTES
* The PortalExecutorHeapMemory crap needs to be eliminated
else
attnelems = 0;
- typeTuple = SearchSysCacheTuple(TYPNAME,
+ typeTuple = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(typename),
0, 0, 0);
tform = (Form_pg_type) GETSTRUCT(typeTuple);
/*** Now, fetch user information ***/
username = GetPgUserName();
- usertuple = SearchSysCacheTuple(USENAME, PointerGetDatum(username),
+ usertuple = SearchSysCacheTuple(USERNAME, PointerGetDatum(username),
0, 0, 0);
if (!HeapTupleIsValid(usertuple)) {
elog(ERROR, "current user '%s' does not exist", username);
/*** Next, find the rule's oid ***/
- rewritetuple = SearchSysCacheTuple(REWRITENAME, PointerGetDatum(rule),
+ rewritetuple = SearchSysCacheTuple(RULENAME, PointerGetDatum(rule),
0, 0, 0);
if (!HeapTupleIsValid(rewritetuple)) {
elog(ERROR, "rule '%s' does not exist", rule);
#ifndef NO_SECURITY
user = GetPgUserName();
- if (!pg_ownercheck(user, type, TYPNAME)) {
+ if (!pg_ownercheck(user, type, TYPENAME)) {
elog(ERROR, "you are not permitted to comment on type '%s'",
type);
}
/*** Next, find the type's oid ***/
- typetuple = SearchSysCacheTuple(TYPNAME, PointerGetDatum(type),
+ typetuple = SearchSysCacheTuple(TYPENAME, PointerGetDatum(type),
0, 0, 0);
if (!HeapTupleIsValid(typetuple)) {
elog(ERROR, "type '%s' does not exist", type);
if (strcmp(argument, "opaque") == 0) {
argoids[i] = 0;
} else {
- argtuple = SearchSysCacheTuple(TYPNAME, PointerGetDatum(argument),
+ argtuple = SearchSysCacheTuple(TYPENAME, PointerGetDatum(argument),
0, 0, 0);
if (!HeapTupleIsValid(argtuple)) {
elog(ERROR, "function argument type '%s' does not exist",
/*** Now, find the corresponding oid for this procedure ***/
- functuple = SearchSysCacheTuple(PRONAME, PointerGetDatum(function),
+ functuple = SearchSysCacheTuple(PROCNAME, PointerGetDatum(function),
Int32GetDatum(argcount),
PointerGetDatum(argoids), 0);
/*** Attempt to fetch the operator oid ***/
- optuple = SearchSysCacheTupleCopy(OPRNAME, PointerGetDatum(opername),
+ optuple = SearchSysCacheTupleCopy(OPERNAME, PointerGetDatum(opername),
ObjectIdGetDatum(leftoid),
ObjectIdGetDatum(rightoid),
CharGetDatum(oprtype));
#ifndef NO_SECURITY
user = GetPgUserName();
- if (!pg_ownercheck(user, (char *) ObjectIdGetDatum(oid), OPROID)) {
+ if (!pg_ownercheck(user, (char *) ObjectIdGetDatum(oid), OPEROID)) {
elog(ERROR, "you are not permitted to comment on operator '%s'",
opername);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.90 1999/11/21 04:16:17 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/copy.c,v 1.91 1999/11/22 17:56:00 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
HeapTuple typeTuple;
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(type),
0, 0, 0);
{
HeapTuple typeTuple;
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(type),
0, 0, 0);
{
HeapTuple typeTuple;
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(type),
0, 0, 0);
{
HeapTuple typeTuple;
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(type),
0, 0, 0);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.51 1999/11/07 23:08:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.52 1999/11/22 17:56:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* form name, type and constraints
*/
attributeName = NameStr(attribute->attname);
- tuple = SearchSysCacheTuple(TYPOID,
+ tuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(attribute->atttypid),
0, 0, 0);
Assert(HeapTupleIsValid(tuple));
tuple = heap_formtuple(desc, datum, nullarr);
heap_insert(relation, tuple);
+
+ if (RelationGetForm(relation)->relhasindex)
+ {
+ Relation idescs[Num_pg_inherits_indices];
+
+ CatalogOpenIndices(Num_pg_inherits_indices, Name_pg_inherits_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_inherits_indices, relation, tuple);
+ CatalogCloseIndices(Num_pg_inherits_indices, idescs);
+ }
+
pfree(tuple);
seqNumber += 1;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/dbcommands.c,v 1.43 1999/10/26 03:12:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/dbcommands.c,v 1.44 1999/11/22 17:56:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
char path[MAXPGPATH];
userName = GetPgUserName();
- utup = SearchSysCacheTuple(USENAME,
+ utup = SearchSysCacheTuple(USERNAME,
PointerGetDatum(userName),
0, 0, 0);
Assert(utup);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/define.c,v 1.36 1999/10/02 21:33:24 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/define.c,v 1.37 1999/11/22 17:56:01 momjian Exp $
*
* DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the
Form_pg_language languageStruct;
/* Lookup the language in the system cache */
- languageTuple = SearchSysCacheTuple(LANNAME,
+ languageTuple = SearchSysCacheTuple(LANGNAME,
PointerGetDatum(languageName),
0, 0, 0);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.13 1999/11/07 23:08:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.14 1999/11/22 17:56:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* FIgetnArgs(funcInfo) = numberOfAttributes; */
FIsetnArgs(funcInfo, numberOfAttributes);
- tuple = SearchSysCacheTuple(PROOID,
+ tuple = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(indproc),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
/* we want the type so we can set the proper alignment, etc. */
if (attribute->typename == NULL)
{
- tuple = SearchSysCacheTuple(TYPOID,
+ tuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(attform->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
#include "access/heapam.h"
#include "catalog/catname.h"
+#include "catalog/indexing.h"
#include "catalog/pg_language.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_shadow.h"
*/
case_translate_language_name(stmt->plname, languageName);
- langTup = SearchSysCacheTuple(LANNAME,
+ langTup = SearchSysCacheTuple(LANGNAME,
PointerGetDatum(languageName),
0, 0, 0);
if (HeapTupleIsValid(langTup))
* ----------------
*/
memset(typev, 0, sizeof(typev));
- procTup = SearchSysCacheTuple(PRONAME,
+ procTup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(stmt->plhandler),
Int32GetDatum(0),
PointerGetDatum(typev),
heap_insert(rel, tup);
+ if (RelationGetForm(rel)->relhasindex)
+ {
+ Relation idescs[Num_pg_language_indices];
+
+ CatalogOpenIndices(Num_pg_language_indices, Name_pg_language_indices, idescs);
+ CatalogIndexInsert(idescs, Num_pg_language_indices, rel, tup);
+ CatalogCloseIndices(Num_pg_language_indices, idescs);
+ }
+
heap_close(rel, RowExclusiveLock);
}
rel = heap_openr(LanguageRelationName, RowExclusiveLock);
- langTup = SearchSysCacheTupleCopy(LANNAME,
+ langTup = SearchSysCacheTupleCopy(LANGNAME,
PointerGetDatum(languageName),
0, 0, 0);
if (!HeapTupleIsValid(langTup))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.39 1999/11/07 23:08:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/remove.c,v 1.40 1999/11/22 17:56:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
relation = heap_openr(OperatorRelationName, RowExclusiveLock);
- tup = SearchSysCacheTupleCopy(OPRNAME,
+ tup = SearchSysCacheTupleCopy(OPERNAME,
PointerGetDatum(operatorName),
ObjectIdGetDatum(typeId1),
ObjectIdGetDatum(typeId2),
userName = GetPgUserName();
if (!pg_ownercheck(userName,
(char *) ObjectIdGetDatum(tup->t_data->t_oid),
- OPROID))
+ OPEROID))
elog(ERROR, "RemoveOperator: operator '%s': permission denied",
operatorName);
#endif
#ifndef NO_SECURITY
userName = GetPgUserName();
- if (!pg_ownercheck(userName, typeName, TYPNAME))
+ if (!pg_ownercheck(userName, typeName, TYPENAME))
elog(ERROR, "RemoveType: type '%s': permission denied",
typeName);
#endif
relation = heap_openr(TypeRelationName, RowExclusiveLock);
- tup = SearchSysCacheTuple(TYPNAME,
+ tup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(typeName),
0, 0, 0);
if (!HeapTupleIsValid(tup))
/* Now, Delete the "array of" that type */
shadow_type = makeArrayTypeName(typeName);
- tup = SearchSysCacheTuple(TYPNAME,
+ tup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(shadow_type),
0, 0, 0);
if (!HeapTupleIsValid(tup))
argList[i] = 0;
else
{
- tup = SearchSysCacheTuple(TYPNAME,
+ tup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(typename),
0, 0, 0);
#endif
relation = heap_openr(ProcedureRelationName, RowExclusiveLock);
- tup = SearchSysCacheTuple(PRONAME,
+ tup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(functionName),
Int32GetDatum(nargs),
PointerGetDatum(argList),
heap_endscan(tgscan);
MemSet(fargtypes, 0, 8 * sizeof(Oid));
- tuple = SearchSysCacheTuple(PRONAME,
+ tuple = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(stmt->funcname),
Int32GetDatum(0),
PointerGetDatum(fargtypes),
{
HeapTuple langTup;
- langTup = SearchSysCacheTuple(LANOID,
+ langTup = SearchSysCacheTuple(LANGOID,
ObjectIdGetDatum(((Form_pg_proc) GETSTRUCT(tuple))->prolang),
0, 0, 0);
if (!HeapTupleIsValid(langTup))
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: user.c,v 1.36 1999/11/21 04:16:16 tgl Exp $
+ * $Id: user.c,v 1.37 1999/11/22 17:56:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
pg_shadow_rel = heap_openr(ShadowRelationName, AccessExclusiveLock);
pg_shadow_dsc = RelationGetDescr(pg_shadow_rel);
- tuple = SearchSysCacheTuple(USENAME,
+ tuple = SearchSysCacheTuple(USERNAME,
PointerGetDatum(stmt->user),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
pg_shadow_rel = heap_openr(ShadowRelationName, AccessExclusiveLock);
pg_dsc = RelationGetDescr(pg_shadow_rel);
- tuple = SearchSysCacheTuple(USENAME,
+ tuple = SearchSysCacheTuple(USERNAME,
PointerGetDatum(user),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.124 1999/11/14 17:27:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/vacuum.c,v 1.125 1999/11/22 17:56:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
else
stats->f_cmpgt.fn_addr = NULL;
- typetuple = SearchSysCacheTuple(TYPOID,
+ typetuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(stats->attr->atttypid),
0, 0, 0);
if (HeapTupleIsValid(typetuple))
ru1.ru_utime.tv_sec - ru0.ru_utime.tv_sec);
if (nitups != num_tuples)
- elog(NOTICE, "Index %s: NUMBER OF INDEX' TUPLES (%u) IS NOT THE SAME AS HEAP' (%u).\nTry recreating the index.",
+ elog(NOTICE, "Index %s: NUMBER OF INDEX' TUPLES (%u) IS NOT THE SAME AS HEAP' (%u).\n\tTry recreating the index.",
RelationGetRelationName(indrel), nitups, num_tuples);
} /* vc_scanoneind */
ru1.ru_utime.tv_sec - ru0.ru_utime.tv_sec);
if (num_index_tuples != num_tuples + keep_tuples)
- elog(NOTICE, "Index %s: NUMBER OF INDEX' TUPLES (%u) IS NOT THE SAME AS HEAP' (%u).\nTry recreating the index.",
+ elog(NOTICE, "Index %s: NUMBER OF INDEX' TUPLES (%u) IS NOT THE SAME AS HEAP' (%u).\n\tTry recreating the index.",
RelationGetRelationName(indrel), num_index_tuples, num_tuples);
} /* vc_vaconeind */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.31 1999/10/17 18:00:29 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeMergejoin.c,v 1.32 1999/11/22 17:56:03 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* whoever marked the "=" operator mergejoinable was a loser.
* ----------------
*/
- optup = SearchSysCacheTuple(OPRNAME,
+ optup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(replaceopname),
ObjectIdGetDatum(oprleft),
ObjectIdGetDatum(oprright),
* spi.c
* Server Programming Interface
*
- * $Id: spi.c,v 1.41 1999/11/07 23:08:06 momjian Exp $
+ * $Id: spi.c,v 1.42 1999/11/22 17:56:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return NULL;
}
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(tupdesc->attrs[fnumber - 1]->atttypid),
0, 0, 0);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/_deadcode/Attic/xfunc.c,v 1.10 1999/09/21 20:58:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/_deadcode/Attic/xfunc.c,v 1.11 1999/11/22 17:56:10 momjian Exp $
*
*-------------------------------------------------------------------------
*/
funcid = get_funcid((Func) node);
/* look up tuple in cache */
- tupl = SearchSysCacheTuple(PROOID,
+ tupl = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(funcid),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
else if (IsA(clause, Var))
{
/* base case: width is width of this attribute */
- tupl = SearchSysCacheTuple(TYPOID,
+ tupl = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(get_vartype((Var) clause)),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
* * get function associated with this Oper, and treat this as * a
* Func
*/
- tupl = SearchSysCacheTuple(OPROID,
+ tupl = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(get_opno((Oper) get_op(clause))),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
/* lookup function and find its return type */
Assert(RegProcedureIsValid(funcid));
- tupl = SearchSysCacheTuple(PROOID,
+ tupl = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(funcid),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
else
/* function returns a base type */
{
- tupl = SearchSysCacheTuple(TYPOID,
+ tupl = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(proc->prorettype),
0, 0, 0);
if (!HeapTupleIsValid(tupl))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.72 1999/09/18 19:06:54 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/indxpath.c,v 1.73 1999/11/22 17:56:07 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
if (pstatus == Prefix_Exact)
{
- optup = SearchSysCacheTuple(OPRNAME,
+ optup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum("="),
ObjectIdGetDatum(datatype),
ObjectIdGetDatum(datatype),
*
* We can always say "x >= prefix".
*/
- optup = SearchSysCacheTuple(OPRNAME,
+ optup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(">="),
ObjectIdGetDatum(datatype),
ObjectIdGetDatum(datatype),
prefix[prefixlen] = '\377';
prefix[prefixlen+1] = '\0';
- optup = SearchSysCacheTuple(OPRNAME,
+ optup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum("<="),
ObjectIdGetDatum(datatype),
ObjectIdGetDatum(datatype),
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.54 1999/10/07 04:23:08 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/clauses.c,v 1.55 1999/11/22 17:56:17 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
result_typeid = func->functype;
}
/* Someday lsyscache.c might provide a function for this */
- func_tuple = SearchSysCacheTuple(PROOID,
+ func_tuple = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(funcid),
0, 0, 0);
if (!HeapTupleIsValid(func_tuple))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.39 1999/11/21 23:25:47 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/plancat.c,v 1.40 1999/11/22 17:56:17 momjian Exp $
*
*-------------------------------------------------------------------------
*/
scan = heap_beginscan(relation, 0, SnapshotNow, 1, key);
while (HeapTupleIsValid(inheritsTuple = heap_getnext(scan, 0)))
{
- inhrelid = ((Form_pg_inherits) GETSTRUCT(inheritsTuple))->inhrel;
+ inhrelid = ((Form_pg_inherits) GETSTRUCT(inheritsTuple))->inhrelid;
list = lappendi(list, inhrelid);
}
heap_endscan(scan);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.24 1999/10/02 23:29:12 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_coerce.c,v 2.25 1999/11/22 17:56:20 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* look for a single-argument function named with the
* target type name
*/
- ftup = SearchSysCacheTuple(PRONAME,
+ ftup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(typeidTypeName(func_typeids[i])),
Int32GetDatum(1),
PointerGetDatum(oid_array),
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.61 1999/11/07 23:08:10 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.62 1999/11/22 17:56:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* just pass through the argument itself. (make this clearer
* with some extra brackets - thomas 1998-12-05)
*/
- if ((HeapTupleIsValid(tp = SearchSysCacheTuple(TYPNAME,
+ if ((HeapTupleIsValid(tp = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(funcname),
0, 0, 0)))
&& IS_BINARY_COMPATIBLE(typeTypeId(tp), basetype))
Form_pg_proc pform;
/* attempt to find with arguments exactly as specified... */
- ftup = SearchSysCacheTuple(PRONAME,
+ ftup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(funcname),
Int32GetDatum(nargs),
PointerGetDatum(oid_array),
if (ncandidates == 1)
{
*true_typeids = current_function_typeids->args;
- ftup = SearchSysCacheTuple(PRONAME,
+ ftup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(funcname),
Int32GetDatum(nargs),
PointerGetDatum(*true_typeids),
/* found something, so use the first one... */
else
{
- ftup = SearchSysCacheTuple(PRONAME,
+ ftup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(funcname),
Int32GetDatum(nargs),
PointerGetDatum(*true_typeids),
*/
do
{
- ScanKeyEntryInitialize(&skey, 0x0, Anum_pg_inherits_inhrel,
+ ScanKeyEntryInitialize(&skey, 0x0, Anum_pg_inherits_inhrelid,
F_OIDEQ,
ObjectIdGetDatum(relid));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.32 1999/11/01 05:06:21 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.33 1999/11/22 17:56:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* Get the type tuple for the array */
typearray = exprType(arrayBase);
- type_tuple = SearchSysCacheTuple(TYPOID,
+ type_tuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(typearray),
0, 0, 0);
if (!HeapTupleIsValid(type_tuple))
type_struct_array->typname);
/* Get the type tuple for the array element type */
- type_tuple = SearchSysCacheTuple(TYPOID,
+ type_tuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(typeelement),
0, 0, 0);
if (!HeapTupleIsValid(type_tuple))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.32 1999/09/18 19:07:12 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.33 1999/11/22 17:56:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
else if ((arg2 == UNKNOWNOID) && (arg1 != InvalidOid))
arg2 = arg1;
- tup = SearchSysCacheTuple(OPRNAME,
+ tup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(op),
ObjectIdGetDatum(arg1),
ObjectIdGetDatum(arg2),
/* Or found exactly one? Then proceed... */
else if (ncandidates == 1)
{
- tup = SearchSysCacheTuple(OPRNAME,
+ tup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(op),
ObjectIdGetDatum(candidates->args[0]),
ObjectIdGetDatum(candidates->args[1]),
targetOids = oper_select_candidate(2, inputOids, candidates);
if (targetOids != NULL)
{
- tup = SearchSysCacheTuple(OPRNAME,
+ tup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(op),
ObjectIdGetDatum(targetOids[0]),
ObjectIdGetDatum(targetOids[1]),
int ncandidates;
Oid *targetOid;
- tup = SearchSysCacheTuple(OPRNAME,
+ tup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(op),
ObjectIdGetDatum(arg),
ObjectIdGetDatum(InvalidOid),
}
else if (ncandidates == 1)
{
- tup = SearchSysCacheTuple(OPRNAME,
+ tup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(op),
ObjectIdGetDatum(candidates->args[0]),
ObjectIdGetDatum(InvalidOid),
if (targetOid != NULL)
{
- tup = SearchSysCacheTuple(OPRNAME,
+ tup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(op),
ObjectIdGetDatum(InvalidOid),
ObjectIdGetDatum(*targetOid),
int ncandidates;
Oid *targetOid;
- tup = SearchSysCacheTuple(OPRNAME,
+ tup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(op),
ObjectIdGetDatum(InvalidOid),
ObjectIdGetDatum(arg),
}
else if (ncandidates == 1)
{
- tup = SearchSysCacheTuple(OPRNAME,
+ tup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(op),
ObjectIdGetDatum(InvalidOid),
ObjectIdGetDatum(candidates->args[0]),
targetOid = oper_select_candidate(1, &arg, candidates);
if (targetOid != NULL)
{
- tup = SearchSysCacheTuple(OPRNAME,
+ tup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum(op),
ObjectIdGetDatum(InvalidOid),
ObjectIdGetDatum(*targetOid),
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.48 1999/11/07 23:08:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.49 1999/11/22 17:56:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
oid_array[i] = InvalidOid;
/* attempt to find with arguments exactly as specified... */
- ftup = SearchSysCacheTuple(PRONAME,
+ ftup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum(funcname),
Int32GetDatum(2),
PointerGetDatum(oid_array),
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.26 1999/11/07 23:08:11 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.27 1999/11/22 17:56:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
bool
typeidIsValid(Oid id)
{
- return (SearchSysCacheTuple(TYPOID,
+ return (SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(id),
0, 0, 0) != NULL);
}
HeapTuple tup;
Form_pg_type typetuple;
- if (!(tup = SearchSysCacheTuple(TYPOID,
+ if (!(tup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(id),
0, 0, 0)))
{
{
HeapTuple tup;
- if (!(tup = SearchSysCacheTuple(TYPOID,
+ if (!(tup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(id),
0, 0, 0)))
{
if (s == NULL)
elog(ERROR, "type(): Null type");
- if (!(tup = SearchSysCacheTuple(TYPNAME,
+ if (!(tup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(s),
0, 0, 0)))
elog(ERROR, "Unable to locate type name '%s' in catalog", s);
Form_pg_type type;
Oid outfunc;
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(type_id),
0, 0, 0);
if (!HeapTupleIsValid(typeTuple))
HeapTuple typeTuple;
Form_pg_type type;
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(type_id),
0, 0, 0);
if (!HeapTupleIsValid(typeTuple))
HeapTuple type_tuple;
Form_pg_type type_struct_array;
- type_tuple = SearchSysCacheTuple(TYPOID,
+ type_tuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(typearray),
0, 0, 0);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.24 1999/11/07 23:08:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/Attic/locks.c,v 1.25 1999/11/22 17:56:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
rte = (RangeTblEntry *) nth(rt_index - 1, parsetree->rtable);
ev_rel = heap_openr(rte->relname, AccessShareLock);
- usertup = SearchSysCacheTuple(USESYSID,
+ usertup = SearchSysCacheTuple(USERSYSID,
ObjectIdGetDatum(ev_rel->rd_rel->relowner),
0, 0, 0);
if (!HeapTupleIsValid(usertup))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.32 1999/11/18 13:56:27 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteRemove.c,v 1.33 1999/11/22 17:56:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
HeapTuple htup;
Oid eventrel;
- htup = SearchSysCacheTuple(REWRITENAME,
+ htup = SearchSysCacheTuple(RULENAME,
PointerGetDatum(rulename),
0, 0, 0);
if (!HeapTupleIsValid(htup))
/*
* Scan the RuleRelation ('pg_rewrite') until we find a tuple
*/
- tuple = SearchSysCacheTupleCopy(REWRITENAME,
+ tuple = SearchSysCacheTupleCopy(RULENAME,
PointerGetDatum(ruleName),
0, 0, 0);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.37 1999/09/18 19:07:20 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteSupport.c,v 1.38 1999/11/22 17:56:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
ruleRelation = heap_openr(RewriteRelationName, AccessShareLock);
ruleTupdesc = RelationGetDescr(ruleRelation);
- ruletuple = SearchSysCacheTuple(RULOID,
+ ruletuple = SearchSysCacheTuple(RULEOID,
ObjectIdGetDatum(ruleoid),
0, 0, 0);
if (ruletuple == NULL)
{
HeapTuple tuple;
- tuple = SearchSysCacheTuple(REWRITENAME,
+ tuple = SearchSysCacheTuple(RULENAME,
PointerGetDatum(ruleName),
0, 0, 0);
return HeapTupleIsValid(tuple);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.30 1999/07/22 02:40:07 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.31 1999/11/22 17:56:26 momjian Exp $
*
* NOTES
* This cruft is the server side of PQfn.
MemSet((char *) fip, 0, (int) sizeof(struct fp_info));
fip->funcid = InvalidOid;
- func_htp = SearchSysCacheTuple(PROOID,
+ func_htp = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(func_id),
0, 0, 0);
if (!HeapTupleIsValid(func_htp))
{
if (OidIsValid(argtypes[i]))
{
- type_htp = SearchSysCacheTuple(TYPOID,
+ type_htp = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(argtypes[i]),
0, 0, 0);
if (!HeapTupleIsValid(type_htp))
if (OidIsValid(rettype))
{
- type_htp = SearchSysCacheTuple(TYPOID,
+ type_htp = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(rettype),
0, 0, 0);
if (!HeapTupleIsValid(type_htp))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.41 1999/10/18 03:32:29 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.42 1999/11/22 17:56:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
switch (aip->ai_idtype)
{
case ACL_IDTYPE_UID:
- htup = SearchSysCacheTuple(USENAME,
+ htup = SearchSysCacheTuple(USERNAME,
PointerGetDatum(name),
0, 0, 0);
if (!HeapTupleIsValid(htup))
switch (aip->ai_idtype)
{
case ACL_IDTYPE_UID:
- htup = SearchSysCacheTuple(USESYSID,
+ htup = SearchSysCacheTuple(USERSYSID,
ObjectIdGetDatum(aip->ai_id),
0, 0, 0);
if (!HeapTupleIsValid(htup))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.48 1999/07/19 07:07:25 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/arrayfuncs.c,v 1.49 1999/11/22 17:56:29 momjian Exp $
*
*-------------------------------------------------------------------------
*/
HeapTuple typeTuple;
Form_pg_type typeStruct;
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(element_type),
0, 0, 0);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.44 1999/11/07 23:08:24 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/regproc.c,v 1.45 1999/11/22 17:56:29 momjian Exp $
*
*-------------------------------------------------------------------------
*/
if (pro_name_or_oid[0] >= '0' &&
pro_name_or_oid[0] <= '9')
{
- proctup = SearchSysCacheTuple(PROOID,
+ proctup = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(oidin(pro_name_or_oid)),
0, 0, 0);
if (HeapTupleIsValid(proctup))
if (!IsBootstrapProcessingMode())
{
- proctup = SearchSysCacheTuple(PROOID,
+ proctup = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(proid),
0, 0, 0);
{
if (*sp != InvalidOid)
{
- typetup = SearchSysCacheTuple(TYPOID,
+ typetup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(*sp),
0, 0, 0);
if (HeapTupleIsValid(typetup))
*
* 1999 Jan Wieck
*
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ri_triggers.c,v 1.2 1999/10/08 12:00:08 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ri_triggers.c,v 1.3 1999/11/22 17:56:29 momjian Exp $
*
* ----------
*/
elog(FATAL, "error in RI operator cache");
/* ----------
- * If not found, lookup the OPRNAME system cache for it
+ * If not found, lookup the OPERNAME system cache for it
* and remember that info.
* ----------
*/
HeapTuple opr_tup;
Form_pg_operator opr_struct;
- opr_tup = SearchSysCacheTuple(OPRNAME,
+ opr_tup = SearchSysCacheTuple(OPERNAME,
PointerGetDatum("="),
ObjectIdGetDatum(typeid),
ObjectIdGetDatum(typeid),
* out of it's tuple
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.31 1999/11/15 02:00:05 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ruleutils.c,v 1.32 1999/11/22 17:56:30 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
HeapTuple proctup;
Form_pg_proc procStruct;
- proctup = SearchSysCacheTuple(PROOID,
+ proctup = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(idxrec->indproc), 0, 0, 0);
if (!HeapTupleIsValid(proctup))
elog(ERROR, "cache lookup for proc %u failed", idxrec->indproc);
* Get the pg_shadow entry and print the result
* ----------
*/
- usertup = SearchSysCacheTuple(USESYSID,
+ usertup = SearchSysCacheTuple(USERSYSID,
ObjectIdGetDatum(uid), 0, 0, 0);
if (HeapTupleIsValid(usertup))
{
HeapTuple tp;
Form_pg_operator optup;
- tp = SearchSysCacheTuple(OPROID,
+ tp = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(opno),
0, 0, 0);
Assert(HeapTupleIsValid(tp));
* Get the functions pg_proc tuple
* ----------
*/
- proctup = SearchSysCacheTuple(PROOID,
+ proctup = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(func->funcid),
0, 0, 0);
if (!HeapTupleIsValid(proctup))
* Get the functions pg_proc tuple
* ----------
*/
- tup = SearchSysCacheTuple(PROOID,
+ tup = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(func->funcid), 0, 0, 0);
if (!HeapTupleIsValid(tup))
elog(ERROR, "cache lookup for proc %u failed", func->funcid);
* Furthermore, the name of the function must be the same
* as the argument/result type name.
*/
- tup = SearchSysCacheTuple(TYPOID,
+ tup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(procStruct->prorettype),
0, 0, 0);
if (!HeapTupleIsValid(tup))
return;
}
- typetup = SearchSysCacheTuple(TYPOID,
+ typetup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(constval->consttype),
0, 0, 0);
if (!HeapTupleIsValid(typetup))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.41 1999/09/18 19:07:49 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/selfuncs.c,v 1.42 1999/11/22 17:56:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
MemSet(oid_array, 0, MAXFARGS * sizeof(Oid));
oid_array[0] = typid;
- ftup = SearchSysCacheTuple(PRONAME,
+ ftup = SearchSysCacheTuple(PROCNAME,
PointerGetDatum("float8"),
Int32GetDatum(1),
PointerGetDatum(oid_array),
*commonfrac = ((Form_pg_statistic) GETSTRUCT(tuple))->stacommonfrac;
/* Get the type input proc for the column datatype */
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(typid),
0, 0, 0);
if (! HeapTupleIsValid(typeTuple))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/sets.c,v 1.26 1999/09/18 19:07:49 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/Attic/sets.c,v 1.27 1999/11/22 17:56:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* until you start the next command.)
*/
CommandCounterIncrement();
- tup = SearchSysCacheTuple(PROOID,
+ tup = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(setoid),
0, 0, 0);
if (!HeapTupleIsValid(tup))
/* change the pg_proc tuple */
procrel = heap_openr(ProcedureRelationName, RowExclusiveLock);
- tup = SearchSysCacheTuple(PROOID,
+ tup = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(setoid),
0, 0, 0);
if (HeapTupleIsValid(tup))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.53 1999/11/21 01:58:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.54 1999/11/22 17:56:31 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
#include "access/valid.h"
+#include "catalog/pg_operator.h"
#include "catalog/pg_type.h"
#include "catalog/catname.h"
#include "catalog/indexing.h"
* ----------------
*/
{
-
/*
* We can only do this optimization because the number of hash
* buckets never changes. Without it, we call malloc() too much.
/* --------------------------------
* SearchSelfReferences
*
- * This call searches a self referencing information,
- *
- * which causes a cycle in system catalog cache
+ * This call searches for self-referencing information,
+ * which causes infinite recursion in the system catalog cache.
+ * This code short-circuits the normal index lookup for cache loads
+ * in those cases and replaces it with a heap scan.
*
* cache should already be initailized
* --------------------------------
{
HeapTuple ntp;
Relation rel;
- static Oid indexSelfOid = 0;
- static HeapTuple indexSelfTuple = 0;
-
- if (cache->id != INDEXRELID)
- return (HeapTuple)0;
- if (!indexSelfOid)
+ if (cache->id == INDEXRELID)
{
- rel = heap_openr(RelationRelationName, AccessShareLock);
- ntp = ClassNameIndexScan(rel, IndexRelidIndex);
- if (!HeapTupleIsValid(ntp))
- elog(ERROR, "SearchSelfRefernces: %s not found in %s",
- IndexRelidIndex, RelationRelationName);
- indexSelfOid = ntp->t_data->t_oid;
- pfree(ntp);
- heap_close(rel, AccessShareLock);
+ static Oid indexSelfOid = InvalidOid;
+ static HeapTuple indexSelfTuple = NULL;
+
+ if (!OidIsValid(indexSelfOid))
+ {
+ /* Find oid of pg_index_indexrelid_index */
+ rel = heap_openr(RelationRelationName, AccessShareLock);
+ ntp = ClassNameIndexScan(rel, IndexRelidIndex);
+ if (!HeapTupleIsValid(ntp))
+ elog(ERROR, "SearchSelfReferences: %s not found in %s",
+ IndexRelidIndex, RelationRelationName);
+ indexSelfOid = ntp->t_data->t_oid;
+ pfree(ntp);
+ heap_close(rel, AccessShareLock);
+ }
+ /* Looking for something other than pg_index_indexrelid_index? */
+ if ((Oid)cache->cc_skey[0].sk_argument != indexSelfOid)
+ return (HeapTuple)0;
+
+ /* Do we need to load our private copy of the tuple? */
+ if (!HeapTupleIsValid(indexSelfTuple))
+ {
+ HeapScanDesc sd;
+ MemoryContext oldcxt;
+
+ if (!CacheCxt)
+ CacheCxt = CreateGlobalMemory("Cache");
+ rel = heap_open(cache->relationId, AccessShareLock);
+ sd = heap_beginscan(rel, false, SnapshotNow, 1, cache->cc_skey);
+ ntp = heap_getnext(sd, 0);
+ if (!HeapTupleIsValid(ntp))
+ elog(ERROR, "SearchSelfReferences: tuple not found");
+ oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
+ indexSelfTuple = heap_copytuple(ntp);
+ MemoryContextSwitchTo(oldcxt);
+ heap_endscan(sd);
+ heap_close(rel, AccessShareLock);
+ }
+ return indexSelfTuple;
}
- if ((Oid)cache->cc_skey[0].sk_argument != indexSelfOid)
- return (HeapTuple)0;
- if (!indexSelfTuple)
+ else if (cache->id == OPEROID)
{
- HeapScanDesc sd;
- MemoryContext oldcxt;
-
- if (!CacheCxt)
- CacheCxt = CreateGlobalMemory("Cache");
- rel = heap_open(cache->relationId, AccessShareLock);
- sd = heap_beginscan(rel, false, SnapshotNow, 1, cache->cc_skey);
- ntp = heap_getnext(sd, 0);
- if (!HeapTupleIsValid(ntp))
- elog(ERROR, "SearchSelfRefernces: tuple not found");
- oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
- indexSelfTuple = heap_copytuple(ntp);
- MemoryContextSwitchTo(oldcxt);
- heap_endscan(sd);
- heap_close(rel, AccessShareLock);
+ /* bootstrapping this requires preloading a range of rows. bjm */
+ static HeapTuple operatorSelfTuple[MAX_OIDCMP-MIN_OIDCMP+1];
+ Oid lookup_oid = (Oid)cache->cc_skey[0].sk_argument;
+
+ if (lookup_oid < MIN_OIDCMP || lookup_oid > MAX_OIDCMP)
+ return (HeapTuple)0;
+
+ if (!HeapTupleIsValid(operatorSelfTuple[lookup_oid-MIN_OIDCMP]))
+ {
+ HeapScanDesc sd;
+ MemoryContext oldcxt;
+
+ if (!CacheCxt)
+ CacheCxt = CreateGlobalMemory("Cache");
+ rel = heap_open(cache->relationId, AccessShareLock);
+ sd = heap_beginscan(rel, false, SnapshotNow, 1, cache->cc_skey);
+ ntp = heap_getnext(sd, 0);
+ if (!HeapTupleIsValid(ntp))
+ elog(ERROR, "SearchSelfReferences: tuple not found");
+ oldcxt = MemoryContextSwitchTo((MemoryContext) CacheCxt);
+ operatorSelfTuple[lookup_oid-MIN_OIDCMP] = heap_copytuple(ntp);
+ MemoryContextSwitchTo(oldcxt);
+ heap_endscan(sd);
+ heap_close(rel, AccessShareLock);
+ }
+ return operatorSelfTuple[lookup_oid-MIN_OIDCMP];
}
+ else
+ return (HeapTuple)0;
- return indexSelfTuple;
}
/* --------------------------------
/*
* resolve self referencing informtion
*/
- if (ntp = SearchSelfReferences(cache), ntp)
- {
- return heap_copytuple(ntp);
- }
+ if ((ntp = SearchSelfReferences(cache)))
+ return heap_copytuple(ntp);
/* ----------------
* find the hash bucket in which to look for the tuple
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.26 1999/07/17 20:18:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/Attic/fcache.c,v 1.27 1999/11/22 17:56:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
relname = (char *) getrelname(rtid, econtext->ecxt_range_table);
- tup = SearchSysCacheTuple(TYPNAME,
+ tup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(relname),
0, 0, 0);
if (!tup)
if (!use_syscache)
elog(ERROR, "what the ????, init the fcache without the catalogs?");
- procedureTuple = SearchSysCacheTuple(PROOID,
+ procedureTuple = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(foid),
0, 0, 0);
* to "null" so we just return it.
* ----------------
*/
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(procedureStruct->prorettype),
0, 0, 0);
else
{
tmp = (text *)
- SearchSysCacheGetAttribute(PROOID,
+ SearchSysCacheGetAttribute(PROCOID,
Anum_pg_proc_probin,
ObjectIdGetDatum(foid),
0, 0, 0);
* Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.35 1999/11/07 23:08:26 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.36 1999/11/22 17:56:32 momjian Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
{
HeapTuple tp;
- tp = SearchSysCacheTuple(OPROID,
+ tp = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(opno),
0, 0, 0);
if (HeapTupleIsValid(tp))
{
HeapTuple tp;
- tp = SearchSysCacheTuple(OPROID,
+ tp = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(opno),
0, 0, 0);
if (HeapTupleIsValid(tp))
{
HeapTuple tp;
- tp = SearchSysCacheTuple(OPROID,
+ tp = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(opno),
0, 0, 0);
if (HeapTupleIsValid(tp))
{
HeapTuple tp;
- tp = SearchSysCacheTuple(OPROID,
+ tp = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(opno),
0, 0, 0);
if (HeapTupleIsValid(tp))
{
HeapTuple optup;
- if ((optup = SearchSysCacheTuple(OPROID,
+ if ((optup = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(opno),
0, 0, 0)))
return optup;
{
HeapTuple tp;
- tp = SearchSysCacheTuple(OPROID,
+ tp = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(opno),
0, 0, 0);
if (HeapTupleIsValid(tp))
{
HeapTuple tp;
- tp = SearchSysCacheTuple(OPROID,
+ tp = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(opno),
0, 0, 0);
if (HeapTupleIsValid(tp))
{
HeapTuple tp;
- tp = SearchSysCacheTuple(OPROID,
+ tp = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(opno),
0, 0, 0);
if (HeapTupleIsValid(tp))
{
HeapTuple tp;
- tp = SearchSysCacheTuple(OPROID,
+ tp = SearchSysCacheTuple(OPEROID,
ObjectIdGetDatum(opno),
0, 0, 0);
if (HeapTupleIsValid(tp))
HeapTuple func_tuple;
Oid funcrettype;
- func_tuple = SearchSysCacheTuple(PROOID,
+ func_tuple = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(funcid),
0, 0, 0);
{
HeapTuple tp;
- tp = SearchSysCacheTuple(TYPOID,
+ tp = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(typid),
0, 0, 0);
if (HeapTupleIsValid(tp))
{
HeapTuple tp;
- tp = SearchSysCacheTuple(TYPOID,
+ tp = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(typid),
0, 0, 0);
if (HeapTupleIsValid(tp))
{
HeapTuple tp;
- tp = SearchSysCacheTuple(TYPOID,
+ tp = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(typid),
0, 0, 0);
if (HeapTupleIsValid(tp))
* First, see if there is a non-null typdefault field (usually there isn't)
*/
typDefault = (struct varlena *)
- SearchSysCacheGetAttribute(TYPOID,
+ SearchSysCacheGetAttribute(TYPEOID,
Anum_pg_type_typdefault,
ObjectIdGetDatum(typid),
0, 0, 0);
* just did --- but at present this path isn't taken often enough to
* make it worth fixing.
*/
- typeTuple = SearchSysCacheTuple(TYPOID,
+ typeTuple = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(typid),
0, 0, 0);
{
HeapTuple tp;
- tp = SearchSysCacheTuple(TYPOID,
+ tp = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(typid),
0, 0, 0);
if (HeapTupleIsValid(tp))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.80 1999/11/21 01:58:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.81 1999/11/22 17:56:32 momjian Exp $
*
*-------------------------------------------------------------------------
*/
for (i = 1; i <= relation->rd_rel->relnatts; i++)
{
- atttup = (HeapTuple) AttributeNumIndexScan(attrel,
+ atttup = (HeapTuple) AttributeRelidNumIndexScan(attrel,
RelationGetRelid(relation), i);
if (!HeapTupleIsValid(atttup))
SetProcessingMode(BootstrapProcessing);
bi.infotype = INFO_RELNAME;
- bi.i.info_name = AttributeNumIndex;
+ bi.i.info_name = AttributeRelidNumIndex;
irel[0] = RelationBuildDesc(bi, NULL);
irel[0]->rd_isnailed = true;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.40 1999/11/18 13:56:29 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.41 1999/11/22 17:56:32 momjian Exp $
*
* NOTES
* These routines allow the parser/planner/executor to perform
typedef HeapTuple (*ScanFunc) ();
-/* ----------------
- * Warning: cacheinfo[] below is changed, then be sure and
- * update the magic constants in syscache.h!
- * ----------------
- */
+
+/*---------------------------------------------------------------------------
+
+ Adding system caches:
+
+ Add your new cache to the list in include/utils/syscache.h. Keep
+ the list sorted alphabetically and adjust the cache numbers
+ accordingly.
+
+ Add your entry to the cacheinfo[] array below. All cache lists are
+ alphabetical, so add it in the proper place. Specify the relation
+ name, number of arguments, argument names, size of tuple, index lookup
+ function, and index name.
+
+ In include/catalog/indexing.h, add a define for the number of indexes
+ in the relation, add a define for the index name, add an extern
+ array to hold the index names, define the index lookup function
+ prototype, and use DECLARE_UNIQUE_INDEX to define the index. Cache
+ lookups return only one row, so the index should be unique.
+
+ In backend/catalog/indexing.c, initialize the relation array with
+ the index names for the relation, and create the index lookup function.
+ Pick one that takes similar arguments and use that one, but keep the
+ function names in the same order as the cache list for clarity.
+
+ Finally, any place your relation gets heap_insert() or
+ heap_replace calls, include code to do a CatalogIndexInsert() to update
+ the system indexes. The heap_* calls do not update indexes.
+
+ bjm 1999/11/22
+
+ ---------------------------------------------------------------------------
+*/
+
static struct cachedesc cacheinfo[] = {
+ {AggregateRelationName, /* AGGNAME */
+ 2,
+ {
+ Anum_pg_aggregate_aggname,
+ Anum_pg_aggregate_aggbasetype,
+ 0,
+ 0
+ },
+ offsetof(FormData_pg_aggregate, agginitval1),
+ AggregateNameTypeIndex,
+ AggregateNameTypeIndexScan},
+ {AccessMethodRelationName, /* AMNAME */
+ 1,
+ {
+ Anum_pg_am_amname,
+ 0,
+ 0,
+ 0
+ },
+ sizeof(FormData_pg_am),
+ AmNameIndex,
+ AmNameIndexScan},
{AccessMethodOperatorRelationName, /* AMOPOPID */
3,
{
},
sizeof(FormData_pg_amop),
AccessMethodOpidIndex,
- (ScanFunc) AccessMethodOpidIndexScan},
+ AccessMethodOpidIndexScan},
{AccessMethodOperatorRelationName, /* AMOPSTRATEGY */
3,
{
0
},
ATTRIBUTE_TUPLE_SIZE,
- AttributeNameIndex,
- (ScanFunc) AttributeNameIndexScan},
+ AttributeRelidNameIndex,
+ AttributeRelidNameIndexScan},
{AttributeRelationName, /* ATTNUM */
2,
{
0
},
ATTRIBUTE_TUPLE_SIZE,
- AttributeNumIndex,
- (ScanFunc) AttributeNumIndexScan},
+ AttributeRelidNumIndex,
+ (ScanFunc) AttributeRelidNumIndexScan},
+ {OperatorClassRelationName, /* CLADEFTYPE */
+ 1,
+ {
+ Anum_pg_opclass_opcdeftype,
+ 0,
+ 0,
+ 0
+ },
+ sizeof(FormData_pg_opclass),
+ OpclassDeftypeIndex,
+ OpclassDeftypeIndexScan},
+ {OperatorClassRelationName, /* CLANAME */
+ 1,
+ {
+ Anum_pg_opclass_opcname,
+ 0,
+ 0,
+ 0
+ },
+ sizeof(FormData_pg_opclass),
+ OpclassNameIndex,
+ OpclassNameIndexScan},
+ {GroupRelationName, /* GRONAME */
+ 1,
+ {
+ Anum_pg_group_groname,
+ 0,
+ 0,
+ 0
+ },
+ offsetof(FormData_pg_group, grolist[0]),
+ GroupNameIndex,
+ GroupNameIndexScan},
+ {GroupRelationName, /* GROSYSID */
+ 1,
+ {
+ Anum_pg_group_grosysid,
+ 0,
+ 0,
+ 0
+ },
+ offsetof(FormData_pg_group, grolist[0]),
+ GroupSysidIndex,
+ GroupSysidIndexScan},
{IndexRelationName, /* INDEXRELID */
1,
{
},
offsetof(FormData_pg_index, indpred),
IndexRelidIndex,
- (ScanFunc) IndexRelidIndexScan},
- {LanguageRelationName, /* LANNAME */
+ IndexRelidIndexScan},
+ {InheritsRelationName, /* INHRELID */
+ 2,
+ {
+ Anum_pg_inherits_inhrelid,
+ Anum_pg_inherits_inhseqno,
+ 0,
+ 0
+ },
+ sizeof(FormData_pg_inherits),
+ InheritsRelidSeqnoIndex,
+ InheritsRelidSeqnoIndexScan},
+ {LanguageRelationName, /* LANGNAME */
1,
{
Anum_pg_language_lanname,
0
},
offsetof(FormData_pg_language, lancompiler),
- NULL,
- NULL},
- {OperatorRelationName, /* OPRNAME */
+ LanguageNameIndex,
+ LanguageNameIndexScan},
+ {LanguageRelationName, /* LANGOID */
+ 1,
+ {
+ ObjectIdAttributeNumber,
+ 0,
+ 0,
+ 0
+ },
+ offsetof(FormData_pg_language, lancompiler),
+ LanguageOidIndex,
+ LanguageOidIndexScan},
+ {ListenerRelationName, /* LISTENREL */
+ 2,
+ {
+ Anum_pg_listener_relname,
+ Anum_pg_listener_pid,
+ 0,
+ 0
+ },
+ sizeof(FormData_pg_listener),
+ ListenerRelnamePidIndex,
+ ListenerRelnamePidIndexScan},
+ {OperatorRelationName, /* OPERNAME */
4,
{
Anum_pg_operator_oprname,
Anum_pg_operator_oprkind
},
sizeof(FormData_pg_operator),
- NULL,
- NULL},
- {OperatorRelationName, /* OPROID */
+ OperatorNameIndex,
+ (ScanFunc) OperatorNameIndexScan},
+ {OperatorRelationName, /* OPEROID */
1,
{
ObjectIdAttributeNumber,
0
},
sizeof(FormData_pg_operator),
- NULL,
- (ScanFunc) NULL},
- {ProcedureRelationName, /* PRONAME */
+ OperatorOidIndex,
+ OperatorOidIndexScan},
+ {ProcedureRelationName, /* PROCNAME */
3,
{
Anum_pg_proc_proname,
offsetof(FormData_pg_proc, prosrc),
ProcedureNameIndex,
(ScanFunc) ProcedureNameIndexScan},
- {ProcedureRelationName, /* PROOID */
+ {ProcedureRelationName, /* PROCOID */
1,
{
ObjectIdAttributeNumber,
},
offsetof(FormData_pg_proc, prosrc),
ProcedureOidIndex,
- (ScanFunc) ProcedureOidIndexScan},
+ ProcedureOidIndexScan},
{RelationRelationName, /* RELNAME */
1,
{
},
CLASS_TUPLE_SIZE,
ClassNameIndex,
- (ScanFunc) ClassNameIndexScan},
+ ClassNameIndexScan},
{RelationRelationName, /* RELOID */
1,
{
},
CLASS_TUPLE_SIZE,
ClassOidIndex,
- (ScanFunc) ClassOidIndexScan},
- {TypeRelationName, /* TYPNAME */
+ ClassOidIndexScan},
+ {RewriteRelationName, /* REWRITENAME */
1,
{
- Anum_pg_type_typname,
+ Anum_pg_rewrite_rulename,
0,
0,
0
},
- offsetof(FormData_pg_type, typalign) +sizeof(char),
- TypeNameIndex,
- TypeNameIndexScan},
- {TypeRelationName, /* TYPOID */
+ offsetof(FormData_pg_rewrite, ev_qual),
+ RewriteRulenameIndex,
+ RewriteRulenameIndexScan},
+ {RewriteRelationName, /* RULEOID */
1,
{
ObjectIdAttributeNumber,
0,
0
},
- offsetof(FormData_pg_type, typalign) +sizeof(char),
- TypeOidIndex,
- TypeOidIndexScan},
- {AccessMethodRelationName, /* AMNAME */
- 1,
- {
- Anum_pg_am_amname,
- 0,
- 0,
- 0
- },
- sizeof(FormData_pg_am),
- NULL,
- NULL},
- {OperatorClassRelationName, /* CLANAME */
+ offsetof(FormData_pg_rewrite, ev_qual),
+ RewriteOidIndex,
+ RewriteOidIndexScan},
+ {TypeRelationName, /* TYPENAME */
1,
{
- Anum_pg_opclass_opcname,
- 0,
+ Anum_pg_type_typname,
0,
- 0
- },
- sizeof(FormData_pg_opclass),
- NULL,
- NULL},
- {InheritsRelationName, /* INHRELID */
- 2,
- {
- Anum_pg_inherits_inhrel,
- Anum_pg_inherits_inhseqno,
0,
0
},
- sizeof(FormData_pg_inherits),
- NULL,
- (ScanFunc) NULL},
- {RewriteRelationName, /* RULOID */
+ offsetof(FormData_pg_type, typalign) +sizeof(char),
+ TypeNameIndex,
+ TypeNameIndexScan},
+ {TypeRelationName, /* TYPEOID */
1,
{
ObjectIdAttributeNumber,
0,
0
},
- offsetof(FormData_pg_rewrite, ev_qual),
- NULL,
- (ScanFunc) NULL},
- {AggregateRelationName, /* AGGNAME */
- 2,
- {
- Anum_pg_aggregate_aggname,
- Anum_pg_aggregate_aggbasetype,
- 0,
- 0
- },
- offsetof(FormData_pg_aggregate, agginitval1),
- NULL,
- (ScanFunc) NULL},
- {ListenerRelationName, /* LISTENREL */
- 2,
- {
- Anum_pg_listener_relname,
- Anum_pg_listener_pid,
- 0,
- 0
- },
- sizeof(FormData_pg_listener),
- NULL,
- (ScanFunc) NULL},
- {ShadowRelationName, /* USENAME */
+ offsetof(FormData_pg_type, typalign) +sizeof(char),
+ TypeOidIndex,
+ TypeOidIndexScan},
+ {ShadowRelationName, /* USERNAME */
1,
{
Anum_pg_shadow_usename,
0
},
sizeof(FormData_pg_shadow),
- NULL,
- (ScanFunc) NULL},
- {ShadowRelationName, /* USESYSID */
+NULL,NULL
+/* ShadowNameIndex,
+ ShadowNameIndexScan*/},
+ {ShadowRelationName, /* USERSYSID */
1,
{
Anum_pg_shadow_usesysid,
0
},
sizeof(FormData_pg_shadow),
- NULL,
- (ScanFunc) NULL},
- {GroupRelationName, /* GRONAME */
- 1,
- {
- Anum_pg_group_groname,
- 0,
- 0,
- 0
- },
- offsetof(FormData_pg_group, grolist[0]),
- NULL,
- (ScanFunc) NULL},
- {GroupRelationName, /* GROSYSID */
- 1,
- {
- Anum_pg_group_grosysid,
- 0,
- 0,
- 0
- },
- offsetof(FormData_pg_group, grolist[0]),
- NULL,
- (ScanFunc) NULL},
- {RewriteRelationName, /* REWRITENAME */
- 1,
- {
- Anum_pg_rewrite_rulename,
- 0,
- 0,
- 0
- },
- offsetof(FormData_pg_rewrite, ev_qual),
- NULL,
- (ScanFunc) NULL},
- {OperatorClassRelationName, /* CLADEFTYPE */
- 1,
- {
- Anum_pg_opclass_opcdeftype,
- 0,
- 0,
- 0
- },
- sizeof(FormData_pg_opclass),
- NULL,
- (ScanFunc) NULL},
- {LanguageRelationName, /* LANOID */
- 1,
- {
- ObjectIdAttributeNumber,
- 0,
- 0,
- 0
- },
- offsetof(FormData_pg_language, lancompiler),
- NULL,
- NULL}
+NULL,NULL
+/* ShadowSysidIndex,
+ ShadowSysidIndexScan*/}
};
static struct catcache *SysCache[lengthof(cacheinfo)];
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/dfmgr.c,v 1.36 1999/11/07 23:08:27 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/dfmgr.c,v 1.37 1999/11/22 17:56:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*/
rel = heap_openr(ProcedureRelationName, AccessShareLock);
- procedureTuple = SearchSysCacheTuple(PROOID,
+ procedureTuple = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(procedureId),
0, 0, 0);
if (!HeapTupleIsValid(procedureTuple))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.32 1999/07/17 20:18:04 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/fmgr/fmgr.c,v 1.33 1999/11/22 17:56:33 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
else
{
- procedureTuple = SearchSysCacheTuple(PROOID,
+ procedureTuple = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(procedureId),
0, 0, 0);
if (!HeapTupleIsValid(procedureTuple))
* this is the case, we return a NULL function pointer and
* the number of arguments from the procedure.
*/
- languageTuple = SearchSysCacheTuple(LANOID,
+ languageTuple = SearchSysCacheTuple(LANGOID,
ObjectIdGetDatum(procedureStruct->prolang),
0, 0, 0);
if (!HeapTupleIsValid(languageTuple))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.35 1999/10/06 21:58:10 vadim Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/init/miscinit.c,v 1.36 1999/11/22 17:56:34 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
userName = GetPgUserName();
- userTup = SearchSysCacheTuple(USENAME,
+ userTup = SearchSysCacheTuple(USERNAME,
PointerGetDatum(userName),
0, 0, 0);
if (!HeapTupleIsValid(userTup))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/misc/superuser.c,v 1.10 1999/07/16 05:23:27 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/misc/superuser.c,v 1.11 1999/11/22 17:56:35 momjian Exp $
*
* DESCRIPTION
* See superuser().
HeapTuple utup;
- utup = SearchSysCacheTuple(USENAME,
+ utup = SearchSysCacheTuple(USERNAME,
PointerGetDatum(UserName),
0, 0, 0);
Assert(utup != NULL);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/common.c,v 1.34 1999/10/23 03:13:26 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/common.c,v 1.35 1999/11/22 17:56:36 momjian Exp $
*
* Modifications - 6/12/96 - dave@bensoft.com - version 1.13.dhb.2
*
numParents = 0;
for (i = 0; i < numInherits; i++)
{
- if (strcmp(inhinfo[i].inhrel, oid) == 0)
+ if (strcmp(inhinfo[i].inhrelid, oid) == 0)
numParents++;
}
j = 0;
for (i = 0; i < numInherits; i++)
{
- if (strcmp(inhinfo[i].inhrel, oid) == 0)
+ if (strcmp(inhinfo[i].inhrelid, oid) == 0)
{
parentInd = findTableByOid(tblinfo, numTables,
inhinfo[i].inhparent);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.123 1999/10/23 03:13:26 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/bin/pg_dump/pg_dump.c,v 1.124 1999/11/22 17:56:36 momjian Exp $
*
* Modifications - 6/10/96 - dave@bensoft.com - version 1.13.dhb
*
return;
for (i = 0; i < numInherits; ++i)
{
- if (inh[i].inhrel)
- free(inh[i].inhrel);
+ if (inh[i].inhrelid)
+ free(inh[i].inhrelid);
if (inh[i].inhparent)
free(inh[i].inhparent);
}
sprintf(query, "SELECT rcname from pg_relcheck, pg_inherits as i "
"where rcrelid = '%s'::oid "
- " and rcrelid = i.inhrel"
+ " and rcrelid = i.inhrelid"
" and exists "
" (select * from pg_relcheck as c "
" where c.rcname = pg_relcheck.rcname "
"where rcrelid = '%s'::oid "
" and not exists "
" (select * from pg_relcheck as c, pg_inherits as i "
- " where i.inhrel = pg_relcheck.rcrelid "
+ " where i.inhrelid = pg_relcheck.rcrelid "
" and c.rcname = pg_relcheck.rcname "
" and c.rcsrc = pg_relcheck.rcsrc "
" and c.rcrelid = i.inhparent) ",
char query[MAX_QUERY_SIZE];
InhInfo *inhinfo;
- int i_inhrel;
+ int i_inhrelid;
int i_inhparent;
/* find all the inheritance information */
- sprintf(query, "SELECT inhrel, inhparent from pg_inherits");
+ sprintf(query, "SELECT inhrelid, inhparent from pg_inherits");
res = PQexec(g_conn, query);
if (!res ||
inhinfo = (InhInfo *) malloc(ntups * sizeof(InhInfo));
- i_inhrel = PQfnumber(res, "inhrel");
+ i_inhrelid = PQfnumber(res, "inhrelid");
i_inhparent = PQfnumber(res, "inhparent");
for (i = 0; i < ntups; i++)
{
- inhinfo[i].inhrel = strdup(PQgetvalue(res, i, i_inhrel));
+ inhinfo[i].inhrelid = strdup(PQgetvalue(res, i, i_inhrelid));
inhinfo[i].inhparent = strdup(PQgetvalue(res, i, i_inhparent));
}
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_dump.h,v 1.40 1999/10/23 03:13:26 tgl Exp $
+ * $Id: pg_dump.h,v 1.41 1999/11/22 17:56:36 momjian Exp $
*
* Modifications - 6/12/96 - dave@bensoft.com - version 1.13.dhb.2
*
typedef struct _inhInfo
{
- char *inhrel;
+ char *inhrelid;
char *inhparent;
} InhInfo;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: catversion.h,v 1.2 1999/11/04 08:01:06 inoue Exp $
+ * $Id: catversion.h,v 1.3 1999/11/22 17:56:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* catalog changes on the same day...)
*/
-#define CATALOG_VERSION_NO 199911041
+#define CATALOG_VERSION_NO 199911221
#endif
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: indexing.h,v 1.28 1999/11/04 08:01:06 inoue Exp $
+ * $Id: indexing.h,v 1.29 1999/11/22 17:56:37 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* Some definitions for indices on pg_attribute
*/
+#define Num_pg_aggregate_indices 1
+#define Num_pg_am_indices 1
#define Num_pg_amop_indices 2
-#define Num_pg_attr_indices 3
+#define Num_pg_attr_indices 2
+#define Num_pg_attrdef_indices 1
+#define Num_pg_class_indices 2
+#define Num_pg_description_indices 1
+#define Num_pg_group_indices 2
#define Num_pg_index_indices 1
+#define Num_pg_inherits_indices 1
+#define Num_pg_language_indices 2
+#define Num_pg_listener_indices 1
+#define Num_pg_opclass_indices 2
+#define Num_pg_operator_indices 2
#define Num_pg_proc_indices 2
-#define Num_pg_type_indices 2
-#define Num_pg_class_indices 2
-#define Num_pg_attrdef_indices 1
#define Num_pg_relcheck_indices 1
+#define Num_pg_rewrite_indices 2
+#define Num_pg_shadow_indices 2
#define Num_pg_trigger_indices 3
-#define Num_pg_description_indices 1
+#define Num_pg_type_indices 2
/*
*/
#define AccessMethodOpidIndex "pg_amop_opid_index"
#define AccessMethodStrategyIndex "pg_amop_strategy_index"
-#define AttributeNameIndex "pg_attribute_relid_attnam_index"
-#define AttributeNumIndex "pg_attribute_relid_attnum_index"
+#define AggregateNameTypeIndex "pg_aggregate_name_type_index"
+#define AmNameIndex "pg_am_name_index"
+#define AttrDefaultIndex "pg_attrdef_adrelid_index"
+#define AttributeRelidNameIndex "pg_attribute_relid_attnam_index"
+#define AttributeRelidNumIndex "pg_attribute_relid_attnum_index"
+#define ClassNameIndex "pg_class_relname_index"
+#define ClassOidIndex "pg_class_oid_index"
+#define DescriptionObjIndex "pg_description_objoid_index"
+#define GroupNameIndex "pg_group_name_index"
+#define GroupSysidIndex "pg_group_sysid_index"
#define IndexRelidIndex "pg_index_indexrelid_index"
-#define AttributeRelidIndex "pg_attribute_attrelid_index"
-#define ProcedureOidIndex "pg_proc_oid_index"
+#define InheritsRelidSeqnoIndex "pg_inherits_relid_seqno_index"
+#define LanguageNameIndex "pg_language_name_index"
+#define LanguageOidIndex "pg_language_oid_index"
+#define ListenerRelnamePidIndex "pg_listener_relname_pid_index"
+#define OpclassDeftypeIndex "pg_opclass_deftype_index"
+#define OpclassNameIndex "pg_opclass_name_index"
+#define OperatorNameIndex "pg_operator_oprname_l_r_k_index"
+#define OperatorOidIndex "pg_operator_oid_index"
#define ProcedureNameIndex "pg_proc_proname_narg_type_index"
-#define TypeOidIndex "pg_type_oid_index"
-#define TypeNameIndex "pg_type_typname_index"
-#define ClassOidIndex "pg_class_oid_index"
-#define ClassNameIndex "pg_class_relname_index"
-#define AttrDefaultIndex "pg_attrdef_adrelid_index"
+#define ProcedureOidIndex "pg_proc_oid_index"
#define RelCheckIndex "pg_relcheck_rcrelid_index"
-#define TriggerRelidIndex "pg_trigger_tgrelid_index"
+#define RewriteOidIndex "pg_rewrite_oid_index"
+#define RewriteRulenameIndex "pg_rewrite_rulename_index"
+#define ShadowNameIndex "pg_shadow_name_index"
+#define ShadowSysidIndex "pg_shadow_sysid_index"
#define TriggerConstrNameIndex "pg_trigger_tgconstrname_index"
#define TriggerConstrRelidIndex "pg_trigger_tgconstrrelid_index"
-#define DescriptionObjIndex "pg_description_objoid_index"
+#define TriggerRelidIndex "pg_trigger_tgrelid_index"
+#define TypeNameIndex "pg_type_typname_index"
+#define TypeOidIndex "pg_type_oid_index"
+extern char *Name_pg_aggregate_indices[];
+extern char *Name_pg_am_indices[];
extern char *Name_pg_amop_indices[];
extern char *Name_pg_attr_indices[];
+extern char *Name_pg_attrdef_indices[];
+extern char *Name_pg_class_indices[];
+extern char *Name_pg_description_indices[];
+extern char *Name_pg_group_indices[];
extern char *Name_pg_index_indices[];
+extern char *Name_pg_inherits_indices[];
+extern char *Name_pg_language_indices[];
+extern char *Name_pg_listener_indices[];
+extern char *Name_pg_opclass_indices[];
+extern char *Name_pg_operator_indices[];
extern char *Name_pg_proc_indices[];
-extern char *Name_pg_type_indices[];
-extern char *Name_pg_class_indices[];
-extern char *Name_pg_attrdef_indices[];
extern char *Name_pg_relcheck_indices[];
+extern char *Name_pg_rewrite_indices[];
+extern char *Name_pg_shadow_indices[];
extern char *Name_pg_trigger_indices[];
-extern char *Name_pg_description_indices[];
+extern char *Name_pg_type_indices[];
extern char *IndexedCatalogNames[];
Oid claid, Oid opopr, Oid opid);
extern HeapTuple AccessMethodStrategyIndexScan(Relation heapRelation,
Oid opid, Oid claid, int2 opstrategy);
-extern HeapTuple AttributeNameIndexScan(Relation heapRelation,
+extern HeapTuple AggregateNameTypeIndexScan(Relation heapRelation,
+ char *aggName, Oid aggType);
+extern HeapTuple AmNameIndexScan(Relation heapRelation, char *amName);
+extern HeapTuple AttributeRelidNameIndexScan(Relation heapRelation,
Oid relid, char *attname);
-extern HeapTuple AttributeNumIndexScan(Relation heapRelation,
+extern HeapTuple AttributeRelidNumIndexScan(Relation heapRelation,
Oid relid, AttrNumber attnum);
+extern HeapTuple ClassNameIndexScan(Relation heapRelation, char *relName);
+extern HeapTuple ClassNameIndexScan(Relation heapRelation, char *relName);
+extern HeapTuple ClassOidIndexScan(Relation heapRelation, Oid relId);
+extern HeapTuple GroupNameIndexScan(Relation heapRelation, char *groName);
+extern HeapTuple GroupSysidIndexScan(Relation heapRelation, int4 sysId);
extern HeapTuple IndexRelidIndexScan(Relation heapRelation, Oid relid);
-extern HeapTuple ProcedureOidIndexScan(Relation heapRelation, Oid procId);
+extern HeapTuple InheritsRelidSeqnoIndexScan(Relation heapRelation, Oid relid,
+ int4 seqno);
+extern HeapTuple LanguageNameIndexScan(Relation heapRelation, char *lanName);
+extern HeapTuple LanguageOidIndexScan(Relation heapRelation, Oid lanId);
+extern HeapTuple ListenerRelnamePidIndexScan(Relation heapRelation, char *relName, int4 pid);
+extern HeapTuple OpclassDeftypeIndexScan(Relation heapRelation, Oid defType);
+extern HeapTuple OpclassNameIndexScan(Relation heapRelation, char *opcName);
+extern HeapTuple OperatorNameIndexScan(Relation heapRelation,
+ char *oprName, Oid oprLeft, Oid oprRight, char oprKind);
+extern HeapTuple OperatorOidIndexScan(Relation heapRelation, Oid oprId);
extern HeapTuple ProcedureNameIndexScan(Relation heapRelation,
char *procName, int2 nargs, Oid *argTypes);
-extern HeapTuple TypeOidIndexScan(Relation heapRelation, Oid typeId);
+extern HeapTuple ProcedureOidIndexScan(Relation heapRelation, Oid procId);
+extern HeapTuple RewriteOidIndexScan(Relation heapRelation, Oid rewriteId);
+extern HeapTuple RewriteRulenameIndexScan(Relation heapRelation,
+ char *ruleName);
+extern HeapTuple ShadowNameIndexScan(Relation heapRelation, char *useName);
+extern HeapTuple ShadowSysidIndexScan(Relation heapRelation, int4 sysId);
extern HeapTuple TypeNameIndexScan(Relation heapRelation, char *typeName);
-extern HeapTuple ClassNameIndexScan(Relation heapRelation, char *relName);
-extern HeapTuple ClassOidIndexScan(Relation heapRelation, Oid relId);
+extern HeapTuple TypeOidIndexScan(Relation heapRelation, Oid typeId);
* The keyword is DECLARE_INDEX every thing after that is just like in a
* normal specification of the 'define index' POSTQUEL command.
*/
-DECLARE_INDEX(pg_amop_opid_index on pg_amop using btree(amopclaid oid_ops, amopopr oid_ops, amopid oid_ops));
-DECLARE_INDEX(pg_amop_strategy_index on pg_amop using btree(amopid oid_ops, amopclaid oid_ops, amopstrategy int2_ops));
-
-DECLARE_INDEX(pg_attribute_relid_attnam_index on pg_attribute using btree(attrelid oid_ops, attname name_ops));
-DECLARE_INDEX(pg_attribute_relid_attnum_index on pg_attribute using btree(attrelid oid_ops, attnum int2_ops));
-DECLARE_INDEX(pg_attribute_attrelid_index on pg_attribute using btree(attrelid oid_ops));
-
-DECLARE_INDEX(pg_index_indexrelid_index on pg_index using btree(indexrelid oid_ops));
-
-DECLARE_INDEX(pg_proc_oid_index on pg_proc using btree(oid oid_ops));
-DECLARE_INDEX(pg_proc_proname_narg_type_index on pg_proc using btree(proname name_ops, pronargs int2_ops, proargtypes oid8_ops));
-
-DECLARE_UNIQUE_INDEX(pg_type_oid_index on pg_type using btree(oid oid_ops));
-DECLARE_UNIQUE_INDEX(pg_type_typname_index on pg_type using btree(typname name_ops));
+DECLARE_UNIQUE_INDEX(pg_aggregate_name_type_index on pg_aggregate using btree(aggname name_ops, aggbasetype oid_ops));
+DECLARE_UNIQUE_INDEX(pg_am_name_index on pg_am using btree(amname name_ops));
+DECLARE_UNIQUE_INDEX(pg_amop_opid_index on pg_amop using btree(amopclaid oid_ops, amopopr oid_ops, amopid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_amop_strategy_index on pg_amop using btree(amopid oid_ops, amopclaid oid_ops, amopstrategy int2_ops));
+/* This following index is not used for a cache and is not unique */
+DECLARE_INDEX(pg_attrdef_adrelid_index on pg_attrdef using btree(adrelid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_attribute_relid_attnam_index on pg_attribute using btree(attrelid oid_ops, attname name_ops));
+DECLARE_UNIQUE_INDEX(pg_attribute_relid_attnum_index on pg_attribute using btree(attrelid oid_ops, attnum int2_ops));
DECLARE_UNIQUE_INDEX(pg_class_oid_index on pg_class using btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_class_relname_index on pg_class using btree(relname name_ops));
-
-DECLARE_INDEX(pg_attrdef_adrelid_index on pg_attrdef using btree(adrelid oid_ops));
-
+DECLARE_UNIQUE_INDEX(pg_description_objoid_index on pg_description using btree(objoid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_group_name_index on pg_group using btree(groname name_ops));
+DECLARE_UNIQUE_INDEX(pg_group_sysid_index on pg_group using btree(grosysid int4_ops));
+DECLARE_UNIQUE_INDEX(pg_index_indexrelid_index on pg_index using btree(indexrelid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_inherits_relid_seqno_index on pg_inherits using btree(inhrelid oid_ops, inhseqno int4_ops));
+DECLARE_UNIQUE_INDEX(pg_language_name_index on pg_language using btree(lanname name_ops));
+DECLARE_UNIQUE_INDEX(pg_language_oid_index on pg_language using btree(oid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_listener_relname_pid_index on pg_listener using btree(relname name_ops, listenerpid int4_ops));
+DECLARE_UNIQUE_INDEX(pg_opclass_deftype_index on pg_opclass using btree(opcdeftype oid_ops));
+DECLARE_UNIQUE_INDEX(pg_opclass_name_index on pg_opclass using btree(opcname name_ops));
+DECLARE_UNIQUE_INDEX(pg_operator_oid_index on pg_operator using btree(oid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_operator_oprname_l_r_k_index on pg_operator using btree(oprname name_ops, oprleft oid_ops, oprright oid_ops, oprkind char_ops));
+DECLARE_UNIQUE_INDEX(pg_proc_oid_index on pg_proc using btree(oid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_proc_proname_narg_type_index on pg_proc using btree(proname name_ops, pronargs int2_ops, proargtypes oid8_ops));
+/* This following index is not used for a cache and is not unique */
DECLARE_INDEX(pg_relcheck_rcrelid_index on pg_relcheck using btree(rcrelid oid_ops));
-
-DECLARE_INDEX(pg_trigger_tgrelid_index on pg_trigger using btree(tgrelid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_rewrite_oid_index on pg_rewrite using btree(oid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_rewrite_rulename_index on pg_rewrite using btree(rulename name_ops));
+/*
+xDECLARE_UNIQUE_INDEX(pg_shadow_name_index on pg_shadow using btree(usename name_ops));
+xDECLARE_UNIQUE_INDEX(pg_shadow_sysid_index on pg_shadow using btree(usesysid int4_ops));
+*/
DECLARE_INDEX(pg_trigger_tgconstrname_index on pg_trigger using btree(tgconstrname name_ops));
DECLARE_INDEX(pg_trigger_tgconstrrelid_index on pg_trigger using btree(tgconstrrelid oid_ops));
-
-DECLARE_INDEX(pg_description_objoid_index on pg_description using btree(objoid oid_ops));
+DECLARE_INDEX(pg_trigger_tgrelid_index on pg_trigger using btree(tgrelid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_type_oid_index on pg_type using btree(oid oid_ops));
+DECLARE_UNIQUE_INDEX(pg_type_typname_index on pg_type using btree(typname name_ops));
/* now build indices in the initialization scripts */
BUILD_INDICES
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_inheritproc.h,v 1.6 1999/02/13 23:21:10 momjian Exp $
+ * $Id: pg_inheritproc.h,v 1.7 1999/11/22 17:56:37 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
CATALOG(pg_inheritproc)
{
NameData inhproname;
- Oid inhargrel;
- Oid inhdefrel;
+ Oid inhargrelid;
+ Oid inhdefrelid;
Oid inhproc;
} FormData_pg_inheritproc;
*/
#define Natts_pg_inheritproc 4
#define Anum_pg_inheritproc_inhproname 1
-#define Anum_pg_inheritproc_inhargrel 2
-#define Anum_pg_inheritproc_inhdefrel 3
+#define Anum_pg_inheritproc_inhargrelid 2
+#define Anum_pg_inheritproc_inhdefrelid 3
#define Anum_pg_inheritproc_inhproc 4
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_inherits.h,v 1.7 1999/02/13 23:21:10 momjian Exp $
+ * $Id: pg_inherits.h,v 1.8 1999/11/22 17:56:37 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
*/
CATALOG(pg_inherits)
{
- Oid inhrel;
+ Oid inhrelid;
Oid inhparent;
int4 inhseqno;
} FormData_pg_inherits;
* ----------------
*/
#define Natts_pg_inherits 3
-#define Anum_pg_inherits_inhrel 1
+#define Anum_pg_inherits_inhrelid 1
#define Anum_pg_inherits_inhparent 2
#define Anum_pg_inherits_inhseqno 3
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_ipl.h,v 1.6 1999/02/13 23:21:10 momjian Exp $
+ * $Id: pg_ipl.h,v 1.7 1999/11/22 17:56:37 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
*/
CATALOG(pg_ipl)
{
- Oid iplrel;
+ Oid iplrelid;
Oid iplipl;
int4 iplseqno;
} FormData_pg_ipl;
* ----------------
*/
#define Natts_pg_ipl 3
-#define Anum_pg_ipl_iplrel 1
+#define Anum_pg_ipl_iplrelid 1
#define Anum_pg_ipl_iplipl 2
#define Anum_pg_ipl_iplseqno 3
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_opclass.h,v 1.20 1999/09/29 21:13:30 wieck Exp $
+ * $Id: pg_opclass.h,v 1.21 1999/11/22 17:56:37 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
DESCR("");
DATA(insert OID = 423 ( float8_ops 701 ));
DESCR("");
-DATA(insert OID = 424 ( int24_ops 0 ));
+/* Technically, deftype is wrong, but it must be unique for index, bjm */
+DATA(insert OID = 424 ( int24_ops 424 ));
DESCR("");
-DATA(insert OID = 425 ( int42_ops 0 ));
+/* Technically, deftype is wrong, but it must be unique for index, bjm */
+DATA(insert OID = 425 ( int42_ops 425 ));
DESCR("");
DATA(insert OID = 426 ( int4_ops 23 ));
DESCR("");
DESCR("");
DATA(insert OID = 432 ( abstime_ops 702 ));
DESCR("");
-DATA(insert OID = 433 ( bigbox_ops 603 ));
+/* Technically, deftype is wrong, but it must be unique for index, bjm */
+DATA(insert OID = 433 ( bigbox_ops 433 ));
DESCR("");
DATA(insert OID = 434 ( poly_ops 604 ));
DESCR("");
DESCR("");
DATA(insert OID = 1313 ( timespan_ops 1186 ));
DESCR("");
-DATA(insert OID = 810 ( macaddr_ops 829 ));
+DATA(insert OID = 810 ( macaddr_ops 829 ));
DESCR("");
-DATA(insert OID = 935 ( network_ops 869 ));
+DATA(insert OID = 935 ( inet_ops 869 ));
DESCR("");
-DATA(insert OID = 652 ( network_ops 650 ));
+DATA(insert OID = 652 ( cidr_ops 650 ));
DESCR("");
-DATA(insert OID = 1768 ( numeric_ops 1700 ));
+DATA(insert OID = 1768 ( numeric_ops 1700 ));
DESCR("");
#endif /* PG_OPCLASS_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_operator.h,v 1.60 1999/10/11 06:28:29 inoue Exp $
+ * $Id: pg_operator.h,v 1.61 1999/11/22 17:56:37 momjian Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
DATA(insert OID = 1284 ( "|" PGUID 0 l t f 0 704 702 0 0 0 0 intervalstart - - ));
DATA(insert OID = 606 ( "<#>" PGUID 0 b t f 702 702 704 0 0 0 0 mktinterval - - ));
DATA(insert OID = 607 ( "=" PGUID 0 b t t 26 26 16 607 608 609 609 oideq eqsel eqjoinsel ));
+#define MIN_OIDCMP 607 /* used by cache code */
DATA(insert OID = 608 ( "<>" PGUID 0 b t f 26 26 16 608 607 0 0 oidne neqsel neqjoinsel ));
+DATA(insert OID = 609 ( "<" PGUID 0 b t f 26 26 16 610 612 0 0 int4lt intltsel intltjoinsel ));
+DATA(insert OID = 610 ( ">" PGUID 0 b t f 26 26 16 609 611 0 0 int4gt intgtsel intgtjoinsel ));
+DATA(insert OID = 611 ( "<=" PGUID 0 b t f 26 26 16 612 610 0 0 int4le intltsel intltjoinsel ));
+DATA(insert OID = 612 ( ">=" PGUID 0 b t f 26 26 16 611 609 0 0 int4ge intgtsel intgtjoinsel ));
+#define MAX_OIDCMP 612 /* used by cache code */
DATA(insert OID = 644 ( "<>" PGUID 0 b t f 30 30 16 644 649 0 0 oid8ne neqsel neqjoinsel ));
DATA(insert OID = 645 ( "<" PGUID 0 b t f 30 30 16 646 648 0 0 oid8lt intltsel intltjoinsel ));
DATA(insert OID = 648 ( ">=" PGUID 0 b t f 30 30 16 647 645 0 0 oid8ge intgtsel intgtjoinsel ));
DATA(insert OID = 649 ( "=" PGUID 0 b t t 30 30 16 649 644 645 645 oid8eq eqsel eqjoinsel ));
-DATA(insert OID = 609 ( "<" PGUID 0 b t f 26 26 16 610 612 0 0 int4lt intltsel intltjoinsel ));
-DATA(insert OID = 610 ( ">" PGUID 0 b t f 26 26 16 609 611 0 0 int4gt intgtsel intgtjoinsel ));
-DATA(insert OID = 611 ( "<=" PGUID 0 b t f 26 26 16 612 610 0 0 int4le intltsel intltjoinsel ));
-DATA(insert OID = 612 ( ">=" PGUID 0 b t f 26 26 16 611 609 0 0 int4ge intgtsel intgtjoinsel ));
-
DATA(insert OID = 613 ( "<->" PGUID 0 b t f 600 628 701 0 0 0 0 dist_pl - - ));
DATA(insert OID = 614 ( "<->" PGUID 0 b t f 600 601 701 0 0 0 0 dist_ps - - ));
DATA(insert OID = 615 ( "<->" PGUID 0 b t f 600 603 701 0 0 0 0 dist_pb - - ));
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: syscache.h,v 1.20 1999/11/01 02:29:27 momjian Exp $
+ * $Id: syscache.h,v 1.21 1999/11/22 17:56:38 momjian Exp $
*
*-------------------------------------------------------------------------
*/
*
* The order of these must match the order
* they are entered into the structure cacheinfo[] in syscache.c
- * The best thing to do is to add yours at the END, because some
- * code assumes that certain caches are at certain places in this
- * array.
+ * Keep them in alphabeticall order.
*/
-#define AMOPOPID 0
-#define AMOPSTRATEGY 1
-#define ATTNAME 2
-#define ATTNUM 3
-#define INDEXRELID 4
-#define LANNAME 5
-#define OPRNAME 6
-#define OPROID 7
-#define PRONAME 8
-#define PROOID 9
-#define RELNAME 10
-#define RELOID 11
-#define TYPNAME 12
-#define TYPOID 13
-#define AMNAME 14
-#define CLANAME 15
-/* #define INDRELIDKEY 16 */
-#define INHRELID 16
-#define RULOID 17
-#define AGGNAME 18
-#define LISTENREL 19
-#define USENAME 20
-#define USESYSID 21
-#define GRONAME 22
-#define GROSYSID 23
-#define REWRITENAME 24
-#define CLADEFTYPE 25
-#define LANOID 26
+#define AGGNAME 0
+#define AMNAME 1
+#define AMOPOPID 2
+#define AMOPSTRATEGY 3
+#define ATTNAME 4
+#define ATTNUM 5
+#define CLADEFTYPE 6
+#define CLANAME 7
+#define GRONAME 8
+#define GROSYSID 9
+#define INDEXRELID 10
+#define INHRELID 11
+#define LANGNAME 12
+#define LANGOID 13
+#define LISTENREL 14
+#define OPERNAME 15
+#define OPEROID 16
+#define PROCNAME 17
+#define PROCOID 18
+#define RELNAME 19
+#define RELOID 20
+#define RULENAME 21
+#define RULEOID 22
+#define TYPENAME 23
+#define TYPEOID 24
+#define USERNAME 25
+#define USERSYSID 26
/* ----------------
* struct cachedesc: information needed for a call to InitSysCache()
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_comp.c,v 1.12 1999/11/07 23:08:34 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_comp.c,v 1.13 1999/11/22 17:56:39 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
* Lookup the pg_proc tuple by Oid
* ----------
*/
- procTup = SearchSysCacheTuple(PROOID,
+ procTup = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(fn_oid),
0, 0, 0);
if (!HeapTupleIsValid(procTup))
* Lookup the functions return type
* ----------
*/
- typeTup = SearchSysCacheTuple(TYPOID,
+ typeTup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(procStruct->prorettype), 0, 0, 0);
if (!HeapTupleIsValid(typeTup))
* Get the parameters type
* ----------
*/
- typeTup = SearchSysCacheTuple(TYPOID,
+ typeTup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(procStruct->proargtypes[i]), 0, 0, 0);
if (!HeapTupleIsValid(typeTup))
* ----------
*/
typeXlated = xlateSqlType(cp);
- typeTup = SearchSysCacheTuple(TYPNAME,
+ typeTup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(typeXlated), 0, 0, 0);
if (HeapTupleIsValid(typeTup))
{
* ----------
*/
typeXlated = xlateSqlType(cp);
- typeTup = SearchSysCacheTuple(TYPNAME,
+ typeTup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(typeXlated), 0, 0, 0);
if (HeapTupleIsValid(typeTup))
{
}
attrStruct = (Form_pg_attribute) GETSTRUCT(attrtup);
- typetup = SearchSysCacheTuple(TYPOID,
+ typetup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(attrStruct->atttypid), 0, 0, 0);
if (!HeapTupleIsValid(typetup))
{
* Fetch the tables pg_type tuple too
* ----------
*/
- typetup = SearchSysCacheTuple(TYPNAME,
+ typetup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(word1), 0, 0, 0);
if (!HeapTupleIsValid(typetup))
{
}
attrStruct = (Form_pg_attribute) GETSTRUCT(attrtup);
- typetup = SearchSysCacheTuple(TYPOID,
+ typetup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(attrStruct->atttypid), 0, 0, 0);
if (!HeapTupleIsValid(typetup))
{
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.14 1999/11/07 23:08:35 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_exec.c,v 1.15 1999/11/22 17:56:40 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
extval = "<NULL>";
else
{
- typetup = SearchSysCacheTuple(TYPOID,
+ typetup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(var->datatype->typoid), 0, 0, 0);
if (!HeapTupleIsValid(typetup))
elog(ERROR, "cache lookup for type %u failed (1)", var->datatype->typoid);
*/
atttype = SPI_gettypeid(rec->tupdesc, i + 1);
atttypmod = rec->tupdesc->attrs[i]->atttypmod;
- typetup = SearchSysCacheTuple(TYPOID,
+ typetup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(atttype), 0, 0, 0);
if (!HeapTupleIsValid(typetup))
elog(ERROR, "cache lookup for type %u failed", atttype);
FmgrInfo finfo_output;
char *extval;
- typetup = SearchSysCacheTuple(TYPOID,
+ typetup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(valtype), 0, 0, 0);
if (!HeapTupleIsValid(typetup))
elog(ERROR, "cache lookup for type %u failed", valtype);
* procedural language (PL)
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.14 1999/11/07 23:08:36 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/pl/tcl/pltcl.c,v 1.15 1999/11/22 17:56:41 momjian Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
/************************************************************
* Lookup the pg_proc tuple by Oid
************************************************************/
- procTup = SearchSysCacheTuple(PROOID,
+ procTup = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(proinfo->fn_oid),
0, 0, 0);
if (!HeapTupleIsValid(procTup))
* Get the required information for input conversion of the
* return value.
************************************************************/
- typeTup = SearchSysCacheTuple(TYPOID,
+ typeTup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(procStruct->prorettype),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
proc_internal_args[0] = '\0';
for (i = 0; i < proinfo->fn_nargs; i++)
{
- typeTup = SearchSysCacheTuple(TYPOID,
+ typeTup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(procStruct->proargtypes[i]),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
/************************************************************
* Lookup the pg_proc tuple by Oid
************************************************************/
- procTup = SearchSysCacheTuple(PROOID,
+ procTup = SearchSysCacheTuple(PROCOID,
ObjectIdGetDatum(proinfo->fn_oid),
0, 0, 0);
if (!HeapTupleIsValid(procTup))
* Lookup the attribute type in the syscache
* for the input function
************************************************************/
- typeTup = SearchSysCacheTuple(TYPOID,
+ typeTup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(tupdesc->attrs[attnum - 1]->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
************************************************************/
for (i = 0; i < nargs; i++)
{
- typeTup = SearchSysCacheTuple(TYPNAME,
+ typeTup = SearchSysCacheTuple(TYPENAME,
PointerGetDatum(args[i]),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
* Lookup the attribute type in the syscache
* for the output function
************************************************************/
- typeTup = SearchSysCacheTuple(TYPOID,
+ typeTup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(tupdesc->attrs[i]->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
* Lookup the attribute type in the syscache
* for the output function
************************************************************/
- typeTup = SearchSysCacheTuple(TYPOID,
+ typeTup = SearchSysCacheTuple(TYPEOID,
ObjectIdGetDatum(tupdesc->attrs[i]->atttypid),
0, 0, 0);
if (!HeapTupleIsValid(typeTup))
projects / postgresql / commitdiff