# files. These .bki files are used to initialize the postgres template
# database.
#
-# Copyright (c) 1994, Regents of the University of California
+# Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
+# Portions Copyright (c) 1994, Regents of the University of California
#
#
# IDENTIFICATION
-# $PostgreSQL: pgsql/src/backend/catalog/genbki.sh,v 1.35 2005/04/14 01:38:16 tgl Exp $
+# $PostgreSQL: pgsql/src/backend/catalog/genbki.sh,v 1.36 2005/04/14 20:03:23 tgl Exp $
#
# NOTES
# non-essential whitespace is removed from the generated file.
iname = substr(data, 1, pos-1);
data = substr(data, pos+1, length(data)-pos);
pos = index(data, ",");
- ioid = substr(data, 1, pos-1);
+ oid = substr(data, 1, pos-1);
data = substr(data, pos+1, length(data)-pos);
- print "declare index " iname " " ioid " " data
+ print "declare index " iname " " oid " " data
}
/^DECLARE_UNIQUE_INDEX\(/ {
iname = substr(data, 1, pos-1);
data = substr(data, pos+1, length(data)-pos);
pos = index(data, ",");
- ioid = substr(data, 1, pos-1);
+ oid = substr(data, 1, pos-1);
data = substr(data, pos+1, length(data)-pos);
- print "declare unique index " iname " " ioid " " data
+ print "declare unique index " iname " " oid " " data
}
/^BUILD_INDICES/ { print "build indices"; }
catalogandoid = substr($1,9,pos-9);
pos = index(catalogandoid, ",");
catalog = substr(catalogandoid, 1, pos-1);
- catalogoid = substr(catalogandoid, pos+1, length(catalogandoid)-pos);
+ oid = substr(catalogandoid, pos+1, length(catalogandoid)-pos);
if ($0 ~ /BKI_BOOTSTRAP/) {
bootstrap = "bootstrap ";
}
# ----------------
-# process the contents of the catalog definition
+# process the columns of the catalog definition
#
# attname[ x ] contains the attribute name for attribute x
# atttype[ x ] contains the attribute type fot attribute x
# if this is the last line, then output the bki catalog stuff.
# ----
if ($1 ~ /}/) {
- print "create " bootstrap shared_relation without_oids catalog " " catalogoid;
+ print "create " bootstrap shared_relation without_oids catalog " " oid;
print "\t(";
for (j=1; j
}
# ----
-# if we are inside the catalog definition, then keep sucking up
+# we are inside the catalog definition, so keep sucking up
# attribute names and types
# ----
if ($2 ~ /\[.*\]/) { # array attribute
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/heap.c,v 1.283 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/heap.c,v 1.284 2005/04/14 20:03:23 tgl Exp $
*
*
* INTERFACE ROUTINES
#include "access/heapam.h"
#include "access/genam.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/heap.h"
#include "catalog/index.h"
#include "catalog/pg_attrdef.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_inherits.h"
+#include "catalog/pg_namespace.h"
#include "catalog/pg_statistic.h"
#include "catalog/pg_type.h"
#include "commands/tablecmds.h"
/*
* open pg_attribute and its indexes.
*/
- rel = heap_openr(AttributeRelationName, RowExclusiveLock);
+ rel = heap_open(AttributeRelationId, RowExclusiveLock);
indstate = CatalogOpenIndexes(rel);
* is creating the same relation name in parallel but hadn't committed
* yet when we checked for a duplicate name above.
*/
- pg_class_desc = heap_openr(RelationRelationName, RowExclusiveLock);
+ pg_class_desc = heap_open(RelationRelationId, RowExclusiveLock);
AddNewRelationTuple(pg_class_desc,
new_rel_desc,
myself.classId = RelationRelationId;
myself.objectId = new_rel_oid;
myself.objectSubId = 0;
- referenced.classId = get_system_catalog_relid(NamespaceRelationName);
+ referenced.classId = NamespaceRelationId;
referenced.objectId = relnamespace;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
ScanKeyData key;
HeapTuple tuple;
- catalogRelation = heap_openr(InheritsRelationName, RowExclusiveLock);
+ catalogRelation = heap_open(InheritsRelationId, RowExclusiveLock);
ScanKeyInit(&key,
Anum_pg_inherits_inhrelid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(relid));
- scan = systable_beginscan(catalogRelation, InheritsRelidSeqnoIndex, true,
+ scan = systable_beginscan(catalogRelation, InheritsRelidSeqnoIndexId, true,
SnapshotNow, 1, &key);
while (HeapTupleIsValid(tuple = systable_getnext(scan)))
HeapTuple tup;
/* Grab an appropriate lock on the pg_class relation */
- pg_class_desc = heap_openr(RelationRelationName, RowExclusiveLock);
+ pg_class_desc = heap_open(RelationRelationId, RowExclusiveLock);
tup = SearchSysCache(RELOID,
ObjectIdGetDatum(relid),
HeapTuple atttup;
/* Grab an appropriate lock on the pg_attribute relation */
- attrel = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attrel = heap_open(AttributeRelationId, RowExclusiveLock);
/* Use the index to scan only attributes of the target relation */
ScanKeyInit(&key[0],
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(relid));
- scan = systable_beginscan(attrel, AttributeRelidNumIndex, true,
+ scan = systable_beginscan(attrel, AttributeRelidNumIndexId, true,
SnapshotNow, 1, key);
/* Delete all the matching tuples */
*/
rel = relation_open(relid, AccessExclusiveLock);
- attr_rel = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attr_rel = heap_open(AttributeRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopy(ATTNUM,
ObjectIdGetDatum(relid),
HeapTuple tuple;
bool found = false;
- attrdef_rel = heap_openr(AttrDefaultRelationName, RowExclusiveLock);
+ attrdef_rel = heap_open(AttrDefaultRelationId, RowExclusiveLock);
ScanKeyInit(&scankeys[0],
Anum_pg_attrdef_adrelid,
BTEqualStrategyNumber, F_INT2EQ,
Int16GetDatum(attnum));
- scan = systable_beginscan(attrdef_rel, AttrDefaultIndex, true,
+ scan = systable_beginscan(attrdef_rel, AttrDefaultIndexId, true,
SnapshotNow, 2, scankeys);
/* There should be at most one matching tuple, but we loop anyway */
{
ObjectAddress object;
- object.classId = RelationGetRelid(attrdef_rel);
+ object.classId = AttrDefaultRelationId;
object.objectId = HeapTupleGetOid(tuple);
object.objectSubId = 0;
AttrNumber myattnum;
/* Grab an appropriate lock on the pg_attrdef relation */
- attrdef_rel = heap_openr(AttrDefaultRelationName, RowExclusiveLock);
+ attrdef_rel = heap_open(AttrDefaultRelationId, RowExclusiveLock);
/* Find the pg_attrdef tuple */
ScanKeyInit(&scankeys[0],
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(attrdefId));
- scan = systable_beginscan(attrdef_rel, AttrDefaultOidIndex, true,
+ scan = systable_beginscan(attrdef_rel, AttrDefaultOidIndexId, true,
SnapshotNow, 1, scankeys);
tuple = systable_getnext(scan);
heap_close(attrdef_rel, RowExclusiveLock);
/* Fix the pg_attribute row */
- attr_rel = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attr_rel = heap_open(AttributeRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopy(ATTNUM,
ObjectIdGetDatum(myrelid),
values[Anum_pg_attrdef_adsrc - 1] = DirectFunctionCall1(textin,
CStringGetDatum(adsrc));
- adrel = heap_openr(AttrDefaultRelationName, RowExclusiveLock);
+ adrel = heap_open(AttrDefaultRelationId, RowExclusiveLock);
tuple = heap_formtuple(adrel->rd_att, values, nulls);
attrdefOid = simple_heap_insert(adrel, tuple);
CatalogUpdateIndexes(adrel, tuple);
- defobject.classId = RelationGetRelid(adrel);
+ defobject.classId = AttrDefaultRelationId;
defobject.objectId = attrdefOid;
defobject.objectSubId = 0;
* Update the pg_attribute entry for the column to show that a default
* exists.
*/
- attrrel = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attrrel = heap_open(AttributeRelationId, RowExclusiveLock);
atttup = SearchSysCacheCopy(ATTNUM,
ObjectIdGetDatum(RelationGetRelid(rel)),
Int16GetDatum(attnum),
HeapTuple reltup;
Form_pg_class relStruct;
- relrel = heap_openr(RelationRelationName, RowExclusiveLock);
+ relrel = heap_open(RelationRelationId, RowExclusiveLock);
reltup = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(RelationGetRelid(rel)),
0, 0, 0);
HeapTuple contup;
/* Grab an appropriate lock on the pg_constraint relation */
- conrel = heap_openr(ConstraintRelationName, RowExclusiveLock);
+ conrel = heap_open(ConstraintRelationId, RowExclusiveLock);
/* Use the index to scan only constraints of the target relation */
ScanKeyInit(&key[0],
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(RelationGetRelid(rel)));
- conscan = systable_beginscan(conrel, ConstraintRelidIndex, true,
+ conscan = systable_beginscan(conrel, ConstraintRelidIndexId, true,
SnapshotNow, 1, key);
/*
{
ObjectAddress conobj;
- conobj.classId = RelationGetRelid(conrel);
+ conobj.classId = ConstraintRelationId;
conobj.objectId = HeapTupleGetOid(contup);
conobj.objectSubId = 0;
int nkeys;
HeapTuple tuple;
- pgstatistic = heap_openr(StatisticRelationName, RowExclusiveLock);
+ pgstatistic = heap_open(StatisticRelationId, RowExclusiveLock);
ScanKeyInit(&key[0],
Anum_pg_statistic_starelid,
nkeys = 2;
}
- scan = systable_beginscan(pgstatistic, StatisticRelidAttnumIndex, true,
+ scan = systable_beginscan(pgstatistic, StatisticRelidAttnumIndexId, true,
SnapshotNow, nkeys, key);
while (HeapTupleIsValid(tuple = systable_getnext(scan)))
* Otherwise, must scan pg_constraint. Right now, it is a seqscan
* because there is no available index on confrelid.
*/
- fkeyRel = heap_openr(ConstraintRelationName, AccessShareLock);
+ fkeyRel = heap_open(ConstraintRelationId, AccessShareLock);
- fkeyScan = systable_beginscan(fkeyRel, NULL, false,
+ fkeyScan = systable_beginscan(fkeyRel, InvalidOid, false,
SnapshotNow, 0, NULL);
while (HeapTupleIsValid(tuple = systable_getnext(fkeyScan)))
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/index.c,v 1.251 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/index.c,v 1.252 2005/04/14 20:03:23 tgl Exp $
*
*
* INTERFACE ROUTINES
#include "access/heapam.h"
#include "bootstrap/bootstrap.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/heap.h"
#include "catalog/index.h"
Relation pg_class;
HeapTuple tuple;
- pg_class = heap_openr(RelationRelationName, RowExclusiveLock);
+ pg_class = heap_open(RelationRelationId, RowExclusiveLock);
/* XXX Natts_pg_class_fixed is a hack - see pg_class.h */
tuple = heap_addheader(Natts_pg_class_fixed,
/*
* open the attribute relation and its indexes
*/
- pg_attribute = heap_openr(AttributeRelationName, RowExclusiveLock);
+ pg_attribute = heap_open(AttributeRelationId, RowExclusiveLock);
indstate = CatalogOpenIndexes(pg_attribute);
/*
* open the system catalog index relation
*/
- pg_index = heap_openr(IndexRelationName, RowExclusiveLock);
+ pg_index = heap_open(IndexRelationId, RowExclusiveLock);
/*
* Build a pg_index tuple
NULL,
NULL);
- referenced.classId = get_system_catalog_relid(ConstraintRelationName);
+ referenced.classId = ConstraintRelationId;
referenced.objectId = conOid;
referenced.objectSubId = 0;
}
/* Store dependency on operator classes */
- referenced.classId = get_system_catalog_relid(OperatorClassRelationName);
for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
{
+ referenced.classId = OperatorClassRelationId;
referenced.objectId = classObjectId[i];
referenced.objectSubId = 0;
/*
* fix INDEX relation, and check for expressional index
*/
- indexRelation = heap_openr(IndexRelationName, RowExclusiveLock);
+ indexRelation = heap_open(IndexRelationId, RowExclusiveLock);
tuple = SearchSysCache(INDEXRELID,
ObjectIdGetDatum(indexId),
* use heap_update, so cheat and overwrite the tuple in-place. In
* normal processing, make a copy to scribble on.
*/
- pg_class = heap_openr(RelationRelationName, RowExclusiveLock);
+ pg_class = heap_open(RelationRelationId, RowExclusiveLock);
if (!IsBootstrapProcessingMode())
{
* Find the pg_class tuple for the given relation. This is not used
* during bootstrap, so okay to use heap_update always.
*/
- pg_class = heap_openr(RelationRelationName, RowExclusiveLock);
+ pg_class = heap_open(RelationRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(RelationGetRelid(relation)),
* case the stats updates will not be WAL-logged and so could be lost
* in a crash. This seems OK considering VACUUM does the same thing.
*/
- pg_class = heap_openr(RelationRelationName, RowExclusiveLock);
+ pg_class = heap_open(RelationRelationId, RowExclusiveLock);
in_place_upd = IsBootstrapProcessingMode() ||
- ReindexIsProcessingHeap(RelationGetRelid(pg_class));
+ ReindexIsProcessingHeap(RelationRelationId);
if (!in_place_upd)
{
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/namespace.c,v 1.74 2005/03/29 00:16:56 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/namespace.c,v 1.75 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/xact.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/namespace.h"
#include "catalog/pg_conversion.h"
* be a waste of cycles). We do this by finding everything that has a
* dependency on the namespace.
*/
- object.classId = get_system_catalog_relid(NamespaceRelationName);
+ object.classId = NamespaceRelationId;
object.objectId = tempNamespaceId;
object.objectSubId = 0;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_aggregate.c,v 1.74 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_aggregate.c,v 1.75 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/pg_aggregate.h"
#include "catalog/pg_language.h"
+#include "catalog/pg_operator.h"
#include "catalog/pg_proc.h"
#include "miscadmin.h"
#include "optimizer/cost.h"
else
nulls[Anum_pg_aggregate_agginitval - 1] = 'n';
- aggdesc = heap_openr(AggregateRelationName, RowExclusiveLock);
+ aggdesc = heap_open(AggregateRelationId, RowExclusiveLock);
tupDesc = aggdesc->rd_att;
tup = heap_formtuple(tupDesc, values, nulls);
/* Depends on sort operator, if any */
if (OidIsValid(sortop))
{
- referenced.classId = get_system_catalog_relid(OperatorRelationName);
+ referenced.classId = OperatorRelationId;
referenced.objectId = sortop;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_constraint.c,v 1.24 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_constraint.c,v 1.25 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "access/genam.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_depend.h"
+#include "catalog/pg_trigger.h"
#include "catalog/pg_type.h"
#include "commands/defrem.h"
#include "miscadmin.h"
int i;
ObjectAddress conobject;
- conDesc = heap_openr(ConstraintRelationName, RowExclusiveLock);
+ conDesc = heap_open(ConstraintRelationId, RowExclusiveLock);
Assert(constraintName);
namestrcpy(&cname, constraintName);
/* update catalog indexes */
CatalogUpdateIndexes(conDesc, tup);
- conobject.classId = RelationGetRelid(conDesc);
+ conobject.classId = ConstraintRelationId;
conobject.objectId = conOid;
conobject.objectSubId = 0;
ScanKeyData skey[2];
HeapTuple tup;
- conDesc = heap_openr(ConstraintRelationName, AccessShareLock);
+ conDesc = heap_open(ConstraintRelationId, AccessShareLock);
found = false;
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(objNamespace));
- conscan = systable_beginscan(conDesc, ConstraintNameNspIndex, true,
+ conscan = systable_beginscan(conDesc, ConstraintNameNspIndexId, true,
SnapshotNow, 2, skey);
while (HeapTupleIsValid(tup = systable_getnext(conscan)))
bool found;
ListCell *l;
- conDesc = heap_openr(ConstraintRelationName, AccessShareLock);
+ conDesc = heap_open(ConstraintRelationId, AccessShareLock);
/* try the unmodified label first */
StrNCpy(modlabel, label, sizeof(modlabel));
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(namespace));
- conscan = systable_beginscan(conDesc, ConstraintNameNspIndex, true,
+ conscan = systable_beginscan(conDesc, ConstraintNameNspIndexId, true,
SnapshotNow, 2, skey);
found = (HeapTupleIsValid(systable_getnext(conscan)));
HeapTuple tup;
Form_pg_constraint con;
- conDesc = heap_openr(ConstraintRelationName, RowExclusiveLock);
+ conDesc = heap_open(ConstraintRelationId, RowExclusiveLock);
ScanKeyInit(&skey[0],
ObjectIdAttributeNumber,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(conId));
- conscan = systable_beginscan(conDesc, ConstraintOidIndex, true,
+ conscan = systable_beginscan(conDesc, ConstraintOidIndexId, true,
SnapshotNow, 1, skey);
tup = systable_getnext(conscan);
HeapTuple relTup;
Form_pg_class classForm;
- pgrel = heap_openr(RelationRelationName, RowExclusiveLock);
+ pgrel = heap_open(RelationRelationId, RowExclusiveLock);
relTup = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(con->conrelid),
0, 0, 0);
{
char *result;
Oid constraintId = InvalidOid;
- Oid pg_trigger_id;
- Oid pg_constraint_id;
Relation depRel;
Relation conRel;
ScanKeyData key[2];
SysScanDesc scan;
HeapTuple tup;
- pg_trigger_id = get_system_catalog_relid(TriggerRelationName);
- pg_constraint_id = get_system_catalog_relid(ConstraintRelationName);
-
/*
* We must grovel through pg_depend to find the owning constraint.
* Perhaps pg_trigger should have a column for the owning constraint ...
* but right now this is not performance-critical code.
*/
- depRel = heap_openr(DependRelationName, AccessShareLock);
+ depRel = heap_open(DependRelationId, AccessShareLock);
ScanKeyInit(&key[0],
Anum_pg_depend_classid,
BTEqualStrategyNumber, F_OIDEQ,
- ObjectIdGetDatum(pg_trigger_id));
+ ObjectIdGetDatum(TriggerRelationId));
ScanKeyInit(&key[1],
Anum_pg_depend_objid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(triggerId));
/* assume we can ignore objsubid for a trigger */
- scan = systable_beginscan(depRel, DependDependerIndex, true,
+ scan = systable_beginscan(depRel, DependDependerIndexId, true,
SnapshotNow, 2, key);
while (HeapTupleIsValid(tup = systable_getnext(scan)))
{
Form_pg_depend foundDep = (Form_pg_depend) GETSTRUCT(tup);
- if (foundDep->refclassid == pg_constraint_id &&
+ if (foundDep->refclassid == ConstraintRelationId &&
foundDep->deptype == DEPENDENCY_INTERNAL)
{
constraintId = foundDep->refobjid;
if (!OidIsValid(constraintId))
return NULL; /* no owning constraint found */
- conRel = heap_openr(ConstraintRelationName, AccessShareLock);
+ conRel = heap_open(ConstraintRelationId, AccessShareLock);
ScanKeyInit(&key[0],
ObjectIdAttributeNumber,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(constraintId));
- scan = systable_beginscan(conRel, ConstraintOidIndex, true,
+ scan = systable_beginscan(conRel, ConstraintOidIndexId, true,
SnapshotNow, 1, key);
tup = systable_getnext(scan);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_conversion.c,v 1.21 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_conversion.c,v 1.22 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/pg_conversion.h"
}
/* open pg_conversion */
- rel = heap_openr(ConversionRelationName, RowExclusiveLock);
+ rel = heap_open(ConversionRelationId, RowExclusiveLock);
tupDesc = rel->rd_att;
/* initialize nulls and values */
/* update the index if any */
CatalogUpdateIndexes(rel, tup);
- myself.classId = RelationGetRelid(rel);
+ myself.classId = ConversionRelationId;
myself.objectId = HeapTupleGetOid(tup);
myself.objectSubId = 0;
/*
* Do the deletion
*/
- object.classId = get_system_catalog_relid(ConversionRelationName);
+ object.classId = ConversionRelationId;
object.objectId = conversionOid;
object.objectSubId = 0;
ObjectIdGetDatum(conversionOid));
/* open pg_conversion */
- rel = heap_openr(ConversionRelationName, RowExclusiveLock);
+ rel = heap_open(ConversionRelationId, RowExclusiveLock);
tupDesc = rel->rd_att;
scan = heap_beginscan(rel, SnapshotNow,
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_depend.c,v 1.12 2004/12/31 21:59:38 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_depend.c,v 1.13 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/dependency.h"
#include "catalog/pg_depend.h"
if (IsBootstrapProcessingMode())
return;
- dependDesc = heap_openr(DependRelationName, RowExclusiveLock);
+ dependDesc = heap_open(DependRelationId, RowExclusiveLock);
/* Don't open indexes unless we need to make an update */
indstate = NULL;
SysScanDesc scan;
HeapTuple tup;
- depRel = heap_openr(DependRelationName, RowExclusiveLock);
+ depRel = heap_open(DependRelationId, RowExclusiveLock);
ScanKeyInit(&key[0],
Anum_pg_depend_classid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(objectId));
- scan = systable_beginscan(depRel, DependDependerIndex, true,
+ scan = systable_beginscan(depRel, DependDependerIndexId, true,
SnapshotNow, 2, key);
while (HeapTupleIsValid(tup = systable_getnext(scan)))
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
- scan = systable_beginscan(rel, DependReferenceIndex, true,
+ scan = systable_beginscan(rel, DependReferenceIndexId, true,
SnapshotNow, 2, key);
/*
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_largeobject.c,v 1.23 2005/02/23 23:27:54 neilc Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_largeobject.c,v 1.24 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/pg_largeobject.h"
#include "miscadmin.h"
char nulls[Natts_pg_largeobject];
int i;
- pg_largeobject = heap_openr(LargeObjectRelationName, RowExclusiveLock);
+ pg_largeobject = heap_open(LargeObjectRelationId, RowExclusiveLock);
/*
* Form new tuple
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(loid));
- pg_largeobject = heap_openr(LargeObjectRelationName, RowExclusiveLock);
+ pg_largeobject = heap_open(LargeObjectRelationId, RowExclusiveLock);
- sd = systable_beginscan(pg_largeobject, LargeObjectLOidPNIndex, true,
+ sd = systable_beginscan(pg_largeobject, LargeObjectLOidPNIndexId, true,
SnapshotNow, 1, skey);
while ((tuple = systable_getnext(sd)) != NULL)
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(loid));
- pg_largeobject = heap_openr(LargeObjectRelationName, AccessShareLock);
+ pg_largeobject = heap_open(LargeObjectRelationId, AccessShareLock);
- sd = systable_beginscan(pg_largeobject, LargeObjectLOidPNIndex, true,
+ sd = systable_beginscan(pg_largeobject, LargeObjectLOidPNIndexId, true,
SnapshotNow, 1, skey);
if (systable_getnext(sd) != NULL)
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_namespace.c,v 1.12 2004/12/31 21:59:38 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_namespace.c,v 1.13 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/pg_namespace.h"
#include "utils/builtins.h"
values[Anum_pg_namespace_nspowner - 1] = Int32GetDatum(ownerSysId);
nulls[Anum_pg_namespace_nspacl - 1] = 'n';
- nspdesc = heap_openr(NamespaceRelationName, RowExclusiveLock);
+ nspdesc = heap_open(NamespaceRelationId, RowExclusiveLock);
tupDesc = nspdesc->rd_att;
tup = heap_formtuple(tupDesc, values, nulls);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_operator.c,v 1.90 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_operator.c,v 1.91 2005/04/14 20:03:23 tgl Exp $
*
* NOTES
* these routines moved here from commands/define.c and somewhat cleaned up.
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
+#include "catalog/pg_namespace.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
Oid leftTypeId, Oid rightTypeId,
bool isCommutator);
-static void makeOperatorDependencies(HeapTuple tuple, Oid pg_operator_relid);
+static void makeOperatorDependencies(HeapTuple tuple);
/*
/*
* open pg_operator
*/
- pg_operator_desc = heap_openr(OperatorRelationName, RowExclusiveLock);
+ pg_operator_desc = heap_open(OperatorRelationId, RowExclusiveLock);
tupDesc = pg_operator_desc->rd_att;
/*
CatalogUpdateIndexes(pg_operator_desc, tup);
/* Add dependencies for the entry */
- makeOperatorDependencies(tup, RelationGetRelid(pg_operator_desc));
+ makeOperatorDependencies(tup);
heap_freetuple(tup);
values[i++] = ObjectIdGetDatum(restOid); /* oprrest */
values[i++] = ObjectIdGetDatum(joinOid); /* oprjoin */
- pg_operator_desc = heap_openr(OperatorRelationName, RowExclusiveLock);
+ pg_operator_desc = heap_open(OperatorRelationId, RowExclusiveLock);
/*
* If we are adding to an operator shell, update; else insert
CatalogUpdateIndexes(pg_operator_desc, tup);
/* Add dependencies for the entry */
- makeOperatorDependencies(tup, RelationGetRelid(pg_operator_desc));
+ makeOperatorDependencies(tup);
heap_close(pg_operator_desc, RowExclusiveLock);
*/
CommandCounterIncrement();
- pg_operator_desc = heap_openr(OperatorRelationName, RowExclusiveLock);
+ pg_operator_desc = heap_open(OperatorRelationId, RowExclusiveLock);
tup = SearchSysCacheCopy(OPEROID,
ObjectIdGetDatum(commId),
* the given operator is a shell.
*/
static void
-makeOperatorDependencies(HeapTuple tuple, Oid pg_operator_relid)
+makeOperatorDependencies(HeapTuple tuple)
{
Form_pg_operator oper = (Form_pg_operator) GETSTRUCT(tuple);
ObjectAddress myself,
referenced;
- myself.classId = pg_operator_relid;
+ myself.classId = OperatorRelationId;
myself.objectId = HeapTupleGetOid(tuple);
myself.objectSubId = 0;
/* Dependency on namespace */
if (OidIsValid(oper->oprnamespace))
{
- referenced.classId = get_system_catalog_relid(NamespaceRelationName);
+ referenced.classId = NamespaceRelationId;
referenced.objectId = oper->oprnamespace;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_proc.c,v 1.127 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_proc.c,v 1.128 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
+#include "catalog/pg_language.h"
+#include "catalog/pg_namespace.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "executor/functions.h"
/* start out with empty permissions */
nulls[Anum_pg_proc_proacl - 1] = 'n';
- rel = heap_openr(ProcedureRelationName, RowExclusiveLock);
+ rel = heap_open(ProcedureRelationId, RowExclusiveLock);
tupDesc = RelationGetDescr(rel);
/* Check for pre-existing definition */
myself.objectSubId = 0;
/* dependency on namespace */
- referenced.classId = get_system_catalog_relid(NamespaceRelationName);
+ referenced.classId = NamespaceRelationId;
referenced.objectId = procNamespace;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
/* dependency on implementation language */
- referenced.classId = get_system_catalog_relid(LanguageRelationName);
+ referenced.classId = LanguageRelationId;
referenced.objectId = languageObjectId;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/catalog/pg_type.c,v 1.99 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/catalog/pg_type.c,v 1.100 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
+#include "catalog/pg_namespace.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "miscadmin.h"
/*
* open pg_type
*/
- pg_type_desc = heap_openr(TypeRelationName, RowExclusiveLock);
+ pg_type_desc = heap_open(TypeRelationId, RowExclusiveLock);
tupDesc = pg_type_desc->rd_att;
/*
* NOTE: updating will not work correctly in bootstrap mode; but we don't
* expect to be overwriting any shell types in bootstrap mode.
*/
- pg_type_desc = heap_openr(TypeRelationName, RowExclusiveLock);
+ pg_type_desc = heap_open(TypeRelationId, RowExclusiveLock);
tup = SearchSysCacheCopy(TYPENAMENSP,
CStringGetDatum(typeName),
/* skip for relation rowtype, since we have indirect dependency */
if (!OidIsValid(relationOid))
{
- referenced.classId = get_system_catalog_relid(NamespaceRelationName);
+ referenced.classId = NamespaceRelationId;
referenced.objectId = typeNamespace;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
Relation pg_type_desc;
HeapTuple tuple;
- pg_type_desc = heap_openr(TypeRelationName, RowExclusiveLock);
+ pg_type_desc = heap_open(TypeRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopy(TYPENAMENSP,
CStringGetDatum(oldTypeName),
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/aggregatecmds.c,v 1.25 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/aggregatecmds.c,v 1.26 2005/04/14 20:03:23 tgl Exp $
*
* DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
else
basetypeOid = ANYOID;
- rel = heap_openr(ProcedureRelationName, RowExclusiveLock);
+ rel = heap_open(ProcedureRelationId, RowExclusiveLock);
procOid = find_aggregate_func(name, basetypeOid, false);
else
basetypeOid = ANYOID;
- rel = heap_openr(ProcedureRelationName, RowExclusiveLock);
+ rel = heap_open(ProcedureRelationId, RowExclusiveLock);
procOid = find_aggregate_func(name, basetypeOid, false);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/analyze.c,v 1.84 2005/03/21 01:24:02 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/analyze.c,v 1.85 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "access/tuptoaster.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/index.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
/*
* We can ANALYZE any table except pg_statistic. See update_attstats
*/
- if (IsSystemNamespace(RelationGetNamespace(onerel)) &&
- strcmp(RelationGetRelationName(onerel), StatisticRelationName) == 0)
+ if (RelationGetRelid(onerel) == StatisticRelationId)
{
relation_close(onerel, AccessShareLock);
return;
if (natts <= 0)
return; /* nothing to do */
- sd = heap_openr(StatisticRelationName, RowExclusiveLock);
+ sd = heap_open(StatisticRelationId, RowExclusiveLock);
for (attno = 0; attno < natts; attno++)
{
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/async.c,v 1.120 2005/03/20 23:40:24 neilc Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/async.c,v 1.121 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/pg_listener.h"
#include "commands/async.h"
#include "libpq/libpq.h"
if (Trace_notify)
elog(DEBUG1, "Async_Listen(%s,%d)", relname, pid);
- lRel = heap_openr(ListenerRelationName, ExclusiveLock);
+ lRel = heap_open(ListenerRelationId, ExclusiveLock);
/* Detect whether we are already listening on this relname */
scan = heap_beginscan(lRel, SnapshotNow, 0, NULL);
if (Trace_notify)
elog(DEBUG1, "Async_Unlisten(%s,%d)", relname, pid);
- lRel = heap_openr(ListenerRelationName, ExclusiveLock);
+ lRel = heap_open(ListenerRelationId, ExclusiveLock);
scan = heap_beginscan(lRel, SnapshotNow, 0, NULL);
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
if (Trace_notify)
elog(DEBUG1, "Async_UnlistenAll");
- lRel = heap_openr(ListenerRelationName, ExclusiveLock);
+ lRel = heap_open(ListenerRelationId, ExclusiveLock);
tdesc = RelationGetDescr(lRel);
/* Find and delete all entries with my listenerPID */
value[0] = value[1] = value[2] = (Datum) 0;
value[Anum_pg_listener_notify - 1] = Int32GetDatum(MyProcPid);
- lRel = heap_openr(ListenerRelationName, ExclusiveLock);
+ lRel = heap_open(ListenerRelationId, ExclusiveLock);
tdesc = RelationGetDescr(lRel);
scan = heap_beginscan(lRel, SnapshotNow, 0, NULL);
StartTransactionCommand();
- lRel = heap_openr(ListenerRelationName, ExclusiveLock);
+ lRel = heap_open(ListenerRelationId, ExclusiveLock);
tdesc = RelationGetDescr(lRel);
/* Scan only entries with my listenerPID */
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/cluster.c,v 1.135 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/cluster.c,v 1.136 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/heap.h"
#include "catalog/index.h"
/*
* Check each index of the relation and set/clear the bit as needed.
*/
- pg_index = heap_openr(IndexRelationName, RowExclusiveLock);
+ pg_index = heap_open(IndexRelationId, RowExclusiveLock);
foreach(index, RelationGetIndexList(rel))
{
CatalogIndexState indstate;
/* We need writable copies of both pg_class tuples. */
- relRelation = heap_openr(RelationRelationName, RowExclusiveLock);
+ relRelation = heap_open(RelationRelationId, RowExclusiveLock);
reltup1 = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(r1),
* ever have indisclustered set, because CLUSTER will refuse to set it
* when called with one of them as argument.
*/
- indRelation = relation_openr(IndexRelationName, AccessShareLock);
+ indRelation = heap_open(IndexRelationId, AccessShareLock);
ScanKeyInit(&entry,
Anum_pg_index_indisclustered,
BTEqualStrategyNumber, F_BOOLEQ,
* Copyright (c) 1996-2005, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/comment.c,v 1.82 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/comment.c,v 1.83 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
+#include "catalog/pg_cast.h"
#include "catalog/pg_constraint.h"
+#include "catalog/pg_conversion.h"
#include "catalog/pg_database.h"
#include "catalog/pg_description.h"
+#include "catalog/pg_language.h"
#include "catalog/pg_largeobject.h"
+#include "catalog/pg_namespace.h"
+#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_rewrite.h"
BTEqualStrategyNumber, F_INT4EQ,
Int32GetDatum(subid));
- description = heap_openr(DescriptionRelationName, RowExclusiveLock);
+ description = heap_open(DescriptionRelationId, RowExclusiveLock);
- sd = systable_beginscan(description, DescriptionObjIndex, true,
+ sd = systable_beginscan(description, DescriptionObjIndexId, true,
SnapshotNow, 3, skey);
while ((oldtuple = systable_getnext(sd)) != NULL)
else
nkeys = 2;
- description = heap_openr(DescriptionRelationName, RowExclusiveLock);
+ description = heap_open(DescriptionRelationId, RowExclusiveLock);
- sd = systable_beginscan(description, DescriptionObjIndex, true,
+ sd = systable_beginscan(description, DescriptionObjIndexId, true,
SnapshotNow, nkeys, skey);
while ((oldtuple = systable_getnext(sd)) != NULL)
}
/* Create the comment using the relation's oid */
-
- CreateComments(RelationGetRelid(relation), RelationRelationId, 0, comment);
+ CreateComments(RelationGetRelid(relation), RelationRelationId,
+ 0, comment);
/* Done, but hold lock until commit */
relation_close(relation, NoLock);
attrname, RelationGetRelationName(relation))));
/* Create the comment using the relation's oid */
-
CreateComments(RelationGetRelid(relation), RelationRelationId,
(int32) attnum, comment);
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_DATABASE,
database);
- /* Create the comment with the pg_database oid */
+ /* Call CreateComments() to create/drop the comments */
CreateComments(oid, DatabaseRelationId, 0, comment);
}
CommentNamespace(List *qualname, char *comment)
{
Oid oid;
- Oid classoid;
char *namespace;
if (list_length(qualname) != 1)
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_NAMESPACE,
namespace);
- /* pg_namespace doesn't have a hard-coded OID, so must look it up */
- classoid = get_system_catalog_relid(NamespaceRelationName);
-
/* Call CreateComments() to create/drop the comments */
- CreateComments(oid, classoid, 0, comment);
+ CreateComments(oid, NamespaceRelationId, 0, comment);
}
/*
HeapTuple tuple;
Oid reloid;
Oid ruleoid;
- Oid classoid;
AclResult aclcheck;
/* Separate relname and trig name */
BTEqualStrategyNumber, F_NAMEEQ,
PointerGetDatum(rulename));
- RewriteRelation = heap_openr(RewriteRelationName, AccessShareLock);
+ RewriteRelation = heap_open(RewriteRelationId, AccessShareLock);
scanDesc = heap_beginscan(RewriteRelation, SnapshotNow,
1, &scanKeyData);
aclcheck_error(aclcheck, ACL_KIND_CLASS,
get_rel_name(reloid));
- /* pg_rewrite doesn't have a hard-coded OID, so must look it up */
- classoid = get_system_catalog_relid(RewriteRelationName);
-
/* Call CreateComments() to create/drop the comments */
- CreateComments(ruleoid, classoid, 0, comment);
+ CreateComments(ruleoid, RewriteRelationId, 0, comment);
heap_close(relation, NoLock);
}
TypeNameToString(tname));
/* Call CreateComments() to create/drop the comments */
-
CreateComments(oid, TypeRelationId, 0, comment);
}
NameListToString(aggregate));
/* Call CreateComments() to create/drop the comments */
-
CreateComments(oid, ProcedureRelationId, 0, comment);
}
NameListToString(function));
/* Call CreateComments() to create/drop the comments */
-
CreateComments(oid, ProcedureRelationId, 0, comment);
}
TypeName *typenode1 = (TypeName *) linitial(arguments);
TypeName *typenode2 = (TypeName *) lsecond(arguments);
Oid oid;
- Oid classoid;
/* Look up the operator */
oid = LookupOperNameTypeNames(opername, typenode1, typenode2, false);
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_OPER,
NameListToString(opername));
- /* pg_operator doesn't have a hard-coded OID, so must look it up */
- classoid = get_system_catalog_relid(OperatorRelationName);
-
/* Call CreateComments() to create/drop the comments */
- CreateComments(oid, classoid, 0, comment);
+ CreateComments(oid, OperatorRelationId, 0, comment);
}
/*
* Fetch the trigger tuple from pg_trigger. There can be only one
* because of the unique index.
*/
- pg_trigger = heap_openr(TriggerRelationName, AccessShareLock);
+ pg_trigger = heap_open(TriggerRelationId, AccessShareLock);
ScanKeyInit(&entry[0],
Anum_pg_trigger_tgrelid,
BTEqualStrategyNumber, F_OIDEQ,
Anum_pg_trigger_tgname,
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(trigname));
- scan = systable_beginscan(pg_trigger, TriggerRelidNameIndex, true,
+ scan = systable_beginscan(pg_trigger, TriggerRelidNameIndexId, true,
SnapshotNow, 2, entry);
triggertuple = systable_getnext(scan);
systable_endscan(scan);
- /* Create the comment with the pg_trigger oid */
-
- CreateComments(oid, RelationGetRelid(pg_trigger), 0, comment);
+ /* Call CreateComments() to create/drop the comments */
+ CreateComments(oid, TriggerRelationId, 0, comment);
/* Done, but hold lock on relation */
* than one match, because constraints are not required to have unique
* names; if so, error out.
*/
- pg_constraint = heap_openr(ConstraintRelationName, AccessShareLock);
+ pg_constraint = heap_open(ConstraintRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
Anum_pg_constraint_conrelid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(RelationGetRelid(relation)));
- scan = systable_beginscan(pg_constraint, ConstraintRelidIndex, true,
+ scan = systable_beginscan(pg_constraint, ConstraintRelidIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tuple = systable_getnext(scan)))
errmsg("constraint \"%s\" for table \"%s\" does not exist",
conName, RelationGetRelationName(relation))));
- /* Create the comment with the pg_constraint oid */
- CreateComments(conOid, RelationGetRelid(pg_constraint), 0, comment);
+ /* Call CreateComments() to create/drop the comments */
+ CreateComments(conOid, ConstraintRelationId, 0, comment);
/* Done, but hold lock on relation */
heap_close(pg_constraint, AccessShareLock);
CommentConversion(List *qualname, char *comment)
{
Oid conversionOid;
- Oid classoid;
conversionOid = FindConversionByName(qualname);
if (!OidIsValid(conversionOid))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CONVERSION,
NameListToString(qualname));
- /* pg_conversion doesn't have a hard-coded OID, so must look it up */
- classoid = get_system_catalog_relid(ConversionRelationName);
-
/* Call CreateComments() to create/drop the comments */
- CreateComments(conversionOid, classoid, 0, comment);
+ CreateComments(conversionOid, ConversionRelationId, 0, comment);
}
/*
CommentLanguage(List *qualname, char *comment)
{
Oid oid;
- Oid classoid;
char *language;
if (list_length(qualname) != 1)
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("must be superuser to comment on procedural language")));
- /* pg_language doesn't have a hard-coded OID, so must look it up */
- classoid = get_system_catalog_relid(LanguageRelationName);
-
/* Call CreateComments() to create/drop the comments */
- CreateComments(oid, classoid, 0, comment);
+ CreateComments(oid, LanguageRelationId, 0, comment);
}
/*
char *opcname;
Oid amID;
Oid opcID;
- Oid classoid;
HeapTuple tuple;
Assert(list_length(arguments) == 1);
ReleaseSysCache(tuple);
- /* pg_opclass doesn't have a hard-coded OID, so must look it up */
- classoid = get_system_catalog_relid(OperatorClassRelationName);
-
/* Call CreateComments() to create/drop the comments */
- CreateComments(opcID, classoid, 0, comment);
+ CreateComments(opcID, OperatorClassRelationId, 0, comment);
}
/*
CommentLargeObject(List *qualname, char *comment)
{
Oid loid;
- Oid classoid;
Node *node;
Assert(list_length(qualname) == 1);
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("large object %u does not exist", loid)));
- /* pg_largeobject doesn't have a hard-coded OID, so must look it up */
- classoid = get_system_catalog_relid(LargeObjectRelationName);
-
/* Call CreateComments() to create/drop the comments */
- CreateComments(loid, classoid, 0, comment);
+ CreateComments(loid, LargeObjectRelationId, 0, comment);
}
/*
Oid targettypeid;
HeapTuple tuple;
Oid castOid;
- Oid classoid;
Assert(list_length(qualname) == 1);
sourcetype = (TypeName *) linitial(qualname);
ReleaseSysCache(tuple);
- /* pg_cast doesn't have a hard-coded OID, so must look it up */
- classoid = get_system_catalog_relid(CastRelationName);
-
/* Call CreateComments() to create/drop the comments */
- CreateComments(castOid, classoid, 0, comment);
+ CreateComments(castOid, CastRelationId, 0, comment);
}
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/conversioncmds.c,v 1.16 2004/12/31 21:59:41 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/conversioncmds.c,v 1.17 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/pg_conversion.h"
#include "access/heapam.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/pg_type.h"
Relation rel;
AclResult aclresult;
- rel = heap_openr(ConversionRelationName, RowExclusiveLock);
+ rel = heap_open(ConversionRelationId, RowExclusiveLock);
conversionOid = FindConversionByName(name);
if (!OidIsValid(conversionOid))
Relation rel;
Form_pg_conversion convForm;
- rel = heap_openr(ConversionRelationName, RowExclusiveLock);
+ rel = heap_open(ConversionRelationId, RowExclusiveLock);
conversionOid = FindConversionByName(name);
if (!OidIsValid(conversionOid))
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/copy.c,v 1.239 2005/03/25 21:57:57 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/copy.c,v 1.240 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
#include "access/printtup.h"
-#include "catalog/catname.h"
#include "catalog/index.h"
#include "catalog/namespace.h"
#include "catalog/pg_index.h"
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/dbcommands.c,v 1.155 2005/03/23 00:03:28 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/dbcommands.c,v 1.156 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/catalog.h"
#include "catalog/pg_database.h"
#include "catalog/pg_shadow.h"
* Iterate through all tablespaces of the template database, and copy
* each one to the new database.
*/
- rel = heap_openr(TableSpaceRelationName, AccessShareLock);
+ rel = heap_open(TableSpaceRelationId, AccessShareLock);
scan = heap_beginscan(rel, SnapshotNow, 0, NULL);
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
/*
* Now OK to grab exclusive lock on pg_database.
*/
- pg_database_rel = heap_openr(DatabaseRelationName, ExclusiveLock);
+ pg_database_rel = heap_open(DatabaseRelationId, ExclusiveLock);
/* Check to see if someone else created same DB name meanwhile. */
if (get_db_info(dbname, NULL, NULL, NULL,
* since ReverifyMyDatabase takes RowShareLock. This allows ordinary
* readers of pg_database to proceed in parallel.
*/
- pgdbrel = heap_openr(DatabaseRelationName, ExclusiveLock);
+ pgdbrel = heap_open(DatabaseRelationId, ExclusiveLock);
if (!get_db_info(dbname, &db_id, &db_owner, NULL,
&db_istemplate, NULL, NULL, NULL, NULL, NULL))
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(db_id));
- pgdbscan = systable_beginscan(pgdbrel, DatabaseOidIndex, true,
+ pgdbscan = systable_beginscan(pgdbrel, DatabaseOidIndexId, true,
SnapshotNow, 1, &key);
tup = systable_getnext(pgdbscan);
* NOTE: this is probably dead code since any such comments should have
* been in that database, not mine.
*/
- DeleteComments(db_id, RelationGetRelid(pgdbrel), 0);
+ DeleteComments(db_id, DatabaseRelationId, 0);
/*
* Drop pages for this database that are in the shared buffer cache.
* Obtain ExclusiveLock so that no new session gets started
* while the rename is in progress.
*/
- rel = heap_openr(DatabaseRelationName, ExclusiveLock);
+ rel = heap_open(DatabaseRelationId, ExclusiveLock);
ScanKeyInit(&key,
Anum_pg_database_datname,
BTEqualStrategyNumber, F_NAMEEQ,
NameGetDatum(oldname));
- scan = systable_beginscan(rel, DatabaseNameIndex, true,
+ scan = systable_beginscan(rel, DatabaseNameIndexId, true,
SnapshotNow, 1, &key);
tup = systable_getnext(scan);
Anum_pg_database_datname,
BTEqualStrategyNumber, F_NAMEEQ,
NameGetDatum(newname));
- scan2 = systable_beginscan(rel, DatabaseNameIndex, true,
+ scan2 = systable_beginscan(rel, DatabaseNameIndexId, true,
SnapshotNow, 1, &key2);
if (HeapTupleIsValid(systable_getnext(scan2)))
ereport(ERROR,
* We don't need ExclusiveLock since we aren't updating the
* flat file.
*/
- rel = heap_openr(DatabaseRelationName, RowExclusiveLock);
+ rel = heap_open(DatabaseRelationId, RowExclusiveLock);
ScanKeyInit(&scankey,
Anum_pg_database_datname,
BTEqualStrategyNumber, F_NAMEEQ,
NameGetDatum(stmt->dbname));
- scan = systable_beginscan(rel, DatabaseNameIndex, true,
+ scan = systable_beginscan(rel, DatabaseNameIndexId, true,
SnapshotNow, 1, &scankey);
tuple = systable_getnext(scan);
if (!HeapTupleIsValid(tuple))
* We don't need ExclusiveLock since we aren't updating the
* flat file.
*/
- rel = heap_openr(DatabaseRelationName, RowExclusiveLock);
+ rel = heap_open(DatabaseRelationId, RowExclusiveLock);
ScanKeyInit(&scankey,
Anum_pg_database_datname,
BTEqualStrategyNumber, F_NAMEEQ,
NameGetDatum(dbname));
- scan = systable_beginscan(rel, DatabaseNameIndex, true,
+ scan = systable_beginscan(rel, DatabaseNameIndexId, true,
SnapshotNow, 1, &scankey);
tuple = systable_getnext(scan);
if (!HeapTupleIsValid(tuple))
AssertArg(name);
/* Caller may wish to grab a better lock on pg_database beforehand... */
- relation = heap_openr(DatabaseRelationName, AccessShareLock);
+ relation = heap_open(DatabaseRelationId, AccessShareLock);
ScanKeyInit(&scanKey,
Anum_pg_database_datname,
BTEqualStrategyNumber, F_NAMEEQ,
NameGetDatum(name));
- scan = systable_beginscan(relation, DatabaseNameIndex, true,
+ scan = systable_beginscan(relation, DatabaseNameIndexId, true,
SnapshotNow, 1, &scanKey);
tuple = systable_getnext(scan);
HeapScanDesc scan;
HeapTuple tuple;
- rel = heap_openr(TableSpaceRelationName, AccessShareLock);
+ rel = heap_open(TableSpaceRelationId, AccessShareLock);
scan = heap_beginscan(rel, SnapshotNow, 0, NULL);
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
Oid oid;
/* There's no syscache for pg_database, so must look the hard way */
- pg_database = heap_openr(DatabaseRelationName, AccessShareLock);
+ pg_database = heap_open(DatabaseRelationId, AccessShareLock);
ScanKeyInit(&entry[0],
Anum_pg_database_datname,
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(dbname));
- scan = systable_beginscan(pg_database, DatabaseNameIndex, true,
+ scan = systable_beginscan(pg_database, DatabaseNameIndexId, true,
SnapshotNow, 1, entry);
dbtuple = systable_getnext(scan);
char *result;
/* There's no syscache for pg_database, so must look the hard way */
- pg_database = heap_openr(DatabaseRelationName, AccessShareLock);
+ pg_database = heap_open(DatabaseRelationId, AccessShareLock);
ScanKeyInit(&entry[0],
ObjectIdAttributeNumber,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(dbid));
- scan = systable_beginscan(pg_database, DatabaseOidIndex, true,
+ scan = systable_beginscan(pg_database, DatabaseOidIndexId, true,
SnapshotNow, 1, entry);
dbtuple = systable_getnext(scan);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/functioncmds.c,v 1.60 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/functioncmds.c,v 1.61 2005/04/14 20:03:23 tgl Exp $
*
* DESCRIPTION
* These routines take the parse tree and pick out the
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
+#include "catalog/pg_aggregate.h"
#include "catalog/pg_cast.h"
#include "catalog/pg_language.h"
#include "catalog/pg_proc.h"
/*
* Delete the pg_proc tuple.
*/
- relation = heap_openr(ProcedureRelationName, RowExclusiveLock);
+ relation = heap_open(ProcedureRelationId, RowExclusiveLock);
tup = SearchSysCache(PROCOID,
ObjectIdGetDatum(funcOid),
*/
if (isagg)
{
- relation = heap_openr(AggregateRelationName, RowExclusiveLock);
+ relation = heap_open(AggregateRelationId, RowExclusiveLock);
tup = SearchSysCache(AGGFNOID,
ObjectIdGetDatum(funcOid),
Relation rel;
AclResult aclresult;
- rel = heap_openr(ProcedureRelationName, RowExclusiveLock);
+ rel = heap_open(ProcedureRelationId, RowExclusiveLock);
procOid = LookupFuncNameTypeNames(name, argtypes, false);
Form_pg_proc procForm;
Relation rel;
- rel = heap_openr(ProcedureRelationName, RowExclusiveLock);
+ rel = heap_open(ProcedureRelationId, RowExclusiveLock);
procOid = LookupFuncNameTypeNames(name, argtypes, false);
DefElem *strict_item = NULL;
DefElem *security_def_item = NULL;
- rel = heap_openr(ProcedureRelationName, RowExclusiveLock);
+ rel = heap_open(ProcedureRelationId, RowExclusiveLock);
funcOid = LookupFuncNameTypeNames(stmt->func->funcname,
stmt->func->funcargs,
HeapTuple tup;
Form_pg_proc procForm;
- pg_proc_rel = heap_openr(ProcedureRelationName, RowExclusiveLock);
+ pg_proc_rel = heap_open(ProcedureRelationId, RowExclusiveLock);
tup = SearchSysCacheCopy(PROCOID,
ObjectIdGetDatum(funcOid),
HeapTuple tup;
Form_pg_proc procForm;
- pg_proc_rel = heap_openr(ProcedureRelationName, RowExclusiveLock);
+ pg_proc_rel = heap_open(ProcedureRelationId, RowExclusiveLock);
tup = SearchSysCacheCopy(PROCOID,
ObjectIdGetDatum(funcOid),
break;
}
- relation = heap_openr(CastRelationName, RowExclusiveLock);
+ relation = heap_open(CastRelationId, RowExclusiveLock);
/*
* Check for duplicate. This is just to give a friendly error
CatalogUpdateIndexes(relation, tuple);
/* make dependency entries */
- myself.classId = RelationGetRelid(relation);
+ myself.classId = CastRelationId;
myself.objectId = HeapTupleGetOid(tuple);
myself.objectSubId = 0;
/*
* Do the deletion
*/
- object.classId = get_system_catalog_relid(CastRelationName);
+ object.classId = CastRelationId;
object.objectId = HeapTupleGetOid(tuple);
object.objectSubId = 0;
SysScanDesc scan;
HeapTuple tuple;
- relation = heap_openr(CastRelationName, RowExclusiveLock);
+ relation = heap_open(CastRelationId, RowExclusiveLock);
ScanKeyInit(&scankey,
ObjectIdAttributeNumber,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(castOid));
- scan = systable_beginscan(relation, CastOidIndex, true,
+ scan = systable_beginscan(relation, CastOidIndexId, true,
SnapshotNow, 1, &scankey);
tuple = systable_getnext(scan);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/indexcmds.c,v 1.129 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/indexcmds.c,v 1.130 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/heap.h"
#include "catalog/index.h"
* We only consider plain relations here (toast rels will be processed
* indirectly by reindex_relation).
*/
- relationRelation = heap_openr(RelationRelationName, AccessShareLock);
+ relationRelation = heap_open(RelationRelationId, AccessShareLock);
scan = heap_beginscan(relationRelation, SnapshotNow, 0, NULL);
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/opclasscmds.c,v 1.31 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/opclasscmds.c,v 1.32 2005/04/14 20:03:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/pg_am.h"
#include "catalog/pg_amop.h"
#include "catalog/pg_amproc.h"
+#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_proc.h"
}
}
- rel = heap_openr(OperatorClassRelationName, RowExclusiveLock);
+ rel = heap_open(OperatorClassRelationId, RowExclusiveLock);
/*
* Make sure there is no existing opclass of this name (this is just
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(amoid));
- scan = systable_beginscan(rel, OpclassAmNameNspIndex, true,
+ scan = systable_beginscan(rel, OpclassAmNameNspIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tup = systable_getnext(scan)))
* Create dependencies. Note: we do not create a dependency link to
* the AM, because we don't currently support DROP ACCESS METHOD.
*/
- myself.classId = RelationGetRelid(rel);
+ myself.classId = OperatorClassRelationId;
myself.objectId = opclassoid;
myself.objectSubId = 0;
/* dependency on namespace */
- referenced.classId = get_system_catalog_relid(NamespaceRelationName);
+ referenced.classId = NamespaceRelationId;
referenced.objectId = namespaceoid;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* dependencies on operators */
- referenced.classId = get_system_catalog_relid(OperatorRelationName);
foreach(l, operators)
{
OpClassMember *op = (OpClassMember *) lfirst(l);
+ referenced.classId = OperatorRelationId;
referenced.objectId = op->object;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
ListCell *l;
int i;
- rel = heap_openr(AccessMethodOperatorRelationName, RowExclusiveLock);
+ rel = heap_open(AccessMethodOperatorRelationId, RowExclusiveLock);
foreach(l, operators)
{
ListCell *l;
int i;
- rel = heap_openr(AccessMethodProcedureRelationName, RowExclusiveLock);
+ rel = heap_open(AccessMethodProcedureRelationId, RowExclusiveLock);
foreach(l, procedures)
{
/*
* Do the deletion
*/
- object.classId = get_system_catalog_relid(OperatorClassRelationName);
+ object.classId = OperatorClassRelationId;
object.objectId = opcID;
object.objectSubId = 0;
/*
* First remove the pg_opclass entry itself.
*/
- rel = heap_openr(OperatorClassRelationName, RowExclusiveLock);
+ rel = heap_open(OperatorClassRelationId, RowExclusiveLock);
tup = SearchSysCache(CLAOID,
ObjectIdGetDatum(opclassOid),
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(opclassOid));
- rel = heap_openr(AccessMethodOperatorRelationName, RowExclusiveLock);
+ rel = heap_open(AccessMethodOperatorRelationId, RowExclusiveLock);
- scan = systable_beginscan(rel, AccessMethodStrategyIndex, true,
+ scan = systable_beginscan(rel, AccessMethodStrategyIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tup = systable_getnext(scan)))
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(opclassOid));
- rel = heap_openr(AccessMethodProcedureRelationName, RowExclusiveLock);
+ rel = heap_open(AccessMethodProcedureRelationId, RowExclusiveLock);
- scan = systable_beginscan(rel, AccessMethodProcedureIndex, true,
+ scan = systable_beginscan(rel, AccessMethodProcedureIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tup = systable_getnext(scan)))
errmsg("access method \"%s\" does not exist",
access_method)));
- rel = heap_openr(OperatorClassRelationName, RowExclusiveLock);
+ rel = heap_open(OperatorClassRelationId, RowExclusiveLock);
/*
* Look up the opclass
errmsg("access method \"%s\" does not exist",
access_method)));
- rel = heap_openr(OperatorClassRelationName, RowExclusiveLock);
+ rel = heap_open(OperatorClassRelationId, RowExclusiveLock);
/*
* Look up the opclass
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/operatorcmds.c,v 1.20 2004/12/31 21:59:41 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/operatorcmds.c,v 1.21 2005/04/14 20:03:24 tgl Exp $
*
* DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
/*
* Do the deletion
*/
- object.classId = get_system_catalog_relid(OperatorRelationName);
+ object.classId = OperatorRelationId;
object.objectId = operOid;
object.objectSubId = 0;
Relation relation;
HeapTuple tup;
- relation = heap_openr(OperatorRelationName, RowExclusiveLock);
+ relation = heap_open(OperatorRelationId, RowExclusiveLock);
tup = SearchSysCache(OPEROID,
ObjectIdGetDatum(operOid),
Relation rel;
Form_pg_operator oprForm;
- rel = heap_openr(OperatorRelationName, RowExclusiveLock);
+ rel = heap_open(OperatorRelationId, RowExclusiveLock);
operOid = LookupOperNameTypeNames(name, typeName1, typeName2,
false);
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/proclang.c,v 1.59 2005/04/14 01:38:16 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/proclang.c,v 1.60 2005/04/14 20:03:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
values[i++] = ObjectIdGetDatum(valProcOid); /* lanvalidator */
nulls[i] = 'n'; /* lanacl */
- rel = heap_openr(LanguageRelationName, RowExclusiveLock);
+ rel = heap_open(LanguageRelationId, RowExclusiveLock);
tupDesc = rel->rd_att;
tup = heap_formtuple(tupDesc, values, nulls);
/*
* Create dependencies for language
*/
- myself.classId = RelationGetRelid(rel);
+ myself.classId = LanguageRelationId;
myself.objectId = HeapTupleGetOid(tup);
myself.objectSubId = 0;
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("language \"%s\" does not exist", languageName)));
- object.classId = get_system_catalog_relid(LanguageRelationName);
+ object.classId = LanguageRelationId;
object.objectId = HeapTupleGetOid(langTup);
object.objectSubId = 0;
Relation rel;
HeapTuple langTup;
- rel = heap_openr(LanguageRelationName, RowExclusiveLock);
+ rel = heap_open(LanguageRelationId, RowExclusiveLock);
langTup = SearchSysCache(LANGOID,
ObjectIdGetDatum(langOid),
HeapTuple tup;
Relation rel;
- rel = heap_openr(LanguageRelationName, RowExclusiveLock);
+ rel = heap_open(LanguageRelationId, RowExclusiveLock);
tup = SearchSysCacheCopy(LANGNAME,
CStringGetDatum(oldname),
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/schemacmds.c,v 1.28 2005/01/27 23:23:55 neilc Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/schemacmds.c,v 1.29 2005/04/14 20:03:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
* Do the deletion. Objects contained in the schema are removed by
* means of their dependency links to the schema.
*/
- object.classId = get_system_catalog_relid(NamespaceRelationName);
+ object.classId = NamespaceRelationId;
object.objectId = namespaceId;
object.objectSubId = 0;
Relation relation;
HeapTuple tup;
- relation = heap_openr(NamespaceRelationName, RowExclusiveLock);
+ relation = heap_open(NamespaceRelationId, RowExclusiveLock);
tup = SearchSysCache(NAMESPACEOID,
ObjectIdGetDatum(schemaOid),
Relation rel;
AclResult aclresult;
- rel = heap_openr(NamespaceRelationName, RowExclusiveLock);
+ rel = heap_open(NamespaceRelationId, RowExclusiveLock);
tup = SearchSysCacheCopy(NAMESPACENAME,
CStringGetDatum(oldname),
Relation rel;
Form_pg_namespace nspForm;
- rel = heap_openr(NamespaceRelationName, RowExclusiveLock);
+ rel = heap_open(NamespaceRelationId, RowExclusiveLock);
tup = SearchSysCache(NAMESPACENAME,
CStringGetDatum(name),
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.154 2005/04/14 01:38:17 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/tablecmds.c,v 1.155 2005/04/14 20:03:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/tuptoaster.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/heap.h"
#include "catalog/index.h"
* and then entered into pg_ipl. Since that catalog doesn't exist
* anymore, there's no need to look for indirect ancestors.)
*/
- relation = heap_openr(InheritsRelationName, RowExclusiveLock);
+ relation = heap_open(InheritsRelationId, RowExclusiveLock);
desc = RelationGetDescr(relation);
seqNumber = 1;
* If the tuple already has the right relhassubclass setting, we don't
* need to update it, but we still need to issue an SI inval message.
*/
- relationRelation = heap_openr(RelationRelationName, RowExclusiveLock);
+ relationRelation = heap_open(RelationRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(relationId),
0, 0, 0);
oldattname)));
}
- attrelation = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attrelation = heap_open(AttributeRelationId, RowExclusiveLock);
atttup = SearchSysCacheCopyAttName(myrelid, oldattname);
if (!HeapTupleIsValid(atttup))
* Find relation's pg_class tuple, and make sure newrelname isn't in
* use.
*/
- relrelation = heap_openr(RelationRelationName, RowExclusiveLock);
+ relrelation = heap_open(RelationRelationId, RowExclusiveLock);
reltup = SearchSysCacheCopy(RELOID,
PointerGetDatum(myrelid),
char nulls[Natts_pg_trigger];
char replaces[Natts_pg_trigger];
- tgrel = heap_openr(TriggerRelationName, RowExclusiveLock);
+ tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
if (fk_scan)
{
ScanKeyInit(&skey[0],
Anum_pg_trigger_tgconstrrelid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(relid));
- trigscan = systable_beginscan(tgrel, TriggerConstrRelidIndex,
+ trigscan = systable_beginscan(tgrel, TriggerConstrRelidIndexId,
true, SnapshotNow,
1, skey);
}
Anum_pg_trigger_tgrelid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(relid));
- trigscan = systable_beginscan(tgrel, TriggerRelidNameIndex,
+ trigscan = systable_beginscan(tgrel, TriggerRelidNameIndexId,
true, SnapshotNow,
1, skey);
}
* We scan pg_depend to find those things that depend on the rowtype.
* (We assume we can ignore refobjsubid for a rowtype.)
*/
- depRel = relation_openr(DependRelationName, AccessShareLock);
+ depRel = heap_open(DependRelationId, AccessShareLock);
ScanKeyInit(&key[0],
Anum_pg_depend_refclassid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(typeOid));
- depScan = systable_beginscan(depRel, DependReferenceIndex, true,
+ depScan = systable_beginscan(depRel, DependReferenceIndexId, true,
SnapshotNow, 2, key);
while (HeapTupleIsValid(depTup = systable_getnext(depScan)))
Form_pg_type tform;
Expr *defval;
- attrdesc = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attrdesc = heap_open(AttributeRelationId, RowExclusiveLock);
/*
* Are we adding the column to a recursion child? If so, check
}
}
- pgclass = heap_openr(RelationRelationName, RowExclusiveLock);
+ pgclass = heap_open(RelationRelationId, RowExclusiveLock);
reltup = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(myrelid),
/*
* lookup the attribute
*/
- attr_rel = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attr_rel = heap_open(AttributeRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopyAttName(RelationGetRelid(rel), colName);
/*
* lookup the attribute
*/
- attr_rel = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attr_rel = heap_open(AttributeRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopyAttName(RelationGetRelid(rel), colName);
newtarget)));
}
- attrelation = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attrelation = heap_open(AttributeRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopyAttName(RelationGetRelid(rel), colName);
newstorage = 0; /* keep compiler quiet */
}
- attrelation = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attrelation = heap_open(AttributeRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopyAttName(RelationGetRelid(rel), colName);
Relation attr_rel;
ListCell *child;
- attr_rel = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attr_rel = heap_open(AttributeRelationId, RowExclusiveLock);
foreach(child, children)
{
Oid childrelid = lfirst_oid(child);
Relation class_rel;
Form_pg_class tuple_class;
- class_rel = heap_openr(RelationRelationName, RowExclusiveLock);
+ class_rel = heap_open(RelationRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(RelationGetRelid(rel)),
/*
* Preset objectAddress fields
*/
- constrobj.classId = get_system_catalog_relid(ConstraintRelationName);
+ constrobj.classId = ConstraintRelationId;
constrobj.objectId = constrOid;
constrobj.objectSubId = 0;
- trigobj.classId = get_system_catalog_relid(TriggerRelationName);
+ trigobj.classId = TriggerRelationId;
trigobj.objectSubId = 0;
/* Make changes-so-far visible */
SysScanDesc scan;
HeapTuple depTup;
- attrelation = heap_openr(AttributeRelationName, RowExclusiveLock);
+ attrelation = heap_open(AttributeRelationId, RowExclusiveLock);
/* Look up the target column */
heapTup = SearchSysCacheCopyAttName(RelationGetRelid(rel), colName);
* index that implements a constraint will not show a direct
* dependency on the column.
*/
- depRel = heap_openr(DependRelationName, RowExclusiveLock);
+ depRel = heap_open(DependRelationId, RowExclusiveLock);
ScanKeyInit(&key[0],
Anum_pg_depend_refclassid,
BTEqualStrategyNumber, F_INT4EQ,
Int32GetDatum((int32) attnum));
- scan = systable_beginscan(depRel, DependReferenceIndex, true,
+ scan = systable_beginscan(depRel, DependReferenceIndexId, true,
SnapshotNow, 3, key);
while (HeapTupleIsValid(depTup = systable_getnext(scan)))
BTEqualStrategyNumber, F_INT4EQ,
Int32GetDatum((int32) attnum));
- scan = systable_beginscan(depRel, DependDependerIndex, true,
+ scan = systable_beginscan(depRel, DependDependerIndexId, true,
SnapshotNow, 3, key);
while (HeapTupleIsValid(depTup = systable_getnext(scan)))
* It should be okay to use DROP_RESTRICT here, since nothing else
* should be depending on these objects.
*/
- if (tab->changedConstraintOids)
- obj.classId = get_system_catalog_relid(ConstraintRelationName);
foreach(l, tab->changedConstraintOids)
{
+ obj.classId = ConstraintRelationId;
obj.objectId = lfirst_oid(l);
obj.objectSubId = 0;
performDeletion(&obj, DROP_RESTRICT);
}
- obj.classId = RelationRelationId;
foreach(l, tab->changedIndexOids)
{
+ obj.classId = RelationRelationId;
obj.objectId = lfirst_oid(l);
obj.objectSubId = 0;
performDeletion(&obj, DROP_RESTRICT);
target_rel = relation_open(relationOid, AccessExclusiveLock);
/* Get its pg_class tuple, too */
- class_rel = heap_openr(RelationRelationName, RowExclusiveLock);
+ class_rel = heap_open(RelationRelationId, RowExclusiveLock);
tuple = SearchSysCache(RELOID,
ObjectIdGetDatum(relationOid),
* SERIAL sequences are those having an internal dependency on one
* of the table's columns (we don't care *which* column, exactly).
*/
- depRel = heap_openr(DependRelationName, AccessShareLock);
+ depRel = heap_open(DependRelationId, AccessShareLock);
ScanKeyInit(&key[0],
Anum_pg_depend_refclassid,
ObjectIdGetDatum(relationOid));
/* we leave refobjsubid unspecified */
- scan = systable_beginscan(depRel, DependReferenceIndex, true,
+ scan = systable_beginscan(depRel, DependReferenceIndexId, true,
SnapshotNow, 2, key);
while (HeapTupleIsValid(tup = systable_getnext(scan)))
reltoastidxid = rel->rd_rel->reltoastidxid;
/* Get a modifiable copy of the relation's pg_class row */
- pg_class = heap_openr(RelationRelationName, RowExclusiveLock);
+ pg_class = heap_open(RelationRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(tableOid),
/*
* Store the toast table's OID in the parent relation's pg_class row
*/
- class_rel = heap_openr(RelationRelationName, RowExclusiveLock);
+ class_rel = heap_open(RelationRelationId, RowExclusiveLock);
reltup = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(relOid),
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/tablespace.c,v 1.16 2005/01/27 23:23:55 neilc Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/tablespace.c,v 1.17 2005/04/14 20:03:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_tablespace.h"
Relation rel;
if (!isRedo)
- rel = heap_openr(TableSpaceRelationName, ExclusiveLock);
+ rel = heap_open(TableSpaceRelationId, ExclusiveLock);
else
rel = NULL;
* is to lock the proposed tablename against other would-be creators.
* The insertion will roll back if we find problems below.
*/
- rel = heap_openr(TableSpaceRelationName, RowExclusiveLock);
+ rel = heap_open(TableSpaceRelationId, RowExclusiveLock);
MemSet(nulls, ' ', Natts_pg_tablespace);
* is trying to do DROP TABLESPACE or TablespaceCreateDbspace
* concurrently.
*/
- rel = heap_openr(TableSpaceRelationName, ExclusiveLock);
+ rel = heap_open(TableSpaceRelationId, ExclusiveLock);
/*
* Find the target tuple
Form_pg_tablespace newform;
/* Search pg_tablespace */
- rel = heap_openr(TableSpaceRelationName, RowExclusiveLock);
+ rel = heap_open(TableSpaceRelationId, RowExclusiveLock);
ScanKeyInit(&entry[0],
Anum_pg_tablespace_spcname,
HeapTuple tup;
/* Search pg_tablespace */
- rel = heap_openr(TableSpaceRelationName, RowExclusiveLock);
+ rel = heap_open(TableSpaceRelationId, RowExclusiveLock);
ScanKeyInit(&entry[0],
Anum_pg_tablespace_spcname,
ScanKeyData entry[1];
/* Search pg_tablespace */
- rel = heap_openr(TableSpaceRelationName, AccessShareLock);
+ rel = heap_open(TableSpaceRelationId, AccessShareLock);
ScanKeyInit(&entry[0],
Anum_pg_tablespace_spcname,
ScanKeyData entry[1];
/* Search pg_tablespace */
- rel = heap_openr(TableSpaceRelationName, AccessShareLock);
+ rel = heap_open(TableSpaceRelationId, AccessShareLock);
ScanKeyInit(&entry[0],
ObjectIdAttributeNumber,
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/trigger.c,v 1.185 2005/04/14 01:38:17 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/trigger.c,v 1.186 2005/04/14 20:03:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "access/xact.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
* NOTE that this is cool only because we have AccessExclusiveLock on the
* relation, so the trigger set won't be changing underneath us.
*/
- tgrel = heap_openr(TriggerRelationName, RowExclusiveLock);
+ tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
ScanKeyInit(&key,
Anum_pg_trigger_tgrelid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(RelationGetRelid(rel)));
- tgscan = systable_beginscan(tgrel, TriggerRelidNameIndex, true,
+ tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
SnapshotNow, 1, &key);
while (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
{
CatalogUpdateIndexes(tgrel, tuple);
- myself.classId = RelationGetRelid(tgrel);
+ myself.classId = TriggerRelationId;
myself.objectId = trigoid;
myself.objectSubId = 0;
* backends (and this one too!) are sent SI message to make them
* rebuild relcache entries.
*/
- pgrel = heap_openr(RelationRelationName, RowExclusiveLock);
+ pgrel = heap_open(RelationRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(RelationGetRelid(rel)),
0, 0, 0);
/*
* Find the trigger, verify permissions, set up object address
*/
- tgrel = heap_openr(TriggerRelationName, AccessShareLock);
+ tgrel = heap_open(TriggerRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
Anum_pg_trigger_tgrelid,
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(trigname));
- tgscan = systable_beginscan(tgrel, TriggerRelidNameIndex, true,
+ tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
SnapshotNow, 2, skey);
tup = systable_getnext(tgscan);
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CLASS,
get_rel_name(relid));
- object.classId = RelationGetRelid(tgrel);
+ object.classId = TriggerRelationId;
object.objectId = HeapTupleGetOid(tup);
object.objectSubId = 0;
HeapTuple tuple;
Form_pg_class classForm;
- tgrel = heap_openr(TriggerRelationName, RowExclusiveLock);
+ tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
/*
* Find the trigger to delete.
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(trigOid));
- tgscan = systable_beginscan(tgrel, TriggerOidIndex, true,
+ tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true,
SnapshotNow, 1, skey);
tup = systable_getnext(tgscan);
* so no one else is creating/deleting triggers on this rel at the
* same time.
*/
- pgrel = heap_openr(RelationRelationName, RowExclusiveLock);
+ pgrel = heap_open(RelationRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(relid),
0, 0, 0);
* NOTE that this is cool only because we have AccessExclusiveLock on the
* relation, so the trigger set won't be changing underneath us.
*/
- tgrel = heap_openr(TriggerRelationName, RowExclusiveLock);
+ tgrel = heap_open(TriggerRelationId, RowExclusiveLock);
/*
* First pass -- look for name conflict
Anum_pg_trigger_tgname,
BTEqualStrategyNumber, F_NAMEEQ,
PointerGetDatum(newname));
- tgscan = systable_beginscan(tgrel, TriggerRelidNameIndex, true,
+ tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
SnapshotNow, 2, key);
if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
ereport(ERROR,
Anum_pg_trigger_tgname,
BTEqualStrategyNumber, F_NAMEEQ,
PointerGetDatum(oldname));
- tgscan = systable_beginscan(tgrel, TriggerRelidNameIndex, true,
+ tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
SnapshotNow, 2, key);
if (HeapTupleIsValid(tuple = systable_getnext(tgscan)))
{
triggers = (Trigger *) palloc(ntrigs * sizeof(Trigger));
/*
- * Note: since we scan the triggers using TriggerRelidNameIndex, we
+ * Note: since we scan the triggers using TriggerRelidNameIndexId, we
* will be reading the triggers in name order, except possibly during
* emergency-recovery operations (ie, IsIgnoringSystemIndexes). This
* in turn ensures that triggers will be fired in name order.
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(RelationGetRelid(relation)));
- tgrel = heap_openr(TriggerRelationName, AccessShareLock);
- tgscan = systable_beginscan(tgrel, TriggerRelidNameIndex, true,
+ tgrel = heap_open(TriggerRelationId, AccessShareLock);
+ tgscan = systable_beginscan(tgrel, TriggerRelidNameIndexId, true,
SnapshotNow, 1, &skey);
while (HeapTupleIsValid(htup = systable_getnext(tgscan)))
* First lookup all trigger Oid's for the constraint names.
* ----------
*/
- tgrel = heap_openr(TriggerRelationName, AccessShareLock);
+ tgrel = heap_open(TriggerRelationId, AccessShareLock);
foreach(l, stmt->constraints)
{
BTEqualStrategyNumber, F_NAMEEQ,
PointerGetDatum(cname));
- tgscan = systable_beginscan(tgrel, TriggerConstrNameIndex, true,
+ tgscan = systable_beginscan(tgrel, TriggerConstrNameIndexId, true,
SnapshotNow, 1, &skey);
/*
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/typecmds.c,v 1.69 2005/04/14 01:38:17 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/typecmds.c,v 1.70 2005/04/14 20:03:24 tgl Exp $
*
* DESCRIPTION
* The "DefineFoo" routines take the parse tree and pick out the
#include "access/heapam.h"
#include "access/genam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/heap.h"
#include "catalog/indexing.h"
Relation relation;
HeapTuple tup;
- relation = heap_openr(TypeRelationName, RowExclusiveLock);
+ relation = heap_open(TypeRelationId, RowExclusiveLock);
tup = SearchSysCache(TYPEOID,
ObjectIdGetDatum(typeOid),
typename->arrayBounds = NIL;
/* Lock the domain in the type table */
- rel = heap_openr(TypeRelationName, RowExclusiveLock);
+ rel = heap_open(TypeRelationId, RowExclusiveLock);
/* Use LookupTypeName here so that shell types can be removed. */
domainoid = LookupTypeName(typename);
typename->arrayBounds = NIL;
/* Lock the type table */
- typrel = heap_openr(TypeRelationName, RowExclusiveLock);
+ typrel = heap_open(TypeRelationId, RowExclusiveLock);
/* Use LookupTypeName here so that shell types can be found (why?). */
domainoid = LookupTypeName(typename);
typename->arrayBounds = NIL;
/* Lock the type table */
- rel = heap_openr(TypeRelationName, RowExclusiveLock);
+ rel = heap_open(TypeRelationId, RowExclusiveLock);
/* Use LookupTypeName here so that shell types can be removed. */
domainoid = LookupTypeName(typename);
domainOwnerCheck(tup, typename);
/* Grab an appropriate lock on the pg_constraint relation */
- conrel = heap_openr(ConstraintRelationName, RowExclusiveLock);
+ conrel = heap_open(ConstraintRelationId, RowExclusiveLock);
/* Use the index to scan only constraints of the target relation */
ScanKeyInit(&key[0],
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(HeapTupleGetOid(tup)));
- conscan = systable_beginscan(conrel, ConstraintTypidIndex, true,
+ conscan = systable_beginscan(conrel, ConstraintTypidIndexId, true,
SnapshotNow, 1, key);
typTup = (Form_pg_type) GETSTRUCT(tup);
{
ObjectAddress conobj;
- conobj.classId = RelationGetRelid(conrel);
+ conobj.classId = ConstraintRelationId;
conobj.objectId = HeapTupleGetOid(contup);
conobj.objectSubId = 0;
typename->arrayBounds = NIL;
/* Lock the type table */
- typrel = heap_openr(TypeRelationName, RowExclusiveLock);
+ typrel = heap_open(TypeRelationId, RowExclusiveLock);
/* Use LookupTypeName here so that shell types can be found (why?). */
domainoid = LookupTypeName(typename);
* We scan pg_depend to find those things that depend on the domain.
* (We assume we can ignore refobjsubid for a domain.)
*/
- depRel = relation_openr(DependRelationName, AccessShareLock);
+ depRel = heap_open(DependRelationId, AccessShareLock);
ScanKeyInit(&key[0],
Anum_pg_depend_refclassid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(domainOid));
- depScan = systable_beginscan(depRel, DependReferenceIndex, true,
+ depScan = systable_beginscan(depRel, DependReferenceIndexId, true,
SnapshotNow, 2, key);
while (HeapTupleIsValid(depTup = systable_getnext(depScan)))
bool notNull = false;
Relation conRel;
- conRel = heap_openr(ConstraintRelationName, AccessShareLock);
+ conRel = heap_open(ConstraintRelationId, AccessShareLock);
for (;;)
{
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(typeOid));
- scan = systable_beginscan(conRel, ConstraintTypidIndex, true,
+ scan = systable_beginscan(conRel, ConstraintTypidIndexId, true,
SnapshotNow, 1, key);
while (HeapTupleIsValid(conTup = systable_getnext(scan)))
typename->arrayBounds = NIL;
/* Lock the type table */
- rel = heap_openr(TypeRelationName, RowExclusiveLock);
+ rel = heap_open(TypeRelationId, RowExclusiveLock);
/* Use LookupTypeName here so that shell types can be processed (why?) */
typeOid = LookupTypeName(typename);
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/backend/commands/user.c,v 1.150 2005/04/14 01:38:17 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/user.c,v 1.151 2005/04/14 20:03:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/pg_database.h"
#include "catalog/pg_group.h"
* to be sure of what the next usesysid should be, and we need to
* protect our eventual update of the flat password file.
*/
- pg_shadow_rel = heap_openr(ShadowRelationName, ExclusiveLock);
+ pg_shadow_rel = heap_open(ShadowRelationId, ExclusiveLock);
pg_shadow_dsc = RelationGetDescr(pg_shadow_rel);
scan = heap_beginscan(pg_shadow_rel, SnapshotNow, 0, NULL);
* secure exclusive lock to protect our update of the flat password
* file.
*/
- pg_shadow_rel = heap_openr(ShadowRelationName, ExclusiveLock);
+ pg_shadow_rel = heap_open(ShadowRelationId, ExclusiveLock);
pg_shadow_dsc = RelationGetDescr(pg_shadow_rel);
tuple = SearchSysCache(SHADOWNAME,
* RowExclusiveLock is sufficient, because we don't need to update the
* flat password file.
*/
- rel = heap_openr(ShadowRelationName, RowExclusiveLock);
+ rel = heap_open(ShadowRelationId, RowExclusiveLock);
oldtuple = SearchSysCache(SHADOWNAME,
PointerGetDatum(stmt->user),
0, 0, 0);
* deleted. Note we secure exclusive lock, because we need to protect
* our update of the flat password file.
*/
- pg_shadow_rel = heap_openr(ShadowRelationName, ExclusiveLock);
+ pg_shadow_rel = heap_open(ShadowRelationId, ExclusiveLock);
pg_shadow_dsc = RelationGetDescr(pg_shadow_rel);
foreach(item, stmt->users)
* don't read the manual, it doesn't seem to be the behaviour one
* would expect either.) -- petere 2000/01/14)
*/
- pg_rel = heap_openr(DatabaseRelationName, AccessShareLock);
+ pg_rel = heap_open(DatabaseRelationId, AccessShareLock);
pg_dsc = RelationGetDescr(pg_rel);
ScanKeyInit(&scankey,
*
* try calling alter group drop user for every group
*/
- pg_rel = heap_openr(GroupRelationName, ExclusiveLock);
+ pg_rel = heap_open(GroupRelationId, ExclusiveLock);
pg_dsc = RelationGetDescr(pg_rel);
scan = heap_beginscan(pg_rel, SnapshotNow, 0, NULL);
while ((tmp_tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
int i;
/* ExclusiveLock because we need to update the password file */
- rel = heap_openr(ShadowRelationName, ExclusiveLock);
+ rel = heap_open(ShadowRelationId, ExclusiveLock);
dsc = RelationGetDescr(rel);
oldtuple = SearchSysCache(SHADOWNAME,
elog(ERROR, "cache lookup failed for relation %u", ShadowRelationId);
if (heap_attisnull(htup, Anum_pg_class_relacl))
+ {
+ Form_pg_class classForm = (Form_pg_class) GETSTRUCT(htup);
+
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
- errmsg("before using passwords you must revoke privileges on %s",
- ShadowRelationName),
+ errmsg("before using passwords you must revoke privileges on %s",
+ NameStr(classForm->relname)),
errdetail("This restriction is to prevent unprivileged users from reading the passwords."),
errhint("Try REVOKE ALL ON \"%s\" FROM PUBLIC.",
- ShadowRelationName)));
+ NameStr(classForm->relname))));
+ }
ReleaseSysCache(htup);
}
* to be sure of what the next grosysid should be, and we need to
* protect our eventual update of the flat group file.
*/
- pg_group_rel = heap_openr(GroupRelationName, ExclusiveLock);
+ pg_group_rel = heap_open(GroupRelationId, ExclusiveLock);
pg_group_dsc = RelationGetDescr(pg_group_rel);
scan = heap_beginscan(pg_group_rel, SnapshotNow, 0, NULL);
/*
* Secure exclusive lock to protect our update of the flat group file.
*/
- pg_group_rel = heap_openr(GroupRelationName, ExclusiveLock);
+ pg_group_rel = heap_open(GroupRelationId, ExclusiveLock);
pg_group_dsc = RelationGetDescr(pg_group_rel);
/*
/*
* Secure exclusive lock to protect our update of the flat group file.
*/
- pg_group_rel = heap_openr(GroupRelationName, ExclusiveLock);
+ pg_group_rel = heap_open(GroupRelationId, ExclusiveLock);
/* Find and delete the group. */
Relation rel;
/* ExclusiveLock because we need to update the flat group file */
- rel = heap_openr(GroupRelationName, ExclusiveLock);
+ rel = heap_open(GroupRelationId, ExclusiveLock);
tup = SearchSysCacheCopy(GRONAME,
CStringGetDatum(oldname),
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/commands/vacuum.c,v 1.305 2005/03/20 22:00:52 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/commands/vacuum.c,v 1.306 2005/04/14 20:03:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/subtrans.h"
#include "access/xlog.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/namespace.h"
#include "catalog/pg_database.h"
#include "catalog/pg_index.h"
BTEqualStrategyNumber, F_CHAREQ,
CharGetDatum(RELKIND_RELATION));
- pgclass = heap_openr(RelationRelationName, AccessShareLock);
+ pgclass = heap_open(RelationRelationId, AccessShareLock);
scan = heap_beginscan(pgclass, SnapshotNow, 1, &key);
/*
* update number of tuples and number of pages in pg_class
*/
- rd = heap_openr(RelationRelationName, RowExclusiveLock);
+ rd = heap_open(RelationRelationId, RowExclusiveLock);
ctup = SearchSysCache(RELOID,
ObjectIdGetDatum(relid),
HeapTuple tuple;
Form_pg_database dbform;
- relation = heap_openr(DatabaseRelationName, RowExclusiveLock);
+ relation = heap_open(DatabaseRelationId, RowExclusiveLock);
/* Must use a heap scan, since there's no syscache for pg_database */
ScanKeyInit(&entry[0],
* Note: the "already wrapped" cases should now be impossible due to the
* defenses in GetNewTransactionId, but we keep them anyway.
*/
- relation = heap_openr(DatabaseRelationName, AccessShareLock);
+ relation = heap_open(DatabaseRelationId, AccessShareLock);
scan = heap_beginscan(relation, SnapshotNow, 0, NULL);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/executor/execUtils.c,v 1.120 2005/04/06 16:34:04 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/executor/execUtils.c,v 1.121 2005/04/14 20:03:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/index.h"
#include "catalog/catalog.h"
#include "catalog/pg_index.h"
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/optimizer/util/plancat.c,v 1.104 2005/04/06 16:34:06 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/optimizer/util/plancat.c,v 1.105 2005/04/14 20:03:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/pg_amop.h"
#include "catalog/pg_inherits.h"
#include "catalog/pg_index.h"
Anum_pg_inherits_inhparent,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(inhparent));
- relation = heap_openr(InheritsRelationName, AccessShareLock);
+ relation = heap_open(InheritsRelationId, AccessShareLock);
scan = heap_beginscan(relation, SnapshotNow, 1, key);
while ((inheritsTuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/backend/parser/analyze.c,v 1.319 2005/04/13 16:50:54 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/parser/analyze.c,v 1.320 2005/04/14 20:03:24 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/heap.h"
#include "catalog/index.h"
#include "catalog/namespace.h"
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.177 2005/03/31 22:46:13 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/parser/parse_func.c,v 1.178 2005/04/14 20:03:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/pg_inherits.h"
#include "catalog/pg_proc.h"
#include "funcapi.h"
queue = list_make1_oid(relid);
visited = NIL;
- inhrel = heap_openr(InheritsRelationName, AccessShareLock);
+ inhrel = heap_open(InheritsRelationId, AccessShareLock);
/*
* Use queue to do a breadth-first traversal of the inheritance graph
*
* Copyright (c) 2001-2005, PostgreSQL Global Development Group
*
- * $PostgreSQL: pgsql/src/backend/postmaster/pgstat.c,v 1.90 2005/04/08 00:55:07 neilc Exp $
+ * $PostgreSQL: pgsql/src/backend/postmaster/pgstat.c,v 1.91 2005/04/14 20:03:25 tgl Exp $
* ----------
*/
#include "postgres.h"
#include "access/heapam.h"
#include "access/xact.h"
-#include "catalog/catname.h"
#include "catalog/pg_database.h"
#include "catalog/pg_shadow.h"
#include "libpq/libpq.h"
dbidused = 0;
dbidlist = (Oid *) palloc(sizeof(Oid) * dbidalloc);
- dbrel = heap_openr(DatabaseRelationName, AccessShareLock);
+ dbrel = heap_open(DatabaseRelationId, AccessShareLock);
dbscan = heap_beginscan(dbrel, SnapshotNow, 0, NULL);
while ((dbtup = heap_getnext(dbscan, ForwardScanDirection)) != NULL)
{
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/rewrite/rewriteDefine.c,v 1.103 2005/04/14 01:38:17 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/rewrite/rewriteDefine.c,v 1.104 2005/04/14 20:03:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/pg_rewrite.h"
/*
* Ready to store new pg_rewrite tuple
*/
- pg_rewrite_desc = heap_openr(RewriteRelationName, RowExclusiveLock);
+ pg_rewrite_desc = heap_open(RewriteRelationId, RowExclusiveLock);
/*
* Check to see if we are replacing an existing tuple
/* If replacing, get rid of old dependencies and make new ones */
if (is_update)
- deleteDependencyRecordsFor(RelationGetRelid(pg_rewrite_desc),
- rewriteObjectId);
+ deleteDependencyRecordsFor(RewriteRelationId, rewriteObjectId);
/*
* Install dependency on rule's relation to ensure it will go away on
Relation pg_rewrite_desc;
HeapTuple ruletup;
- pg_rewrite_desc = heap_openr(RewriteRelationName, RowExclusiveLock);
+ pg_rewrite_desc = heap_open(RewriteRelationId, RowExclusiveLock);
ruletup = SearchSysCacheCopy(RULERELNAME,
ObjectIdGetDatum(owningRel),
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/rewrite/rewriteRemove.c,v 1.61 2004/12/31 22:00:46 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/rewrite/rewriteRemove.c,v 1.62 2005/04/14 20:03:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/pg_rewrite.h"
/*
* Do the deletion
*/
- object.classId = get_system_catalog_relid(RewriteRelationName);
+ object.classId = RewriteRelationId;
object.objectId = HeapTupleGetOid(tuple);
object.objectSubId = 0;
/*
* Open the pg_rewrite relation.
*/
- RewriteRelation = heap_openr(RewriteRelationName, RowExclusiveLock);
+ RewriteRelation = heap_open(RewriteRelationId, RowExclusiveLock);
/*
* Find the tuple for the target rule.
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(ruleOid));
- rcscan = systable_beginscan(RewriteRelation, RewriteOidIndex, true,
+ rcscan = systable_beginscan(RewriteRelation, RewriteOidIndexId, true,
SnapshotNow, 1, skey);
tuple = systable_getnext(rcscan);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/rewrite/rewriteSupport.c,v 1.60 2004/12/31 22:00:46 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/rewrite/rewriteSupport.c,v 1.61 2005/04/14 20:03:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "postgres.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "rewrite/rewriteSupport.h"
#include "utils/inval.h"
* Find the tuple to update in pg_class, using syscache for the
* lookup.
*/
- relationRelation = heap_openr(RelationRelationName, RowExclusiveLock);
+ relationRelation = heap_open(RelationRelationId, RowExclusiveLock);
tuple = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(relationId),
0, 0, 0);
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/storage/large_object/inv_api.c,v 1.109 2005/01/27 23:24:09 neilc Exp $
+ * $PostgreSQL: pgsql/src/backend/storage/large_object/inv_api.c,v 1.110 2005/04/14 20:03:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "access/tuptoaster.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/pg_largeobject.h"
#include "commands/comment.h"
/* Use RowExclusiveLock since we might either read or write */
if (lo_heap_r == NULL)
- lo_heap_r = heap_openr(LargeObjectRelationName, RowExclusiveLock);
+ lo_heap_r = heap_open(LargeObjectRelationId, RowExclusiveLock);
if (lo_index_r == NULL)
- lo_index_r = index_openr(LargeObjectLOidPNIndex);
+ lo_index_r = index_open(LargeObjectLOidPNIndexId);
}
PG_CATCH();
{
int
inv_drop(Oid lobjId)
{
- Oid classoid;
-
LargeObjectDrop(lobjId);
- /* pg_largeobject doesn't have a hard-coded OID, so must look it up */
- classoid = get_system_catalog_relid(LargeObjectRelationName);
-
/* Delete any comments on the large object */
- DeleteComments(lobjId, classoid, 0);
+ DeleteComments(lobjId, LargeObjectRelationId, 0);
/*
* Advance command counter so that tuple removal will be seen by later
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/regproc.c,v 1.93 2005/03/29 00:17:08 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/regproc.c,v 1.94 2005/04/14 20:03:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/genam.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/pg_operator.h"
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(pro_name_or_oid));
- hdesc = heap_openr(ProcedureRelationName, AccessShareLock);
- sysscan = systable_beginscan(hdesc, ProcedureNameArgsNspIndex, true,
+ hdesc = heap_open(ProcedureRelationId, AccessShareLock);
+ sysscan = systable_beginscan(hdesc, ProcedureNameArgsNspIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(opr_name_or_oid));
- hdesc = heap_openr(OperatorRelationName, AccessShareLock);
- sysscan = systable_beginscan(hdesc, OperatorNameNspIndex, true,
+ hdesc = heap_open(OperatorRelationId, AccessShareLock);
+ sysscan = systable_beginscan(hdesc, OperatorNameNspIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(class_name_or_oid));
- hdesc = heap_openr(RelationRelationName, AccessShareLock);
- sysscan = systable_beginscan(hdesc, ClassNameNspIndex, true,
+ hdesc = heap_open(RelationRelationId, AccessShareLock);
+ sysscan = systable_beginscan(hdesc, ClassNameNspIndexId, true,
SnapshotNow, 1, skey);
if (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
BTEqualStrategyNumber, F_NAMEEQ,
CStringGetDatum(typ_name_or_oid));
- hdesc = heap_openr(TypeRelationName, AccessShareLock);
- sysscan = systable_beginscan(hdesc, TypeNameNspIndex, true,
+ hdesc = heap_open(TypeRelationId, AccessShareLock);
+ sysscan = systable_beginscan(hdesc, TypeNameNspIndexId, true,
SnapshotNow, 1, skey);
if (HeapTupleIsValid(tuple = systable_getnext(sysscan)))
* back to source text
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.192 2005/04/14 01:38:19 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/ruleutils.c,v 1.193 2005/04/14 20:03:26 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
#include
#include "access/genam.h"
-#include "catalog/catname.h"
#include "catalog/dependency.h"
#include "catalog/heap.h"
#include "catalog/index.h"
/*
* Fetch the pg_trigger tuple by the Oid of the trigger
*/
- tgrel = heap_openr(TriggerRelationName, AccessShareLock);
+ tgrel = heap_open(TriggerRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
ObjectIdAttributeNumber,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(trigid));
- tgscan = systable_beginscan(tgrel, TriggerOidIndex, true,
+ tgscan = systable_beginscan(tgrel, TriggerOidIndexId, true,
SnapshotNow, 1, skey);
ht_trig = systable_getnext(tgscan);
* Fetch the pg_constraint row. There's no syscache for pg_constraint
* so we must do it the hard way.
*/
- conDesc = heap_openr(ConstraintRelationName, AccessShareLock);
+ conDesc = heap_open(ConstraintRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
ObjectIdAttributeNumber,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(constraintId));
- conscan = systable_beginscan(conDesc, ConstraintOidIndex, true,
+ conscan = systable_beginscan(conDesc, ConstraintOidIndexId, true,
SnapshotNow, 1, skey);
tup = systable_getnext(conscan);
column, tablerv->relname)));
/* Search the dependency table for the dependent sequence */
- depRel = heap_openr(DependRelationName, AccessShareLock);
+ depRel = heap_open(DependRelationId, AccessShareLock);
ScanKeyInit(&key[0],
Anum_pg_depend_refclassid,
BTEqualStrategyNumber, F_INT4EQ,
Int32GetDatum(attnum));
- scan = systable_beginscan(depRel, DependReferenceIndex, true,
+ scan = systable_beginscan(depRel, DependReferenceIndexId, true,
SnapshotNow, 3, key);
while (HeapTupleIsValid(tup = systable_getnext(scan)))
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.176 2005/04/01 20:31:50 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/adt/selfuncs.c,v 1.177 2005/04/14 20:03:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "access/nbtree.h"
#include "access/tuptoaster.h"
-#include "catalog/catname.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/cache/catcache.c,v 1.119 2005/03/25 18:30:27 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/cache/catcache.c,v 1.120 2005/04/14 20:03:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/pg_opclass.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_type.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "miscadmin.h"
#ifdef CATCACHE_STATS
#include "utils/syscache.h"
- /* #define CACHEDEBUG */ /* turns DEBUG elogs on */
+/* #define CACHEDEBUG */ /* turns DEBUG elogs on */
/*
* Constants related to size of the catcache.
{
if (cache->cc_ntup == 0 && cache->cc_searches == 0)
continue; /* don't print unused caches */
- elog(DEBUG2, "catcache %s/%s: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld discards, %ld lsrch, %ld lhits",
+ elog(DEBUG2, "catcache %s/%u: %d tup, %ld srch, %ld+%ld=%ld hits, %ld+%ld=%ld loads, %ld invals, %ld discards, %ld lsrch, %ld lhits",
cache->cc_relname,
- cache->cc_indname,
+ cache->cc_indexoid,
cache->cc_ntup,
cache->cc_searches,
cache->cc_hits,
#ifdef CACHEDEBUG
#define InitCatCache_DEBUG2 \
do { \
- elog(DEBUG2, "InitCatCache: rel=%s id=%d nkeys=%d size=%d", \
- cp->cc_relname, cp->id, cp->cc_nkeys, cp->cc_nbuckets); \
+ elog(DEBUG2, "InitCatCache: rel=%u ind=%u id=%d nkeys=%d size=%d", \
+ cp->cc_reloid, cp->cc_indexoid, cp->id, \
+ cp->cc_nkeys, cp->cc_nbuckets); \
} while(0)
#else
CatCache *
InitCatCache(int id,
- const char *relname,
- const char *indname,
+ Oid reloid,
+ Oid indexoid,
int reloidattr,
int nkeys,
const int *key)
* other internal fields. But don't open the relation yet.
*/
cp->id = id;
- cp->cc_relname = relname;
- cp->cc_indname = indname;
- cp->cc_reloid = InvalidOid; /* temporary */
+ cp->cc_relname = "(not known yet)";
+ cp->cc_reloid = reloid;
+ cp->cc_indexoid = indexoid;
cp->cc_relisshared = false; /* temporary */
cp->cc_tupdesc = (TupleDesc) NULL;
cp->cc_reloidattr = reloidattr;
* that the relcache entry can be opened at this point!
*/
#ifdef CACHEDEBUG
-#define CatalogCacheInitializeCache_DEBUG2 \
- elog(DEBUG2, "CatalogCacheInitializeCache: cache @%p %s", cache, \
- cache->cc_relname)
+#define CatalogCacheInitializeCache_DEBUG1 \
+ elog(DEBUG2, "CatalogCacheInitializeCache: cache @%p rel=%u", cache, \
+ cache->cc_reloid)
#define CatalogCacheInitializeCache_DEBUG2 \
do { \
} while(0)
#else
-#define CatalogCacheInitializeCache_DEBUG2
+#define CatalogCacheInitializeCache_DEBUG1
#define CatalogCacheInitializeCache_DEBUG2
#endif
TupleDesc tupdesc;
int i;
- CatalogCacheInitializeCache_DEBUG2;
+ CatalogCacheInitializeCache_DEBUG1;
/*
* Open the relation without locking --- we only need the tupdesc,
* which we assume will never change ...
*/
- relation = heap_openr(cache->cc_relname, NoLock);
+ relation = heap_open(cache->cc_reloid, NoLock);
Assert(RelationIsValid(relation));
/*
tupdesc = CreateTupleDescCopyConstr(RelationGetDescr(relation));
/*
- * get the relation's OID and relisshared flag, too
+ * save the relation's name and relisshared flag, too (cc_relname
+ * is used only for debugging purposes)
*/
- cache->cc_reloid = RelationGetRelid(relation);
+ cache->cc_relname = pstrdup(RelationGetRelationName(relation));
cache->cc_relisshared = RelationGetForm(relation)->relisshared;
/*
{
Relation idesc;
- idesc = index_openr(cache->cc_indname);
+ idesc = index_open(cache->cc_indexoid);
index_close(idesc);
}
}
relation = heap_open(cache->cc_reloid, AccessShareLock);
scandesc = systable_beginscan(relation,
- cache->cc_indname,
+ cache->cc_indexoid,
IndexScanOK(cache, cur_skey),
SnapshotNow,
cache->cc_nkeys,
* If tuple was not found, we need to build a negative cache entry
* containing a fake tuple. The fake tuple has the correct key
* columns, but nulls everywhere else.
+ *
+ * In bootstrap mode, we don't build negative entries, because the
+ * cache invalidation mechanism isn't alive and can't clear them
+ * if the tuple gets created later. (Bootstrap doesn't do UPDATEs,
+ * so it doesn't need cache inval for that.)
*/
if (ct == NULL)
{
+ if (IsBootstrapProcessingMode())
+ return NULL;
+
ntp = build_dummy_tuple(cache, cache->cc_nkeys, cur_skey);
ct = CatalogCacheCreateEntry(cache, ntp,
hashValue, hashIndex,
relation = heap_open(cache->cc_reloid, AccessShareLock);
scandesc = systable_beginscan(relation,
- cache->cc_indname,
+ cache->cc_indexoid,
true,
SnapshotNow,
nkeys,
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/cache/lsyscache.c,v 1.123 2005/04/11 23:06:56 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/cache/lsyscache.c,v 1.124 2005/04/14 20:03:26 tgl Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
0, 0);
}
-/*
- * get_system_catalog_relid
- * Get the OID of a system catalog identified by name.
- */
-Oid
-get_system_catalog_relid(const char *catname)
-{
- Oid relid;
-
- relid = GetSysCacheOid(RELNAMENSP,
- PointerGetDatum(catname),
- ObjectIdGetDatum(PG_CATALOG_NAMESPACE),
- 0, 0);
- if (!OidIsValid(relid))
- elog(ERROR, "cache lookup failed for system relation %s", catname);
-
- return relid;
-}
-
#ifdef NOT_USED
/*
* get_relnatts
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/cache/relcache.c,v 1.219 2005/04/14 01:38:19 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/cache/relcache.c,v 1.220 2005/04/14 20:03:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* RelationCacheInitialize - initialize relcache
* RelationCacheInitializePhase2 - finish initializing relcache
* RelationIdGetRelation - get a reldesc by relation id
- * RelationSysNameGetRelation - get a reldesc by system rel name
* RelationIdCacheGetRelation - get a cached reldesc by relid
* RelationClose - close an open relation
*
#include "access/genam.h"
#include "access/heapam.h"
#include "catalog/catalog.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
#include "catalog/pg_amop.h"
/*
* Hash tables that index the relation cache
*
- * Relations are looked up two ways, by OID and by name,
- * thus there are two hash tables for referencing them.
- *
- * The OID index covers all relcache entries. The name index
- * covers *only* system relations (only those in PG_CATALOG_NAMESPACE).
+ * We used to index the cache by both name and OID, but now there
+ * is only an index by OID.
*/
+typedef struct relidcacheent
+{
+ Oid reloid;
+ Relation reldesc;
+} RelIdCacheEnt;
+
static HTAB *RelationIdCache;
-static HTAB *RelationSysNameCache;
/*
* This flag is false until we have prepared the critical relcache entries
*/
static bool need_eosubxact_work = false;
-/*
- * RelationBuildDescInfo exists so code can be shared
- * between RelationIdGetRelation() and RelationSysNameGetRelation()
- */
-typedef struct RelationBuildDescInfo
-{
- int infotype; /* lookup by id or by name */
-#define INFO_RELID 1
-#define INFO_RELNAME 2
- union
- {
- Oid info_id; /* relation object id */
- char *info_name; /* system relation name */
- } i;
-} RelationBuildDescInfo;
-
-typedef struct relidcacheent
-{
- Oid reloid;
- Relation reldesc;
-} RelIdCacheEnt;
-
-typedef struct relnamecacheent
-{
- NameData relname;
- Relation reldesc;
-} RelNameCacheEnt;
/*
* macros to manipulate the lookup hashtables
errmsg("out of memory"))); \
/* used to give notice if found -- now just keep quiet */ \
idhentry->reldesc = RELATION; \
- if (IsSystemNamespace(RelationGetNamespace(RELATION))) \
- { \
- char *relname = RelationGetRelationName(RELATION); \
- RelNameCacheEnt *namehentry; \
- namehentry = (RelNameCacheEnt*)hash_search(RelationSysNameCache, \
- relname, \
- HASH_ENTER, \
- &found); \
- if (namehentry == NULL) \
- ereport(ERROR, \
- (errcode(ERRCODE_OUT_OF_MEMORY), \
- errmsg("out of memory"))); \
- /* used to give notice if found -- now just keep quiet */ \
- namehentry->reldesc = RELATION; \
- } \
} while(0)
#define RelationIdCacheLookup(ID, RELATION) \
do { \
RelIdCacheEnt *hentry; \
hentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
- (void *)&(ID), HASH_FIND,NULL); \
- if (hentry) \
- RELATION = hentry->reldesc; \
- else \
- RELATION = NULL; \
-} while(0)
-
-#define RelationSysNameCacheLookup(NAME, RELATION) \
-do { \
- RelNameCacheEnt *hentry; \
- hentry = (RelNameCacheEnt*)hash_search(RelationSysNameCache, \
- (void *) (NAME), HASH_FIND,NULL); \
+ (void *) &(ID), HASH_FIND,NULL); \
if (hentry) \
RELATION = hentry->reldesc; \
else \
do { \
RelIdCacheEnt *idhentry; \
idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
- (void *)&(RELATION->rd_id), \
+ (void *) &(RELATION->rd_id), \
HASH_REMOVE, NULL); \
if (idhentry == NULL) \
elog(WARNING, "trying to delete a rd_id reldesc that does not exist"); \
- if (IsSystemNamespace(RelationGetNamespace(RELATION))) \
- { \
- char *relname = RelationGetRelationName(RELATION); \
- RelNameCacheEnt *namehentry; \
- namehentry = (RelNameCacheEnt*)hash_search(RelationSysNameCache, \
- relname, \
- HASH_REMOVE, NULL); \
- if (namehentry == NULL) \
- elog(WARNING, "trying to delete a relname reldesc that does not exist"); \
- } \
} while(0)
static void RelationReloadClassinfo(Relation relation);
static void RelationFlushRelation(Relation relation);
-static Relation RelationSysNameCacheGetRelation(const char *relationName);
static bool load_relcache_init_file(void);
static void write_relcache_init_file(void);
static void formrdesc(const char *relationName, Oid relationReltype,
bool hasoids, int natts, FormData_pg_attribute *att);
-static HeapTuple ScanPgRelation(RelationBuildDescInfo buildinfo, bool indexOK);
+static HeapTuple ScanPgRelation(Oid targetRelId, bool indexOK);
static Relation AllocateRelationDesc(Relation relation, Form_pg_class relp);
-static void RelationBuildTupleDesc(RelationBuildDescInfo buildinfo,
- Relation relation);
-static Relation RelationBuildDesc(RelationBuildDescInfo buildinfo,
- Relation oldrelation);
+static void RelationBuildTupleDesc(Relation relation);
+static Relation RelationBuildDesc(Oid targetRelId, Relation oldrelation);
static void RelationInitPhysicalAddr(Relation relation);
static TupleDesc GetPgIndexDescriptor(void);
static void AttrDefaultFetch(Relation relation);
* ScanPgRelation
*
* this is used by RelationBuildDesc to find a pg_class
- * tuple matching either a relation name or a relation id
- * as specified in buildinfo.
+ * tuple matching targetRelId.
*
* NB: the returned tuple has been copied into palloc'd storage
* and must eventually be freed with heap_freetuple.
*/
static HeapTuple
-ScanPgRelation(RelationBuildDescInfo buildinfo, bool indexOK)
+ScanPgRelation(Oid targetRelId, bool indexOK)
{
HeapTuple pg_class_tuple;
Relation pg_class_desc;
- const char *indexRelname;
SysScanDesc pg_class_scan;
- ScanKeyData key[2];
- int nkeys;
+ ScanKeyData key[1];
/*
* form a scan key
*/
- switch (buildinfo.infotype)
- {
- case INFO_RELID:
- ScanKeyInit(&key[0],
- ObjectIdAttributeNumber,
- BTEqualStrategyNumber, F_OIDEQ,
- ObjectIdGetDatum(buildinfo.i.info_id));
- nkeys = 1;
- indexRelname = ClassOidIndex;
- break;
-
- case INFO_RELNAME:
- ScanKeyInit(&key[0],
- Anum_pg_class_relname,
- BTEqualStrategyNumber, F_NAMEEQ,
- NameGetDatum(buildinfo.i.info_name));
- ScanKeyInit(&key[1],
- Anum_pg_class_relnamespace,
- BTEqualStrategyNumber, F_OIDEQ,
- ObjectIdGetDatum(PG_CATALOG_NAMESPACE));
- nkeys = 2;
- indexRelname = ClassNameNspIndex;
- break;
-
- default:
- elog(ERROR, "unrecognized buildinfo type: %d",
- buildinfo.infotype);
- return NULL; /* keep compiler quiet */
- }
+ ScanKeyInit(&key[0],
+ ObjectIdAttributeNumber,
+ BTEqualStrategyNumber, F_OIDEQ,
+ ObjectIdGetDatum(targetRelId));
/*
* Open pg_class and fetch a tuple. Force heap scan if we haven't yet
* startup without a pg_internal.init file). The caller can also
* force a heap scan by setting indexOK == false.
*/
- pg_class_desc = heap_openr(RelationRelationName, AccessShareLock);
- pg_class_scan = systable_beginscan(pg_class_desc, indexRelname,
+ pg_class_desc = heap_open(RelationRelationId, AccessShareLock);
+ pg_class_scan = systable_beginscan(pg_class_desc, ClassOidIndexId,
indexOK && criticalRelcachesBuilt,
SnapshotNow,
- nkeys, key);
+ 1, key);
pg_class_tuple = systable_getnext(pg_class_scan);
* the pg_attribute, pg_attrdef & pg_constraint system catalogs.
*/
static void
-RelationBuildTupleDesc(RelationBuildDescInfo buildinfo,
- Relation relation)
+RelationBuildTupleDesc(Relation relation)
{
HeapTuple pg_attribute_tuple;
Relation pg_attribute_desc;
* yet built the critical relcache entries (this includes initdb and
* startup without a pg_internal.init file).
*/
- pg_attribute_desc = heap_openr(AttributeRelationName, AccessShareLock);
+ pg_attribute_desc = heap_open(AttributeRelationId, AccessShareLock);
pg_attribute_scan = systable_beginscan(pg_attribute_desc,
- AttributeRelidNumIndex,
+ AttributeRelidNumIndexId,
criticalRelcachesBuilt,
SnapshotNow,
2, skey);
/*
* open pg_rewrite and begin a scan
*
- * Note: since we scan the rules using RewriteRelRulenameIndex, we will
- * be reading the rules in name order, except possibly during
+ * Note: since we scan the rules using RewriteRelRulenameIndexId,
+ * we will be reading the rules in name order, except possibly during
* emergency-recovery operations (ie, IsIgnoringSystemIndexes). This
* in turn ensures that rules will be fired in name order.
*/
- rewrite_desc = heap_openr(RewriteRelationName, AccessShareLock);
+ rewrite_desc = heap_open(RewriteRelationId, AccessShareLock);
rewrite_tupdesc = RelationGetDescr(rewrite_desc);
rewrite_scan = systable_beginscan(rewrite_desc,
- RewriteRelRulenameIndex,
+ RewriteRelRulenameIndexId,
true, SnapshotNow,
1, &key);
* --------------------------------
*/
static Relation
-RelationBuildDesc(RelationBuildDescInfo buildinfo,
- Relation oldrelation)
+RelationBuildDesc(Oid targetRelId, Relation oldrelation)
{
Relation relation;
Oid relid;
/*
* find the tuple in pg_class corresponding to the given relation id
*/
- pg_class_tuple = ScanPgRelation(buildinfo, true);
+ pg_class_tuple = ScanPgRelation(targetRelId, true);
/*
* if no such tuple exists, return NULL
/*
* initialize the tuple descriptor (relation->rd_att).
*/
- RelationBuildTupleDesc(buildinfo, relation);
+ RelationBuildTupleDesc(relation);
/*
* Fetch rules and triggers that affect this relation
Anum_pg_amop_amopsubtype,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(InvalidOid));
- rel = heap_openr(AccessMethodOperatorRelationName,
- AccessShareLock);
- scan = systable_beginscan(rel, AccessMethodStrategyIndex, indexOK,
+ rel = heap_open(AccessMethodOperatorRelationId, AccessShareLock);
+ scan = systable_beginscan(rel, AccessMethodStrategyIndexId, indexOK,
SnapshotNow, 2, skey);
while (HeapTupleIsValid(htup = systable_getnext(scan)))
Anum_pg_amproc_amprocsubtype,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(InvalidOid));
- rel = heap_openr(AccessMethodProcedureRelationName,
- AccessShareLock);
- scan = systable_beginscan(rel, AccessMethodProcedureIndex, indexOK,
+ rel = heap_open(AccessMethodProcedureRelationId, AccessShareLock);
+ scan = systable_beginscan(rel, AccessMethodProcedureIndexId, indexOK,
SnapshotNow, 2, skey);
while (HeapTupleIsValid(htup = systable_getnext(scan)))
return rd;
}
-/*
- * RelationSysNameCacheGetRelation
- *
- * As above, but lookup by name; only works for system catalogs.
- */
-static Relation
-RelationSysNameCacheGetRelation(const char *relationName)
-{
- Relation rd;
- NameData name;
-
- /*
- * make sure that the name key used for hash lookup is properly
- * null-padded
- */
- namestrcpy(&name, relationName);
- RelationSysNameCacheLookup(NameStr(name), rd);
-
- if (RelationIsValid(rd))
- {
- RelationIncrementReferenceCount(rd);
- /* revalidate nailed index if necessary */
- if (!rd->rd_isvalid)
- RelationReloadClassinfo(rd);
- }
-
- return rd;
-}
-
/*
* RelationIdGetRelation
*
RelationIdGetRelation(Oid relationId)
{
Relation rd;
- RelationBuildDescInfo buildinfo;
/*
* first try and get a reldesc from the cache
* no reldesc in the cache, so have RelationBuildDesc() build one and
* add it.
*/
- buildinfo.infotype = INFO_RELID;
- buildinfo.i.info_id = relationId;
-
- rd = RelationBuildDesc(buildinfo, NULL);
- if (RelationIsValid(rd))
- RelationIncrementReferenceCount(rd);
- return rd;
-}
-
-/*
- * RelationSysNameGetRelation
- *
- * As above, but lookup by name; only works for system catalogs.
- */
-Relation
-RelationSysNameGetRelation(const char *relationName)
-{
- Relation rd;
- RelationBuildDescInfo buildinfo;
-
- /*
- * first try and get a reldesc from the cache
- */
- rd = RelationSysNameCacheGetRelation(relationName);
- if (RelationIsValid(rd))
- return rd;
-
- /*
- * no reldesc in the cache, so have RelationBuildDesc() build one and
- * add it.
- */
- buildinfo.infotype = INFO_RELNAME;
- buildinfo.i.info_name = (char *) relationName;
-
- rd = RelationBuildDesc(buildinfo, NULL);
+ rd = RelationBuildDesc(relationId, NULL);
if (RelationIsValid(rd))
RelationIncrementReferenceCount(rd);
return rd;
static void
RelationReloadClassinfo(Relation relation)
{
- RelationBuildDescInfo buildinfo;
bool indexOK;
HeapTuple pg_class_tuple;
Form_pg_class relp;
/* Should be called only for invalidated nailed indexes */
Assert(relation->rd_isnailed && !relation->rd_isvalid &&
relation->rd_rel->relkind == RELKIND_INDEX);
- /* Read the pg_class row */
- buildinfo.infotype = INFO_RELID;
- buildinfo.i.info_id = relation->rd_id;
-
/*
+ * Read the pg_class row
+ *
* Don't try to use an indexscan of pg_class_oid_index to reload the
* info for pg_class_oid_index ...
*/
- indexOK = strcmp(RelationGetRelationName(relation), ClassOidIndex) != 0;
- pg_class_tuple = ScanPgRelation(buildinfo, indexOK);
+ indexOK = (RelationGetRelid(relation) != ClassOidIndexId);
+ pg_class_tuple = ScanPgRelation(RelationGetRelid(relation), indexOK);
if (!HeapTupleIsValid(pg_class_tuple))
elog(ERROR, "could not find tuple for system relation %u",
- relation->rd_id);
+ RelationGetRelid(relation));
relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
memcpy((char *) relation->rd_rel, (char *) relp, CLASS_TUPLE_SIZE);
/* Now we can recalculate physical address */
* is good because whatever ref counts the entry may have do not
* necessarily belong to that resource owner.
*/
+ Oid save_relid = RelationGetRelid(relation);
int old_refcnt = relation->rd_refcnt;
SubTransactionId old_createSubid = relation->rd_createSubid;
TupleDesc old_att = relation->rd_att;
RuleLock *old_rules = relation->rd_rules;
MemoryContext old_rulescxt = relation->rd_rulescxt;
- RelationBuildDescInfo buildinfo;
- buildinfo.infotype = INFO_RELID;
- buildinfo.i.info_id = RelationGetRelid(relation);
-
- if (RelationBuildDesc(buildinfo, relation) != relation)
+ if (RelationBuildDesc(save_relid, relation) != relation)
{
/* Should only get here if relation was deleted */
flush_rowtype_cache(old_reltype);
if (old_rulescxt)
MemoryContextDelete(old_rulescxt);
pfree(relation);
- elog(ERROR, "relation %u deleted while still in use",
- buildinfo.i.info_id);
+ elog(ERROR, "relation %u deleted while still in use", save_relid);
}
relation->rd_refcnt = old_refcnt;
relation->rd_createSubid = old_createSubid;
if (relation->rd_isnailed &&
relation->rd_rel->relkind == RELKIND_INDEX)
{
- if (strcmp(RelationGetRelationName(relation),
- ClassOidIndex) == 0)
+ if (RelationGetRelid(relation) == ClassOidIndexId)
rebuildFirstList = lcons(relation, rebuildFirstList);
else
rebuildFirstList = lappend(rebuildFirstList, relation);
* create hashtables that index the relcache
*/
MemSet(&ctl, 0, sizeof(ctl));
- ctl.keysize = sizeof(NameData);
- ctl.entrysize = sizeof(RelNameCacheEnt);
- RelationSysNameCache = hash_create("Relcache by name", INITRELCACHESIZE,
- &ctl, HASH_ELEM);
-
ctl.keysize = sizeof(Oid);
ctl.entrysize = sizeof(RelIdCacheEnt);
ctl.hash = tag_hash;
if (IsBootstrapProcessingMode() ||
!load_relcache_init_file())
{
- formrdesc(RelationRelationName, PG_CLASS_RELTYPE_OID,
+ formrdesc("pg_class", PG_CLASS_RELTYPE_OID,
true, Natts_pg_class, Desc_pg_class);
- formrdesc(AttributeRelationName, PG_ATTRIBUTE_RELTYPE_OID,
+ formrdesc("pg_attribute", PG_ATTRIBUTE_RELTYPE_OID,
false, Natts_pg_attribute, Desc_pg_attribute);
- formrdesc(ProcedureRelationName, PG_PROC_RELTYPE_OID,
+ formrdesc("pg_proc", PG_PROC_RELTYPE_OID,
true, Natts_pg_proc, Desc_pg_proc);
- formrdesc(TypeRelationName, PG_TYPE_RELTYPE_OID,
+ formrdesc("pg_type", PG_TYPE_RELTYPE_OID,
true, Natts_pg_type, Desc_pg_type);
#define NUM_CRITICAL_RELS 4 /* fix if you change list above */
*/
if (!criticalRelcachesBuilt)
{
- RelationBuildDescInfo buildinfo;
Relation ird;
-#define LOAD_CRIT_INDEX(indname) \
+#define LOAD_CRIT_INDEX(indexoid) \
do { \
- buildinfo.infotype = INFO_RELNAME; \
- buildinfo.i.info_name = (indname); \
- ird = RelationBuildDesc(buildinfo, NULL); \
+ ird = RelationBuildDesc((indexoid), NULL); \
ird->rd_isnailed = true; \
ird->rd_refcnt = 1; \
} while (0)
- LOAD_CRIT_INDEX(ClassNameNspIndex);
- LOAD_CRIT_INDEX(ClassOidIndex);
- LOAD_CRIT_INDEX(AttributeRelidNumIndex);
- LOAD_CRIT_INDEX(IndexRelidIndex);
- LOAD_CRIT_INDEX(AccessMethodStrategyIndex);
- LOAD_CRIT_INDEX(AccessMethodProcedureIndex);
- LOAD_CRIT_INDEX(OperatorOidIndex);
+ LOAD_CRIT_INDEX(ClassOidIndexId);
+ LOAD_CRIT_INDEX(AttributeRelidNumIndexId);
+ LOAD_CRIT_INDEX(IndexRelidIndexId);
+ LOAD_CRIT_INDEX(AccessMethodStrategyIndexId);
+ LOAD_CRIT_INDEX(AccessMethodProcedureIndexId);
+ LOAD_CRIT_INDEX(OperatorOidIndexId);
-#define NUM_CRITICAL_INDEXES 7 /* fix if you change list above */
+#define NUM_CRITICAL_INDEXES 6 /* fix if you change list above */
criticalRelcachesBuilt = true;
}
* fields of pg_index before we have the standard catalog caches available.
* We use predefined data that's set up in just the same way as the
* bootstrapped reldescs used by formrdesc(). The resulting tupdesc is
- * not 100% kosher: it does not have the correct relation OID in attrelid,
+ * not 100% kosher: it does not have the correct rowtype OID in tdtypeid,
* nor does it have a TupleConstr field. But it's good enough for the
* purpose of extracting fields.
*/
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(RelationGetRelid(relation)));
- adrel = heap_openr(AttrDefaultRelationName, AccessShareLock);
- adscan = systable_beginscan(adrel, AttrDefaultIndex, true,
+ adrel = heap_open(AttrDefaultRelationId, AccessShareLock);
+ adscan = systable_beginscan(adrel, AttrDefaultIndexId, true,
SnapshotNow, 1, &skey);
found = 0;
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(RelationGetRelid(relation)));
- conrel = heap_openr(ConstraintRelationName, AccessShareLock);
- conscan = systable_beginscan(conrel, ConstraintRelidIndex, true,
+ conrel = heap_open(ConstraintRelationId, AccessShareLock);
+ conscan = systable_beginscan(conrel, ConstraintRelidIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(htup = systable_getnext(conscan)))
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(RelationGetRelid(relation)));
- indrel = heap_openr(IndexRelationName, AccessShareLock);
- indscan = systable_beginscan(indrel, IndexIndrelidIndex, true,
+ indrel = heap_open(IndexRelationId, AccessShareLock);
+ indscan = systable_beginscan(indrel, IndexIndrelidIndexId, true,
SnapshotNow, 1, &skey);
while (HeapTupleIsValid(htup = systable_getnext(indscan)))
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/cache/syscache.c,v 1.97 2005/03/29 00:17:12 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/cache/syscache.c,v 1.98 2005/04/14 20:03:26 tgl Exp $
*
* NOTES
* These routines allow the parser/planner/executor to perform
#include "access/heapam.h"
#include "access/transam.h"
#include "utils/builtins.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/pg_aggregate.h"
#include "catalog/pg_amop.h"
Add your entry to the cacheinfo[] array below. All cache lists are
alphabetical, so add it in the proper place. Specify the relation
- name, index name, number of keys, and key attribute numbers. If the
+ OID, index OID, number of keys, and key attribute numbers. If the
relation contains tuples that are associated with a particular relation
(for example, its attributes, rules, triggers, etc) then specify the
attribute number that contains the OID of the associated relation.
There must be a unique index underlying each syscache (ie, an index
whose key is the same as that of the cache). If there is not one
- already, add definitions for it to include/catalog/indexing.h: you
- need a #define for the index name and a DECLARE_UNIQUE_INDEX macro
- with the actual declaration. (This will require a catversion.h update,
- while simply adding/deleting caches only requires a recompile.)
+ already, add definitions for it to include/catalog/indexing.h: you need
+ to add a DECLARE_UNIQUE_INDEX macro and a #define for the index OID.
+ (Adding an index requires a catversion.h update, while simply
+ adding/deleting caches only requires a recompile.)
Finally, any place your relation gets heap_insert() or
- heap_update calls, make sure there is a CatalogUpdateIndexes() or
+ heap_update() calls, make sure there is a CatalogUpdateIndexes() or
similar call. The heap_* calls do not update indexes.
bjm 1999/11/22
- ---------------------------------------------------------------------------
+*---------------------------------------------------------------------------
*/
/*
*/
struct cachedesc
{
- const char *name; /* name of the relation being cached */
- const char *indname; /* name of index relation for this cache */
+ Oid reloid; /* OID of the relation being cached */
+ Oid indoid; /* OID of index relation for this cache */
int reloidattr; /* attr number of rel OID reference, or 0 */
int nkeys; /* # of keys needed for cache lookup */
int key[4]; /* attribute numbers of key attrs */
};
static const struct cachedesc cacheinfo[] = {
- {AggregateRelationName, /* AGGFNOID */
- AggregateFnoidIndex,
+ {AggregateRelationId, /* AGGFNOID */
+ AggregateFnoidIndexId,
0,
1,
{
0,
0
}},
- {AccessMethodRelationName, /* AMNAME */
- AmNameIndex,
+ {AccessMethodRelationId, /* AMNAME */
+ AmNameIndexId,
0,
1,
{
0,
0
}},
- {AccessMethodRelationName, /* AMOID */
- AmOidIndex,
+ {AccessMethodRelationId, /* AMOID */
+ AmOidIndexId,
0,
1,
{
0,
0
}},
- {AccessMethodOperatorRelationName, /* AMOPOPID */
- AccessMethodOperatorIndex,
+ {AccessMethodOperatorRelationId, /* AMOPOPID */
+ AccessMethodOperatorIndexId,
0,
2,
{
0,
0
}},
- {AccessMethodOperatorRelationName, /* AMOPSTRATEGY */
- AccessMethodStrategyIndex,
+ {AccessMethodOperatorRelationId, /* AMOPSTRATEGY */
+ AccessMethodStrategyIndexId,
0,
3,
{
Anum_pg_amop_amopstrategy,
0
}},
- {AccessMethodProcedureRelationName, /* AMPROCNUM */
- AccessMethodProcedureIndex,
+ {AccessMethodProcedureRelationId, /* AMPROCNUM */
+ AccessMethodProcedureIndexId,
0,
3,
{
Anum_pg_amproc_amprocnum,
0
}},
- {AttributeRelationName, /* ATTNAME */
- AttributeRelidNameIndex,
+ {AttributeRelationId, /* ATTNAME */
+ AttributeRelidNameIndexId,
Anum_pg_attribute_attrelid,
2,
{
0,
0
}},
- {AttributeRelationName, /* ATTNUM */
- AttributeRelidNumIndex,
+ {AttributeRelationId, /* ATTNUM */
+ AttributeRelidNumIndexId,
Anum_pg_attribute_attrelid,
2,
{
0
}},
{
- CastRelationName, /* CASTSOURCETARGET */
- CastSourceTargetIndex,
+ CastRelationId, /* CASTSOURCETARGET */
+ CastSourceTargetIndexId,
0,
2,
{
0,
0
}},
- {OperatorClassRelationName, /* CLAAMNAMENSP */
- OpclassAmNameNspIndex,
+ {OperatorClassRelationId, /* CLAAMNAMENSP */
+ OpclassAmNameNspIndexId,
0,
3,
{
Anum_pg_opclass_opcnamespace,
0
}},
- {OperatorClassRelationName, /* CLAOID */
- OpclassOidIndex,
+ {OperatorClassRelationId, /* CLAOID */
+ OpclassOidIndexId,
0,
1,
{
0,
0
}},
- {ConversionRelationName, /* CONDEFAULT */
- ConversionDefaultIndex,
+ {ConversionRelationId, /* CONDEFAULT */
+ ConversionDefaultIndexId,
0,
4,
{
Anum_pg_conversion_contoencoding,
ObjectIdAttributeNumber,
}},
- {ConversionRelationName, /* CONNAMENSP */
- ConversionNameNspIndex,
+ {ConversionRelationId, /* CONNAMENSP */
+ ConversionNameNspIndexId,
0,
2,
{
0,
0
}},
- {ConversionRelationName, /* CONOID */
- ConversionOidIndex,
+ {ConversionRelationId, /* CONOID */
+ ConversionOidIndexId,
0,
1,
{
0,
0
}},
- {GroupRelationName, /* GRONAME */
- GroupNameIndex,
+ {GroupRelationId, /* GRONAME */
+ GroupNameIndexId,
0,
1,
{
0,
0
}},
- {GroupRelationName, /* GROSYSID */
- GroupSysidIndex,
+ {GroupRelationId, /* GROSYSID */
+ GroupSysidIndexId,
0,
1,
{
0,
0
}},
- {IndexRelationName, /* INDEXRELID */
- IndexRelidIndex,
+ {IndexRelationId, /* INDEXRELID */
+ IndexRelidIndexId,
Anum_pg_index_indrelid,
1,
{
0,
0
}},
- {InheritsRelationName, /* INHRELID */
- InheritsRelidSeqnoIndex,
+ {InheritsRelationId, /* INHRELID */
+ InheritsRelidSeqnoIndexId,
Anum_pg_inherits_inhrelid,
2,
{
0,
0
}},
- {LanguageRelationName, /* LANGNAME */
- LanguageNameIndex,
+ {LanguageRelationId, /* LANGNAME */
+ LanguageNameIndexId,
0,
1,
{
0,
0
}},
- {LanguageRelationName, /* LANGOID */
- LanguageOidIndex,
+ {LanguageRelationId, /* LANGOID */
+ LanguageOidIndexId,
0,
1,
{
0,
0
}},
- {NamespaceRelationName, /* NAMESPACENAME */
- NamespaceNameIndex,
+ {NamespaceRelationId, /* NAMESPACENAME */
+ NamespaceNameIndexId,
0,
1,
{
0,
0
}},
- {NamespaceRelationName, /* NAMESPACEOID */
- NamespaceOidIndex,
+ {NamespaceRelationId, /* NAMESPACEOID */
+ NamespaceOidIndexId,
0,
1,
{
0,
0
}},
- {OperatorRelationName, /* OPERNAMENSP */
- OperatorNameNspIndex,
+ {OperatorRelationId, /* OPERNAMENSP */
+ OperatorNameNspIndexId,
0,
4,
{
Anum_pg_operator_oprright,
Anum_pg_operator_oprnamespace
}},
- {OperatorRelationName, /* OPEROID */
- OperatorOidIndex,
+ {OperatorRelationId, /* OPEROID */
+ OperatorOidIndexId,
0,
1,
{
0,
0
}},
- {ProcedureRelationName, /* PROCNAMEARGSNSP */
- ProcedureNameArgsNspIndex,
+ {ProcedureRelationId, /* PROCNAMEARGSNSP */
+ ProcedureNameArgsNspIndexId,
0,
3,
{
Anum_pg_proc_pronamespace,
0
}},
- {ProcedureRelationName, /* PROCOID */
- ProcedureOidIndex,
+ {ProcedureRelationId, /* PROCOID */
+ ProcedureOidIndexId,
0,
1,
{
0,
0
}},
- {RelationRelationName, /* RELNAMENSP */
- ClassNameNspIndex,
+ {RelationRelationId, /* RELNAMENSP */
+ ClassNameNspIndexId,
ObjectIdAttributeNumber,
2,
{
0,
0
}},
- {RelationRelationName, /* RELOID */
- ClassOidIndex,
+ {RelationRelationId, /* RELOID */
+ ClassOidIndexId,
ObjectIdAttributeNumber,
1,
{
0,
0
}},
- {RewriteRelationName, /* RULERELNAME */
- RewriteRelRulenameIndex,
+ {RewriteRelationId, /* RULERELNAME */
+ RewriteRelRulenameIndexId,
Anum_pg_rewrite_ev_class,
2,
{
0,
0
}},
- {ShadowRelationName, /* SHADOWNAME */
- ShadowNameIndex,
+ {ShadowRelationId, /* SHADOWNAME */
+ ShadowNameIndexId,
0,
1,
{
0,
0
}},
- {ShadowRelationName, /* SHADOWSYSID */
- ShadowSysidIndex,
+ {ShadowRelationId, /* SHADOWSYSID */
+ ShadowSysidIndexId,
0,
1,
{
0,
0
}},
- {StatisticRelationName, /* STATRELATT */
- StatisticRelidAttnumIndex,
+ {StatisticRelationId, /* STATRELATT */
+ StatisticRelidAttnumIndexId,
Anum_pg_statistic_starelid,
2,
{
0,
0
}},
- {TypeRelationName, /* TYPENAMENSP */
- TypeNameNspIndex,
+ {TypeRelationId, /* TYPENAMENSP */
+ TypeNameNspIndexId,
Anum_pg_type_typrelid,
2,
{
0,
0
}},
- {TypeRelationName, /* TYPEOID */
- TypeOidIndex,
+ {TypeRelationId, /* TYPEOID */
+ TypeOidIndexId,
Anum_pg_type_typrelid,
1,
{
}}
};
-static CatCache *SysCache[
- lengthof(cacheinfo)];
+static CatCache *SysCache[lengthof(cacheinfo)];
static int SysCacheSize = lengthof(cacheinfo);
static bool CacheInitialized = false;
for (cacheId = 0; cacheId < SysCacheSize; cacheId++)
{
SysCache[cacheId] = InitCatCache(cacheId,
- cacheinfo[cacheId].name,
- cacheinfo[cacheId].indname,
+ cacheinfo[cacheId].reloid,
+ cacheinfo[cacheId].indoid,
cacheinfo[cacheId].reloidattr,
cacheinfo[cacheId].nkeys,
cacheinfo[cacheId].key);
if (!PointerIsValid(SysCache[cacheId]))
- elog(ERROR, "could not initialize cache %s (%d)",
- cacheinfo[cacheId].name, cacheId);
+ elog(ERROR, "could not initialize cache %u (%d)",
+ cacheinfo[cacheId].reloid, cacheId);
}
CacheInitialized = true;
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/cache/typcache.c,v 1.11 2004/12/31 22:01:25 pgsql Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/cache/typcache.c,v 1.12 2005/04/14 20:03:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "access/hash.h"
#include "access/nbtree.h"
-#include "catalog/catname.h"
#include "catalog/indexing.h"
#include "catalog/pg_am.h"
#include "catalog/pg_opclass.h"
* that we consider all opclasses, regardless of the current search
* path.
*/
- rel = heap_openr(OperatorClassRelationName, AccessShareLock);
+ rel = heap_open(OperatorClassRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
Anum_pg_opclass_opcamid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(am_id));
- scan = systable_beginscan(rel, OpclassAmNameNspIndex, true,
+ scan = systable_beginscan(rel, OpclassAmNameNspIndexId, true,
SnapshotNow, 1, skey);
while (HeapTupleIsValid(tup = systable_getnext(scan)))
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/backend/utils/init/flatfiles.c,v 1.5 2005/04/14 01:38:20 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/init/flatfiles.c,v 1.6 2005/04/14 20:03:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/pg_database.h"
#include "catalog/pg_group.h"
#include "catalog/pg_namespace.h"
* so get the locks we need before writing anything.
*/
if (database_file_update_subid != InvalidSubTransactionId)
- drel = heap_openr(DatabaseRelationName, ExclusiveLock);
+ drel = heap_open(DatabaseRelationId, ExclusiveLock);
if (group_file_update_subid != InvalidSubTransactionId)
- grel = heap_openr(GroupRelationName, ExclusiveLock);
+ grel = heap_open(GroupRelationId, ExclusiveLock);
if (user_file_update_subid != InvalidSubTransactionId)
- urel = heap_openr(ShadowRelationName, ExclusiveLock);
+ urel = heap_open(ShadowRelationId, ExclusiveLock);
/* Okay to write the files */
if (database_file_update_subid != InvalidSubTransactionId)
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/init/miscinit.c,v 1.138 2005/03/18 03:48:49 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/init/miscinit.c,v 1.139 2005/04/14 20:03:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include
#endif
-#include "catalog/catname.h"
#include "catalog/pg_shadow.h"
#include "libpq/libpq-be.h"
#include "miscadmin.h"
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/utils/init/postinit.c,v 1.144 2005/03/19 23:27:06 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/utils/init/postinit.c,v 1.145 2005/04/14 20:03:26 tgl Exp $
*
*
*-------------------------------------------------------------------------
#include "catalog/catalog.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/namespace.h"
#include "catalog/pg_database.h"
#include "catalog/pg_shadow.h"
* Because we grab RowShareLock here, we can be sure that dropdb()
* is not running in parallel with us (any more).
*/
- pgdbrel = heap_openr(DatabaseRelationName, RowShareLock);
+ pgdbrel = heap_open(DatabaseRelationId, RowShareLock);
ScanKeyInit(&key,
Anum_pg_database_datname,
HeapScanDesc scan;
bool result;
- pg_shadow_rel = heap_openr(ShadowRelationName, AccessExclusiveLock);
+ pg_shadow_rel = heap_open(ShadowRelationId, AccessExclusiveLock);
pg_shadow_dsc = RelationGetDescr(pg_shadow_rel);
scan = heap_beginscan(pg_shadow_rel, SnapshotNow, 0, NULL);
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/access/genam.h,v 1.49 2005/03/27 23:53:04 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/access/genam.h,v 1.50 2005/04/14 20:03:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
extern Relation index_open(Oid relationId);
extern Relation index_openrv(const RangeVar *relation);
-extern Relation index_openr(const char *sysRelationName);
extern void index_close(Relation relation);
extern bool index_insert(Relation indexRelation,
Datum *values, bool *isnull,
* heap-or-index access to system catalogs (in genam.c)
*/
extern SysScanDesc systable_beginscan(Relation heapRelation,
- const char *indexRelname,
+ Oid indexId,
bool indexOK,
Snapshot snapshot,
int nkeys, ScanKey key);
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/access/heapam.h,v 1.98 2005/03/21 01:24:04 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/access/heapam.h,v 1.99 2005/04/14 20:03:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern Relation relation_open(Oid relationId, LOCKMODE lockmode);
extern Relation conditional_relation_open(Oid relationId, LOCKMODE lockmode, bool nowait);
extern Relation relation_openrv(const RangeVar *relation, LOCKMODE lockmode);
-extern Relation relation_openr(const char *sysRelationName, LOCKMODE lockmode);
extern void relation_close(Relation relation, LOCKMODE lockmode);
extern Relation heap_open(Oid relationId, LOCKMODE lockmode);
extern Relation heap_openrv(const RangeVar *relation, LOCKMODE lockmode);
-extern Relation heap_openr(const char *sysRelationName, LOCKMODE lockmode);
#define heap_close(r,l) relation_close(r,l)
+++ /dev/null
-/*-------------------------------------------------------------------------
- *
- * catname.h
- * POSTGRES system catalog relation name definitions.
- *
- *
- * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
- * Portions Copyright (c) 1994, Regents of the University of California
- *
- * $PostgreSQL: pgsql/src/include/catalog/catname.h,v 1.35 2005/04/14 01:38:20 tgl Exp $
- *
- *-------------------------------------------------------------------------
- */
-#ifndef CATNAME_H
-#define CATNAME_H
-
-
-#define AggregateRelationName "pg_aggregate"
-#define AccessMethodRelationName "pg_am"
-#define AccessMethodOperatorRelationName "pg_amop"
-#define AccessMethodProcedureRelationName "pg_amproc"
-#define AttributeRelationName "pg_attribute"
-#define CastRelationName "pg_cast"
-#define ConstraintRelationName "pg_constraint"
-#define ConversionRelationName "pg_conversion"
-#define DatabaseRelationName "pg_database"
-#define DependRelationName "pg_depend"
-#define DescriptionRelationName "pg_description"
-#define GroupRelationName "pg_group"
-#define IndexRelationName "pg_index"
-#define InheritsRelationName "pg_inherits"
-#define LanguageRelationName "pg_language"
-#define LargeObjectRelationName "pg_largeobject"
-#define ListenerRelationName "pg_listener"
-#define NamespaceRelationName "pg_namespace"
-#define OperatorClassRelationName "pg_opclass"
-#define OperatorRelationName "pg_operator"
-#define ProcedureRelationName "pg_proc"
-#define RelationRelationName "pg_class"
-#define RewriteRelationName "pg_rewrite"
-#define ShadowRelationName "pg_shadow"
-#define StatisticRelationName "pg_statistic"
-#define TableSpaceRelationName "pg_tablespace"
-#define TypeRelationName "pg_type"
-#define AttrDefaultRelationName "pg_attrdef"
-#define TriggerRelationName "pg_trigger"
-
-#endif /* CATNAME_H */
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/catalog/indexing.h,v 1.86 2005/04/14 01:38:20 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/catalog/indexing.h,v 1.87 2005/04/14 20:03:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/htup.h"
-/*
- * Names of indexes on system catalogs
- *
- * References to specific system indexes in the C code should use these
- * macros rather than hardwiring the actual index name.
- */
-#define AccessMethodOperatorIndex "pg_amop_opr_opc_index"
-#define AccessMethodStrategyIndex "pg_amop_opc_strat_index"
-#define AccessMethodProcedureIndex "pg_amproc_opc_proc_index"
-#define AggregateFnoidIndex "pg_aggregate_fnoid_index"
-#define AmNameIndex "pg_am_name_index"
-#define AmOidIndex "pg_am_oid_index"
-#define AttrDefaultIndex "pg_attrdef_adrelid_adnum_index"
-#define AttrDefaultOidIndex "pg_attrdef_oid_index"
-#define AttributeRelidNameIndex "pg_attribute_relid_attnam_index"
-#define AttributeRelidNumIndex "pg_attribute_relid_attnum_index"
-#define CastOidIndex "pg_cast_oid_index"
-#define CastSourceTargetIndex "pg_cast_source_target_index"
-#define ClassNameNspIndex "pg_class_relname_nsp_index"
-#define ClassOidIndex "pg_class_oid_index"
-#define ConstraintNameNspIndex "pg_constraint_conname_nsp_index"
-#define ConstraintOidIndex "pg_constraint_oid_index"
-#define ConstraintRelidIndex "pg_constraint_conrelid_index"
-#define ConstraintTypidIndex "pg_constraint_contypid_index"
-#define ConversionDefaultIndex "pg_conversion_default_index"
-#define ConversionNameNspIndex "pg_conversion_name_nsp_index"
-#define ConversionOidIndex "pg_conversion_oid_index"
-#define DatabaseNameIndex "pg_database_datname_index"
-#define DatabaseOidIndex "pg_database_oid_index"
-#define DependDependerIndex "pg_depend_depender_index"
-#define DependReferenceIndex "pg_depend_reference_index"
-#define DescriptionObjIndex "pg_description_o_c_o_index"
-#define GroupNameIndex "pg_group_name_index"
-#define GroupSysidIndex "pg_group_sysid_index"
-#define IndexIndrelidIndex "pg_index_indrelid_index"
-#define IndexRelidIndex "pg_index_indexrelid_index"
-#define InheritsRelidSeqnoIndex "pg_inherits_relid_seqno_index"
-#define LanguageNameIndex "pg_language_name_index"
-#define LanguageOidIndex "pg_language_oid_index"
-#define LargeObjectLOidPNIndex "pg_largeobject_loid_pn_index"
-#define NamespaceNameIndex "pg_namespace_nspname_index"
-#define NamespaceOidIndex "pg_namespace_oid_index"
-#define OpclassAmNameNspIndex "pg_opclass_am_name_nsp_index"
-#define OpclassOidIndex "pg_opclass_oid_index"
-#define OperatorNameNspIndex "pg_operator_oprname_l_r_n_index"
-#define OperatorOidIndex "pg_operator_oid_index"
-#define ProcedureNameArgsNspIndex "pg_proc_proname_args_nsp_index"
-#define ProcedureOidIndex "pg_proc_oid_index"
-#define RewriteOidIndex "pg_rewrite_oid_index"
-#define RewriteRelRulenameIndex "pg_rewrite_rel_rulename_index"
-#define ShadowNameIndex "pg_shadow_usename_index"
-#define ShadowSysidIndex "pg_shadow_usesysid_index"
-#define StatisticRelidAttnumIndex "pg_statistic_relid_att_index"
-#define TablespaceNameIndex "pg_tablespace_spcname_index"
-#define TablespaceOidIndex "pg_tablespace_oid_index"
-#define TriggerConstrNameIndex "pg_trigger_tgconstrname_index"
-#define TriggerConstrRelidIndex "pg_trigger_tgconstrrelid_index"
-#define TriggerRelidNameIndex "pg_trigger_tgrelid_tgname_index"
-#define TriggerOidIndex "pg_trigger_oid_index"
-#define TypeNameNspIndex "pg_type_typname_nsp_index"
-#define TypeOidIndex "pg_type_oid_index"
-
/*
* The state object used by CatalogOpenIndexes and friends is actually the
* The keyword is DECLARE_INDEX or DECLARE_UNIQUE_INDEX. The first two
* arguments are the index name and OID, the rest is much like a standard
* 'create index' SQL command.
+ *
+ * For each index, we also provide a #define for its OID. References to
+ * the index in the C code should always use these #defines, not the actual
+ * index name (much less the numeric OID).
*/
DECLARE_UNIQUE_INDEX(pg_aggregate_fnoid_index,2650, on pg_aggregate using btree(aggfnoid oid_ops));
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/utils/catcache.h,v 1.53 2005/03/25 18:30:28 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/utils/catcache.h,v 1.54 2005/04/14 20:03:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
int id; /* cache identifier --- see syscache.h */
struct catcache *cc_next; /* link to next catcache */
const char *cc_relname; /* name of relation the tuples come from */
- const char *cc_indname; /* name of index matching cache keys */
Oid cc_reloid; /* OID of relation the tuples come from */
+ Oid cc_indexoid; /* OID of index matching cache keys */
bool cc_relisshared; /* is relation shared across databases? */
TupleDesc cc_tupdesc; /* tuple descriptor (copied from reldesc) */
int cc_reloidattr; /* AttrNumber of relation OID attr, or 0 */
extern void CreateCacheMemoryContext(void);
extern void AtEOXact_CatCache(bool isCommit);
-extern CatCache *InitCatCache(int id, const char *relname, const char *indname,
+extern CatCache *InitCatCache(int id, Oid reloid, Oid indexoid,
int reloidattr,
int nkeys, const int *key);
extern void InitCatCachePhase2(CatCache *cache);
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/utils/lsyscache.h,v 1.97 2005/04/11 23:06:56 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/utils/lsyscache.h,v 1.98 2005/04/14 20:03:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern bool func_strict(Oid funcid);
extern char func_volatile(Oid funcid);
extern Oid get_relname_relid(const char *relname, Oid relnamespace);
-extern Oid get_system_catalog_relid(const char *catname);
extern char *get_rel_name(Oid relid);
extern Oid get_rel_namespace(Oid relid);
extern Oid get_rel_type_id(Oid relid);
* Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $PostgreSQL: pgsql/src/include/utils/relcache.h,v 1.49 2005/04/14 01:38:22 tgl Exp $
+ * $PostgreSQL: pgsql/src/include/utils/relcache.h,v 1.50 2005/04/14 20:03:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* relation lookup routines
*/
extern Relation RelationIdGetRelation(Oid relationId);
-extern Relation RelationSysNameGetRelation(const char *relationName);
/* finds an existing cache entry, but won't make a new one */
extern Relation RelationIdCacheGetRelation(Oid relationId);
* procedural language
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/pl/plpgsql/src/pl_comp.c,v 1.87 2005/04/07 14:53:04 tgl Exp $
+ * $PostgreSQL: pgsql/src/pl/plpgsql/src/pl_comp.c,v 1.88 2005/04/14 20:03:27 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
#include "pl.tab.h"
#include "access/heapam.h"
-#include "catalog/catname.h"
#include "catalog/namespace.h"
#include "catalog/pg_attribute.h"
#include "catalog/pg_attrdef.h"
projects / postgresql.git / commitdiff