<!--
Documentation of the system catalogs, directed toward PostgreSQL developers
- $Header: /cvsroot/pgsql/doc/src/sgml/catalogs.sgml,v 2.37 2002/03/22 21:34:43 tgl Exp $
+ $Header: /cvsroot/pgsql/doc/src/sgml/catalogs.sgml,v 2.38 2002/03/26 19:15:10 tgl Exp $
-->
<chapter id="catalogs">
</row>
<row>
+ <entry>relnamespace</entry>
+ <entry><type>oid</type></entry>
+ <entry>pg_namespace.oid</entry>
+ <entry>
+ The OID of the namespace that contains this relation
+ </entry>
+ </row>
+
+ <row>
<entry>reltype</entry>
<entry><type>oid</type></entry>
<entry>pg_type.oid</entry>
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.131 2002/03/03 17:47:53 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/heap/heapam.c,v 1.132 2002/03/26 19:15:11 tgl Exp $
*
*
* INTERFACE ROUTINES
* relation_open - open any relation by relation OID
- * relation_openr - open any relation by name
+ * relation_openrv - open any relation specified by a RangeVar
+ * relation_openr - open a system relation by name
* relation_close - close any relation
* heap_open - open a heap relation by relation OID
- * heap_openr - open a heap relation by name
+ * heap_openrv - open a heap relation specified by a RangeVar
+ * heap_openr - open a system heap relation by name
* heap_close - (now just a macro for relation_close)
* heap_beginscan - begin relation scan
* heap_rescan - restart a relation scan
#include "access/valid.h"
#include "access/xlogutils.h"
#include "catalog/catalog.h"
+#include "catalog/namespace.h"
#include "miscadmin.h"
#include "utils/inval.h"
#include "utils/relcache.h"
}
/* ----------------
- * relation_openr - open any relation by name
+ * relation_openrv - open any relation specified by a RangeVar
*
- * As above, but lookup by name instead of OID.
+ * As above, but the relation is specified by a RangeVar.
* ----------------
*/
Relation
-relation_openr(const char *relationName, LOCKMODE lockmode)
+relation_openrv(const RangeVar *relation, LOCKMODE lockmode)
{
- Relation r;
-
- Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES);
+ Oid relOid;
/*
- * increment access statistics
+ * In bootstrap mode, don't do any namespace processing.
*/
- IncrHeapAccessStat(local_openr);
- IncrHeapAccessStat(global_openr);
+ if (IsBootstrapProcessingMode())
+ {
+ Assert(relation->schemaname == NULL);
+ return relation_openr(relation->relname, lockmode);
+ }
/*
* Check for shared-cache-inval messages before trying to open the
* relation. This is needed to cover the case where the name
* identifies a rel that has been dropped and recreated since the
- * start of our transaction: if we don't flush the old relcache entry
+ * start of our transaction: if we don't flush the old syscache entry
* then we'll latch onto that entry and suffer an error when we do
* LockRelation. Note that relation_open does not need to do this,
* since a relation's OID never changes.
if (lockmode != NoLock)
AcceptInvalidationMessages();
+ /* Look up the appropriate relation using namespace search */
+ relOid = RangeVarGetRelid(relation, false);
+
+ /* Let relation_open do the rest */
+ return relation_open(relOid, lockmode);
+}
+
+/* ----------------
+ * relation_openr - open a system relation specified by name.
+ *
+ * As above, but the relation is specified by an unqualified name;
+ * it is assumed to live in the system catalog namespace.
+ * ----------------
+ */
+Relation
+relation_openr(const char *sysRelationName, LOCKMODE lockmode)
+{
+ Relation r;
+
+ Assert(lockmode >= NoLock && lockmode < MAX_LOCKMODES);
+
+ /*
+ * increment access statistics
+ */
+ IncrHeapAccessStat(local_openr);
+ IncrHeapAccessStat(global_openr);
+
+ /*
+ * We assume we should not need to worry about the rel's OID changing,
+ * hence no need for AcceptInvalidationMessages here.
+ */
+
/* The relcache does all the real work... */
- r = RelationNameGetRelation(relationName);
+ r = RelationSysNameGetRelation(sysRelationName);
if (!RelationIsValid(r))
- elog(ERROR, "Relation \"%s\" does not exist", relationName);
+ elog(ERROR, "Relation \"%s\" does not exist", sysRelationName);
if (lockmode != NoLock)
LockRelation(r, lockmode);
}
/* ----------------
- * heap_openr - open a heap relation by name
+ * heap_openrv - open a heap relation specified
+ * by a RangeVar node
+ *
+ * As above, but relation is specified by a RangeVar.
+ * ----------------
+ */
+Relation
+heap_openrv(const RangeVar *relation, LOCKMODE lockmode)
+{
+ Relation r;
+
+ r = relation_openrv(relation, lockmode);
+
+ if (r->rd_rel->relkind == RELKIND_INDEX)
+ elog(ERROR, "%s is an index relation",
+ RelationGetRelationName(r));
+ else if (r->rd_rel->relkind == RELKIND_SPECIAL)
+ elog(ERROR, "%s is a special relation",
+ RelationGetRelationName(r));
+
+ pgstat_initstats(&r->pgstat_info, r);
+
+ return r;
+}
+
+/* ----------------
+ * heap_openr - open a system heap relation specified by name.
*
- * As above, but lookup by name instead of OID.
+ * As above, but the relation is specified by an unqualified name;
+ * it is assumed to live in the system catalog namespace.
* ----------------
*/
Relation
-heap_openr(const char *relationName, LOCKMODE lockmode)
+heap_openr(const char *sysRelationName, LOCKMODE lockmode)
{
Relation r;
- r = relation_openr(relationName, lockmode);
+ r = relation_openr(sysRelationName, lockmode);
if (r->rd_rel->relkind == RELKIND_INDEX)
elog(ERROR, "%s is an index relation",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.55 2001/11/02 16:30:29 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/access/index/indexam.c,v 1.56 2002/03/26 19:15:14 tgl Exp $
*
* INTERFACE ROUTINES
* index_open - open an index relation by relation OID
- * index_openr - open an index relation by name
+ * index_openrv - open an index relation specified by a RangeVar
+ * index_openr - open a system index relation by name
* index_close - close an index relation
* index_beginscan - start a scan of an index
* index_rescan - restart a scan of an index
}
/* ----------------
- * index_openr - open an index relation by name
+ * index_openrv - open an index relation specified
+ * by a RangeVar node
*
- * As above, but lookup by name instead of OID.
+ * As above, but relation is specified by a RangeVar.
* ----------------
*/
Relation
-index_openr(const char *relationName)
+index_openrv(const RangeVar *relation)
{
Relation r;
- r = relation_openr(relationName, NoLock);
+ r = relation_openrv(relation, NoLock);
+
+ if (r->rd_rel->relkind != RELKIND_INDEX)
+ elog(ERROR, "%s is not an index relation",
+ RelationGetRelationName(r));
+
+ pgstat_initstats(&r->pgstat_info, r);
+
+ return r;
+}
+
+/* ----------------
+ * index_openr - open a system index relation specified by name.
+ *
+ * As above, but the relation is specified by an unqualified name;
+ * it is assumed to live in the system catalog namespace.
+ * ----------------
+ */
+Relation
+index_openr(const char *sysRelationName)
+{
+ Relation r;
+
+ r = relation_openr(sysRelationName, NoLock);
if (r->rd_rel->relkind != RELKIND_INDEX)
elog(ERROR, "%s is not an index relation",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.40 2002/03/02 21:39:20 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootparse.y,v 1.41 2002/03/26 19:15:16 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/pg_am.h"
#include "catalog/pg_attribute.h"
#include "catalog/pg_class.h"
+#include "catalog/pg_namespace.h"
#include "commands/defrem.h"
#include "miscadmin.h"
+#include "nodes/makefuncs.h"
#include "nodes/nodes.h"
#include "nodes/parsenodes.h"
#include "nodes/pg_list.h"
}
tupdesc = CreateTupleDesc(numattr, attrtypes);
- reldesc = heap_create(LexIDStr($4), tupdesc,
+ reldesc = heap_create(LexIDStr($4),
+ PG_CATALOG_NAMESPACE,
+ tupdesc,
false, true, true);
reldesc->rd_rel->relhasoids = ! ($3);
elog(DEBUG3, "bootstrap relation created");
tupdesc = CreateTupleDesc(numattr,attrtypes);
id = heap_create_with_catalog(LexIDStr($4),
+ PG_CATALOG_NAMESPACE,
tupdesc,
RELKIND_RELATION,
! ($3),
{
do_start();
- DefineIndex(LexIDStr($5),
+ DefineIndex(makeRangeVar(NULL, LexIDStr($5)),
LexIDStr($3),
LexIDStr($7),
$9, false, false, NULL, NIL);
{
do_start();
- DefineIndex(LexIDStr($6),
+ DefineIndex(makeRangeVar(NULL, LexIDStr($6)),
LexIDStr($4),
LexIDStr($8),
$10, true, false, NULL, NIL);
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.124 2002/03/15 19:20:34 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/bootstrap/bootstrap.c,v 1.125 2002/03/26 19:15:16 tgl Exp $
*
*-------------------------------------------------------------------------
*/
typedef struct _IndexList
{
- char *il_heap;
- char *il_ind;
+ Oid il_heap;
+ Oid il_ind;
IndexInfo *il_info;
struct _IndexList *il_next;
} IndexList;
* are present in the index.
*/
void
-index_register(char *heap,
- char *ind,
+index_register(Oid heap,
+ Oid ind,
IndexInfo *indexInfo)
{
IndexList *newind;
oldcxt = MemoryContextSwitchTo(nogc);
newind = (IndexList *) palloc(sizeof(IndexList));
- newind->il_heap = pstrdup(heap);
- newind->il_ind = pstrdup(ind);
+ newind->il_heap = heap;
+ newind->il_ind = ind;
newind->il_info = (IndexInfo *) palloc(sizeof(IndexInfo));
memcpy(newind->il_info, indexInfo, sizeof(IndexInfo));
Relation heap;
Relation ind;
- heap = heap_openr(ILHead->il_heap, NoLock);
- ind = index_openr(ILHead->il_ind);
+ heap = heap_open(ILHead->il_heap, NoLock);
+ ind = index_open(ILHead->il_ind);
index_build(heap, ind, ILHead->il_info);
/*
#
# Makefile for backend/catalog
#
-# $Header: /cvsroot/pgsql/src/backend/catalog/Makefile,v 1.38 2002/03/22 21:34:43 tgl Exp $
+# $Header: /cvsroot/pgsql/src/backend/catalog/Makefile,v 1.39 2002/03/26 19:15:22 tgl Exp $
#
#-------------------------------------------------------------------------
top_builddir = ../../..
include $(top_builddir)/src/Makefile.global
-OBJS = catalog.o heap.o index.o indexing.o aclchk.o \
+OBJS = catalog.o heap.o index.o indexing.o namespace.o aclchk.o \
pg_aggregate.o pg_largeobject.o pg_namespace.o \
pg_operator.o pg_proc.o pg_type.o
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.58 2002/03/21 23:27:19 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/aclchk.c,v 1.59 2002/03/26 19:15:22 tgl Exp $
*
* NOTES
* See acl.h.
#include "catalog/catalog.h"
#include "catalog/catname.h"
#include "catalog/indexing.h"
+#include "catalog/namespace.h"
#include "catalog/pg_aggregate.h"
#include "catalog/pg_group.h"
#include "catalog/pg_language.h"
foreach(i, stmt->objects)
{
- char *relname = ((RangeVar *) lfirst(i))->relname;
+ RangeVar *relvar = (RangeVar *) lfirst(i);
+ Oid relOid;
Relation relation;
HeapTuple tuple;
Form_pg_class pg_class_tuple;
/* open pg_class */
relation = heap_openr(RelationRelationName, RowExclusiveLock);
- tuple = SearchSysCache(RELNAME,
- PointerGetDatum(relname),
+ relOid = RangeVarGetRelid(relvar, false);
+ tuple = SearchSysCache(RELOID,
+ ObjectIdGetDatum(relOid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "relation \"%s\" not found",
- relname);
+ elog(ERROR, "relation %u not found", relOid);
pg_class_tuple = (Form_pg_class) GETSTRUCT(tuple);
- if (!pg_class_ownercheck(tuple->t_data->t_oid, GetUserId()))
+ if (!pg_class_ownercheck(relOid, GetUserId()))
elog(ERROR, "%s: permission denied",
- relname);
+ relvar->relname);
if (pg_class_tuple->relkind == RELKIND_INDEX)
elog(ERROR, "\"%s\" is an index",
- relname);
+ relvar->relname);
/*
* If there's no ACL, create a default using the pg_class.relowner
* field.
*/
- aclDatum = SysCacheGetAttr(RELNAME, tuple, Anum_pg_class_relacl,
+ aclDatum = SysCacheGetAttr(RELOID, tuple, Anum_pg_class_relacl,
&isNull);
if (isNull)
old_acl = acldefault(pg_class_tuple->relowner);
#
#
# IDENTIFICATION
-# $Header: /cvsroot/pgsql/src/backend/catalog/Attic/genbki.sh,v 1.25 2001/11/30 20:21:06 tgl Exp $
+# $Header: /cvsroot/pgsql/src/backend/catalog/Attic/genbki.sh,v 1.26 2002/03/26 19:15:24 tgl Exp $
#
# NOTES
# non-essential whitespace is removed from the generated file.
fi
done
+# Get PG_CATALOG_NAMESPACE from catalog/pg_namespace.h
+for dir in $INCLUDE_DIRS; do
+ if [ -f "$dir/catalog/pg_namespace.h" ]; then
+ PG_CATALOG_NAMESPACE=`grep '^#define[ ]*PG_CATALOG_NAMESPACE' $dir/catalog/pg_namespace.h | $AWK '{ print $3 }'`
+ break
+ fi
+done
+
# Get FirstGenBKIObjectId from access/transam.h
for dir in $INCLUDE_DIRS; do
if [ -f "$dir/access/transam.h" ]; then
-e "s/(TransactionId/(xid/g" \
-e "s/PGUID/1/g" \
-e "s/NAMEDATALEN/$NAMEDATALEN/g" \
+ -e "s/PGNSP/$PG_CATALOG_NAMESPACE/g" \
-e "s/DEFAULT_ATTSTATTARGET/$DEFAULTATTSTATTARGET/g" \
-e "s/INDEX_MAX_KEYS\*2/$INDEXMAXKEYS2/g" \
-e "s/INDEX_MAX_KEYS\*4/$INDEXMAXKEYS4/g" \
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.191 2002/03/22 02:56:30 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.192 2002/03/26 19:15:25 tgl Exp $
*
*
* INTERFACE ROUTINES
#include "catalog/indexing.h"
#include "catalog/pg_attrdef.h"
#include "catalog/pg_inherits.h"
-#include "catalog/pg_index.h"
+#include "catalog/pg_namespace.h"
#include "catalog/pg_relcheck.h"
#include "catalog/pg_statistic.h"
#include "catalog/pg_type.h"
#include "optimizer/planmain.h"
#include "optimizer/prep.h"
#include "optimizer/var.h"
-#include "parser/parse_coerce.h"
#include "parser/parse_expr.h"
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
-#include "parser/parse_type.h"
#include "rewrite/rewriteRemove.h"
#include "storage/smgr.h"
#include "utils/builtins.h"
*/
Relation
heap_create(char *relname,
+ Oid relnamespace,
TupleDesc tupDesc,
bool istemp,
bool storage_create,
static unsigned int uniqueId = 0;
Oid relid;
- Oid tblNode = MyDatabaseId;
+ Oid dbid = MyDatabaseId;
+ RelFileNode rnode;
bool nailme = false;
Relation rel;
/*
* Real ugly stuff to assign the proper relid in the relation
* descriptor follows. Note that only "bootstrapped" relations whose
- * OIDs are hard-coded in pg_class.h need be listed here.
+ * OIDs are hard-coded in pg_class.h need be listed here. We also
+ * have to take special care for those rels that should be nailed
+ * in cache and/or are shared across databases.
*/
- if (relname && IsSystemRelationName(relname))
+ if (relname && relnamespace == PG_CATALOG_NAMESPACE)
{
if (strcmp(TypeRelationName, relname) == 0)
{
}
else if (strcmp(ShadowRelationName, relname) == 0)
{
- tblNode = InvalidOid;
+ dbid = InvalidOid;
relid = RelOid_pg_shadow;
}
else if (strcmp(GroupRelationName, relname) == 0)
{
- tblNode = InvalidOid;
+ dbid = InvalidOid;
relid = RelOid_pg_group;
}
else if (strcmp(DatabaseRelationName, relname) == 0)
{
- tblNode = InvalidOid;
+ dbid = InvalidOid;
relid = RelOid_pg_database;
}
else
{
relid = newoid();
if (IsSharedSystemRelationName(relname))
- tblNode = InvalidOid;
+ dbid = InvalidOid;
}
}
else
}
/*
+ * For now, the physical identifier of the relation is the same as the
+ * logical identifier.
+ */
+ rnode.tblNode = dbid;
+ rnode.relNode = relid;
+
+ /*
* build the relcache entry.
*/
- rel = RelationBuildLocalRelation(relname, tupDesc,
- relid, tblNode,
+ rel = RelationBuildLocalRelation(relname,
+ relnamespace,
+ tupDesc,
+ relid, dbid,
+ rnode,
nailme);
/*
* 1) CheckAttributeNames() is used to make certain the tuple
* descriptor contains a valid set of attribute names
*
- * 2) pg_class is opened and RelationFindRelid()
+ * 2) pg_class is opened and get_relname_relid()
* performs a scan to ensure that no relation with the
* same name already exists.
*
}
/* --------------------------------
- * RelnameFindRelid
- *
- * Find any existing relation of the given name.
- * --------------------------------
- */
-Oid
-RelnameFindRelid(const char *relname)
-{
- Oid relid;
-
- /*
- * If this is not bootstrap (initdb) time, use the catalog index on
- * pg_class.
- */
- if (!IsBootstrapProcessingMode())
- {
- relid = GetSysCacheOid(RELNAME,
- PointerGetDatum(relname),
- 0, 0, 0);
- }
- else
- {
- Relation pg_class_desc;
- ScanKeyData key;
- HeapScanDesc pg_class_scan;
- HeapTuple tuple;
-
- pg_class_desc = heap_openr(RelationRelationName, AccessShareLock);
-
- /*
- * At bootstrap time, we have to do this the hard way. Form the
- * scan key.
- */
- ScanKeyEntryInitialize(&key,
- 0,
- (AttrNumber) Anum_pg_class_relname,
- (RegProcedure) F_NAMEEQ,
- PointerGetDatum(relname));
-
- /*
- * begin the scan
- */
- pg_class_scan = heap_beginscan(pg_class_desc,
- 0,
- SnapshotNow,
- 1,
- &key);
-
- /*
- * get a tuple. if the tuple is NULL then it means we didn't find
- * an existing relation.
- */
- tuple = heap_getnext(pg_class_scan, 0);
-
- if (HeapTupleIsValid(tuple))
- relid = tuple->t_data->t_oid;
- else
- relid = InvalidOid;
-
- heap_endscan(pg_class_scan);
-
- heap_close(pg_class_desc, AccessShareLock);
- }
- return relid;
-}
-
-/* --------------------------------
* AddNewAttributeTuples
*
* this registers the new relation's schema by adding
*/
Oid
heap_create_with_catalog(char *relname,
+ Oid relnamespace,
TupleDesc tupdesc,
char relkind,
bool relhasoids,
CheckAttributeNames(tupdesc, relhasoids);
/* temp tables can mask non-temp tables */
- if ((!istemp && RelnameFindRelid(relname)) ||
+ if ((!istemp && get_relname_relid(relname, relnamespace)) ||
(istemp && is_temp_rel_name(relname)))
elog(ERROR, "Relation '%s' already exists", relname);
* heap_storage_create() does all the "real" work of creating the disk
* file for the relation.
*/
- new_rel_desc = heap_create(relname, tupdesc, istemp, false,
- allow_system_table_mods);
+ new_rel_desc = heap_create(relname, relnamespace, tupdesc,
+ istemp, false, allow_system_table_mods);
/* Fetch the relation OID assigned by heap_create */
new_rel_oid = new_rel_desc->rd_att->attrs[0]->attrelid;
heap_close(catalogRelation, RowExclusiveLock);
}
-/* --------------------------------
+/*
* RelationRemoveIndexes
- *
- * --------------------------------
*/
static void
RelationRemoveIndexes(Relation relation)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.173 2002/03/03 17:47:54 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/index.c,v 1.174 2002/03/26 19:15:28 tgl Exp $
*
*
* INTERFACE ROUTINES
#include "utils/catcache.h"
#include "utils/fmgroids.h"
#include "utils/inval.h"
+#include "utils/lsyscache.h"
#include "utils/relcache.h"
#include "utils/syscache.h"
#include "utils/temprel.h"
+
/*
* macros used in guessing how many tuples are on a page.
*/
((natts) * AVG_ATTR_SIZE + MAXALIGN(sizeof(HeapTupleHeaderData))))
/* non-export function prototypes */
-static Oid GetHeapRelationOid(char *heapRelationName, char *indexRelationName,
- bool istemp);
static TupleDesc BuildFuncTupleDesc(Oid funcOid,
Oid *classObjectId);
static TupleDesc ConstructTupleDescriptor(Relation heapRelation,
int numatts, AttrNumber *attNums,
Oid *classObjectId);
static void ConstructIndexReldesc(Relation indexRelation, Oid amoid);
-static Oid UpdateRelationRelation(Relation indexRelation, char *temp_relname);
+static void UpdateRelationRelation(Relation indexRelation, char *temp_relname);
static void InitializeAttributeOids(Relation indexRelation,
int numatts, Oid indexoid);
static void AppendAttributeTuples(Relation indexRelation, int numatts);
return reindexing;
}
-/* ----------------------------------------------------------------
- * GetHeapRelationOid
- * ----------------------------------------------------------------
- */
-static Oid
-GetHeapRelationOid(char *heapRelationName, char *indexRelationName, bool istemp)
-{
- Oid indoid;
- Oid heapoid;
-
-
- indoid = RelnameFindRelid(indexRelationName);
-
- if ((!istemp && OidIsValid(indoid)) ||
- (istemp && is_temp_rel_name(indexRelationName)))
- elog(ERROR, "index named \"%s\" already exists",
- indexRelationName);
-
- heapoid = RelnameFindRelid(heapRelationName);
-
- if (!OidIsValid(heapoid))
- elog(ERROR, "cannot create index on non-existent relation \"%s\"",
- heapRelationName);
-
- return heapoid;
-}
-
static TupleDesc
BuildFuncTupleDesc(Oid funcOid,
Oid *classObjectId)
* UpdateRelationRelation
* ----------------------------------------------------------------
*/
-static Oid
+static void
UpdateRelationRelation(Relation indexRelation, char *temp_relname)
{
Relation pg_class;
HeapTuple tuple;
- Oid tupleOid;
Relation idescs[Num_pg_class_indices];
pg_class = heap_openr(RelationRelationName, RowExclusiveLock);
(void *) indexRelation->rd_rel);
/*
- * the new tuple must have the same oid as the relcache entry for the
- * index. sure would be embarrassing to do this sort of thing in
- * polite company.
+ * the new tuple must have the oid already chosen for the index.
+ * sure would be embarrassing to do this sort of thing in polite company.
*/
tuple->t_data->t_oid = RelationGetRelid(indexRelation);
heap_insert(pg_class, tuple);
CatalogCloseIndices(Num_pg_class_indices, idescs);
}
- tupleOid = tuple->t_data->t_oid;
heap_freetuple(tuple);
heap_close(pg_class, RowExclusiveLock);
-
- return tupleOid;
}
/* ----------------------------------------------------------------
* ----------------------------------------------------------------
*/
Oid
-index_create(char *heapRelationName,
+index_create(Oid heapRelationId,
char *indexRelationName,
IndexInfo *indexInfo,
Oid accessMethodObjectId,
Oid *classObjectId,
+ bool istemp,
bool primary,
bool allow_system_table_mods)
{
Relation heapRelation;
Relation indexRelation;
TupleDesc indexTupDesc;
- Oid heapoid;
+ Oid namespaceId;
Oid indexoid;
- bool istemp = is_temp_rel_name(heapRelationName);
char *temp_relname = NULL;
SetReindexProcessing(false);
/*
+ * Only SELECT ... FOR UPDATE are allowed while doing this
+ */
+ heapRelation = heap_open(heapRelationId, ShareLock);
+
+ namespaceId = RelationGetNamespace(heapRelation);
+
+ /*
* check parameters
*/
if (indexInfo->ii_NumIndexAttrs < 1 ||
indexInfo->ii_NumKeyAttrs < 1)
elog(ERROR, "must index at least one column");
- if (heapRelationName && !allow_system_table_mods &&
- IsSystemRelationName(heapRelationName) && IsNormalProcessingMode())
+ if (!allow_system_table_mods &&
+ IsSystemRelationName(RelationGetRelationName(heapRelation)) &&
+ IsNormalProcessingMode())
elog(ERROR, "User-defined indexes on system catalogs are not supported");
- /*
- * get heap relation oid and open the heap relation
- */
- heapoid = GetHeapRelationOid(heapRelationName, indexRelationName, istemp);
-
- /*
- * Only SELECT ... FOR UPDATE are allowed while doing this
- */
- heapRelation = heap_open(heapoid, ShareLock);
+ if ((!istemp && get_relname_relid(indexRelationName, namespaceId)) ||
+ (istemp && is_temp_rel_name(indexRelationName)))
+ elog(ERROR, "index named \"%s\" already exists",
+ indexRelationName);
/*
* construct tuple descriptor for index tuples
/*
* create the index relation
*/
- indexRelation = heap_create(indexRelationName, indexTupDesc,
+ indexRelation = heap_create(indexRelationName,
+ namespaceId,
+ indexTupDesc,
istemp, false, allow_system_table_mods);
+ indexoid = RelationGetRelid(indexRelation);
/*
* Obtain exclusive lock on it. Although no other backends can see it
* (append RELATION tuple)
* ----------------
*/
- indexoid = UpdateRelationRelation(indexRelation, temp_relname);
+ UpdateRelationRelation(indexRelation, temp_relname);
/*
* We create the disk file for this relation here
* (Or, could define a rule to maintain the predicate) --Nels, Feb '92
* ----------------
*/
- UpdateIndexRelation(indexoid, heapoid, indexInfo,
+ UpdateIndexRelation(indexoid, heapRelationId, indexInfo,
classObjectId, primary);
/*
*/
if (IsBootstrapProcessingMode())
{
- index_register(heapRelationName, indexRelationName, indexInfo);
+ index_register(heapRelationId, indexoid, indexInfo);
/* XXX shouldn't we close the heap and index rels here? */
}
else
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.84 2002/03/22 21:34:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/indexing.c,v 1.85 2002/03/26 19:15:30 tgl Exp $
*
*-------------------------------------------------------------------------
*/
char *Name_pg_attrdef_indices[Num_pg_attrdef_indices] =
{AttrDefaultIndex};
char *Name_pg_class_indices[Num_pg_class_indices] =
-{ClassNameIndex, ClassOidIndex};
+{ClassNameNspIndex, ClassOidIndex};
char *Name_pg_database_indices[Num_pg_database_indices] =
{DatabaseNameIndex, DatabaseOidIndex};
char *Name_pg_group_indices[Num_pg_group_indices] =
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * namespace.c
+ * code to support accessing and searching namespaces
+ *
+ * This is separate from pg_namespace.c, which contains the routines that
+ * directly manipulate the pg_namespace system catalog. This module
+ * provides routines associated with defining a "namespace search path"
+ * and implementing search-path-controlled searches.
+ *
+ *
+ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ * $Header: /cvsroot/pgsql/src/backend/catalog/namespace.c,v 1.1 2002/03/26 19:15:32 tgl Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#include "postgres.h"
+
+#include "catalog/namespace.h"
+#include "catalog/pg_namespace.h"
+#include "miscadmin.h"
+#include "utils/lsyscache.h"
+#include "utils/syscache.h"
+
+
+/*
+ * RangeVarGetRelid
+ * Given a RangeVar describing an existing relation,
+ * select the proper namespace and look up the relation OID.
+ *
+ * If the relation is not found, return InvalidOid if failOK = true,
+ * otherwise raise an error.
+ */
+Oid
+RangeVarGetRelid(const RangeVar *relation, bool failOK)
+{
+ Oid namespaceId;
+ Oid relId;
+
+ /*
+ * We check the catalog name and then ignore it.
+ */
+ if (relation->catalogname)
+ {
+ if (strcmp(relation->catalogname, DatabaseName) != 0)
+ elog(ERROR, "Cross-database references are not implemented");
+ }
+
+ if (relation->schemaname)
+ {
+ namespaceId = GetSysCacheOid(NAMESPACENAME,
+ CStringGetDatum(relation->schemaname),
+ 0, 0, 0);
+ if (!OidIsValid(namespaceId))
+ elog(ERROR, "Namespace \"%s\" does not exist",
+ relation->schemaname);
+ relId = get_relname_relid(relation->relname, namespaceId);
+ }
+ else
+ {
+ relId = RelnameGetRelid(relation->relname);
+ }
+
+ if (!OidIsValid(relId) && !failOK)
+ {
+ if (relation->schemaname)
+ elog(ERROR, "Relation \"%s\".\"%s\" does not exist",
+ relation->schemaname, relation->relname);
+ else
+ elog(ERROR, "Relation \"%s\" does not exist",
+ relation->relname);
+ }
+ return relId;
+}
+
+/*
+ * RangeVarGetCreationNamespace
+ * Given a RangeVar describing a to-be-created relation,
+ * choose which namespace to create it in.
+ */
+Oid
+RangeVarGetCreationNamespace(const RangeVar *newRelation)
+{
+ Oid namespaceId;
+
+ /*
+ * We check the catalog name and then ignore it.
+ */
+ if (newRelation->catalogname)
+ {
+ if (strcmp(newRelation->catalogname, DatabaseName) != 0)
+ elog(ERROR, "Cross-database references are not implemented");
+ }
+
+ if (newRelation->schemaname)
+ {
+ namespaceId = GetSysCacheOid(NAMESPACENAME,
+ CStringGetDatum(newRelation->schemaname),
+ 0, 0, 0);
+ if (!OidIsValid(namespaceId))
+ elog(ERROR, "Namespace \"%s\" does not exist",
+ newRelation->schemaname);
+ }
+ else
+ {
+ /* XXX Wrong! Need to get a default schema from somewhere */
+ namespaceId = PG_CATALOG_NAMESPACE;
+ }
+
+ return namespaceId;
+}
+
+/*
+ * RelnameGetRelid
+ * Try to resolve an unqualified relation name.
+ * Returns OID if relation found in search path, else InvalidOid.
+ */
+Oid
+RelnameGetRelid(const char *relname)
+{
+ /* XXX Wrong! must search search path */
+ return get_relname_relid(relname, PG_CATALOG_NAMESPACE);
+}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.72 2002/02/19 20:11:12 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/cluster.c,v 1.73 2002/03/26 19:15:35 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static Oid copy_heap(Oid OIDOldHeap, char *NewName, bool istemp);
-static void copy_index(Oid OIDOldIndex, Oid OIDNewHeap, char *NewIndexName);
+static void copy_index(Oid OIDOldIndex, Oid OIDNewHeap, char *NewIndexName,
+ bool istemp);
static void rebuildheap(Oid OIDNewHeap, Oid OIDOldHeap, Oid OIDOldIndex);
/*
* hand, re-creating n indexes may blow out the space.
*/
void
-cluster(char *oldrelname, char *oldindexname)
+cluster(RangeVar *oldrelation, char *oldindexname)
{
Oid OIDOldHeap,
OIDOldIndex,
bool istemp;
char NewHeapName[NAMEDATALEN];
char NewIndexName[NAMEDATALEN];
- char saveoldrelname[NAMEDATALEN];
- char saveoldindexname[NAMEDATALEN];
+ RangeVar *saveoldrelation;
+ RangeVar *saveoldindex;
+ RangeVar *NewHeap;
+ RangeVar *NewIndex;
/*
- * Copy the arguments into local storage, just to be safe.
+ * FIXME SCHEMAS: The old code had the comment:
+ * "Copy the arguments into local storage, just to be safe."
+ * By using copyObject we are not using local storage.
+ * Was that really necessary?
*/
- StrNCpy(saveoldrelname, oldrelname, NAMEDATALEN);
- StrNCpy(saveoldindexname, oldindexname, NAMEDATALEN);
+ saveoldrelation = copyObject(oldrelation);
+ saveoldindex = copyObject(oldrelation);
+ saveoldindex->relname = pstrdup(oldindexname);
/*
* We grab exclusive access to the target rel and index for the
* duration of the transaction.
*/
- OldHeap = heap_openr(saveoldrelname, AccessExclusiveLock);
+ OldHeap = heap_openrv(saveoldrelation, AccessExclusiveLock);
OIDOldHeap = RelationGetRelid(OldHeap);
- OldIndex = index_openr(saveoldindexname);
+ OldIndex = index_openrv(saveoldindex);
LockRelation(OldIndex, AccessExclusiveLock);
OIDOldIndex = RelationGetRelid(OldIndex);
- istemp = is_temp_rel_name(saveoldrelname);
+ istemp = is_temp_rel_name(saveoldrelation->relname);
/*
* Check that index is in fact an index on the given relation
*/
if (OldIndex->rd_index->indrelid != OIDOldHeap)
elog(ERROR, "CLUSTER: \"%s\" is not an index for table \"%s\"",
- saveoldindexname, saveoldrelname);
+ saveoldindex->relname, saveoldrelation->relname);
/* Drop relcache refcnts, but do NOT give up the locks */
heap_close(OldHeap, NoLock);
/* Create new index over the tuples of the new heap. */
snprintf(NewIndexName, NAMEDATALEN, "temp_%u", OIDOldIndex);
- copy_index(OIDOldIndex, OIDNewHeap, NewIndexName);
+ copy_index(OIDOldIndex, OIDNewHeap, NewIndexName, istemp);
CommandCounterIncrement();
/* Destroy old heap (along with its index) and rename new. */
- heap_drop_with_catalog(saveoldrelname, allowSystemTableMods);
+ heap_drop_with_catalog(saveoldrelation->relname, allowSystemTableMods);
CommandCounterIncrement();
- renamerel(NewHeapName, saveoldrelname);
+ NewHeap = copyObject(saveoldrelation);
+ NewHeap->relname = NewHeapName;
+ NewIndex = copyObject(saveoldindex);
+ NewIndex->relname = NewIndexName;
+
+ renamerel(NewHeap, saveoldrelation->relname);
/* This one might be unnecessary, but let's be safe. */
CommandCounterIncrement();
- renamerel(NewIndexName, saveoldindexname);
+ renamerel(NewIndex, saveoldindex->relname);
}
static Oid
*/
tupdesc = CreateTupleDescCopyConstr(OldHeapDesc);
- OIDNewHeap = heap_create_with_catalog(NewName, tupdesc,
+ OIDNewHeap = heap_create_with_catalog(NewName,
+ RelationGetNamespace(OldHeap),
+ tupdesc,
OldHeap->rd_rel->relkind,
OldHeap->rd_rel->relhasoids,
istemp,
* AlterTableCreateToastTable ends with CommandCounterIncrement(), so
* that the TOAST table will be visible for insertion.
*/
- AlterTableCreateToastTable(NewName, true);
+ AlterTableCreateToastTable(OIDNewHeap, true);
heap_close(OldHeap, NoLock);
}
static void
-copy_index(Oid OIDOldIndex, Oid OIDNewHeap, char *NewIndexName)
+copy_index(Oid OIDOldIndex, Oid OIDNewHeap, char *NewIndexName, bool istemp)
{
Relation OldIndex,
NewHeap;
* Create a new index like the old one. To do this I get the info
* from pg_index, and add a new index with a temporary name (that will
* be changed later).
- *
- * NOTE: index_create will cause the new index to be a temp relation if
- * its parent table is, so we don't need to do anything special for
- * the temp-table case here.
*/
indexInfo = BuildIndexInfo(OldIndex->rd_index);
- index_create(RelationGetRelationName(NewHeap),
+ index_create(OIDNewHeap,
NewIndexName,
indexInfo,
OldIndex->rd_rel->relam,
OldIndex->rd_index->indclass,
+ istemp,
OldIndex->rd_index->indisprimary,
allowSystemTableMods);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.165 2002/03/22 21:34:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/command.c,v 1.166 2002/03/26 19:15:36 tgl Exp $
*
* NOTES
* The PerformAddAttribute() code, like most of the relation
#include "catalog/heap.h"
#include "catalog/index.h"
#include "catalog/indexing.h"
+#include "catalog/namespace.h"
#include "catalog/pg_attrdef.h"
#include "catalog/pg_index.h"
#include "catalog/pg_namespace.h"
#include "catalog/pg_type.h"
#include "commands/command.h"
#include "commands/trigger.h"
-#include "commands/defrem.h"
#include "executor/execdefs.h"
#include "executor/executor.h"
#include "miscadmin.h"
rel = heap_openr(RelationRelationName, RowExclusiveLock);
- reltup = SearchSysCache(RELNAME,
- PointerGetDatum(relationName),
+ reltup = SearchSysCache(RELOID,
+ ObjectIdGetDatum(myrelid),
0, 0, 0);
if (!HeapTupleIsValid(reltup))
relationName);
if (SearchSysCacheExists(ATTNAME,
- ObjectIdGetDatum(reltup->t_data->t_oid),
+ ObjectIdGetDatum(myrelid),
PointerGetDatum(colDef->colname),
0, 0))
elog(ERROR, "ALTER TABLE: column name \"%s\" already exists in table \"%s\"",
attribute = (Form_pg_attribute) GETSTRUCT(attributeTuple);
- attribute->attrelid = reltup->t_data->t_oid;
+ attribute->attrelid = myrelid;
namestrcpy(&(attribute->attname), colDef->colname);
attribute->atttypid = typeTuple->t_data->t_oid;
attribute->attstattarget = DEFAULT_ATTSTATTARGET;
*/
if (colDef->constraints != NIL)
{
- rel = heap_openr(relationName, AccessExclusiveLock);
+ rel = heap_open(myrelid, AccessExclusiveLock);
AddRelationRawConstraints(rel, NIL, colDef->constraints);
heap_close(rel, NoLock);
}
* Automatically create the secondary relation for TOAST if it
* formerly had no such but now has toastable attributes.
*/
- AlterTableCreateToastTable(relationName, true);
+ AlterTableCreateToastTable(myrelid, true);
}
}
else
{
- htup = SearchSysCache(RELOID,
- ObjectIdGetDatum(index->indexrelid),
- 0, 0, 0);
- RemoveIndex(NameStr(((Form_pg_class) GETSTRUCT(htup))->relname));
- ReleaseSysCache(htup);
+ index_drop(index->indexrelid);
}
break;
}
* lock the pg_class tuple for update
*/
rel = heap_openr(RelationRelationName, RowExclusiveLock);
- reltup = SearchSysCache(RELNAME,
- PointerGetDatum(relationName),
+ reltup = SearchSysCache(RELOID,
+ ObjectIdGetDatum(myrelid),
0, 0, 0);
if (!HeapTupleIsValid(reltup))
elog(ERROR, "ALTER TABLE: relation \"%s\" not found",
* Get the target pg_attribute tuple and make a modifiable copy
*/
tup = SearchSysCacheCopy(ATTNAME,
- ObjectIdGetDatum(reltup->t_data->t_oid),
+ ObjectIdGetDatum(myrelid),
PointerGetDatum(colName),
0, 0);
if (!HeapTupleIsValid(tup))
* someone doesn't delete rows out from under us.
*/
- pkrel = heap_openr(fkconstraint->pktable->relname, AccessExclusiveLock);
+ pkrel = heap_openrv(fkconstraint->pktable,
+ AccessExclusiveLock);
if (pkrel->rd_rel->relkind != RELKIND_RELATION)
elog(ERROR, "referenced table \"%s\" not a relation",
fkconstraint->pktable->relname);
* ALTER TABLE OWNER
*/
void
-AlterTableOwner(const char *relationName, const char *newOwnerName)
+AlterTableOwner(const RangeVar *tgtrel, const char *newOwnerName)
{
- Oid relationOid;
- Relation relation;
- int32 newOwnerSysId;
+ Relation rel;
+ Oid myrelid;
+ int32 newOwnerSysId;
/* check that we are the superuser */
if (!superuser())
elog(ERROR, "ALTER TABLE: permission denied");
/* lookup the OID of the target relation */
- relation = RelationNameGetRelation(relationName);
- relationOid = relation->rd_id;
- RelationClose(relation);
+ rel = relation_openrv(tgtrel, AccessExclusiveLock);
+ myrelid = RelationGetRelid(rel);
+ heap_close(rel, NoLock); /* close rel but keep lock! */
/* lookup the sysid of the new owner */
newOwnerSysId = get_usesysid(newOwnerName);
/* do all the actual work */
- AlterTableOwnerId(relationOid, newOwnerSysId);
+ AlterTableOwnerId(myrelid, newOwnerSysId);
}
static void
AlterTableOwnerId(Oid relationOid, int32 newOwnerSysId)
{
+ Relation target_rel;
Relation class_rel;
HeapTuple tuple;
Relation idescs[Num_pg_class_indices];
Form_pg_class tuple_class;
+ /* Get exclusive lock till end of transaction on the target table */
+ target_rel = heap_open(relationOid, AccessExclusiveLock);
+
+ /* Get its pg_class tuple, too */
+ class_rel = heap_openr(RelationRelationName, RowExclusiveLock);
+
tuple = SearchSysCacheCopy(RELOID,
ObjectIdGetDatum(relationOid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "ALTER TABLE: object ID %hd not found",
- relationOid);
-
+ elog(ERROR, "ALTER TABLE: relation %u not found", relationOid);
tuple_class = (Form_pg_class) GETSTRUCT(tuple);
/* Can we change the ownership of this tuple? */
* Okay, this is a valid tuple: change its ownership and
* write to the heap.
*/
- class_rel = heap_openr(RelationRelationName, RowExclusiveLock);
tuple_class->relowner = newOwnerSysId;
simple_heap_update(class_rel, &tuple->t_self, tuple);
* indexes that belong to the table, as well as the table's toast
* table (if it has one)
*/
- if (tuple_class->relkind == RELKIND_RELATION)
+ if (tuple_class->relkind == RELKIND_RELATION ||
+ tuple_class->relkind == RELKIND_TOASTVALUE)
{
- /* Search for indexes belonging to this table */
- Relation target_rel;
List *index_oid_list, *i;
/* Find all the indexes belonging to this relation */
- target_rel = heap_open(relationOid, RowExclusiveLock);
index_oid_list = RelationGetIndexList(target_rel);
- heap_close(target_rel, RowExclusiveLock);
/* For each index, recursively change its ownership */
- foreach (i, index_oid_list)
+ foreach(i, index_oid_list)
{
AlterTableOwnerId(lfirsti(i), newOwnerSysId);
}
freeList(index_oid_list);
+ }
+ if (tuple_class->relkind == RELKIND_RELATION)
+ {
/* If it has a toast table, recurse to change its ownership */
if (tuple_class->reltoastrelid != InvalidOid)
{
}
heap_freetuple(tuple);
- heap_close(class_rel, NoLock);
+ heap_close(class_rel, RowExclusiveLock);
+ heap_close(target_rel, NoLock);
}
static void
* ALTER TABLE CREATE TOAST TABLE
*/
void
-AlterTableCreateToastTable(const char *relationName, bool silent)
+AlterTableCreateToastTable(Oid relOid, bool silent)
{
Relation rel;
- Oid myrelid;
HeapTuple reltup;
HeapTupleData classtuple;
TupleDesc tupdesc;
* Grab an exclusive lock on the target table, which we will NOT
* release until end of transaction.
*/
- rel = heap_openr(relationName, AccessExclusiveLock);
- myrelid = RelationGetRelid(rel);
+ rel = heap_open(relOid, AccessExclusiveLock);
if (rel->rd_rel->relkind != RELKIND_RELATION)
elog(ERROR, "ALTER TABLE: relation \"%s\" is not a table",
- relationName);
+ RelationGetRelationName(rel));
- if (!pg_class_ownercheck(myrelid, GetUserId()))
+ if (!pg_class_ownercheck(relOid, GetUserId()))
elog(ERROR, "ALTER TABLE: permission denied");
/*
*/
class_rel = heap_openr(RelationRelationName, RowExclusiveLock);
- reltup = SearchSysCache(RELNAME,
- PointerGetDatum(relationName),
+ reltup = SearchSysCache(RELOID,
+ ObjectIdGetDatum(relOid),
0, 0, 0);
if (!HeapTupleIsValid(reltup))
elog(ERROR, "ALTER TABLE: relation \"%s\" not found",
- relationName);
+ RelationGetRelationName(rel));
classtuple.t_self = reltup->t_self;
ReleaseSysCache(reltup);
}
elog(ERROR, "ALTER TABLE: relation \"%s\" already has a toast table",
- relationName);
+ RelationGetRelationName(rel));
}
/*
}
elog(ERROR, "ALTER TABLE: relation \"%s\" does not need a toast table",
- relationName);
+ RelationGetRelationName(rel));
}
/*
* Create the toast table and its index
*/
- sprintf(toast_relname, "pg_toast_%u", myrelid);
- sprintf(toast_idxname, "pg_toast_%u_idx", myrelid);
+ sprintf(toast_relname, "pg_toast_%u", relOid);
+ sprintf(toast_idxname, "pg_toast_%u_idx", relOid);
/* this is pretty painful... need a tuple descriptor */
tupdesc = CreateTemplateTupleDesc(3);
* collision, and the toast rel will be destroyed when its master is,
* so there's no need to handle the toast rel as temp.
*/
- toast_relid = heap_create_with_catalog(toast_relname, tupdesc,
+ toast_relid = heap_create_with_catalog(toast_relname,
+ RelationGetNamespace(rel),
+ tupdesc,
RELKIND_TOASTVALUE, false,
false, true);
classObjectId[0] = OID_BTREE_OPS_OID;
classObjectId[1] = INT4_BTREE_OPS_OID;
- toast_idxid = index_create(toast_relname, toast_idxname, indexInfo,
+ toast_idxid = index_create(toast_relid, toast_idxname, indexInfo,
BTREE_AM_OID, classObjectId,
- true, true);
+ false, true, true);
/*
* Update toast rel's pg_class entry to show that it has an index. The
foreach(p, lockstmt->relations)
{
RangeVar *relation = lfirst(p);
- char *relname = relation->relname;
Oid reloid;
- int aclresult;
+ int32 aclresult;
Relation rel;
/*
* We don't want to open the relation until we've checked privilege.
* So, manually get the relation OID.
*/
- reloid = GetSysCacheOid(RELNAME,
- PointerGetDatum(relname),
- 0, 0, 0);
- if (!OidIsValid(reloid))
- elog(ERROR, "LOCK TABLE: relation \"%s\" does not exist",
- relname);
+ reloid = RangeVarGetRelid(relation, false);
if (lockstmt->mode == AccessShareLock)
aclresult = pg_class_aclcheck(reloid, GetUserId(),
/* Currently, we only allow plain tables to be locked */
if (rel->rd_rel->relkind != RELKIND_RELATION)
elog(ERROR, "LOCK TABLE: %s is not a table",
- relname);
+ relation->relname);
relation_close(rel, NoLock); /* close rel, keep lock */
}
* Copyright (c) 1999-2001, PostgreSQL Global Development Group
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/comment.c,v 1.36 2002/03/21 23:27:20 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/comment.c,v 1.37 2002/03/26 19:15:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/indexing.h"
#include "catalog/pg_database.h"
#include "catalog/pg_description.h"
+#include "catalog/pg_namespace.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_rewrite.h"
#include "catalog/pg_trigger.h"
*------------------------------------------------------------------
*/
-static void CommentRelation(int objtype, char *relation, char *comment);
+static void CommentRelation(int objtype, char * schemaname, char *relation,
+ char *comment);
static void CommentAttribute(char *relation, char *attrib, char *comment);
static void CommentDatabase(char *database, char *comment);
static void CommentRewrite(char *rule, char *comment);
*/
void
-CommentObject(int objtype, char *objname, char *objproperty,
+CommentObject(int objtype, char *schemaname, char *objname, char *objproperty,
List *objlist, char *comment)
{
switch (objtype)
case SEQUENCE:
case TABLE:
case VIEW:
- CommentRelation(objtype, objname, comment);
+ CommentRelation(objtype, schemaname, objname, comment);
break;
case COLUMN:
CommentAttribute(objname, objproperty, comment);
*/
static void
-CommentRelation(int reltype, char *relname, char *comment)
+CommentRelation(int reltype, char *schemaname, char *relname, char *comment)
{
Relation relation;
+ RangeVar *tgtrel = makeNode(RangeVar);
+
+
+ tgtrel->relname = relname;
+ tgtrel->schemaname = schemaname;
+ /* FIXME SCHEMA: Can we add comments to temp relations? */
+ tgtrel->istemp = false;
/*
* Open the relation. We do this mainly to acquire a lock that
* did, they'd fail to remove the entry we are about to make in
* pg_description.)
*/
- relation = relation_openr(relname, AccessShareLock);
+ relation = relation_openrv(tgtrel, AccessShareLock);
/* Check object security */
if (!pg_class_ownercheck(RelationGetRelid(relation), GetUserId()))
/* pg_rewrite doesn't have a hard-coded OID, so must look it up */
- classoid = GetSysCacheOid(RELNAME,
- PointerGetDatum(RewriteRelationName),
- 0, 0, 0);
+ classoid = get_relname_relid(RewriteRelationName, PG_CATALOG_NAMESPACE);
Assert(OidIsValid(classoid));
/* Call CreateComments() to create/drop the comments */
/* pg_aggregate doesn't have a hard-coded OID, so must look it up */
- classoid = GetSysCacheOid(RELNAME,
- PointerGetDatum(AggregateRelationName),
- 0, 0, 0);
+ classoid = get_relname_relid(AggregateRelationName, PG_CATALOG_NAMESPACE);
Assert(OidIsValid(classoid));
/* Call CreateComments() to create/drop the comments */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.91 2002/03/22 02:56:31 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/creatinh.c,v 1.92 2002/03/26 19:15:40 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/catalog.h"
#include "catalog/catname.h"
-#include "catalog/indexing.h"
#include "catalog/heap.h"
+#include "catalog/indexing.h"
+#include "catalog/namespace.h"
#include "catalog/pg_inherits.h"
+#include "catalog/pg_namespace.h"
#include "catalog/pg_type.h"
#include "commands/creatinh.h"
#include "miscadmin.h"
DefineRelation(CreateStmt *stmt, char relkind)
{
char *relname = palloc(NAMEDATALEN);
+ Oid namespaceId;
List *schema = stmt->tableElts;
int numberOfAttributes;
Oid relationId;
StrNCpy(relname, (stmt->relation)->relname, NAMEDATALEN);
/*
+ * Look up the namespace in which we are supposed to create the
+ * relation.
+ */
+ namespaceId = RangeVarGetCreationNamespace(stmt->relation);
+
+ /*
* Merge domain attributes into the known columns before processing table
* inheritance. Otherwise we risk adding double constraints to a
* domain-type column that's inherited.
}
}
- relationId = heap_create_with_catalog(relname, descriptor,
+ relationId = heap_create_with_catalog(relname, namespaceId,
+ descriptor,
relkind,
stmt->hasoids || parentHasOids,
stmt->relation->istemp,
* Input arguments:
* 'schema' is the column/attribute definition for the table. (It's a list
* of ColumnDef's.) It is destructively changed.
- * 'supers' is a list of names (as Value objects) of parent relations.
+ * 'supers' is a list of names (as RangeVar nodes) of parent relations.
* 'istemp' is TRUE if we are creating a temp relation.
*
* Output arguments:
}
/*
- * Reject duplicate names in the list of parents, too.
- *
- * XXX needs to be smarter about schema-qualified table names.
- */
- foreach(entry, supers)
- {
- List *rest;
-
- foreach(rest, lnext(entry))
- {
- if (strcmp(((RangeVar *) lfirst(entry))->relname,
- ((RangeVar *) lfirst(rest))->relname) == 0)
- elog(ERROR, "CREATE TABLE: inherited relation \"%s\" duplicated",
- ((RangeVar *) lfirst(entry))->relname);
- }
- }
-
- /*
* Scan the parents left-to-right, and merge their attributes to form
* a list of inherited attributes (inhSchema). Also check to see if
* we need to inherit an OID column.
child_attno = 0;
foreach(entry, supers)
{
- char *name = ((RangeVar *) lfirst(entry))->relname;
+ RangeVar *parent = (RangeVar *) lfirst(entry);
Relation relation;
TupleDesc tupleDesc;
TupleConstr *constr;
AttrNumber *newattno;
AttrNumber parent_attno;
- relation = heap_openr(name, AccessShareLock);
+ relation = heap_openrv(parent, AccessShareLock);
if (relation->rd_rel->relkind != RELKIND_RELATION)
- elog(ERROR, "CREATE TABLE: inherited relation \"%s\" is not a table", name);
+ elog(ERROR, "CREATE TABLE: inherited relation \"%s\" is not a table",
+ parent->relname);
/* Permanent rels cannot inherit from temporary ones */
- if (!istemp && is_temp_rel_name(name))
- elog(ERROR, "CREATE TABLE: cannot inherit from temp relation \"%s\"", name);
+ if (!istemp && is_temp_rel_name(parent->relname))
+ elog(ERROR, "CREATE TABLE: cannot inherit from temp relation \"%s\"",
+ parent->relname);
/*
* We should have an UNDER permission flag for this, but for now,
* demand that creator of a child table own the parent.
*/
if (!pg_class_ownercheck(RelationGetRelid(relation), GetUserId()))
- elog(ERROR, "you do not own table \"%s\"", name);
+ elog(ERROR, "you do not own table \"%s\"",
+ parent->relname);
+
+ /*
+ * Reject duplications in the list of parents.
+ */
+ if (intMember(RelationGetRelid(relation), parentOids))
+ elog(ERROR, "CREATE TABLE: inherited relation \"%s\" duplicated",
+ parent->relname);
- parentOids = lappendi(parentOids, relation->rd_id);
- setRelhassubclassInRelation(relation->rd_id, true);
+ parentOids = lappendi(parentOids, RelationGetRelid(relation));
+ setRelhassubclassInRelation(RelationGetRelid(relation), true);
parentHasOids |= relation->rd_rel->relhasoids;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.64 2002/03/20 19:43:47 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/indexcmds.c,v 1.65 2002/03/26 19:15:41 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/catalog.h"
#include "catalog/catname.h"
-#include "catalog/heap.h"
#include "catalog/index.h"
+#include "catalog/namespace.h"
#include "catalog/pg_opclass.h"
#include "commands/defrem.h"
#include "miscadmin.h"
#include "utils/fmgroids.h"
#include "utils/lsyscache.h"
#include "utils/syscache.h"
+#include "utils/temprel.h"
#define IsFuncIndex(ATTR_LIST) (((IndexElem*)lfirst(ATTR_LIST))->args != NIL)
* 'rangetable' is needed to interpret the predicate.
*/
void
-DefineIndex(char *heapRelationName,
+DefineIndex(RangeVar *heapRelation,
char *indexRelationName,
char *accessMethodName,
List *attributeList,
Oid *classObjectId;
Oid accessMethodId;
Oid relationId;
+ bool istemp = is_temp_rel_name(heapRelation->relname);
Relation rel;
HeapTuple tuple;
Form_pg_am accessMethodForm;
/*
* Open heap relation, acquire a suitable lock on it, remember its OID
*/
- rel = heap_openr(heapRelationName, ShareLock);
+ rel = heap_openrv(heapRelation, ShareLock);
/* Note: during bootstrap may see uncataloged relation */
if (rel->rd_rel->relkind != RELKIND_RELATION &&
rel->rd_rel->relkind != RELKIND_UNCATALOGED)
elog(ERROR, "DefineIndex: relation \"%s\" is not a table",
- heapRelationName);
+ heapRelation->relname);
relationId = RelationGetRelid(rel);
heap_close(rel, NoLock);
if (!IsBootstrapProcessingMode() &&
- IsSystemRelationName(heapRelationName) &&
+ IsSystemRelationName(heapRelation->relname) &&
!IndexesAreActive(relationId, false))
elog(ERROR, "Existing indexes are inactive. REINDEX first");
relationId, accessMethodName, accessMethodId);
}
- index_create(heapRelationName, indexRelationName,
+ index_create(relationId, indexRelationName,
indexInfo, accessMethodId, classObjectId,
- primary, allowSystemTableMods);
+ istemp, primary, allowSystemTableMods);
/*
* We update the relation's pg_class tuple even if it already has
* ...
*/
void
-RemoveIndex(char *name)
+RemoveIndex(RangeVar *relation)
{
+ Oid indOid;
HeapTuple tuple;
- tuple = SearchSysCache(RELNAME,
- PointerGetDatum(name),
+ indOid = RangeVarGetRelid(relation, false);
+ tuple = SearchSysCache(RELOID,
+ ObjectIdGetDatum(indOid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "index \"%s\" does not exist", name);
+ elog(ERROR, "index \"%s\" does not exist", relation->relname);
if (((Form_pg_class) GETSTRUCT(tuple))->relkind != RELKIND_INDEX)
elog(ERROR, "relation \"%s\" is of type \"%c\"",
- name, ((Form_pg_class) GETSTRUCT(tuple))->relkind);
-
- index_drop(tuple->t_data->t_oid);
+ relation->relname, ((Form_pg_class) GETSTRUCT(tuple))->relkind);
ReleaseSysCache(tuple);
+
+ index_drop(indOid);
}
/*
* ...
*/
void
-ReindexIndex(const char *name, bool force /* currently unused */ )
+ReindexIndex(RangeVar *indexRelation, bool force /* currently unused */ )
{
+ Oid indOid;
HeapTuple tuple;
bool overwrite = false;
if (IsTransactionBlock())
elog(ERROR, "REINDEX cannot run inside a BEGIN/END block");
- tuple = SearchSysCache(RELNAME,
- PointerGetDatum(name),
+ indOid = RangeVarGetRelid(indexRelation, false);
+ tuple = SearchSysCache(RELOID,
+ ObjectIdGetDatum(indOid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "index \"%s\" does not exist", name);
+ elog(ERROR, "index \"%s\" does not exist", indexRelation->relname);
if (((Form_pg_class) GETSTRUCT(tuple))->relkind != RELKIND_INDEX)
elog(ERROR, "relation \"%s\" is of type \"%c\"",
- name, ((Form_pg_class) GETSTRUCT(tuple))->relkind);
+ indexRelation->relname,
+ ((Form_pg_class) GETSTRUCT(tuple))->relkind);
+
+ ReleaseSysCache(tuple);
if (IsIgnoringSystemIndexes())
overwrite = true;
- if (!reindex_index(tuple->t_data->t_oid, force, overwrite))
- elog(WARNING, "index \"%s\" wasn't reindexed", name);
-
- ReleaseSysCache(tuple);
+ if (!reindex_index(indOid, force, overwrite))
+ elog(WARNING, "index \"%s\" wasn't reindexed", indexRelation->relname);
}
/*
* ...
*/
void
-ReindexTable(const char *name, bool force)
+ReindexTable(RangeVar *relation, bool force)
{
+ Oid heapOid;
HeapTuple tuple;
/*
if (IsTransactionBlock())
elog(ERROR, "REINDEX cannot run inside a BEGIN/END block");
- tuple = SearchSysCache(RELNAME,
- PointerGetDatum(name),
+ heapOid = RangeVarGetRelid(relation, false);
+ tuple = SearchSysCache(RELOID,
+ ObjectIdGetDatum(heapOid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "table \"%s\" does not exist", name);
+ elog(ERROR, "table \"%s\" does not exist", relation->relname);
if (((Form_pg_class) GETSTRUCT(tuple))->relkind != RELKIND_RELATION)
elog(ERROR, "relation \"%s\" is of type \"%c\"",
- name, ((Form_pg_class) GETSTRUCT(tuple))->relkind);
-
- if (!reindex_relation(tuple->t_data->t_oid, force))
- elog(WARNING, "table \"%s\" wasn't reindexed", name);
+ relation->relname,
+ ((Form_pg_class) GETSTRUCT(tuple))->relkind);
ReleaseSysCache(tuple);
+
+ if (!reindex_relation(heapOid, force))
+ elog(WARNING, "table \"%s\" wasn't reindexed", relation->relname);
}
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.64 2002/03/21 23:27:21 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/Attic/rename.c,v 1.65 2002/03/26 19:15:43 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "utils/acl.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
+#include "utils/lsyscache.h"
#include "utils/relcache.h"
#include "utils/syscache.h"
#include "utils/temprel.h"
* renamerel - change the name of a relation
*/
void
-renamerel(const char *oldrelname, const char *newrelname)
+renamerel(const RangeVar *relation, const char *newrelname)
{
Relation targetrelation;
Relation relrelation; /* for RELATION relation */
HeapTuple reltup;
+ Oid namespaceId;
Oid reloid;
char relkind;
bool relhastriggers;
Relation irelations[Num_pg_class_indices];
- if (!allowSystemTableMods && IsSystemRelationName(oldrelname))
+ if (!allowSystemTableMods && IsSystemRelationName(relation->relname))
elog(ERROR, "renamerel: system relation \"%s\" may not be renamed",
- oldrelname);
+ relation->relname);
if (!allowSystemTableMods && IsSystemRelationName(newrelname))
elog(ERROR, "renamerel: Illegal class name: \"%s\" -- pg_ is reserved for system catalogs",
* Check for renaming a temp table, which only requires altering the
* temp-table mapping, not the underlying table.
*/
- if (rename_temp_relation(oldrelname, newrelname))
+ if (rename_temp_relation(relation->relname, newrelname))
return; /* all done... */
/*
* Grab an exclusive lock on the target table or index, which we will
* NOT release until end of transaction.
*/
- targetrelation = relation_openr(oldrelname, AccessExclusiveLock);
+ targetrelation = relation_openrv(relation, AccessExclusiveLock);
+ namespaceId = RelationGetNamespace(targetrelation);
reloid = RelationGetRelid(targetrelation);
relkind = targetrelation->rd_rel->relkind;
relhastriggers = (targetrelation->rd_rel->reltriggers > 0);
*/
relrelation = heap_openr(RelationRelationName, RowExclusiveLock);
- reltup = SearchSysCacheCopy(RELNAME,
- PointerGetDatum(oldrelname),
+ reltup = SearchSysCacheCopy(RELOID,
+ PointerGetDatum(reloid),
0, 0, 0);
if (!HeapTupleIsValid(reltup))
- elog(ERROR, "renamerel: relation \"%s\" does not exist", oldrelname);
+ elog(ERROR, "renamerel: relation \"%s\" does not exist",
+ relation->relname);
- if (RelnameFindRelid(newrelname) != InvalidOid)
+ if (get_relname_relid(newrelname, namespaceId) != InvalidOid)
elog(ERROR, "renamerel: relation \"%s\" exists", newrelname);
/*
* Also rename the associated type, if any.
*/
if (relkind != RELKIND_INDEX)
- TypeRename(oldrelname, newrelname);
+ TypeRename(relation->relname, newrelname);
/*
* If it's a view, must also rename the associated ON SELECT rule.
char *oldrulename,
*newrulename;
- oldrulename = MakeRetrieveViewRuleName(oldrelname);
+ oldrulename = MakeRetrieveViewRuleName(relation->relname);
newrulename = MakeRetrieveViewRuleName(newrelname);
RenameRewriteRule(oldrulename, newrulename);
}
{
/* update tgargs where relname is primary key */
update_ri_trigger_args(reloid,
- oldrelname, newrelname,
+ relation->relname, newrelname,
false, true);
/* update tgargs where relname is foreign key */
update_ri_trigger_args(reloid,
- oldrelname, newrelname,
+ relation->relname, newrelname,
true, true);
}
}
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.107 2002/03/21 23:27:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.108 2002/03/26 19:15:45 tgl Exp $
*
*-------------------------------------------------------------------------
*/
char *constrname = "";
Oid constrrelid = InvalidOid;
- rel = heap_openr(stmt->relation->relname, AccessExclusiveLock);
+ rel = heap_openrv(stmt->relation, AccessExclusiveLock);
if (rel->rd_rel->relkind != RELKIND_RELATION)
elog(ERROR, "CreateTrigger: relation \"%s\" is not a table",
*/
Relation conrel;
- conrel = heap_openr(stmt->constrrel->relname, NoLock);
+ conrel = heap_openrv(stmt->constrrel, NoLock);
constrrelid = conrel->rd_id;
heap_close(conrel, NoLock);
}
* rebuild relcache entries.
*/
pgrel = heap_openr(RelationRelationName, RowExclusiveLock);
- tuple = SearchSysCacheCopy(RELNAME,
- PointerGetDatum(stmt->relation->relname),
+ tuple = SearchSysCacheCopy(RELOID,
+ ObjectIdGetDatum(RelationGetRelid(rel)),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
elog(ERROR, "CreateTrigger: relation %s not found in pg_class",
int found = 0;
int tgfound = 0;
- rel = heap_openr(stmt->relation->relname, AccessExclusiveLock);
+ rel = heap_openrv(stmt->relation, AccessExclusiveLock);
if (rel->rd_rel->relkind != RELKIND_RELATION)
elog(ERROR, "DropTrigger: relation \"%s\" is not a table",
* rebuild relcache entries.
*/
pgrel = heap_openr(RelationRelationName, RowExclusiveLock);
- tuple = SearchSysCacheCopy(RELNAME,
- PointerGetDatum(stmt->relation->relname),
+ tuple = SearchSysCacheCopy(RELOID,
+ ObjectIdGetDatum(RelationGetRelid(rel)),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
elog(ERROR, "DropTrigger: relation %s not found in pg_class",
pgrel = heap_openr(RelationRelationName, RowExclusiveLock);
tup = SearchSysCacheCopy(RELOID,
- RelationGetRelid(rel),
+ ObjectIdGetDatum(RelationGetRelid(rel)),
0, 0, 0);
if (!HeapTupleIsValid(tup))
elog(ERROR, "RelationRemoveTriggers: relation %u not found in pg_class",
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/commands/user.c,v 1.93 2002/03/06 06:09:37 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/user.c,v 1.94 2002/03/26 19:15:48 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* check to see if there is an ACL on pg_shadow
*/
static void
-CheckPgUserAclNotNull()
+CheckPgUserAclNotNull(void)
{
HeapTuple htup;
- htup = SearchSysCache(RELNAME,
- PointerGetDatum(ShadowRelationName),
+ htup = SearchSysCache(RELOID,
+ ObjectIdGetDatum(RelOid_pg_shadow),
0, 0, 0);
if (!HeapTupleIsValid(htup))
elog(ERROR, "CheckPgUserAclNotNull: \"%s\" not found",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.154 2002/03/21 23:27:23 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.155 2002/03/26 19:15:54 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/heap.h"
+#include "catalog/namespace.h"
#include "commands/command.h"
#include "commands/trigger.h"
#include "executor/execdebug.h"
if (operation == CMD_SELECT)
{
- char *intoName;
- Oid intoRelationId;
- TupleDesc tupdesc;
-
if (!parseTree->isPortal)
{
/*
*/
if (parseTree->into != NULL)
{
+ char *intoName;
+ Oid namespaceId;
+ Oid intoRelationId;
+ TupleDesc tupdesc;
+
/*
* create the "into" relation
*/
intoName = parseTree->into->relname;
+ namespaceId = RangeVarGetCreationNamespace(parseTree->into);
/*
* have to copy tupType to get rid of constraints
intoRelationId =
heap_create_with_catalog(intoName,
+ namespaceId,
tupdesc,
RELKIND_RELATION, true,
parseTree->into->istemp,
* with CommandCounterIncrement(), so that the TOAST table
* will be visible for insertion.
*/
- AlterTableCreateToastTable(intoName, true);
+ AlterTableCreateToastTable(intoRelationId, true);
intoRelationDesc = heap_open(intoRelationId,
AccessExclusiveLock);
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.222 2002/03/22 02:56:33 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.223 2002/03/26 19:15:56 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/catname.h"
#include "catalog/heap.h"
#include "catalog/index.h"
+#include "catalog/namespace.h"
#include "catalog/pg_index.h"
#include "catalog/pg_type.h"
#include "nodes/makefuncs.h"
static void transformColumnType(ParseState *pstate, ColumnDef *column);
static void transformFkeyCheckAttrs(FkConstraint *fkconstraint, Oid *pktypoid);
static void transformFkeyGetPrimaryKey(FkConstraint *fkconstraint, Oid *pktypoid);
-static bool relationHasPrimaryKey(char *relname);
+static bool relationHasPrimaryKey(Oid relationOid);
static Oid transformFkeyGetColType(CreateStmtContext *cxt, char *colname);
static void release_pstate_resources(ParseState *pstate);
static FromExpr *makeFromExpr(List *fromlist, Node *quals);
/* In ALTER TABLE case, a primary index might already exist */
if (cxt->pkey != NULL ||
(OidIsValid(cxt->relOid) &&
- relationHasPrimaryKey((cxt->relation)->relname)))
+ relationHasPrimaryKey(cxt->relOid)))
elog(ERROR, "%s / PRIMARY KEY multiple primary keys"
" for table '%s' are not allowed",
cxt->stmtType, (cxt->relation)->relname);
int count;
Assert(IsA(inh, RangeVar));
- rel = heap_openr(inh->relname, AccessShareLock);
+ rel = heap_openrv(inh, AccessShareLock);
if (rel->rd_rel->relkind != RELKIND_RELATION)
elog(ERROR, "inherited table \"%s\" is not a relation",
- strVal(inh));
+ inh->relname);
for (count = 0; count < rel->rd_att->natts; count++)
{
Form_pg_attribute inhattr = rel->rd_att->attrs[count];
* beforehand. We don't need to hold a refcount on the relcache
* entry, however.
*/
- heap_close(heap_openr(stmt->relation->relname, AccessExclusiveLock),
+ heap_close(heap_openrv(stmt->relation, AccessExclusiveLock),
NoLock);
/*
cxt.relation = stmt->relation;
cxt.inhRelations = NIL;
cxt.relation->istemp = is_temp_rel_name(stmt->relation->relname);
- cxt.relOid = GetSysCacheOid(RELNAME,
- PointerGetDatum((stmt->relation)->relname),
- 0, 0, 0);
+ cxt.relOid = RangeVarGetRelid(stmt->relation, false);
cxt.hasoids = SearchSysCacheExists(ATTNUM,
ObjectIdGetDatum(cxt.relOid),
Int16GetDatum(ObjectIdAttributeNumber),
cxt.relation = stmt->relation;
cxt.inhRelations = NIL;
cxt.relation->istemp = is_temp_rel_name(stmt->relation->relname);
- cxt.relOid = GetSysCacheOid(RELNAME,
- PointerGetDatum((stmt->relation)->relname),
- 0, 0, 0);
+ cxt.relOid = RangeVarGetRelid(stmt->relation, false);
cxt.hasoids = SearchSysCacheExists(ATTNUM,
ObjectIdGetDatum(cxt.relOid),
Int16GetDatum(ObjectIdAttributeNumber),
/*
* Open the referenced table
*/
- pkrel = heap_openr(fkconstraint->pktable->relname, AccessShareLock);
+ pkrel = heap_openrv(fkconstraint->pktable, AccessShareLock);
if (pkrel->rd_rel->relkind != RELKIND_RELATION)
elog(ERROR, "Referenced relation \"%s\" is not a table",
/*
* Open the referenced table
*/
- pkrel = heap_openr(fkconstraint->pktable->relname, AccessShareLock);
+ pkrel = heap_openrv(fkconstraint->pktable, AccessShareLock);
if (pkrel->rd_rel->relkind != RELKIND_RELATION)
elog(ERROR, "Referenced relation \"%s\" is not a table",
* See whether an existing relation has a primary key.
*/
static bool
-relationHasPrimaryKey(char *relname)
+relationHasPrimaryKey(Oid relationOid)
{
bool result = false;
Relation rel;
List *indexoidlist,
*indexoidscan;
- rel = heap_openr(relname, AccessShareLock);
+ rel = heap_open(relationOid, AccessShareLock);
/*
* Get the list of index OIDs for the table from the relcache, and
int count;
Assert(IsA(inh, RangeVar));
- rel = heap_openr(inh->relname, AccessShareLock);
+ rel = heap_openrv(inh, AccessShareLock);
if (rel->rd_rel->relkind != RELKIND_RELATION)
elog(ERROR, "inherited table \"%s\" is not a relation",
- strVal(inh));
+ inh->relname);
for (count = 0; count < rel->rd_att->natts; count++)
{
char *name = NameStr(rel->rd_att->attrs[count]->attname);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.86 2002/03/22 02:56:33 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.87 2002/03/26 19:15:57 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* analyze.c will eventually do the corresponding heap_close(), but *not*
* release the lock.
*/
- pstate->p_target_relation = heap_openr(relation->relname, RowExclusiveLock);
+ pstate->p_target_relation = heap_openrv(relation, RowExclusiveLock);
/*
* Now build an RTE.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.65 2002/03/22 02:56:34 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.66 2002/03/26 19:15:59 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* access level depending on whether we're doing SELECT FOR UPDATE.
*/
lockmode = isForUpdate(pstate, refname) ? RowShareLock : AccessShareLock;
- rel = heap_openr(relation->relname, lockmode);
+ rel = heap_openrv(relation, lockmode);
rte->relid = RelationGetRelid(rel);
eref = alias ? (Alias *) copyObject(alias) : makeAlias(refname, NIL);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.65 2002/03/21 23:27:23 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteDefine.c,v 1.66 2002/03/26 19:16:02 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* actions. But for now, let's just grab AccessExclusiveLock all the
* time.
*/
- event_relation = heap_openr(event_obj->relname, AccessExclusiveLock);
+ event_relation = heap_openrv(event_obj, AccessExclusiveLock);
ev_relid = RelationGetRelid(event_relation);
/*
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.139 2002/03/24 04:31:08 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/utility.c,v 1.140 2002/03/26 19:16:03 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/catalog.h"
+#include "catalog/namespace.h"
#include "catalog/pg_shadow.h"
#include "commands/async.h"
#include "commands/cluster.h"
}
static void
-CheckDropPermissions(char *name, char rightkind)
+CheckDropPermissions(RangeVar *rel, char rightkind)
{
struct kindstrings *rentry;
+ Oid relOid;
HeapTuple tuple;
Form_pg_class classform;
break;
Assert(rentry->kind != '\0');
- tuple = SearchSysCache(RELNAME,
- PointerGetDatum(name),
+ relOid = RangeVarGetRelid(rel, true);
+ if (!OidIsValid(relOid))
+ elog(ERROR, "%s \"%s\" does not exist", rentry->name, rel->relname);
+ tuple = SearchSysCache(RELOID,
+ ObjectIdGetDatum(relOid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "%s \"%s\" does not exist", rentry->name, name);
+ elog(ERROR, "%s \"%s\" does not exist", rentry->name, rel->relname);
classform = (Form_pg_class) GETSTRUCT(tuple);
if (classform->relkind != rightkind)
- DropErrorMsg(name, classform->relkind, rightkind);
+ DropErrorMsg(rel->relname, classform->relkind, rightkind);
- if (!pg_class_ownercheck(tuple->t_data->t_oid, GetUserId()))
+ if (!pg_class_ownercheck(relOid, GetUserId()))
elog(ERROR, "you do not own %s \"%s\"",
- rentry->name, name);
+ rentry->name, rel->relname);
- if (!allowSystemTableMods && IsSystemRelationName(name) &&
- !is_temp_relname(name))
+ if (!allowSystemTableMods && IsSystemRelationName(rel->relname) &&
+ !is_temp_relname(rel->relname))
elog(ERROR, "%s \"%s\" is a system %s",
- rentry->name, name, rentry->name);
+ rentry->name, rel->relname, rentry->name);
ReleaseSysCache(tuple);
}
static void
-CheckOwnership(char *relname, bool noCatalogs)
+CheckOwnership(RangeVar *rel, bool noCatalogs)
{
+ Oid relOid;
HeapTuple tuple;
- tuple = SearchSysCache(RELNAME,
- PointerGetDatum(relname),
+ relOid = RangeVarGetRelid(rel, false);
+ tuple = SearchSysCache(RELOID,
+ ObjectIdGetDatum(relOid),
0, 0, 0);
if (!HeapTupleIsValid(tuple))
- elog(ERROR, "Relation \"%s\" does not exist", relname);
+ elog(ERROR, "Relation \"%s\" does not exist", rel->relname);
- if (!pg_class_ownercheck(tuple->t_data->t_oid, GetUserId()))
- elog(ERROR, "%s: %s", relname,
+ if (!pg_class_ownercheck(relOid, GetUserId()))
+ elog(ERROR, "%s: %s", rel->relname,
aclcheck_error_strings[ACLCHECK_NOT_OWNER]);
if (noCatalogs)
{
- if (!allowSystemTableMods && IsSystemRelationName(relname))
+ if (!allowSystemTableMods && IsSystemRelationName(rel->relname))
elog(ERROR, "relation \"%s\" is a system catalog",
- relname);
+ rel->relname);
}
ReleaseSysCache(tuple);
break;
case T_CreateStmt:
- DefineRelation((CreateStmt *) parsetree, RELKIND_RELATION);
+ {
+ Oid relOid;
- /*
- * Let AlterTableCreateToastTable decide if this one needs a
- * secondary relation too.
- */
- CommandCounterIncrement();
- AlterTableCreateToastTable(((CreateStmt *) parsetree)->relation->relname,
- true);
+ relOid = DefineRelation((CreateStmt *) parsetree,
+ RELKIND_RELATION);
+
+ /*
+ * Let AlterTableCreateToastTable decide if this one needs a
+ * secondary relation too.
+ */
+ CommandCounterIncrement();
+ AlterTableCreateToastTable(relOid, true);
+ }
break;
case T_DropStmt:
{
DropStmt *stmt = (DropStmt *) parsetree;
- List *args = stmt->objects;
List *arg;
- foreach(arg, args)
+ foreach(arg, stmt->objects)
{
- relname = ((RangeVar *) lfirst(arg))->relname;
+ RangeVar *rel = (RangeVar *) lfirst(arg);
+
+ relname = rel->relname;
switch (stmt->removeType)
{
case DROP_TABLE:
- CheckDropPermissions(relname, RELKIND_RELATION);
+ CheckDropPermissions(rel, RELKIND_RELATION);
RemoveRelation(relname);
break;
case DROP_SEQUENCE:
- CheckDropPermissions(relname, RELKIND_SEQUENCE);
+ CheckDropPermissions(rel, RELKIND_SEQUENCE);
RemoveRelation(relname);
break;
case DROP_VIEW:
- CheckDropPermissions(relname, RELKIND_VIEW);
+ CheckDropPermissions(rel, RELKIND_VIEW);
RemoveView(relname);
break;
case DROP_INDEX:
- CheckDropPermissions(relname, RELKIND_INDEX);
- RemoveIndex(relname);
+ CheckDropPermissions(rel, RELKIND_INDEX);
+ RemoveIndex(rel);
break;
case DROP_RULE:
case T_CommentStmt:
{
- CommentStmt *statement;
+ CommentStmt *stmt;
- statement = ((CommentStmt *) parsetree);
+ stmt = ((CommentStmt *) parsetree);
- CommentObject(statement->objtype, statement->objname,
- statement->objproperty, statement->objlist,
- statement->comment);
+ CommentObject(stmt->objtype, stmt->objschema, stmt->objname,
+ stmt->objproperty, stmt->objlist, stmt->comment);
}
break;
RenameStmt *stmt = (RenameStmt *) parsetree;
relname = stmt->relation->relname;
- CheckOwnership(relname, true);
+ CheckOwnership(stmt->relation, true);
/* ----------------
* XXX using len == 3 to tell the difference
* Note: we also rename the "type" tuple corresponding to
* the relation.
*/
- renamerel(relname, /* old name */
+ renamerel(stmt->relation, /* old relation */
stmt->newname); /* new name */
}
else
stmt->behavior);
break;
case 'E': /* CREATE TOAST TABLE */
- AlterTableCreateToastTable(stmt->relation->relname,
+ AlterTableCreateToastTable(RangeVarGetRelid(stmt->relation, false),
false);
break;
case 'U': /* ALTER OWNER */
- AlterTableOwner(stmt->relation->relname,
+ AlterTableOwner(stmt->relation,
stmt->name);
break;
default: /* oops */
{
IndexStmt *stmt = (IndexStmt *) parsetree;
- relname = stmt->relation->relname;
- CheckOwnership(relname, true);
+ CheckOwnership(stmt->relation, true);
- DefineIndex(stmt->relation->relname, /* relation */
+ DefineIndex(stmt->relation, /* relation */
stmt->idxname, /* index name */
stmt->accessMethod, /* am name */
stmt->indexParams, /* parameters */
{
ClusterStmt *stmt = (ClusterStmt *) parsetree;
- relname = stmt->relation->relname;
- CheckOwnership(relname, true);
+ CheckOwnership(stmt->relation, true);
- cluster(relname, stmt->indexname);
+ cluster(stmt->relation, stmt->indexname);
}
break;
elog(ERROR, "\"%s\" is a system index. call REINDEX under standalone postgres with -P -O options",
relname);
}
- CheckOwnership(relname, false);
- ReindexIndex(relname, stmt->force);
+ CheckOwnership(stmt->relation, false);
+ ReindexIndex(stmt->relation, stmt->force);
break;
case TABLE:
- relname = (char *) stmt->relation->relname;
- CheckOwnership(relname, false);
- ReindexTable(relname, stmt->force);
+ CheckOwnership(stmt->relation, false);
+ ReindexTable(stmt->relation, stmt->force);
break;
case DATABASE:
relname = (char *) stmt->name;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.69 2002/03/21 23:27:24 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/acl.c,v 1.70 2002/03/26 19:16:05 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/heapam.h"
#include "catalog/catalog.h"
+#include "catalog/namespace.h"
#include "catalog/pg_shadow.h"
#include "catalog/pg_type.h"
#include "lib/stringinfo.h"
/*
* has_table_privilege_name_name
* Check user privileges on a relation given
- * name usename, name relname, and text priv name.
+ * name username, name relname, and text priv name.
*
* RETURNS
* a boolean value
text *priv_type_text)
{
int32 usesysid;
- char *relname;
+ AclMode mode;
+ int32 result;
/*
* Lookup userid based on username
usesysid = get_usesysid(username);
/*
- * Lookup relname based on rel oid
+ * Convert priv_type_text to an AclMode
*/
- relname = get_rel_name(reloid);
- if (relname == NULL)
- elog(ERROR, "has_table_privilege: invalid relation oid %u",
- reloid);
+ mode = convert_priv_string(priv_type_text);
/*
- * Make use of has_table_privilege_id_cname. It accepts the arguments
- * we now have.
+ * Finally, check for the privilege
*/
- return has_table_privilege_id_cname(usesysid, relname, priv_type_text);
+ result = pg_class_aclcheck(reloid, usesysid, mode);
+
+ if (result == ACLCHECK_OK)
+ return true;
+ else
+ return false;
}
/*
* Convert relname to rel OID.
*/
- reloid = GetSysCacheOid(RELNAME,
- PointerGetDatum(relname),
- 0, 0, 0);
+ reloid = RelnameGetRelid(relname);
if (!OidIsValid(reloid))
elog(ERROR, "has_table_privilege: relation \"%s\" does not exist",
relname);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.92 2002/03/06 20:49:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/catcache.c,v 1.93 2002/03/26 19:16:08 tgl Exp $
*
*-------------------------------------------------------------------------
*/
CatCache *
InitCatCache(int id,
- char *relname,
- char *indname,
+ const char *relname,
+ const char *indname,
int reloidattr,
int nkeys,
- int *key)
+ const int *key)
{
CatCache *cp;
MemoryContext oldcxt;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.65 2002/03/22 02:56:35 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.66 2002/03/26 19:16:09 tgl Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
/* ---------- RELATION CACHE ---------- */
+/*
+ * get_relname_relid
+ * Given name and namespace of a relation, look up the OID.
+ *
+ * Returns InvalidOid if there is no such relation.
+ */
+Oid
+get_relname_relid(const char *relname, Oid relnamespace)
+{
+ return GetSysCacheOid(RELNAMENSP,
+ PointerGetDatum(relname),
+ ObjectIdGetDatum(relnamespace),
+ 0, 0);
+}
+
#ifdef NOT_USED
/*
* get_relnatts
/*
* get_rel_name
- *
* Returns the name of a given relation.
*
- * Note: returns a palloc'd copy of the string, or NULL if no such relation.
+ * Returns a palloc'd copy of the string, or NULL if no such relation.
+ *
+ * NOTE: since relation name is not unique, be wary of code that uses this
+ * for anything except preparing error messages.
*/
char *
get_rel_name(Oid relid)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.157 2002/03/19 02:18:22 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.158 2002/03/26 19:16:10 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* INTERFACE ROUTINES
* RelationCacheInitialize - initialize relcache
* RelationCacheInitializePhase2 - finish initializing relcache
- * RelationIdCacheGetRelation - get a reldesc from the cache (id)
- * RelationNameCacheGetRelation - get a reldesc from the cache (name)
* RelationIdGetRelation - get a reldesc by relation id
- * RelationNameGetRelation - get a reldesc by relation name
+ * RelationSysNameGetRelation - get a reldesc by system rel name
+ * RelationIdCacheGetRelation - get a cached reldesc by relid
* RelationClose - close an open relation
*
* NOTES
#include "access/istrat.h"
#include "catalog/catalog.h"
#include "catalog/catname.h"
-#include "catalog/index.h"
#include "catalog/indexing.h"
#include "catalog/pg_amop.h"
#include "catalog/pg_amproc.h"
#include "catalog/pg_attrdef.h"
#include "catalog/pg_attribute.h"
#include "catalog/pg_index.h"
+#include "catalog/pg_namespace.h"
#include "catalog/pg_opclass.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_relcheck.h"
#define RELCACHE_INIT_FILENAME "pg_internal.init"
/*
- * hardcoded tuple descriptors. see lib/backend/catalog/pg_attribute.h
+ * hardcoded tuple descriptors. see include/catalog/pg_attribute.h
*/
static FormData_pg_attribute Desc_pg_class[Natts_pg_class] = {Schema_pg_class};
static FormData_pg_attribute Desc_pg_attribute[Natts_pg_attribute] = {Schema_pg_attribute};
/*
* Hash tables that index the relation cache
*
- * Relations are looked up two ways, by name and by id,
+ * 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).
*/
-static HTAB *RelationNameCache;
static HTAB *RelationIdCache;
+static HTAB *RelationSysNameCache;
/*
* Bufmgr uses RelFileNode for lookup. Actually, I would like to do
/*
* RelationBuildDescInfo exists so code can be shared
- * between RelationIdGetRelation() and RelationNameGetRelation()
+ * between RelationIdGetRelation() and RelationSysNameGetRelation()
*/
typedef struct RelationBuildDescInfo
{
union
{
Oid info_id; /* relation object id */
- char *info_name; /* relation name */
+ char *info_name; /* system relation name */
} i;
} RelationBuildDescInfo;
-typedef struct relnamecacheent
-{
- NameData relname;
- Relation reldesc;
-} RelNameCacheEnt;
-
typedef struct relidcacheent
{
Oid reloid;
Relation reldesc;
} RelIdCacheEnt;
+typedef struct relnamecacheent
+{
+ NameData relname;
+ Relation reldesc;
+} RelNameCacheEnt;
+
typedef struct relnodecacheent
{
RelFileNode relnode;
*/
#define RelationCacheInsert(RELATION) \
do { \
- RelIdCacheEnt *idhentry; RelNameCacheEnt *namehentry; \
- char *relname; RelNodeCacheEnt *nodentry; bool found; \
- relname = RelationGetPhysicalRelationName(RELATION); \
- namehentry = (RelNameCacheEnt*)hash_search(RelationNameCache, \
- relname, \
- HASH_ENTER, \
- &found); \
- if (namehentry == NULL) \
- elog(ERROR, "out of memory for relation descriptor cache"); \
- /* used to give notice if found -- now just keep quiet */ ; \
- namehentry->reldesc = RELATION; \
+ RelIdCacheEnt *idhentry; RelNodeCacheEnt *nodentry; bool found; \
idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
(void *) &(RELATION->rd_id), \
HASH_ENTER, \
&found); \
if (idhentry == NULL) \
elog(ERROR, "out of memory for relation descriptor cache"); \
- /* used to give notice if found -- now just keep quiet */ ; \
+ /* used to give notice if found -- now just keep quiet */ \
idhentry->reldesc = RELATION; \
nodentry = (RelNodeCacheEnt*)hash_search(RelationNodeCache, \
(void *) &(RELATION->rd_node), \
&found); \
if (nodentry == NULL) \
elog(ERROR, "out of memory for relation descriptor cache"); \
- /* used to give notice if found -- now just keep quiet */ ; \
+ /* used to give notice if found -- now just keep quiet */ \
nodentry->reldesc = RELATION; \
+ if (RelationGetNamespace(RELATION) == PG_CATALOG_NAMESPACE) \
+ { \
+ char *relname = RelationGetPhysicalRelationName(RELATION); \
+ RelNameCacheEnt *namehentry; \
+ namehentry = (RelNameCacheEnt*)hash_search(RelationSysNameCache, \
+ relname, \
+ HASH_ENTER, \
+ &found); \
+ if (namehentry == NULL) \
+ elog(ERROR, "out of memory for relation descriptor cache"); \
+ /* used to give notice if found -- now just keep quiet */ \
+ namehentry->reldesc = RELATION; \
+ } \
} while(0)
-#define RelationNameCacheLookup(NAME, RELATION) \
+#define RelationIdCacheLookup(ID, RELATION) \
do { \
- RelNameCacheEnt *hentry; \
- hentry = (RelNameCacheEnt*)hash_search(RelationNameCache, \
- (void *) (NAME), HASH_FIND,NULL); \
+ RelIdCacheEnt *hentry; \
+ hentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
+ (void *)&(ID), HASH_FIND,NULL); \
if (hentry) \
RELATION = hentry->reldesc; \
else \
RELATION = NULL; \
} while(0)
-#define RelationIdCacheLookup(ID, RELATION) \
+#define RelationSysNameCacheLookup(NAME, RELATION) \
do { \
- RelIdCacheEnt *hentry; \
- hentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
- (void *)&(ID), HASH_FIND,NULL); \
+ RelNameCacheEnt *hentry; \
+ hentry = (RelNameCacheEnt*)hash_search(RelationSysNameCache, \
+ (void *) (NAME), HASH_FIND,NULL); \
if (hentry) \
RELATION = hentry->reldesc; \
else \
#define RelationCacheDelete(RELATION) \
do { \
- RelNameCacheEnt *namehentry; RelIdCacheEnt *idhentry; \
- char *relname; RelNodeCacheEnt *nodentry; \
- relname = RelationGetPhysicalRelationName(RELATION); \
- namehentry = (RelNameCacheEnt*)hash_search(RelationNameCache, \
- relname, \
- HASH_REMOVE, NULL); \
- if (namehentry == NULL) \
- elog(WARNING, "trying to delete a reldesc that does not exist."); \
+ RelIdCacheEnt *idhentry; RelNodeCacheEnt *nodentry; \
idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
(void *)&(RELATION->rd_id), \
HASH_REMOVE, NULL); \
HASH_REMOVE, NULL); \
if (nodentry == NULL) \
elog(WARNING, "trying to delete a reldesc that does not exist."); \
+ if (RelationGetNamespace(RELATION) == PG_CATALOG_NAMESPACE) \
+ { \
+ char *relname = RelationGetPhysicalRelationName(RELATION); \
+ RelNameCacheEnt *namehentry; \
+ namehentry = (RelNameCacheEnt*)hash_search(RelationSysNameCache, \
+ relname, \
+ HASH_REMOVE, NULL); \
+ if (namehentry == NULL) \
+ elog(WARNING, "trying to delete a reldesc that does not exist."); \
+ } \
} while(0)
static void RelationReloadClassinfo(Relation relation);
#endif /* ENABLE_REINDEX_NAILED_RELATIONS */
static void RelationFlushRelation(Relation relation);
-static Relation RelationNameCacheGetRelation(const char *relationName);
+static Relation RelationSysNameCacheGetRelation(const char *relationName);
static bool load_relcache_init_file(void);
static void write_relcache_init_file(void);
-static void formrdesc(char *relationName, int natts,
+static void formrdesc(const char *relationName, int natts,
FormData_pg_attribute *att);
static HeapTuple ScanPgRelation(RelationBuildDescInfo buildinfo);
/*
- * RelationIdGetRelation() and RelationNameGetRelation()
- * support functions
- */
-
-
-/*
* ScanPgRelation
*
* this is used by RelationBuildDesc to find a pg_class
Relation pg_class_desc;
const char *indexRelname;
SysScanDesc pg_class_scan;
- ScanKeyData key;
+ ScanKeyData key[2];
+ int nkeys;
/*
* form a scan key
switch (buildinfo.infotype)
{
case INFO_RELID:
- ScanKeyEntryInitialize(&key, 0,
+ ScanKeyEntryInitialize(&key[0], 0,
ObjectIdAttributeNumber,
F_OIDEQ,
ObjectIdGetDatum(buildinfo.i.info_id));
+ nkeys = 1;
indexRelname = ClassOidIndex;
break;
case INFO_RELNAME:
- ScanKeyEntryInitialize(&key, 0,
+ ScanKeyEntryInitialize(&key[0], 0,
Anum_pg_class_relname,
F_NAMEEQ,
NameGetDatum(buildinfo.i.info_name));
- indexRelname = ClassNameIndex;
+ ScanKeyEntryInitialize(&key[1], 0,
+ Anum_pg_class_relnamespace,
+ F_OIDEQ,
+ ObjectIdGetDatum(PG_CATALOG_NAMESPACE));
+ nkeys = 2;
+ indexRelname = ClassNameNspIndex;
break;
default:
pg_class_scan = systable_beginscan(pg_class_desc, indexRelname,
criticalRelcachesBuilt,
SnapshotNow,
- 1, &key);
+ nkeys, key);
pg_class_tuple = systable_getnext(pg_class_scan);
(char *) attp,
ATTRIBUTE_TUPLE_SIZE);
-
-
- /*
- * Update constraint/default info
- */
- if (attp->attnotnull)
+ /* Update constraint/default info */
+ if (attp->attnotnull)
constr->has_not_null = true;
if (attp->atthasdef)
* NOTE: we assume we are already switched into CacheMemoryContext.
*/
static void
-formrdesc(char *relationName,
+formrdesc(const char *relationName,
int natts,
FormData_pg_attribute *att)
{
relation->rd_rel = (Form_pg_class) palloc(CLASS_TUPLE_SIZE);
MemSet(relation->rd_rel, 0, CLASS_TUPLE_SIZE);
- strcpy(RelationGetPhysicalRelationName(relation), relationName);
+ namestrcpy(&relation->rd_rel->relname, relationName);
+ relation->rd_rel->relnamespace = PG_CATALOG_NAMESPACE;
/*
* It's important to distinguish between shared and non-shared
}
/*
- * RelationNameCacheGetRelation
+ * RelationSysNameCacheGetRelation
*
- * As above, but lookup by name.
+ * As above, but lookup by name; only works for system catalogs.
*/
static Relation
-RelationNameCacheGetRelation(const char *relationName)
+RelationSysNameCacheGetRelation(const char *relationName)
{
Relation rd;
NameData name;
* null-padded
*/
namestrcpy(&name, relationName);
- RelationNameCacheLookup(NameStr(name), rd);
+ RelationSysNameCacheLookup(NameStr(name), rd);
if (RelationIsValid(rd))
RelationIncrementReferenceCount(rd);
RelationBuildDescInfo buildinfo;
/*
- * increment access statistics
- */
- IncrHeapAccessStat(local_RelationIdGetRelation);
- IncrHeapAccessStat(global_RelationIdGetRelation);
-
- /*
* first try and get a reldesc from the cache
*/
rd = RelationIdCacheGetRelation(relationId);
}
/*
- * RelationNameGetRelation
+ * RelationSysNameGetRelation
*
- * As above, but lookup by name.
+ * As above, but lookup by name; only works for system catalogs.
*/
Relation
-RelationNameGetRelation(const char *relationName)
+RelationSysNameGetRelation(const char *relationName)
{
char *temprelname;
Relation rd;
RelationBuildDescInfo buildinfo;
/*
- * increment access statistics
- */
- IncrHeapAccessStat(local_RelationNameGetRelation);
- IncrHeapAccessStat(global_RelationNameGetRelation);
-
- /*
* if caller is looking for a temp relation, substitute its real name;
* we only index temp rels by their real names.
*/
/*
* first try and get a reldesc from the cache
*/
- rd = RelationNameCacheGetRelation(relationName);
+ rd = RelationSysNameCacheGetRelation(relationName);
if (RelationIsValid(rd))
return rd;
RelationCacheInvalidate(void)
{
HASH_SEQ_STATUS status;
- RelNameCacheEnt *namehentry;
+ RelIdCacheEnt *idhentry;
Relation relation;
List *rebuildList = NIL;
List *l;
/* Phase 1 */
- hash_seq_init(&status, RelationNameCache);
+ hash_seq_init(&status, RelationIdCache);
- while ((namehentry = (RelNameCacheEnt *) hash_seq_search(&status)) != NULL)
+ while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
{
- relation = namehentry->reldesc;
+ relation = idhentry->reldesc;
/* Ignore xact-local relations, since they are never SI targets */
if (relation->rd_myxactonly)
RelationCacheAbort(void)
{
HASH_SEQ_STATUS status;
- RelNameCacheEnt *namehentry;
+ RelIdCacheEnt *idhentry;
- hash_seq_init(&status, RelationNameCache);
+ hash_seq_init(&status, RelationIdCache);
- while ((namehentry = (RelNameCacheEnt *) hash_seq_search(&status)) != NULL)
+ while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
{
- Relation relation = namehentry->reldesc;
+ Relation relation = idhentry->reldesc;
if (relation->rd_isnailed)
RelationSetReferenceCount(relation, 1);
*/
Relation
RelationBuildLocalRelation(const char *relname,
+ Oid relnamespace,
TupleDesc tupDesc,
Oid relid, Oid dbid,
+ RelFileNode rnode,
bool nailit)
{
Relation rel;
rel->rd_rel = (Form_pg_class) palloc(CLASS_TUPLE_SIZE);
MemSet((char *) rel->rd_rel, 0, CLASS_TUPLE_SIZE);
- strcpy(RelationGetPhysicalRelationName(rel), relname);
+ namestrcpy(&rel->rd_rel->relname, relname);
+ rel->rd_rel->relnamespace = relnamespace;
rel->rd_rel->relkind = RELKIND_UNCATALOGED;
rel->rd_rel->relhasoids = true;
rel->rd_rel->reltype = InvalidOid;
/*
- * Insert relation OID and database/tablespace ID into the right
- * places. XXX currently we assume physical tblspace/relnode are same
- * as logical dbid/reloid. Probably should pass an extra pair of
- * parameters.
+ * Insert relation physical and logical identifiers (OIDs) into the
+ * right places.
*/
rel->rd_rel->relisshared = (dbid == InvalidOid);
for (i = 0; i < natts; i++)
rel->rd_att->attrs[i]->attrelid = relid;
- RelationInitLockInfo(rel); /* see lmgr.c */
+ rel->rd_node = rnode;
+ rel->rd_rel->relfilenode = rnode.relNode;
- rel->rd_node.tblNode = dbid;
- rel->rd_node.relNode = relid;
- rel->rd_rel->relfilenode = relid;
+ RelationInitLockInfo(rel); /* see lmgr.c */
/*
* Okay to insert into the relcache hash tables.
MemSet(&ctl, 0, sizeof(ctl));
ctl.keysize = sizeof(NameData);
ctl.entrysize = sizeof(RelNameCacheEnt);
- RelationNameCache = hash_create("Relcache by name", INITRELCACHESIZE,
- &ctl, HASH_ELEM);
+ RelationSysNameCache = hash_create("Relcache by name", INITRELCACHESIZE,
+ &ctl, HASH_ELEM);
ctl.keysize = sizeof(Oid);
ctl.entrysize = sizeof(RelIdCacheEnt);
RelationCacheInitializePhase2(void)
{
HASH_SEQ_STATUS status;
- RelNameCacheEnt *namehentry;
+ RelIdCacheEnt *idhentry;
if (IsBootstrapProcessingMode())
return;
RelationSetReferenceCount(ird, 1); \
} while (0)
- LOAD_CRIT_INDEX(ClassNameIndex);
+ LOAD_CRIT_INDEX(ClassNameNspIndex);
LOAD_CRIT_INDEX(ClassOidIndex);
LOAD_CRIT_INDEX(AttributeRelidNumIndex);
LOAD_CRIT_INDEX(IndexRelidIndex);
* Also, if any of the relcache entries have rules or triggers,
* load that info the hard way since it isn't recorded in the cache file.
*/
- hash_seq_init(&status, RelationNameCache);
+ hash_seq_init(&status, RelationIdCache);
- while ((namehentry = (RelNameCacheEnt *) hash_seq_search(&status)) != NULL)
+ while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
{
- Relation relation = namehentry->reldesc;
+ Relation relation = idhentry->reldesc;
/*
* If it's a faked-up entry, read the real pg_class tuple.
MemSet(&ctl, 0, sizeof(ctl));
ctl.keysize = sizeof(NameData);
ctl.entrysize = sizeof(RelNameCacheEnt);
- RelationNameCache = hash_create("Relcache by name", INITRELCACHESIZE,
- &ctl, HASH_ELEM);
+ RelationSysNameCache = hash_create("Relcache by name", INITRELCACHESIZE,
+ &ctl, HASH_ELEM);
ctl.keysize = sizeof(Oid);
ctl.entrysize = sizeof(RelIdCacheEnt);
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
- if (RelationNameCache)
- hash_destroy(RelationNameCache);
if (RelationIdCache)
hash_destroy(RelationIdCache);
+ if (RelationSysNameCache)
+ hash_destroy(RelationSysNameCache);
if (RelationNodeCache)
hash_destroy(RelationNodeCache);
- RelationNameCache = RelationIdCache = RelationNodeCache = NULL;
+ RelationIdCache = RelationSysNameCache = RelationNodeCache = NULL;
MemoryContextSwitchTo(oldcxt);
}
char tempfilename[MAXPGPATH];
char finalfilename[MAXPGPATH];
HASH_SEQ_STATUS status;
- RelNameCacheEnt *namehentry;
+ RelIdCacheEnt *idhentry;
MemoryContext oldcxt;
int i;
/*
* Write all the reldescs (in no particular order).
*/
- hash_seq_init(&status, RelationNameCache);
+ hash_seq_init(&status, RelationIdCache);
initFileRelationIds = NIL;
- while ((namehentry = (RelNameCacheEnt *) hash_seq_search(&status)) != NULL)
+ while ((idhentry = (RelIdCacheEnt *) hash_seq_search(&status)) != NULL)
{
- Relation rel = namehentry->reldesc;
+ Relation rel = idhentry->reldesc;
Form_pg_class relform = rel->rd_rel;
Size len;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.69 2002/03/22 21:34:44 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/syscache.c,v 1.70 2002/03/26 19:16:14 tgl Exp $
*
* NOTES
* These routines allow the parser/planner/executor to perform
*/
struct cachedesc
{
- char *name; /* name of the relation being cached */
- char *indname; /* name of index relation for this cache */
+ const char *name; /* name of the relation being cached */
+ const char *indname; /* name 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 struct cachedesc cacheinfo[] = {
+static const struct cachedesc cacheinfo[] = {
{AggregateRelationName, /* AGGNAME */
AggregateNameTypeIndex,
0,
0,
0
}},
- {RelationRelationName, /* RELNAME */
- ClassNameIndex,
+ {RelationRelationName, /* RELNAMENSP */
+ ClassNameNspIndex,
ObjectIdAttributeNumber,
- 1,
+ 2,
{
Anum_pg_class_relname,
- 0,
+ Anum_pg_class_relnamespace,
0,
0
}},
* when sought. This is a kluge ... temp table substitution should be
* happening at a higher level ...
*/
- if (cacheId == RELNAME || cacheId == TYPENAME)
+ if (cacheId == RELNAMENSP || cacheId == TYPENAME)
{
char *nontemp_relname;
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: genam.h,v 1.32 2002/02/19 20:11:19 tgl Exp $
+ * $Id: genam.h,v 1.33 2002/03/26 19:16:17 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/itup.h"
#include "access/relscan.h"
#include "access/sdir.h"
+#include "nodes/primnodes.h"
/* Struct for statistics returned by bulk-delete operation */
* generalized index_ interface routines (in indexam.c)
*/
extern Relation index_open(Oid relationId);
-extern Relation index_openr(const char *relationName);
+extern Relation index_openrv(const RangeVar *relation);
+extern Relation index_openr(const char *sysRelationName);
extern void index_close(Relation relation);
extern InsertIndexResult index_insert(Relation relation,
Datum *datum, char *nulls,
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: heapam.h,v 1.72 2001/11/05 17:46:31 momjian Exp $
+ * $Id: heapam.h,v 1.73 2002/03/26 19:16:17 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "access/relscan.h"
#include "access/tupmacs.h"
#include "access/xlogutils.h"
+#include "nodes/primnodes.h"
#include "storage/block.h"
#include "storage/lmgr.h"
#include "utils/rel.h"
/* heapam.c */
extern Relation relation_open(Oid relationId, LOCKMODE lockmode);
-extern Relation relation_openr(const char *relationName, LOCKMODE lockmode);
+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_openr(const char *relationName, 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)
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: bootstrap.h,v 1.27 2002/03/02 21:39:34 momjian Exp $
+ * $Id: bootstrap.h,v 1.28 2002/03/26 19:16:20 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern int numattr;
extern int BootstrapMain(int ac, char *av[]);
-extern void index_register(char *heap, char *ind, IndexInfo *indexInfo);
+extern void index_register(Oid heap, Oid ind, IndexInfo *indexInfo);
extern void err_out(void);
extern void InsertOneTuple(Oid objectid);
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: catversion.h,v 1.110 2002/03/22 21:34:44 tgl Exp $
+ * $Id: catversion.h,v 1.111 2002/03/26 19:16:22 tgl Exp $
*
*-------------------------------------------------------------------------
*/
*/
/* yyyymmddN */
-#define CATALOG_VERSION_NO 200203221
+#define CATALOG_VERSION_NO 200203251
#endif
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: heap.h,v 1.46 2002/03/20 19:44:52 tgl Exp $
+ * $Id: heap.h,v 1.47 2002/03/26 19:16:23 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parse_node.h"
#include "utils/rel.h"
+
typedef struct RawColumnDefault
{
AttrNumber attnum; /* attribute to attach default to */
* tree) */
} RawColumnDefault;
-extern Oid RelnameFindRelid(const char *relname);
-
-extern Relation heap_create(char *relname, TupleDesc tupDesc,
+extern Relation heap_create(char *relname, Oid relnamespace,
+ TupleDesc tupDesc,
bool istemp, bool storage_create,
bool allow_system_table_mods);
extern void heap_storage_create(Relation rel);
-extern Oid heap_create_with_catalog(char *relname, TupleDesc tupdesc,
+extern Oid heap_create_with_catalog(char *relname, Oid relnamespace,
+ TupleDesc tupdesc,
char relkind, bool relhasoids, bool istemp,
bool allow_system_table_mods);
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: index.h,v 1.45 2002/03/10 06:02:24 momjian Exp $
+ * $Id: index.h,v 1.46 2002/03/26 19:16:25 tgl Exp $
*
*-------------------------------------------------------------------------
*/
void *state);
-extern Oid index_create(char *heapRelationName,
+extern Oid index_create(Oid heapRelationId,
char *indexRelationName,
IndexInfo *indexInfo,
Oid accessMethodObjectId,
Oid *classObjectId,
+ bool istemp,
bool primary,
bool allow_system_table_mods);
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: indexing.h,v 1.58 2002/03/22 21:34:44 tgl Exp $
+ * $Id: indexing.h,v 1.59 2002/03/26 19:16:26 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#define AttrDefaultIndex "pg_attrdef_adrelid_adnum_index"
#define AttributeRelidNameIndex "pg_attribute_relid_attnam_index"
#define AttributeRelidNumIndex "pg_attribute_relid_attnum_index"
-#define ClassNameIndex "pg_class_relname_index"
+#define ClassNameNspIndex "pg_class_relname_nsp_index"
#define ClassOidIndex "pg_class_oid_index"
#define DatabaseNameIndex "pg_database_datname_index"
#define DatabaseOidIndex "pg_database_oid_index"
DECLARE_UNIQUE_INDEX(pg_attribute_relid_attnam_index on pg_attribute using btree(attrelid oid_ops, attname name_ops));
DECLARE_UNIQUE_INDEX(pg_attribute_relid_attnum_index on pg_attribute using btree(attrelid oid_ops, attnum int2_ops));
DECLARE_UNIQUE_INDEX(pg_class_oid_index on pg_class using btree(oid oid_ops));
-DECLARE_UNIQUE_INDEX(pg_class_relname_index on pg_class using btree(relname name_ops));
+DECLARE_UNIQUE_INDEX(pg_class_relname_nsp_index on pg_class using btree(relname name_ops, relnamespace oid_ops));
DECLARE_UNIQUE_INDEX(pg_database_datname_index on pg_database using btree(datname name_ops));
DECLARE_UNIQUE_INDEX(pg_database_oid_index on pg_database using btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_description_o_c_o_index on pg_description using btree(objoid oid_ops, classoid oid_ops, objsubid int4_ops));
--- /dev/null
+/*-------------------------------------------------------------------------
+ *
+ * namespace.h
+ * prototypes for functions in backend/catalog/namespace.c
+ *
+ *
+ * Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * $Id: namespace.h,v 1.1 2002/03/26 19:16:28 tgl Exp $
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef NAMESPACE_H
+#define NAMESPACE_H
+
+#include "nodes/primnodes.h"
+
+
+extern Oid RangeVarGetRelid(const RangeVar *relation, bool failOK);
+
+extern Oid RangeVarGetCreationNamespace(const RangeVar *newRelation);
+
+extern Oid RelnameGetRelid(const char *relname);
+
+#endif /* NAMESPACE_H */
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_attribute.h,v 1.85 2002/03/20 19:44:55 tgl Exp $
+ * $Id: pg_attribute.h,v 1.86 2002/03/26 19:16:29 tgl Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
*/
#define Schema_pg_class \
{ 1259, {"relname"}, 19, DEFAULT_ATTSTATTARGET, NAMEDATALEN, 1, 0, -1, -1, false, 'p', false, 'i', false, false }, \
-{ 1259, {"reltype"}, 26, 0, 4, 2, 0, -1, -1, true, 'p', false, 'i', false, false }, \
-{ 1259, {"relowner"}, 23, 0, 4, 3, 0, -1, -1, true, 'p', false, 'i', false, false }, \
-{ 1259, {"relam"}, 26, 0, 4, 4, 0, -1, -1, true, 'p', false, 'i', false, false }, \
-{ 1259, {"relfilenode"}, 26, 0, 4, 5, 0, -1, -1, true, 'p', false, 'i', false, false }, \
-{ 1259, {"relpages"}, 23, 0, 4, 6, 0, -1, -1, true, 'p', false, 'i', false, false }, \
-{ 1259, {"reltuples"}, 700, 0, 4, 7, 0, -1, -1, false, 'p', false, 'i', false, false }, \
-{ 1259, {"reltoastrelid"}, 26, 0, 4, 8, 0, -1, -1, true, 'p', false, 'i', false, false }, \
-{ 1259, {"reltoastidxid"}, 26, 0, 4, 9, 0, -1, -1, true, 'p', false, 'i', false, false }, \
-{ 1259, {"relhasindex"}, 16, 0, 1, 10, 0, -1, -1, true, 'p', false, 'c', false, false }, \
-{ 1259, {"relisshared"}, 16, 0, 1, 11, 0, -1, -1, true, 'p', false, 'c', false, false }, \
-{ 1259, {"relkind"}, 18, 0, 1, 12, 0, -1, -1, true, 'p', false, 'c', false, false }, \
-{ 1259, {"relnatts"}, 21, 0, 2, 13, 0, -1, -1, true, 'p', false, 's', false, false }, \
-{ 1259, {"relchecks"}, 21, 0, 2, 14, 0, -1, -1, true, 'p', false, 's', false, false }, \
-{ 1259, {"reltriggers"}, 21, 0, 2, 15, 0, -1, -1, true, 'p', false, 's', false, false }, \
-{ 1259, {"relukeys"}, 21, 0, 2, 16, 0, -1, -1, true, 'p', false, 's', false, false }, \
-{ 1259, {"relfkeys"}, 21, 0, 2, 17, 0, -1, -1, true, 'p', false, 's', false, false }, \
-{ 1259, {"relrefs"}, 21, 0, 2, 18, 0, -1, -1, true, 'p', false, 's', false, false }, \
-{ 1259, {"relhasoids"}, 16, 0, 1, 19, 0, -1, -1, true, 'p', false, 'c', false, false }, \
-{ 1259, {"relhaspkey"}, 16, 0, 1, 20, 0, -1, -1, true, 'p', false, 'c', false, false }, \
-{ 1259, {"relhasrules"}, 16, 0, 1, 21, 0, -1, -1, true, 'p', false, 'c', false, false }, \
-{ 1259, {"relhassubclass"},16, 0, 1, 22, 0, -1, -1, true, 'p', false, 'c', false, false }, \
-{ 1259, {"relacl"}, 1034, 0, -1, 23, 0, -1, -1, false, 'x', false, 'i', false, false }
+{ 1259, {"relnamespace"}, 26, 0, 4, 2, 0, -1, -1, true, 'p', false, 'i', false, false }, \
+{ 1259, {"reltype"}, 26, 0, 4, 3, 0, -1, -1, true, 'p', false, 'i', false, false }, \
+{ 1259, {"relowner"}, 23, 0, 4, 4, 0, -1, -1, true, 'p', false, 'i', false, false }, \
+{ 1259, {"relam"}, 26, 0, 4, 5, 0, -1, -1, true, 'p', false, 'i', false, false }, \
+{ 1259, {"relfilenode"}, 26, 0, 4, 6, 0, -1, -1, true, 'p', false, 'i', false, false }, \
+{ 1259, {"relpages"}, 23, 0, 4, 7, 0, -1, -1, true, 'p', false, 'i', false, false }, \
+{ 1259, {"reltuples"}, 700, 0, 4, 8, 0, -1, -1, false, 'p', false, 'i', false, false }, \
+{ 1259, {"reltoastrelid"}, 26, 0, 4, 9, 0, -1, -1, true, 'p', false, 'i', false, false }, \
+{ 1259, {"reltoastidxid"}, 26, 0, 4, 10, 0, -1, -1, true, 'p', false, 'i', false, false }, \
+{ 1259, {"relhasindex"}, 16, 0, 1, 11, 0, -1, -1, true, 'p', false, 'c', false, false }, \
+{ 1259, {"relisshared"}, 16, 0, 1, 12, 0, -1, -1, true, 'p', false, 'c', false, false }, \
+{ 1259, {"relkind"}, 18, 0, 1, 13, 0, -1, -1, true, 'p', false, 'c', false, false }, \
+{ 1259, {"relnatts"}, 21, 0, 2, 14, 0, -1, -1, true, 'p', false, 's', false, false }, \
+{ 1259, {"relchecks"}, 21, 0, 2, 15, 0, -1, -1, true, 'p', false, 's', false, false }, \
+{ 1259, {"reltriggers"}, 21, 0, 2, 16, 0, -1, -1, true, 'p', false, 's', false, false }, \
+{ 1259, {"relukeys"}, 21, 0, 2, 17, 0, -1, -1, true, 'p', false, 's', false, false }, \
+{ 1259, {"relfkeys"}, 21, 0, 2, 18, 0, -1, -1, true, 'p', false, 's', false, false }, \
+{ 1259, {"relrefs"}, 21, 0, 2, 19, 0, -1, -1, true, 'p', false, 's', false, false }, \
+{ 1259, {"relhasoids"}, 16, 0, 1, 20, 0, -1, -1, true, 'p', false, 'c', false, false }, \
+{ 1259, {"relhaspkey"}, 16, 0, 1, 21, 0, -1, -1, true, 'p', false, 'c', false, false }, \
+{ 1259, {"relhasrules"}, 16, 0, 1, 22, 0, -1, -1, true, 'p', false, 'c', false, false }, \
+{ 1259, {"relhassubclass"},16, 0, 1, 23, 0, -1, -1, true, 'p', false, 'c', false, false }, \
+{ 1259, {"relacl"}, 1034, 0, -1, 24, 0, -1, -1, false, 'x', false, 'i', false, false }
DATA(insert ( 1259 relname 19 DEFAULT_ATTSTATTARGET NAMEDATALEN 1 0 -1 -1 f p f i f f));
-DATA(insert ( 1259 reltype 26 0 4 2 0 -1 -1 t p f i f f));
-DATA(insert ( 1259 relowner 23 0 4 3 0 -1 -1 t p f i f f));
-DATA(insert ( 1259 relam 26 0 4 4 0 -1 -1 t p f i f f));
-DATA(insert ( 1259 relfilenode 26 0 4 5 0 -1 -1 t p f i f f));
-DATA(insert ( 1259 relpages 23 0 4 6 0 -1 -1 t p f i f f));
-DATA(insert ( 1259 reltuples 700 0 4 7 0 -1 -1 f p f i f f));
-DATA(insert ( 1259 reltoastrelid 26 0 4 8 0 -1 -1 t p f i f f));
-DATA(insert ( 1259 reltoastidxid 26 0 4 9 0 -1 -1 t p f i f f));
-DATA(insert ( 1259 relhasindex 16 0 1 10 0 -1 -1 t p f c f f));
-DATA(insert ( 1259 relisshared 16 0 1 11 0 -1 -1 t p f c f f));
-DATA(insert ( 1259 relkind 18 0 1 12 0 -1 -1 t p f c f f));
-DATA(insert ( 1259 relnatts 21 0 2 13 0 -1 -1 t p f s f f));
-DATA(insert ( 1259 relchecks 21 0 2 14 0 -1 -1 t p f s f f));
-DATA(insert ( 1259 reltriggers 21 0 2 15 0 -1 -1 t p f s f f));
-DATA(insert ( 1259 relukeys 21 0 2 16 0 -1 -1 t p f s f f));
-DATA(insert ( 1259 relfkeys 21 0 2 17 0 -1 -1 t p f s f f));
-DATA(insert ( 1259 relrefs 21 0 2 18 0 -1 -1 t p f s f f));
-DATA(insert ( 1259 relhasoids 16 0 1 19 0 -1 -1 t p f c f f));
-DATA(insert ( 1259 relhaspkey 16 0 1 20 0 -1 -1 t p f c f f));
-DATA(insert ( 1259 relhasrules 16 0 1 21 0 -1 -1 t p f c f f));
-DATA(insert ( 1259 relhassubclass 16 0 1 22 0 -1 -1 t p f c f f));
-DATA(insert ( 1259 relacl 1034 0 -1 23 0 -1 -1 f x f i f f));
+DATA(insert ( 1259 relnamespace 26 0 4 2 0 -1 -1 t p f i f f));
+DATA(insert ( 1259 reltype 26 0 4 3 0 -1 -1 t p f i f f));
+DATA(insert ( 1259 relowner 23 0 4 4 0 -1 -1 t p f i f f));
+DATA(insert ( 1259 relam 26 0 4 5 0 -1 -1 t p f i f f));
+DATA(insert ( 1259 relfilenode 26 0 4 6 0 -1 -1 t p f i f f));
+DATA(insert ( 1259 relpages 23 0 4 7 0 -1 -1 t p f i f f));
+DATA(insert ( 1259 reltuples 700 0 4 8 0 -1 -1 f p f i f f));
+DATA(insert ( 1259 reltoastrelid 26 0 4 9 0 -1 -1 t p f i f f));
+DATA(insert ( 1259 reltoastidxid 26 0 4 10 0 -1 -1 t p f i f f));
+DATA(insert ( 1259 relhasindex 16 0 1 11 0 -1 -1 t p f c f f));
+DATA(insert ( 1259 relisshared 16 0 1 12 0 -1 -1 t p f c f f));
+DATA(insert ( 1259 relkind 18 0 1 13 0 -1 -1 t p f c f f));
+DATA(insert ( 1259 relnatts 21 0 2 14 0 -1 -1 t p f s f f));
+DATA(insert ( 1259 relchecks 21 0 2 15 0 -1 -1 t p f s f f));
+DATA(insert ( 1259 reltriggers 21 0 2 16 0 -1 -1 t p f s f f));
+DATA(insert ( 1259 relukeys 21 0 2 17 0 -1 -1 t p f s f f));
+DATA(insert ( 1259 relfkeys 21 0 2 18 0 -1 -1 t p f s f f));
+DATA(insert ( 1259 relrefs 21 0 2 19 0 -1 -1 t p f s f f));
+DATA(insert ( 1259 relhasoids 16 0 1 20 0 -1 -1 t p f c f f));
+DATA(insert ( 1259 relhaspkey 16 0 1 21 0 -1 -1 t p f c f f));
+DATA(insert ( 1259 relhasrules 16 0 1 22 0 -1 -1 t p f c f f));
+DATA(insert ( 1259 relhassubclass 16 0 1 23 0 -1 -1 t p f c f f));
+DATA(insert ( 1259 relacl 1034 0 -1 24 0 -1 -1 f x f i f f));
DATA(insert ( 1259 ctid 27 0 6 -1 0 -1 -1 f p f i f f));
DATA(insert ( 1259 oid 26 0 4 -2 0 -1 -1 t p f i f f));
DATA(insert ( 1259 xmin 28 0 4 -3 0 -1 -1 t p f i f f));
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: pg_class.h,v 1.62 2002/03/19 02:18:22 momjian Exp $
+ * $Id: pg_class.h,v 1.63 2002/03/26 19:16:35 tgl Exp $
*
* NOTES
* the genbki.sh script reads this file and generates .bki
CATALOG(pg_class) BOOTSTRAP
{
NameData relname; /* class name */
+ Oid relnamespace; /* OID of namespace containing this class */
Oid reltype; /* OID of associated entry in pg_type */
int4 relowner; /* class owner */
Oid relam; /* index access method; 0 if not an index */
* relacl field. This is a kluge.
* ----------------
*/
-#define Natts_pg_class_fixed 22
-#define Natts_pg_class 23
+#define Natts_pg_class_fixed 23
+#define Natts_pg_class 24
#define Anum_pg_class_relname 1
-#define Anum_pg_class_reltype 2
-#define Anum_pg_class_relowner 3
-#define Anum_pg_class_relam 4
-#define Anum_pg_class_relfilenode 5
-#define Anum_pg_class_relpages 6
-#define Anum_pg_class_reltuples 7
-#define Anum_pg_class_reltoastrelid 8
-#define Anum_pg_class_reltoastidxid 9
-#define Anum_pg_class_relhasindex 10
-#define Anum_pg_class_relisshared 11
-#define Anum_pg_class_relkind 12
-#define Anum_pg_class_relnatts 13
-#define Anum_pg_class_relchecks 14
-#define Anum_pg_class_reltriggers 15
-#define Anum_pg_class_relukeys 16
-#define Anum_pg_class_relfkeys 17
-#define Anum_pg_class_relrefs 18
-#define Anum_pg_class_relhasoids 19
-#define Anum_pg_class_relhaspkey 20
-#define Anum_pg_class_relhasrules 21
-#define Anum_pg_class_relhassubclass 22
-#define Anum_pg_class_relacl 23
+#define Anum_pg_class_relnamespace 2
+#define Anum_pg_class_reltype 3
+#define Anum_pg_class_relowner 4
+#define Anum_pg_class_relam 5
+#define Anum_pg_class_relfilenode 6
+#define Anum_pg_class_relpages 7
+#define Anum_pg_class_reltuples 8
+#define Anum_pg_class_reltoastrelid 9
+#define Anum_pg_class_reltoastidxid 10
+#define Anum_pg_class_relhasindex 11
+#define Anum_pg_class_relisshared 12
+#define Anum_pg_class_relkind 13
+#define Anum_pg_class_relnatts 14
+#define Anum_pg_class_relchecks 15
+#define Anum_pg_class_reltriggers 16
+#define Anum_pg_class_relukeys 17
+#define Anum_pg_class_relfkeys 18
+#define Anum_pg_class_relrefs 19
+#define Anum_pg_class_relhasoids 20
+#define Anum_pg_class_relhaspkey 21
+#define Anum_pg_class_relhasrules 22
+#define Anum_pg_class_relhassubclass 23
+#define Anum_pg_class_relacl 24
/* ----------------
* initial contents of pg_class
* ----------------
*/
-DATA(insert OID = 1247 ( pg_type 71 PGUID 0 1247 0 0 0 0 f f r 22 0 0 0 0 0 t f f f _null_ ));
+DATA(insert OID = 1247 ( pg_type PGNSP 71 PGUID 0 1247 0 0 0 0 f f r 22 0 0 0 0 0 t f f f _null_ ));
DESCR("");
-DATA(insert OID = 1249 ( pg_attribute 75 PGUID 0 1249 0 0 0 0 f f r 15 0 0 0 0 0 f f f f _null_ ));
+DATA(insert OID = 1249 ( pg_attribute PGNSP 75 PGUID 0 1249 0 0 0 0 f f r 15 0 0 0 0 0 f f f f _null_ ));
DESCR("");
-DATA(insert OID = 1255 ( pg_proc 81 PGUID 0 1255 0 0 0 0 f f r 18 0 0 0 0 0 t f f f _null_ ));
+DATA(insert OID = 1255 ( pg_proc PGNSP 81 PGUID 0 1255 0 0 0 0 f f r 18 0 0 0 0 0 t f f f _null_ ));
DESCR("");
-DATA(insert OID = 1259 ( pg_class 83 PGUID 0 1259 0 0 0 0 f f r 23 0 0 0 0 0 t f f f _null_ ));
+DATA(insert OID = 1259 ( pg_class PGNSP 83 PGUID 0 1259 0 0 0 0 f f r 24 0 0 0 0 0 t f f f _null_ ));
DESCR("");
-DATA(insert OID = 1260 ( pg_shadow 86 PGUID 0 1260 0 0 0 0 f t r 9 0 0 0 0 0 f f f f _null_ ));
+DATA(insert OID = 1260 ( pg_shadow PGNSP 86 PGUID 0 1260 0 0 0 0 f t r 9 0 0 0 0 0 f f f f _null_ ));
DESCR("");
-DATA(insert OID = 1261 ( pg_group 87 PGUID 0 1261 0 0 0 0 f t r 3 0 0 0 0 0 f f f f _null_ ));
+DATA(insert OID = 1261 ( pg_group PGNSP 87 PGUID 0 1261 0 0 0 0 f t r 3 0 0 0 0 0 f f f f _null_ ));
DESCR("");
-DATA(insert OID = 1262 ( pg_database 88 PGUID 0 1262 0 0 0 0 f t r 10 0 0 0 0 0 t f f f _null_ ));
+DATA(insert OID = 1262 ( pg_database PGNSP 88 PGUID 0 1262 0 0 0 0 f t r 10 0 0 0 0 0 t f f f _null_ ));
DESCR("");
-DATA(insert OID = 376 ( pg_xactlock 0 PGUID 0 0 0 0 0 0 f t s 1 0 0 0 0 0 f f f f _null_ ));
+DATA(insert OID = 376 ( pg_xactlock PGNSP 0 PGUID 0 0 0 0 0 0 f t s 1 0 0 0 0 0 f f f f _null_ ));
DESCR("");
#define RelOid_pg_type 1247
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994-5, Regents of the University of California
*
- * $Id: cluster.h,v 1.12 2001/11/05 17:46:33 momjian Exp $
+ * $Id: cluster.h,v 1.13 2002/03/26 19:16:40 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* functions
*/
-extern void cluster(char *oldrelname, char *oldindexname);
+extern void cluster(RangeVar *oldrelation, char *oldindexname);
#endif /* CLUSTER_H */
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: command.h,v 1.34 2002/03/21 16:01:41 tgl Exp $
+ * $Id: command.h,v 1.35 2002/03/26 19:16:40 tgl Exp $
*
*-------------------------------------------------------------------------
*/
bool inh, const char *constrName,
int behavior);
-extern void AlterTableCreateToastTable(const char *relationName,
- bool silent);
+extern void AlterTableCreateToastTable(Oid relOid, bool silent);
-extern void AlterTableOwner(const char *relationName, const char *newOwnerName);
+extern void AlterTableOwner(const RangeVar *tgtrel, const char *newOwnerName);
/*
* LOCK
*------------------------------------------------------------------
*/
-extern void CommentObject(int objtype, char *objname, char *objproperty,
- List *objlist, char *comment);
+extern void CommentObject(int objtype, char * schemaname, char *objname,
+ char *objproperty, List *objlist, char *comment);
extern void DeleteComments(Oid oid, Oid classoid);
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: defrem.h,v 1.31 2002/03/19 02:18:23 momjian Exp $
+ * $Id: defrem.h,v 1.32 2002/03/26 19:16:47 tgl Exp $
*
*-------------------------------------------------------------------------
*/
/*
* prototypes in indexcmds.c
*/
-extern void DefineIndex(char *heapRelationName,
+extern void DefineIndex(RangeVar *heapRelation,
char *indexRelationName,
char *accessMethodName,
List *attributeList,
bool primary,
Expr *predicate,
List *rangetable);
-extern void RemoveIndex(char *name);
-extern void ReindexIndex(const char *indexRelationName, bool force);
-extern void ReindexTable(const char *relationName, bool force);
+extern void RemoveIndex(RangeVar *relation);
+extern void ReindexIndex(RangeVar *indexRelation, bool force);
+extern void ReindexTable(RangeVar *relation, bool force);
extern void ReindexDatabase(const char *databaseName, bool force, bool all);
/*
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: rename.h,v 1.13 2001/11/05 17:46:33 momjian Exp $
+ * $Id: rename.h,v 1.14 2002/03/26 19:16:49 tgl Exp $
*
*-------------------------------------------------------------------------
*/
char *newattname,
int recurse);
-extern void renamerel(const char *oldrelname,
+extern void renamerel(const RangeVar *relation,
const char *newrelname);
#endif /* RENAME_H */
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: parsenodes.h,v 1.164 2002/03/22 02:56:36 tgl Exp $
+ * $Id: parsenodes.h,v 1.165 2002/03/26 19:16:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/primnodes.h"
-typedef enum InhOption
-{
- INH_NO, /* Do NOT scan child tables */
- INH_YES, /* DO scan child tables */
- INH_DEFAULT /* Use current SQL_inheritance option */
-} InhOption;
-
-
/*****************************************************************************
* Query Tree
*****************************************************************************/
* statement */
int resultRelation; /* target relation (index into rtable) */
- struct RangeVar *into; /* target relation or portal (cursor)
+ RangeVar *into; /* target relation or portal (cursor)
* for portal just name is meaningful */
bool isPortal; /* is this a retrieve into portal? */
bool isBinary; /* binary portal? */
} SortGroupBy;
/*
- * Alias -
- * specifies an alias for a range variable; the alias might also
- * specify renaming of columns within the table.
- */
-typedef struct Alias
-{
- NodeTag type;
- char *aliasname; /* aliased rel name (never qualified) */
- List *colnames; /* optional list of column aliases */
- /* Note: colnames is a list of Value nodes (always strings) */
-} Alias;
-
-/*
- * RangeVar - range variable, used in FROM clauses
- *
- * Also used to represent table names in utility statements; there, the alias
- * field is not used, and inhOpt shows whether to apply the operation
- * recursively to child tables. In some contexts it is also useful to carry
- * a TEMP table indication here.
- */
-typedef struct RangeVar
-{
- NodeTag type;
- char *catalogname; /* the catalog (database) name, or NULL */
- char *schemaname; /* the schema name, or NULL */
- char *relname; /* the relation/sequence name */
- InhOption inhOpt; /* expand rel by inheritance?
- * recursively act on children? */
- bool istemp; /* is this a temp relation/sequence? */
- Alias *alias; /* table alias & optional column aliases */
-} RangeVar;
-
-/*
* RangeSubselect - subquery appearing in a FROM clause
*/
typedef struct RangeSubselect
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: primnodes.h,v 1.59 2002/03/21 16:01:48 tgl Exp $
+ * $Id: primnodes.h,v 1.60 2002/03/26 19:16:53 tgl Exp $
*
*-------------------------------------------------------------------------
*/
} Fjoin;
+/*
+ * Alias -
+ * specifies an alias for a range variable; the alias might also
+ * specify renaming of columns within the table.
+ */
+typedef struct Alias
+{
+ NodeTag type;
+ char *aliasname; /* aliased rel name (never qualified) */
+ List *colnames; /* optional list of column aliases */
+ /* Note: colnames is a list of Value nodes (always strings) */
+} Alias;
+
+typedef enum InhOption
+{
+ INH_NO, /* Do NOT scan child tables */
+ INH_YES, /* DO scan child tables */
+ INH_DEFAULT /* Use current SQL_inheritance option */
+} InhOption;
+
+/*
+ * RangeVar - range variable, used in FROM clauses
+ *
+ * Also used to represent table names in utility statements; there, the alias
+ * field is not used, and inhOpt shows whether to apply the operation
+ * recursively to child tables. In some contexts it is also useful to carry
+ * a TEMP table indication here.
+ */
+typedef struct RangeVar
+{
+ NodeTag type;
+ char *catalogname; /* the catalog (database) name, or NULL */
+ char *schemaname; /* the schema name, or NULL */
+ char *relname; /* the relation/sequence name */
+ InhOption inhOpt; /* expand rel by inheritance?
+ * recursively act on children? */
+ bool istemp; /* is this a temp relation/sequence? */
+ Alias *alias; /* table alias & optional column aliases */
+} RangeVar;
+
+
/* ----------------------------------------------------------------
* node types for executable expressions
* ----------------------------------------------------------------
Node *rarg; /* right subtree */
List *using; /* USING clause, if any (list of String) */
Node *quals; /* qualifiers on join, if any */
- struct Alias *alias; /* user-written alias clause, if any */
+ Alias *alias; /* user-written alias clause, if any */
int rtindex; /* RT index assigned for join */
} JoinExpr;
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: catcache.h,v 1.40 2002/03/06 20:49:46 momjian Exp $
+ * $Id: catcache.h,v 1.41 2002/03/26 19:16:56 tgl Exp $
*
*-------------------------------------------------------------------------
*/
{
int id; /* cache identifier --- see syscache.h */
struct catcache *cc_next; /* link to next catcache */
- char *cc_relname; /* name of relation the tuples come from */
- char *cc_indname; /* name of index matching cache keys */
+ 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 */
bool cc_relisshared; /* is relation shared? */
TupleDesc cc_tupdesc; /* tuple descriptor (copied from reldesc) */
extern void CreateCacheMemoryContext(void);
extern void AtEOXact_CatCache(bool isCommit);
-extern CatCache *InitCatCache(int id, char *relname, char *indname,
+extern CatCache *InitCatCache(int id, const char *relname, const char *indname,
int reloidattr,
- int nkeys, int *key);
+ int nkeys, const int *key);
extern void InitCatCachePhase2(CatCache *cache);
extern HeapTuple SearchCatCache(CatCache *cache,
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: lsyscache.h,v 1.45 2002/03/22 02:56:37 tgl Exp $
+ * $Id: lsyscache.h,v 1.46 2002/03/26 19:16:57 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern RegProcedure get_oprjoin(Oid opno);
extern Oid get_func_rettype(Oid funcid);
extern bool func_iscachable(Oid funcid);
+extern Oid get_relname_relid(const char *relname, Oid relnamespace);
extern char *get_rel_name(Oid relid);
extern Oid get_rel_type_id(Oid relid);
extern int16 get_typlen(Oid typid);
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: rel.h,v 1.56 2002/02/19 20:11:19 tgl Exp $
+ * $Id: rel.h,v 1.57 2002/03/26 19:16:58 tgl Exp $
*
*-------------------------------------------------------------------------
*/
RelationGetPhysicalRelationName(relation) \
)
+/*
+ * RelationGetNamespace
+ *
+ * Returns the rel's namespace OID.
+ */
+#define RelationGetNamespace(relation) \
+ ((relation)->rd_rel->relnamespace)
+
/* added to prevent circular dependency. bjm 1999/11/15 */
extern char *get_temp_rel_by_physicalname(const char *relname);
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: relcache.h,v 1.30 2002/02/19 20:11:20 tgl Exp $
+ * $Id: relcache.h,v 1.31 2002/03/26 19:16:59 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* relation lookup routines
*/
extern Relation RelationIdGetRelation(Oid relationId);
-extern Relation RelationNameGetRelation(const char *relationName);
-extern Relation RelationNodeCacheGetRelation(RelFileNode rnode);
+extern Relation RelationSysNameGetRelation(const char *relationName);
/* finds an existing cache entry, but won't make a new one */
extern Relation RelationIdCacheGetRelation(Oid relationId);
+extern Relation RelationNodeCacheGetRelation(RelFileNode rnode);
extern void RelationClose(Relation relation);
* Routine to create a relcache entry for an about-to-be-created relation
*/
extern Relation RelationBuildLocalRelation(const char *relname,
+ Oid relnamespace,
TupleDesc tupDesc,
Oid relid, Oid dbid,
+ RelFileNode rnode,
bool nailit);
/*
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: syscache.h,v 1.39 2002/03/22 21:34:44 tgl Exp $
+ * $Id: syscache.h,v 1.40 2002/03/26 19:16:59 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#define OPEROID 20
#define PROCNAME 21
#define PROCOID 22
-#define RELNAME 23
+#define RELNAMENSP 23
#define RELOID 24
#define RULENAME 25
#define SHADOWNAME 26
* procedural language
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_comp.c,v 1.38 2002/03/06 06:10:45 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/pl/plpgsql/src/pl_comp.c,v 1.39 2002/03/26 19:17:02 tgl Exp $
*
* This software is copyrighted by Jan Wieck - Hamburg.
*
#include "access/heapam.h"
#include "catalog/catname.h"
+#include "catalog/namespace.h"
#include "catalog/pg_proc.h"
#include "catalog/pg_type.h"
#include "catalog/pg_class.h"
char *word2;
PLpgSQL_nsitem *nse;
bool old_nsstate;
+ Oid classOid;
HeapTuple classtup;
Form_pg_class classStruct;
HeapTuple attrtup;
/*
* First word could also be a table name
*/
- classtup = SearchSysCache(RELNAME,
- PointerGetDatum(word1),
+ classOid = RelnameGetRelid(word1);
+ if (!OidIsValid(classOid))
+ {
+ pfree(word1);
+ return T_ERROR;
+ }
+ classtup = SearchSysCache(RELOID,
+ ObjectIdGetDatum(classOid),
0, 0, 0);
if (!HeapTupleIsValid(classtup))
{
* Fetch the named table field and it's type
*/
attrtup = SearchSysCache(ATTNAME,
- ObjectIdGetDatum(classtup->t_data->t_oid),
+ ObjectIdGetDatum(classOid),
PointerGetDatum(word2),
0, 0);
if (!HeapTupleIsValid(attrtup))
typ = (PLpgSQL_type *) malloc(sizeof(PLpgSQL_type));
typ->typname = strdup(NameStr(typeStruct->typname));
- typ->typoid = typetup->t_data->t_oid;
+ typ->typoid = attrStruct->atttypid;
perm_fmgr_info(typeStruct->typinput, &(typ->typinput));
typ->typelem = typeStruct->typelem;
typ->typbyval = typeStruct->typbyval;
int
plpgsql_parse_wordrowtype(char *string)
{
+ Oid classOid;
HeapTuple classtup;
Form_pg_class classStruct;
HeapTuple typetup;
cp = strchr(word1, '%');
*cp = '\0';
- classtup = SearchSysCache(RELNAME,
- PointerGetDatum(word1),
+ classOid = RelnameGetRelid(word1);
+ if (!OidIsValid(classOid))
+ elog(ERROR, "%s: no such class", word1);
+ classtup = SearchSysCache(RELOID,
+ ObjectIdGetDatum(classOid),
0, 0, 0);
if (!HeapTupleIsValid(classtup))
elog(ERROR, "%s: no such class", word1);
elog(ERROR, "%s isn't a table", word1);
/*
- * Fetch the table's pg_type tuple too
- */
- typetup = SearchSysCache(TYPENAME,
- PointerGetDatum(word1),
- 0, 0, 0);
- if (!HeapTupleIsValid(typetup))
- elog(ERROR, "cache lookup for %s in pg_type failed", word1);
-
- /*
* Create a row datum entry and all the required variables that it
* will point to.
*/
row->dtype = PLPGSQL_DTYPE_ROW;
row->nfields = classStruct->relnatts;
- row->rowtypeclass = typetup->t_data->t_oid;
+ row->rowtypeclass = classStruct->reltype;
row->fieldnames = malloc(sizeof(char *) * row->nfields);
row->varnos = malloc(sizeof(int) * row->nfields);
- ReleaseSysCache(typetup);
-
for (i = 0; i < row->nfields; i++)
{
/*
* Get the attribute and it's type
*/
attrtup = SearchSysCache(ATTNUM,
- ObjectIdGetDatum(classtup->t_data->t_oid),
+ ObjectIdGetDatum(classOid),
Int16GetDatum(i + 1),
0, 0);
if (!HeapTupleIsValid(attrtup))
strcat(var->refname, cp);
var->datatype = malloc(sizeof(PLpgSQL_type));
var->datatype->typname = strdup(NameStr(typeStruct->typname));
- var->datatype->typoid = typetup->t_data->t_oid;
+ var->datatype->typoid = attrStruct->atttypid;
perm_fmgr_info(typeStruct->typinput, &(var->datatype->typinput));
var->datatype->typelem = typeStruct->typelem;
var->datatype->typbyval = typeStruct->typbyval;
OSDN Git Service
