- 4 bytes per row (on most machines), slightly improving performance.
CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } | UNLOGGED ] TABLE [ IF NOT EXISTS ] table_name
[ (column_name [, ...] ) ]
- [ WITH ( storage_parameter [= value] [, ... ] ) | WITH OIDS | WITH OUT OIDS ]
+ [ WITH ( storage_parameter [= value] [, ... ] ) | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE tablespace_name ]
AS query
This clause specifies optional storage parameters for the new table;
see
endterm="sql-createtable-storage-parameters-title"/> for more
- information. The WITH clause
- can also include OIDS=TRUE (or just OIDS )
- to specify that rows of the new table
- should have OIDs (object identifiers) assigned to them, or
- OIDS=FALSE to specify that the rows should not have OIDs.
- See
+ information. For backward-compatibility the WITH
+ clause for a table can also include OIDS=FALSE to
+ specify that rows of the new table should contain no OIDs (object
+ identifiers), OIDS=TRUE is not supported anymore.
+ OIDs.
- WITH OIDS
WITHOUT OIDS
- These are obsolescent syntaxes equivalent to WITH (OIDS)
- and WITH (OIDS=FALSE) , respectively. If you wish to give
- both an OIDS setting and storage parameters, you must use
- the WITH ( ... ) syntax; see above.
+ This is backward-compatible syntax for declaring a table
+ WITHOUT OIDS , creating a table WITH
+ OIDS is not supported anymore.
TABLE AS offers a superset of the functionality offered
by SELECT INTO .
-
- The CREATE TABLE AS command allows the user to
- explicitly specify whether OIDs should be included. If the
- presence of OIDs is not explicitly specified,
- the
- used.
-
Create a new temporary table films_recent , consisting of
only recent entries from the table films , using a
- prepared statement. The new table has OIDs and will be dropped at commit:
+ prepared statement. The new table will be dropped at commit:
PREPARE recentfilms(date) AS
SELECT * FROM films WHERE date_prod > $1;
-CREATE TEMP TABLE films_recent WITH (OIDS) ON COMMIT DROP AS
+CREATE TEMP TABLE films_recent ON COMMIT DROP AS
EXECUTE recentfilms('2002-01-01');
The
WITH clause is a
PostgreSQL - extension; neither storage parameters nor OIDs are in the standard.
+ extension; storage parameters are not in the standard.
-
- -o
- --oids
-
- Dump object identifiers (
OID s) as part of the
- data for every table. Use this option if your application references
- columns in some way (e.g., in a foreign key constraint).
- Otherwise, this option should not be used.
-
-
-
-
-O
--no-owner
CREATE TABLE AS offers a superset of the
functionality provided by SELECT INTO .
-
- To add OIDs to the table created by SELECT INTO ,
- enable the
- variable. Alternatively, CREATE TABLE AS can be
- used with the WITH OIDS clause.
-
Prevent foreign tables from being created with OIDS
- when <xref linkend="guc-default-with-oids"/ > is true
+ when <literal>default_with_oids"> is true
(Etsuro Fujita)
Prevent foreign tables from being created with OIDS
- when <xref linkend="guc-default-with-oids"/ > is true
+ when <literal>default_with_oids"> is true
(Etsuro Fujita)
Prevent foreign tables from being created with OIDS
- when <xref linkend="guc-default-with-oids"/ > is true
+ when <literal>default_with_oids"> is true
(Etsuro Fujita)
/* make sure it's in the bdesc's context */
oldcxt = MemoryContextSwitchTo(brdesc->bd_context);
- tupdesc = CreateTemplateTupleDesc(brdesc->bd_totalstored, false );
+ tupdesc = CreateTemplateTupleDesc(brdesc->bd_totalstored);
for (i = 0; i < brdesc->bd_tupdesc->natts; i++)
{
{
case TableOidAttributeNumber:
case SelfItemPointerAttributeNumber:
- case ObjectIdAttributeNumber:
case MinTransactionIdAttributeNumber:
case MinCommandIdAttributeNumber:
case MaxTransactionIdAttributeNumber:
/* pass-by-reference datatype */
result = PointerGetDatum(&(tup->t_self));
break;
- case ObjectIdAttributeNumber:
- result = ObjectIdGetDatum(HeapTupleGetOid(tup));
- break;
case MinTransactionIdAttributeNumber:
result = TransactionIdGetDatum(HeapTupleHeaderGetRawXmin(tup->t_data));
break;
else
targetNullLen = 0;
- if (tupleDesc->tdhasoid)
- len += sizeof(Oid);
-
/*
* Allocate and zero the space needed. Note that the tuple body and
* HeapTupleData management structure are allocated in one chunk.
if (hasnull)
len += BITMAPLEN(numberOfAttributes);
- if (tupleDescriptor->tdhasoid)
- len += sizeof(Oid);
-
hoff = len = MAXALIGN(len); /* align user data safely */
data_len = heap_compute_data_size(tupleDescriptor, values, isnull);
HeapTupleHeaderSetNatts(td, numberOfAttributes);
td->t_hoff = hoff;
- if (tupleDescriptor->tdhasoid) /* else leave infomask = 0 */
- td->t_infomask = HEAP_HASOID;
-
heap_fill_tuple(tupleDescriptor,
values,
isnull,
pfree(isnull);
/*
- * copy the identification info of the old tuple: t_ctid, t_self, and OID
- * (if any)
+ * copy the identification info of the old tuple: t_ctid, t_self
*/
newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
newTuple->t_self = tuple->t_self;
newTuple->t_tableOid = tuple->t_tableOid;
- if (tupleDesc->tdhasoid)
- HeapTupleSetOid(newTuple, HeapTupleGetOid(tuple));
return newTuple;
}
pfree(isnull);
/*
- * copy the identification info of the old tuple: t_ctid, t_self, and OID
- * (if any)
+ * copy the identification info of the old tuple: t_ctid, t_self
*/
newTuple->t_data->t_ctid = tuple->t_data->t_ctid;
newTuple->t_self = tuple->t_self;
newTuple->t_tableOid = tuple->t_tableOid;
- if (tupleDesc->tdhasoid)
- HeapTupleSetOid(newTuple, HeapTupleGetOid(tuple));
return newTuple;
}
if (hasnull)
len += BITMAPLEN(numberOfAttributes);
- if (tupleDescriptor->tdhasoid)
- len += sizeof(Oid);
-
hoff = len = MAXALIGN(len); /* align user data safely */
data_len = heap_compute_data_size(tupleDescriptor, values, isnull);
HeapTupleHeaderSetNatts(tuple, numberOfAttributes);
tuple->t_hoff = hoff + MINIMAL_TUPLE_OFFSET;
- if (tupleDescriptor->tdhasoid) /* else leave infomask = 0 */
- tuple->t_infomask = HEAP_HASOID;
-
heap_fill_tuple(tupleDescriptor,
values,
isnull,
* reloptions value (possibly NULL), and we replace or remove entries
* as needed.
*
- * If ignoreOids is true, then we should ignore any occurrence of "oids"
- * in the list (it will be or has been handled by interpretOidsOption()) .
+ * If acceptOidsOff is true, then we allow oids = false, but throw error when
+ * on. This is solely needed for backwards compatibility .
*
* Note that this is not responsible for determining whether the options
* are valid, but it does check that namespaces for all the options given are
*/
Datum
transformRelOptions(Datum oldOptions, List *defList, const char *namspace,
- char *validnsps[], bool ignoreOids , bool isReset)
+ char *validnsps[], bool acceptOidsOff , bool isReset)
{
Datum result;
ArrayBuildState *astate;
def->defnamespace)));
}
- if (ignoreOids && strcmp(def->defname, "oids") == 0)
- continue;
-
/* ignore if not in the same namespace */
if (namspace == NULL)
{
value = defGetString(def);
else
value = "true";
+
+ /*
+ * This is not a great place for this test, but there's no other
+ * convenient place to filter the option out. As WITH (oids =
+ * false) will be removed someday, this seems like an acceptable
+ * amount of ugly.
+ */
+ if (acceptOidsOff && def->defnamespace == NULL &&
+ strcmp(def->defname, "oids") == 0)
+ {
+ if (defGetBoolean(def))
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("tables declared WITH OIDS are not supported")));
+ /* skip over option, reloptions machinery doesn't know it */
+ continue;
+ }
+
len = VARHDRSZ + strlen(def->defname) + 1 + strlen(value);
/* +1 leaves room for sprintf's trailing null */
t = (text *) palloc(len + 1);
/*
* Check to see if the map is one-to-one, in which case we need not do a
- * tuple conversion. We must also insist that both tupdescs either
- * specify or don't specify an OID column, else we need a conversion to
- * add/remove space for that. (For some callers, presence or absence of
- * an OID column perhaps would not really matter, but let's be safe.)
+ * tuple conversion.
*/
- if (indesc->natts == outdesc->natts &&
- indesc->tdhasoid == outdesc->tdhasoid)
+ if (indesc->natts == outdesc->natts)
{
for (i = 0; i < n; i++)
{
/*
* Check to see if the map is one-to-one, in which case we need not do a
- * tuple conversion. We must also insist that both tupdescs either
- * specify or don't specify an OID column, else we need a conversion to
- * add/remove space for that. (For some callers, presence or absence of
- * an OID column perhaps would not really matter, but let's be safe.)
+ * tuple conversion.
*/
- if (indesc->natts == outdesc->natts &&
- indesc->tdhasoid == outdesc->tdhasoid)
+ if (indesc->natts == outdesc->natts)
{
same = true;
for (i = 0; i < n; i++)
* caller can overwrite this if needed.
*/
TupleDesc
-CreateTemplateTupleDesc(int natts, bool hasoid )
+CreateTemplateTupleDesc(int natts)
{
TupleDesc desc;
desc->constr = NULL;
desc->tdtypeid = RECORDOID;
desc->tdtypmod = -1;
- desc->tdhasoid = hasoid;
desc->tdrefcount = -1; /* assume not reference-counted */
return desc;
* caller can overwrite this if needed.
*/
TupleDesc
-CreateTupleDesc(int natts, bool hasoid, Form_pg_attribute *attrs)
+CreateTupleDesc(int natts, Form_pg_attribute *attrs)
{
TupleDesc desc;
int i;
- desc = CreateTemplateTupleDesc(natts, hasoid );
+ desc = CreateTemplateTupleDesc(natts);
for (i = 0; i < natts; ++i)
memcpy(TupleDescAttr(desc, i), attrs[i], ATTRIBUTE_FIXED_PART_SIZE);
TupleDesc desc;
int i;
- desc = CreateTemplateTupleDesc(tupdesc->natts, tupdesc->tdhasoid );
+ desc = CreateTemplateTupleDesc(tupdesc->natts);
/* Flat-copy the attribute array */
memcpy(TupleDescAttr(desc, 0),
TupleConstr *constr = tupdesc->constr;
int i;
- desc = CreateTemplateTupleDesc(tupdesc->natts, tupdesc->tdhasoid );
+ desc = CreateTemplateTupleDesc(tupdesc->natts);
/* Flat-copy the attribute array */
memcpy(TupleDescAttr(desc, 0),
return false;
if (tupdesc1->tdtypeid != tupdesc2->tdtypeid)
return false;
- if (tupdesc1->tdhasoid != tupdesc2->tdhasoid)
- return false;
for (i = 0; i < tupdesc1->natts; i++)
{
s = hash_combine(0, hash_uint32(desc->natts));
s = hash_combine(s, hash_uint32(desc->tdtypeid));
- s = hash_combine(s, hash_uint32(desc->tdhasoid));
for (i = 0; i < desc->natts; ++i)
s = hash_combine(s, hash_uint32(TupleDescAttr(desc, i)->atttypid));
* allocate a new tuple descriptor
*/
natts = list_length(schema);
- desc = CreateTemplateTupleDesc(natts, false );
+ desc = CreateTemplateTupleDesc(natts);
has_not_null = false;
attnum = 0;
/*
* allocate a new tuple descriptor
*/
- desc = CreateTemplateTupleDesc(natts, false );
+ desc = CreateTemplateTupleDesc(natts);
attnum = 0;
state->tupdesc[i] = state->origTupdesc;
else
{
- state->tupdesc[i] = CreateTemplateTupleDesc(2, false );
+ state->tupdesc[i] = CreateTemplateTupleDesc(2);
TupleDescInitEntry(state->tupdesc[i], (AttrNumber) 1, NULL,
INT2OID, -1, 0);
* types.
*/
natts = RelationGetNumberOfAttributes(scan->indexRelation);
- so->giststate->fetchTupdesc = CreateTemplateTupleDesc(natts, false );
+ so->giststate->fetchTupdesc = CreateTemplateTupleDesc(natts);
for (attno = 1; attno <= natts; attno++)
{
TupleDescInitEntry(so->giststate->fetchTupdesc, attno, NULL,
* TID where the tuple was stored. But note that any toasting of fields
* within the tuple data is NOT reflected into *tup.
*/
-O id
+vo id
heap_insert(Relation relation, HeapTuple tup, CommandId cid,
int options, BulkInsertState bistate)
{
tup->t_self = heaptup->t_self;
heap_freetuple(heaptup);
}
-
- return HeapTupleGetOid(tup);
}
/*
(errcode(ERRCODE_INVALID_TRANSACTION_STATE),
errmsg("cannot insert tuples in a parallel worker")));
- if (relation->rd_rel->relhasoids)
- {
-#ifdef NOT_USED
- /* this is redundant with an Assert in HeapTupleSetOid */
- Assert(tup->t_data->t_infomask & HEAP_HASOID);
-#endif
-
- /*
- * If the object id of this tuple has already been assigned, trust the
- * caller. There are a couple of ways this can happen. At initial db
- * creation, the backend program sets oids for tuples. When we define
- * an index, we set the oid. Finally, in the future, we may allow
- * users to set their own object ids in order to support a persistent
- * object store (objects need to contain pointers to one another).
- */
- if (!OidIsValid(HeapTupleGetOid(tup)))
- HeapTupleSetOid(tup, GetNewOid(relation));
- }
- else
- {
- /* check there is not space for an OID */
- Assert(!(tup->t_data->t_infomask & HEAP_HASOID));
- }
-
tup->t_data->t_infomask &= ~(HEAP_XACT_MASK);
tup->t_data->t_infomask2 &= ~(HEAP2_XACT_MASK);
tup->t_data->t_infomask |= HEAP_XMAX_INVALID;
* This should be used rather than using heap_insert directly in most places
* where we are modifying system catalogs.
*/
-O id
+vo id
simple_heap_insert(Relation relation, HeapTuple tup)
{
- return heap_insert(relation, tup, GetCurrentCommandId(true), 0, NULL);
+ heap_insert(relation, tup, GetCurrentCommandId(true), 0, NULL);
}
/*
/* the new tuple is ready, except for this: */
newtup->t_tableOid = RelationGetRelid(relation);
- /* Fill in OID for newtup */
- if (relation->rd_rel->relhasoids)
- {
-#ifdef NOT_USED
- /* this is redundant with an Assert in HeapTupleSetOid */
- Assert(newtup->t_data->t_infomask & HEAP_HASOID);
-#endif
- HeapTupleSetOid(newtup, HeapTupleGetOid(&oldtup));
- }
- else
- {
- /* check there is not space for an OID */
- Assert(!(newtup->t_data->t_infomask & HEAP_HASOID));
- }
-
/* Determine columns modified by the update. */
modified_attrs = HeapDetermineModifiedColumns(relation, interesting_attrs,
&oldtup, newtup);
/*
* Likewise, automatically say "not equal" for any system attribute other
- * than OID and tableOID; we cannot expect these to be consistent in a HOT
- * chain, or even to be set correctly yet in the new tuple.
+ * than tableOID; we cannot expect these to be consistent in a HOT chain,
+ * or even to be set correctly yet in the new tuple.
*/
if (attrnum < 0)
{
- if (attrnum != ObjectIdAttributeNumber &&
- attrnum != TableOidAttributeNumber)
+ if (attrnum != TableOidAttributeNumber)
return false;
}
int attno = idx_rel->rd_index->indkey.values[natt];
if (attno < 0)
- {
- /*
- * The OID column can appear in an index definition, but that's
- * OK, because we always copy the OID if present (see below).
- * Other system columns may not.
- */
- if (attno == ObjectIdAttributeNumber)
- continue;
elog(ERROR, "system column in index");
- }
nulls[attno - 1] = false;
}
*copy = true;
RelationClose(idx_rel);
- /*
- * Always copy oids if the table has them, even if not included in the
- * index. The space in the logged tuple is used anyway, so there's little
- * point in not including the information.
- */
- if (relation->rd_rel->relhasoids)
- HeapTupleSetOid(key_tuple, HeapTupleGetOid(tp));
-
/*
* If the tuple, which by here only contains indexed columns, still has
* toasted columns, force them to be inlined. This is somewhat unlikely
hoff = SizeofHeapTupleHeader;
if (has_nulls)
hoff += BITMAPLEN(numAttrs);
- if (newtup->t_data->t_infomask & HEAP_HASOID)
- hoff += sizeof(Oid);
hoff = MAXALIGN(hoff);
/* now convert to a limit on the tuple data size */
maxDataLen = RelationGetToastTupleTarget(rel, TOAST_TUPLE_TARGET) - hoff;
new_header_len = SizeofHeapTupleHeader;
if (has_nulls)
new_header_len += BITMAPLEN(numAttrs);
- if (olddata->t_infomask & HEAP_HASOID)
- new_header_len += sizeof(Oid);
new_header_len = MAXALIGN(new_header_len);
new_data_len = heap_compute_data_size(tupleDesc,
toast_values, toast_isnull);
memcpy(new_data, olddata, SizeofHeapTupleHeader);
HeapTupleHeaderSetNatts(new_data, numAttrs);
new_data->t_hoff = new_header_len;
- if (olddata->t_infomask & HEAP_HASOID)
- HeapTupleHeaderSetOid(new_data, HeapTupleHeaderGetOid(olddata));
/* Copy over the data, and fill the null bitmap if needed */
heap_fill_tuple(tupleDesc,
new_tuple = heap_form_tuple(tupleDesc, toast_values, toast_isnull);
/*
- * Be sure to copy the tuple's OID and identity fields. We also make a
- * point of copying visibility info, just in case anybody looks at those
- * fields in a syscache entry.
+ * Be sure to copy the tuple's identity fields. We also make a point of
+ * copying visibility info, just in case anybody looks at those fields in
+ * a syscache entry.
*/
- if (tupleDesc->tdhasoid)
- HeapTupleSetOid(new_tuple, HeapTupleGetOid(tup));
-
new_tuple->t_self = tup->t_self;
new_tuple->t_tableOid = tup->t_tableOid;
new_header_len = SizeofHeapTupleHeader;
if (has_nulls)
new_header_len += BITMAPLEN(numAttrs);
- if (tup->t_infomask & HEAP_HASOID)
- new_header_len += sizeof(Oid);
new_header_len = MAXALIGN(new_header_len);
new_data_len = heap_compute_data_size(tupleDesc,
toast_values, toast_isnull);
memcpy(new_data, tup, SizeofHeapTupleHeader);
HeapTupleHeaderSetNatts(new_data, numAttrs);
new_data->t_hoff = new_header_len;
- if (tup->t_infomask & HEAP_HASOID)
- HeapTupleHeaderSetOid(new_data, HeapTupleHeaderGetOid(tup));
/* Set the composite-Datum header fields correctly */
HeapTupleHeaderSetDatumLength(new_data, new_tuple_len);
*
* Test whether a toast value with the given ID exists in the toast relation.
* For safety, we consider a value to exist if there are either live or dead
- * toast rows with that ID; see notes for GetNewOid().
+ * toast rows with that ID; see notes for GetNewOidWithIndex ().
* ----------
*/
static bool
* Construct a tuple descriptor for the result row. This must match this
* function's pg_proc entry!
*/
- tupdesc = CreateTemplateTupleDesc(2, false );
+ tupdesc = CreateTemplateTupleDesc(2);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "xid",
XIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "timestamp",
false);
multi->iter = 0;
- tupdesc = CreateTemplateTupleDesc(2, false );
+ tupdesc = CreateTemplateTupleDesc(2);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "xid",
XIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "mode",
/* build tupdesc for result tuples */
/* this had better match pg_prepared_xacts view in system_views.sql */
- tupdesc = CreateTemplateTupleDesc(5, false );
+ tupdesc = CreateTemplateTupleDesc(5);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "transaction",
XIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "gid",
* OIDs are generated by a cluster-wide counter. Since they are only 32 bits
* wide, counter wraparound will occur eventually, and therefore it is unwise
* to assume they are unique unless precautions are taken to make them so.
- * Hence, this routine should generally not be used directly. The only
- * direct callers should be GetNewOid () and GetNewRelFileNode() in
+ * Hence, this routine should generally not be used directly. The only direct
+ * callers should be GetNewOidWithIndex () and GetNewRelFileNode() in
* catalog/catalog.c.
*/
Oid
* Construct a tuple descriptor for the result row. This must match this
* function's pg_proc entry!
*/
- resultTupleDesc = CreateTemplateTupleDesc(2, false );
+ resultTupleDesc = CreateTemplateTupleDesc(2);
TupleDescInitEntry(resultTupleDesc, (AttrNumber) 1, "file_name",
TEXTOID, -1, 0);
TupleDescInitEntry(resultTupleDesc, (AttrNumber) 2, "file_offset",
%type boot_index_params
%type boot_index_param
%type boot_ident
-%type optbootstrap optsharedrelation optwithoutoids boot_column_nullness
-%type oidspec optoideq opt rowtypeoid
+%type optbootstrap optsharedrelation boot_column_nullness
+%type oidspec optrowtypeoid
%token ID
%token COMMA EQUALS LPAREN RPAREN
/* All the rest are unreserved, and should be handled in boot_ident! */
%token OPEN XCLOSE XCREATE INSERT_TUPLE
%token XDECLARE INDEX ON USING XBUILD INDICES UNIQUE XTOAST
-%token OBJ_ID XBOOTSTRAP XSHARED_RELATION XWITHOUT_OIDS X ROWTYPE_OID
+%token OBJ_ID XBOOTSTRAP XSHARED_RELATION XROWTYPE_OID
%token XFORCE XNOT XNULL
%start TopLevel
;
Boot_CreateStmt:
- XCREATE boot_ident oidspec optbootstrap optsharedrelation optwithoutoids opt rowtypeoid LPAREN
+ XCREATE boot_ident oidspec optbootstrap optsharedrelation optrowtypeoid LPAREN
{
do_start();
numattr = 0;
do_start();
- tupdesc = CreateTupleDesc(numattr, !($6), attrtypes);
+ tupdesc = CreateTupleDesc(numattr, attrtypes);
shared_relation = $5;
PG_CATALOG_NAMESPACE,
shared_relation ? GLOBALTABLESPACE_OID : 0,
$3,
- $7 ,
+ $6 ,
InvalidOid,
BOOTSTRAP_SUPERUSERID,
tupdesc,
RELPERSISTENCE_PERMANENT,
shared_relation,
mapped_relation,
- true,
- 0,
ONCOMMIT_NOOP,
(Datum) 0,
false,
;
Boot_InsertStmt:
- INSERT_TUPLE optoideq
+ INSERT_TUPLE
{
do_start();
- if ($2)
- elog(DEBUG4, "inserting row with oid %u", $2);
- else
- elog(DEBUG4, "inserting row");
+ elog(DEBUG4, "inserting row");
num_columns_read = 0;
}
LPAREN boot_column_val_list RPAREN
numattr, num_columns_read);
if (boot_reldesc == NULL)
elog(FATAL, "relation not open");
- InsertOneTuple($2 );
+ InsertOneTuple();
do_end();
}
;
| { $$ = 0; }
;
-optwithoutoids:
- XWITHOUT_OIDS { $$ = 1; }
- | { $$ = 0; }
- ;
-
optrowtypeoid:
XROWTYPE_OID oidspec { $$ = $2; }
| { $$ = InvalidOid; }
boot_ident { $$ = atooid($1); }
;
-optoideq:
- OBJ_ID EQUALS oidspec { $$ = $3; }
- | { $$ = InvalidOid; }
- ;
-
boot_column_val_list:
boot_column_val
| boot_column_val_list boot_column_val
| OBJ_ID { $$ = pstrdup($1); }
| XBOOTSTRAP { $$ = pstrdup($1); }
| XSHARED_RELATION { $$ = pstrdup($1); }
- | XWITHOUT_OIDS { $$ = pstrdup($1); }
| XROWTYPE_OID { $$ = pstrdup($1); }
| XFORCE { $$ = pstrdup($1); }
| XNOT { $$ = pstrdup($1); }
OID { yylval.kw = "OID"; return OBJ_ID; }
bootstrap { yylval.kw = "bootstrap"; return XBOOTSTRAP; }
shared_relation { yylval.kw = "shared_relation"; return XSHARED_RELATION; }
-without_oids { yylval.kw = "without_oids"; return XWITHOUT_OIDS; }
rowtype_oid { yylval.kw = "rowtype_oid"; return XROWTYPE_OID; }
insert { yylval.kw = "insert"; return INSERT_TUPLE; }
app = Typ;
while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
- (*app)->am_oid = HeapTupleGetOid(tup) ;
+ (*app)->am_oid = ((Form_pg_type) GETSTRUCT(tup))->oid ;
memcpy((char *) &(*app)->am_typ,
(char *) GETSTRUCT(tup),
sizeof((*app)->am_typ));
* ----------------
*/
void
-InsertOneTuple(Oid object id)
+InsertOneTuple(vo id)
{
HeapTuple tuple;
TupleDesc tupDesc;
int i;
- elog(DEBUG4, "inserting row oid %u, %d columns", objectid , numattr);
+ elog(DEBUG4, "inserting row with %d columns" , numattr);
- tupDesc = CreateTupleDesc(numattr,
- RelationGetForm(boot_reldesc)->relhasoids,
- attrtypes);
+ tupDesc = CreateTupleDesc(numattr, attrtypes);
tuple = heap_form_tuple(tupDesc, values, Nulls);
- if (objectid != (Oid) 0)
- HeapTupleSetOid(tuple, objectid);
pfree(tupDesc); /* just free's tupDesc, not the attrtypes */
simple_heap_insert(boot_reldesc, tuple);
app = Typ;
while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
- (*app)->am_oid = HeapTupleGetOid(tup) ;
+ (*app)->am_oid = ((Form_pg_type) GETSTRUCT(tup))->oid ;
memmove((char *) &(*app++)->am_typ,
(char *) GETSTRUCT(tup),
sizeof((*app)->am_typ));
$catalog{bootstrap} = /BKI_BOOTSTRAP/ ? ' bootstrap' : '';
$catalog{shared_relation} =
/BKI_SHARED_RELATION/ ? ' shared_relation' : '';
- $catalog{without_oids} =
- /BKI_WITHOUT_OIDS/ ? ' without_oids' : '';
if (/BKI_ROWTYPE_OID\((\d+),(\w+)\)/)
{
$catalog{rowtype_oid} = $1;
{
;
}
+ elsif ($attname eq 'oid')
+ {
+ ;
+ }
elsif (defined $column->{default})
{
$row->{$attname} = $column->{default};
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
- objects = lappend_oid(objects, HeapTupleGetOid(tuple));
+ Oid oid = ((Form_pg_proc) GETSTRUCT(tuple))->oid;
+
+ objects = lappend_oid(objects, oid);
}
heap_endscan(scan);
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
- relations = lappend_oid(relations, HeapTupleGetOid(tuple));
+ Oid oid = ((Form_pg_class) GETSTRUCT(tuple))->oid;
+
+ relations = lappend_oid(relations, oid);
}
heap_endscan(scan);
* there shouldn't be anything depending on this entry.
*/
myself.classId = DefaultAclRelationId;
- myself.objectId = HeapTupleGetOid(tuple) ;
+ myself.objectId = ((Form_pg_default_acl) GETSTRUCT(tuple))->oid ;
myself.objectSubId = 0;
performDeletion(&myself, DROP_RESTRICT, 0);
}
else
{
+ Oid defAclOid;
+
/* Prepare to insert or update pg_default_acl entry */
MemSet(values, 0, sizeof(values));
MemSet(nulls, false, sizeof(nulls));
if (isNew)
{
/* insert new entry */
+ defAclOid = GetNewOidWithIndex(rel, DefaultAclOidIndexId,
+ Anum_pg_default_acl_oid);
+ values[Anum_pg_default_acl_oid - 1] = ObjectIdGetDatum(defAclOid);
values[Anum_pg_default_acl_defaclrole - 1] = ObjectIdGetDatum(iacls->roleid);
values[Anum_pg_default_acl_defaclnamespace - 1] = ObjectIdGetDatum(iacls->nspid);
values[Anum_pg_default_acl_defaclobjtype - 1] = CharGetDatum(objtype);
}
else
{
+ defAclOid = ((Form_pg_default_acl) GETSTRUCT(tuple))->oid;
+
/* update existing entry */
values[Anum_pg_default_acl_defaclacl - 1] = PointerGetDatum(new_acl);
replaces[Anum_pg_default_acl_defaclacl - 1] = true;
if (isNew)
{
/* dependency on role */
- recordDependencyOnOwner(DefaultAclRelationId,
- HeapTupleGetOid(newtuple),
+ recordDependencyOnOwner(DefaultAclRelationId, defAclOid,
iacls->roleid);
/* dependency on namespace */
referenced;
myself.classId = DefaultAclRelationId;
- myself.objectId = HeapTupleGetOid(newtuple) ;
+ myself.objectId = defAclOid ;
myself.objectSubId = 0;
referenced.classId = NamespaceRelationId;
nnewmembers = aclmembers(new_acl, &newmembers);
updateAclDependencies(DefaultAclRelationId,
- HeapTupleGetOid(newtuple) , 0,
+ defAclOid , 0,
iacls->roleid,
noldmembers, oldmembers,
nnewmembers, newmembers);
if (isNew)
- InvokeObjectPostCreateHook(DefaultAclRelationId,
- HeapTupleGetOid(newtuple), 0);
+ InvokeObjectPostCreateHook(DefaultAclRelationId, defAclOid, 0);
else
- InvokeObjectPostAlterHook(DefaultAclRelationId,
- HeapTupleGetOid(newtuple), 0);
+ InvokeObjectPostAlterHook(DefaultAclRelationId, defAclOid, 0);
}
if (HeapTupleIsValid(tuple))
rel = heap_open(DefaultAclRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_default_acl_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(objid));
rel = heap_open(DefaultAclRelationId, RowExclusiveLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_default_acl_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(defaclOid));
if (curr_att == InvalidAttrNumber)
continue;
- /* Skip OID column if it doesn't exist */
- if (curr_att == ObjectIdAttributeNumber && !classForm->relhasoids)
- continue;
-
/* Views don't have any system columns at all */
if (classForm->relkind == RELKIND_VIEW && curr_att < 0)
continue;
CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
/* Update the shared dependency ACL info */
- updateAclDependencies(DatabaseRelationId, HeapTupleGetOid(tuple) , 0,
+ updateAclDependencies(DatabaseRelationId, pg_database_tuple->oid , 0,
ownerId,
noldmembers, oldmembers,
nnewmembers, newmembers);
/* Update the shared dependency ACL info */
updateAclDependencies(ForeignDataWrapperRelationId,
- HeapTupleGetOid(tuple) , 0,
+ pg_fdw_tuple->oid , 0,
ownerId,
noldmembers, oldmembers,
nnewmembers, newmembers);
/* Update the shared dependency ACL info */
updateAclDependencies(ForeignServerRelationId,
- HeapTupleGetOid(tuple) , 0,
+ pg_server_tuple->oid , 0,
ownerId,
noldmembers, oldmembers,
nnewmembers, newmembers);
recordExtensionInitPriv(langId, LanguageRelationId, 0, new_acl);
/* Update the shared dependency ACL info */
- updateAclDependencies(LanguageRelationId, HeapTupleGetOid(tuple) , 0,
+ updateAclDependencies(LanguageRelationId, pg_language_tuple->oid , 0,
ownerId,
noldmembers, oldmembers,
nnewmembers, newmembers);
/* There's no syscache for pg_largeobject_metadata */
ScanKeyInit(&entry[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_largeobject_metadata_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(loid));
/* Update the shared dependency ACL info */
updateAclDependencies(LargeObjectRelationId,
- HeapTupleGetOid(tuple) , 0,
+ form_lo_meta->oid , 0,
ownerId,
noldmembers, oldmembers,
nnewmembers, newmembers);
recordExtensionInitPriv(nspid, NamespaceRelationId, 0, new_acl);
/* Update the shared dependency ACL info */
- updateAclDependencies(NamespaceRelationId, HeapTupleGetOid(tuple) , 0,
+ updateAclDependencies(NamespaceRelationId, pg_namespace_tuple->oid , 0,
ownerId,
noldmembers, oldmembers,
nnewmembers, newmembers);
AccessShareLock);
ScanKeyInit(&entry[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_largeobject_metadata_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(lobj_oid));
AccessShareLock);
ScanKeyInit(&entry[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_largeobject_metadata_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(lobj_oid));
pg_extension = heap_open(ExtensionRelationId, AccessShareLock);
ScanKeyInit(&entry[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_extension_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(ext_oid));
/* There's no syscache for pg_largeobject_metadata */
ScanKeyInit(&entry[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_largeobject_metadata_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(objoid));
#include
#include "access/genam.h"
+#include "access/heapam.h"
+#include "access/htup_details.h"
#include "access/sysattr.h"
#include "access/transam.h"
#include "catalog/catalog.h"
#include "miscadmin.h"
#include "storage/fd.h"
#include "utils/fmgroids.h"
+#include "utils/fmgrprotos.h"
#include "utils/rel.h"
+#include "utils/syscache.h"
#include "utils/tqual.h"
/*
- * GetNewOid
- * Generate a new OID that is unique within the given relation.
- *
- * Caller must have a suitable lock on the relation.
- *
- * Uniqueness is promised only if the relation has a unique index on OID.
- * This is true for all system catalogs that have OIDs, but might not be
- * true for user tables. Note that we are effectively assuming that the
- * table has a relatively small number of entries (much less than 2^32)
- * and there aren't very long runs of consecutive existing OIDs. Again,
- * this is reasonable for system catalogs but less so for user tables.
+ * GetNewOidWithIndex
+ * Generate a new OID that is unique within the system relation.
*
* Since the OID is not immediately inserted into the table, there is a
* race condition here; but a problem could occur only if someone else
* of transient conflicts for as long as our own MVCC snapshots think a
* recently-deleted row is live. The risk is far higher when selecting TOAST
* OIDs, because SnapshotToast considers dead rows as active indefinitely.)
- */
-Oid
-GetNewOid(Relation relation)
-{
- Oid oidIndex;
-
- /* If relation doesn't have OIDs at all, caller is confused */
- Assert(relation->rd_rel->relhasoids);
-
- /* In bootstrap mode, we don't have any indexes to use */
- if (IsBootstrapProcessingMode())
- return GetNewObjectId();
-
- /* The relcache will cache the identity of the OID index for us */
- oidIndex = RelationGetOidIndex(relation);
-
- /* If no OID index, just hand back the next OID counter value */
- if (!OidIsValid(oidIndex))
- {
- /*
- * System catalogs that have OIDs should *always* have a unique OID
- * index; we should only take this path for user tables. Give a
- * warning if it looks like somebody forgot an index.
- */
- if (IsSystemRelation(relation))
- elog(WARNING, "generating possibly-non-unique OID for \"%s\"",
- RelationGetRelationName(relation));
-
- return GetNewObjectId();
- }
-
- /* Otherwise, use the index to find a nonconflicting OID */
- return GetNewOidWithIndex(relation, oidIndex, ObjectIdAttributeNumber);
-}
-
-/*
- * GetNewOidWithIndex
- * Guts of GetNewOid: use the supplied index
+ *
+ * Note that we are effectively assuming that the table has a relatively small
+ * number of entries (much less than 2^32) and there aren't very long runs of
+ * consecutive existing OIDs. This is a mostly reasonable assumption for
+ * system catalogs.
*
* This is exported separately because there are cases where we want to use
* an index that will not be recognized by RelationGetOidIndex: TOAST tables
ScanKeyData key;
bool collides;
+ /* Only system relations are supported */
+ Assert(IsSystemRelation(relation));
+
+ /* In bootstrap mode, we don't have any indexes to use */
+ if (IsBootstrapProcessingMode())
+ return GetNewObjectId();
+
/*
* We should never be asked to generate a new pg_type OID during
* pg_upgrade; doing so would risk collisions with the OIDs it wants to
* is also an unused OID within pg_class. If the result is to be used only
* as a relfilenode for an existing relation, pass NULL for pg_class.
*
- * As with GetNewOid, there is some theoretical risk of a race condition,
- * but it doesn't seem worth worrying about.
+ * As with GetNewObjectIdWithIndex(), there is some theoretical risk of a race
+ * condition, but it doesn't seem worth worrying about.
*
* Note: we don't support using this in bootstrap mode. All relations
* created by bootstrap have preassigned OIDs, so there's no need.
/* Generate the OID */
if (pg_class)
- rnode.node.relNode = GetNewOid(pg_class);
+ rnode.node.relNode = GetNewOidWithIndex(pg_class, ClassOidIndexId,
+ Anum_pg_class_oid);
else
rnode.node.relNode = GetNewObjectId();
return rnode.node.relNode;
}
+
+/*
+ * SQL callable interface for GetNewOidWithIndex(). Outside of initdb's
+ * direct insertions into catalog tables, and recovering from corruption, this
+ * should rarely be needed.
+ *
+ * Function is intentionally not documented in the user facing docs.
+ */
+Datum
+pg_nextoid(PG_FUNCTION_ARGS)
+{
+ Oid reloid = PG_GETARG_OID(0);
+ Name attname = PG_GETARG_NAME(1);
+ Oid idxoid = PG_GETARG_OID(2);
+ Relation rel;
+ Relation idx;
+ HeapTuple atttuple;
+ Form_pg_attribute attform;
+ AttrNumber attno;
+ Oid newoid;
+
+ /*
+ * As this function is not intended to be used during normal running, and
+ * only supports system catalogs (which require superuser permissions to
+ * modify), just checking for superuser ought to not obstruct valid
+ * usecases.
+ */
+ if (!superuser())
+ ereport(ERROR,
+ (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
+ errmsg("must be superuser to call pg_nextoid")));
+
+ rel = heap_open(reloid, RowExclusiveLock);
+ idx = index_open(idxoid, RowExclusiveLock);
+
+ if (!IsSystemRelation(rel))
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("pg_nextoid() can only be used on system relation")));
+
+ if (idx->rd_index->indrelid != RelationGetRelid(rel))
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("index %s does not belong to table %s",
+ RelationGetRelationName(idx),
+ RelationGetRelationName(rel))));
+
+ atttuple = SearchSysCacheAttName(reloid, NameStr(*attname));
+ if (!HeapTupleIsValid(atttuple))
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("attribute %s does not exists",
+ NameStr(*attname))));
+
+ attform = ((Form_pg_attribute) GETSTRUCT(atttuple));
+ attno = attform->attnum;
+
+ if (attform->atttypid != OIDOID)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("attribute %s is not of type oid",
+ NameStr(*attname))));
+
+ if (IndexRelationGetNumberOfKeyAttributes(idx) != 1 ||
+ idx->rd_index->indkey.values[0] != attno)
+ ereport(ERROR,
+ (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+ errmsg("index %s is not the index for attribute %s",
+ RelationGetRelationName(idx),
+ NameStr(*attname))));
+
+ newoid = GetNewOidWithIndex(rel, idxoid, attno);
+
+ ReleaseSysCache(atttuple);
+ heap_close(rel, RowExclusiveLock);
+ index_close(idx, RowExclusiveLock);
+
+ return newoid;
+}
# While duplicate OIDs would only cause a failure if they appear in
# the same catalog, our project policy is that manually assigned OIDs
# should be globally unique, to avoid confusion.
+#
+# Also use the loop to determine the maximum explicitly assigned oid
+# found in the data file, we'll use that for default oid assignments.
my $found = 0;
+my $maxoid = 0;
foreach my $oid (keys %oidcounts)
{
+ if ($oid > $maxoid)
+ {
+ $maxoid = $oid;
+ }
next unless $oidcounts{$oid} > 1;
print STDERR "Duplicate OIDs detected:\n" if !$found;
print STDERR "$oid\n";
print $bki "create $catname $catalog->{relation_oid}"
. $catalog->{shared_relation}
. $catalog->{bootstrap}
- . $catalog->{without_oids}
. $catalog->{rowtype_oid_clause};
my $first = 1;
foreach my $key (keys %bki_values)
{
next
- if $key eq "oid"
- || $key eq "oid_symbol"
+ if $key eq "oid_symbol"
|| $key eq "array_type_oid"
|| $key eq "descr"
|| $key eq "autogenerated"
my $attname = $column->{name};
my $atttype = $column->{type};
+ # Assign oid if oid column exists and no explicit assignment in row
+ if ($attname eq "oid" and not defined $bki_values{$attname})
+ {
+ $bki_values{$attname} = $maxoid;
+ $maxoid++;
+ }
+
# Substitute constant values we acquired above.
# (It's intentional that this can apply to parts of a field).
$bki_values{$attname} =~ s/\bPGUID\b/$BOOTSTRAP_SUPERUSERID/g;
$attnum = 0;
my @SYS_ATTRS = (
{ name => 'ctid', type => 'tid' },
- { name => 'oid', type => 'oid' },
{ name => 'xmin', type => 'xid' },
{ name => 'cmin', type => 'cid' },
{ name => 'xmax', type => 'xid' },
$row{attrelid} = $table->{relation_oid};
$row{attstattarget} = '0';
- # Omit the oid column if the catalog doesn't have them
- next
- if $table->{without_oids}
- && $attr->{name} eq 'oid';
-
morph_row_for_pgattr(\%row, $schema, $attr, 1);
print_bki_insert(\%row, $schema);
}
my $schema = shift;
my @bki_values;
- my $oid = $row->{oid} ? "OID = $row->{oid} " : '';
foreach my $column (@$schema)
{
push @bki_values, $bki_value;
}
- printf $bki "insert %s( %s )\n", $oid , join(' ', @bki_values);
+ printf $bki "insert ( %s )\n" , join(' ', @bki_values);
return;
}
};
static const FormData_pg_attribute a2 = {
- .attname = {"oid"},
- .atttypid = OIDOID,
- .attlen = sizeof(Oid),
- .attnum = ObjectIdAttributeNumber,
- .attcacheoff = -1,
- .atttypmod = -1,
- .attbyval = true,
- .attstorage = 'p',
- .attalign = 'i',
- .attnotnull = true,
- .attislocal = true,
-};
-
-static const FormData_pg_attribute a3 = {
.attname = {"xmin"},
.atttypid = XIDOID,
.attlen = sizeof(TransactionId),
.attislocal = true,
};
-static const FormData_pg_attribute a4 = {
+static const FormData_pg_attribute a3 = {
.attname = {"cmin"},
.atttypid = CIDOID,
.attlen = sizeof(CommandId),
.attislocal = true,
};
-static const FormData_pg_attribute a5 = {
+static const FormData_pg_attribute a4 = {
.attname = {"xmax"},
.atttypid = XIDOID,
.attlen = sizeof(TransactionId),
.attislocal = true,
};
-static const FormData_pg_attribute a6 = {
+static const FormData_pg_attribute a5 = {
.attname = {"cmax"},
.atttypid = CIDOID,
.attlen = sizeof(CommandId),
* table of a particular class/type. In any case table is still the word
* used in SQL.
*/
-static const FormData_pg_attribute a7 = {
+static const FormData_pg_attribute a6 = {
.attname = {"tableoid"},
.atttypid = OIDOID,
.attlen = sizeof(Oid),
.attislocal = true,
};
-static const FormData_pg_attribute *SysAtt[] = {&a1, &a2, &a3, &a4, &a5, &a6, &a7 };
+static const FormData_pg_attribute *SysAtt[] = {&a1, &a2, &a3, &a4, &a5, &a6};
/*
* This function returns a Form_pg_attribute pointer for a system attribute.
* happen if there's a problem upstream.
*/
const FormData_pg_attribute *
-SystemAttributeDefinition(AttrNumber attno, bool relhasoids )
+SystemAttributeDefinition(AttrNumber attno)
{
if (attno >= 0 || attno < -(int) lengthof(SysAtt))
elog(ERROR, "invalid system attribute number %d", attno);
- if (attno == ObjectIdAttributeNumber && !relhasoids)
- elog(ERROR, "invalid system attribute number %d", attno);
return SysAtt[-attno - 1];
}
* pointer for a prototype definition. If not, return NULL.
*/
const FormData_pg_attribute *
-SystemAttributeByName(const char *attname, bool relhasoids )
+SystemAttributeByName(const char *attname)
{
int j;
{
const FormData_pg_attribute *att = SysAtt[j];
- if (relhasoids || att->attnum != ObjectIdAttributeNumber)
- {
- if (strcmp(NameStr(att->attname), attname) == 0)
- return att;
- }
+ if (strcmp(NameStr(att->attname), attname) == 0)
+ return att;
}
return NULL;
{
Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
- if (SystemAttributeByName(NameStr(attr->attname),
- tupdesc->tdhasoid) != NULL)
+ if (SystemAttributeByName(NameStr(attr->attname)) != NULL)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_COLUMN),
errmsg("column name \"%s\" conflicts with a system column name",
static void
AddNewAttributeTuples(Oid new_rel_oid,
TupleDesc tupdesc,
- char relkind,
- bool oidislocal,
- int oidinhcount)
+ char relkind)
{
Form_pg_attribute attr;
int i;
{
FormData_pg_attribute attStruct;
- /* skip OID where appropriate */
- if (!tupdesc->tdhasoid &&
- SysAtt[i]->attnum == ObjectIdAttributeNumber)
- continue;
-
memcpy(&attStruct, (char *) SysAtt[i], sizeof(FormData_pg_attribute));
/* Fill in the correct relation OID in the copied tuple */
attStruct.attrelid = new_rel_oid;
- /* Fill in correct inheritance info for the OID column */
- if (attStruct.attnum == ObjectIdAttributeNumber)
- {
- attStruct.attislocal = oidislocal;
- attStruct.attinhcount = oidinhcount;
- }
-
InsertPgAttributeTuple(rel, &attStruct, indstate);
}
}
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ values[Anum_pg_class_oid - 1] = ObjectIdGetDatum(new_rel_oid);
values[Anum_pg_class_relname - 1] = NameGetDatum(&rd_rel->relname);
values[Anum_pg_class_relnamespace - 1] = ObjectIdGetDatum(rd_rel->relnamespace);
values[Anum_pg_class_reltype - 1] = ObjectIdGetDatum(rd_rel->reltype);
values[Anum_pg_class_relkind - 1] = CharGetDatum(rd_rel->relkind);
values[Anum_pg_class_relnatts - 1] = Int16GetDatum(rd_rel->relnatts);
values[Anum_pg_class_relchecks - 1] = Int16GetDatum(rd_rel->relchecks);
- values[Anum_pg_class_relhasoids - 1] = BoolGetDatum(rd_rel->relhasoids);
values[Anum_pg_class_relhasrules - 1] = BoolGetDatum(rd_rel->relhasrules);
values[Anum_pg_class_relhastriggers - 1] = BoolGetDatum(rd_rel->relhastriggers);
values[Anum_pg_class_relrowsecurity - 1] = BoolGetDatum(rd_rel->relrowsecurity);
tup = heap_form_tuple(RelationGetDescr(pg_class_desc), values, nulls);
- /*
- * The new tuple must have the oid already chosen for the rel. Sure would
- * be embarrassing to do this sort of thing in polite company.
- */
- HeapTupleSetOid(tup, new_rel_oid);
-
/* finally insert the new tuple, update the indexes, and clean up */
CatalogTupleInsert(pg_class_desc, tup);
* relpersistence: rel's persistence status (permanent, temp, or unlogged)
* shared_relation: true if it's to be a shared relation
* mapped_relation: true if the relation will use the relfilenode map
- * oidislocal: true if oid column (if any) should be marked attislocal
- * oidinhcount: attinhcount to assign to oid column (if any)
* oncommit: ON COMMIT marking (only relevant if it's a temp table)
* reloptions: reloptions in Datum form, or (Datum) 0 if none
* use_user_acl: true if should look for user-defined default permissions;
char relpersistence,
bool shared_relation,
bool mapped_relation,
- bool oidislocal,
- int oidinhcount,
OnCommitAction oncommit,
Datum reloptions,
bool use_user_acl,
* autogenerated array, we can rename it out of the way; otherwise we can
* at least give a good error message.
*/
- old_type_oid = GetSysCacheOid2(TYPENAMENSP,
+ old_type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
CStringGetDatum(relname),
ObjectIdGetDatum(relnamespace));
if (OidIsValid(old_type_oid))
/*
* now add tuples to pg_attribute for the attributes in our new relation.
*/
- AddNewAttributeTuples(relid, new_rel_desc->rd_att, relkind,
- oidislocal, oidinhcount);
+ AddNewAttributeTuples(relid, new_rel_desc->rd_att, relkind);
/*
* Make a dependency link to force the relation to be deleted if its
while (HeapTupleIsValid(tuple = systable_getnext(scan)))
{
ObjectAddress object;
+ Form_pg_attrdef attrtuple = (Form_pg_attrdef) GETSTRUCT(tuple);
object.classId = AttrDefaultRelationId;
- object.objectId = HeapTupleGetOid(tuple) ;
+ object.objectId = attrtuple->oid ;
object.objectSubId = 0;
performDeletion(&object, behavior,
/* Find the pg_attrdef tuple */
ScanKeyInit(&scankeys[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_attrdef_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(attrdefId));
ObjectAddress colobject,
defobject;
+ adrel = heap_open(AttrDefaultRelationId, RowExclusiveLock);
+
/*
* Flatten expression to string form for storage.
*/
/*
* Make the pg_attrdef entry.
*/
+ attrdefOid = GetNewOidWithIndex(adrel, AttrDefaultOidIndexId,
+ Anum_pg_attrdef_oid);
+ values[Anum_pg_attrdef_oid - 1] = ObjectIdGetDatum(attrdefOid);
values[Anum_pg_attrdef_adrelid - 1] = RelationGetRelid(rel);
values[Anum_pg_attrdef_adnum - 1] = attnum;
values[Anum_pg_attrdef_adbin - 1] = CStringGetTextDatum(adbin);
- adrel = heap_open(AttrDefaultRelationId, RowExclusiveLock);
-
tuple = heap_form_tuple(adrel->rd_att, values, nulls);
- attrdefOid = CatalogTupleInsert(adrel, tuple);
+ CatalogTupleInsert(adrel, tuple);
defobject.classId = AttrDefaultRelationId;
defobject.objectId = attrdefOid;
/*
* allocate the new tuple descriptor
*/
- indexTupDesc = CreateTemplateTupleDesc(numatts, false );
+ indexTupDesc = CreateTemplateTupleDesc(numatts);
/*
* Fill in the pg_attribute row.
/* Simple index column */
const FormData_pg_attribute *from;
- if (atnum < 0)
- {
- /*
- * here we are indexing on a system attribute (-1...-n)
- */
- from = SystemAttributeDefinition(atnum,
- heapRelation->rd_rel->relhasoids);
- }
- else
- {
- /*
- * here we are indexing on a normal attribute (1...n)
- */
- if (atnum > natts) /* safety check */
- elog(ERROR, "invalid column number %d", atnum);
- from = TupleDescAttr(heapTupDesc,
- AttrNumberGetAttrOffset(atnum));
- }
+ Assert(atnum > 0); /* should've been caught above */
+
+ if (atnum > natts) /* safety check */
+ elog(ERROR, "invalid column number %d", atnum);
+ from = TupleDescAttr(heapTupDesc,
+ AttrNumberGetAttrOffset(atnum));
namecpy(&to->attname, &from->attname);
to->atttypid = from->atttypid;
*/
indexRelation->rd_rel->relowner = heapRelation->rd_rel->relowner;
indexRelation->rd_rel->relam = accessMethodObjectId;
- indexRelation->rd_rel->relhasoids = false;
indexRelation->rd_rel->relispartition = OidIsValid(parentIndexRelid);
/*
ScanKeyData key[1];
ScanKeyInit(&key[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_class_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(relid));
* have index entries. Also, a new pg_class index will be created with a
* correct entry for its own pg_class row because we do
* RelationSetNewRelfilenode() before we do index_build().
- *
- * Note that we also clear pg_class's rd_oidindex until the loop is done,
- * so that that index can't be accessed either. This means we cannot
- * safely generate new relation OIDs while in the loop; shouldn't be a
- * problem.
*/
is_pg_class = (RelationGetRelid(rel) == RelationRelationId);
Oid indexOid = lfirst_oid(indexId);
if (is_pg_class)
- RelationSetIndexList(rel, doneIndexes, InvalidOid );
+ RelationSetIndexList(rel, doneIndexes);
reindex_index(indexOid, !(flags & REINDEX_REL_CHECK_CONSTRAINTS),
persistence, options);
ResetReindexPending();
if (is_pg_class)
- RelationSetIndexList(rel, indexIds, ClassOidIndexId );
+ RelationSetIndexList(rel, indexIds);
/*
* Close rel, but continue to hold the lock.
* and building the index info structures is moderately expensive.
* (Use CatalogTupleInsertWithInfo in such cases.)
*/
-O id
+vo id
CatalogTupleInsert(Relation heapRel, HeapTuple tup)
{
CatalogIndexState indstate;
- Oid oid;
indstate = CatalogOpenIndexes(heapRel);
- oid = simple_heap_insert(heapRel, tup);
+ simple_heap_insert(heapRel, tup);
CatalogIndexInsert(indstate, tup);
CatalogCloseIndexes(indstate);
-
- return oid;
}
/*
* might cache the CatalogIndexState data somewhere (perhaps in the relcache)
* so that callers needn't trouble over this ... but we don't do so today.
*/
-O id
+vo id
CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup,
CatalogIndexState indstate)
{
- Oid oid;
-
- oid = simple_heap_insert(heapRel, tup);
+ simple_heap_insert(heapRel, tup);
CatalogIndexInsert(indstate, tup);
-
- return oid;
}
/*
is_supported yes_or_no,
is_verified_by character_data,
comments character_data
-) WITHOUT OIDS ;
+);
-- Will be filled with external data by initdb.
integer_value cardinal_number,
character_value character_data,
comments character_data
-) WITHOUT OIDS ;
+);
INSERT INTO sql_implementation_info VALUES ('10003', 'CATALOG NAME', NULL, 'Y', NULL);
INSERT INTO sql_implementation_info VALUES ('10004', 'COLLATING SEQUENCE', NULL, (SELECT default_collate_name FROM character_sets), NULL);
sql_language_implementation character_data,
sql_language_binding_style character_data,
sql_language_programming_language character_data
-) WITHOUT OIDS ;
+);
INSERT INTO sql_languages VALUES ('ISO 9075', '1999', 'CORE', NULL, NULL, 'DIRECT', NULL);
INSERT INTO sql_languages VALUES ('ISO 9075', '1999', 'CORE', NULL, NULL, 'EMBEDDED', 'C');
is_supported yes_or_no,
is_verified_by character_data,
comments character_data
-) WITHOUT OIDS ;
+);
INSERT INTO sql_packages VALUES ('PKG000', 'Core', 'NO', NULL, '');
INSERT INTO sql_packages VALUES ('PKG001', 'Enhanced datetime facilities', 'YES', NULL, '');
is_supported yes_or_no,
is_verified_by character_data,
comments character_data
-) WITHOUT OIDS ;
+);
INSERT INTO sql_parts VALUES ('1', 'Framework (SQL/Framework)', 'NO', NULL, '');
INSERT INTO sql_parts VALUES ('2', 'Foundation (SQL/Foundation)', 'NO', NULL, '');
sizing_name character_data,
supported_value cardinal_number,
comments character_data
-) WITHOUT OIDS ;
+);
INSERT INTO sql_sizing VALUES (34, 'MAXIMUM CATALOG NAME LENGTH', 63, NULL);
INSERT INTO sql_sizing VALUES (30, 'MAXIMUM COLUMN NAME LENGTH', 63, NULL);
profile_id character_data,
required_value cardinal_number,
comments character_data
-) WITHOUT OIDS ;
+);
GRANT SELECT ON sql_sizing_profiles TO PUBLIC;
{
Oid namespaceId = lfirst_oid(l);
- typid = GetSysCacheOid2(TYPENAMENSP,
+ typid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
PointerGetDatum(typname),
ObjectIdGetDatum(namespaceId));
if (OidIsValid(typid))
palloc(offsetof(struct _FuncCandidateList, args) +
effective_nargs * sizeof(Oid));
newResult->pathpos = pathpos;
- newResult->oid = HeapTupleGetOid(proctup) ;
+ newResult->oid = procform->oid ;
newResult->nargs = effective_nargs;
newResult->argnumbers = argnumbers;
if (argnumbers)
ObjectIdGetDatum(namespaceId));
if (HeapTupleIsValid(opertup))
{
- Oid result = HeapTupleGetOid(opertup);
+ Form_pg_operator operclass = (Form_pg_operator) GETSTRUCT(opertup);
+ Oid result = operclass->oid;
ReleaseSysCache(opertup);
return result;
if (operform->oprnamespace == namespaceId)
{
- Oid result = HeapTupleGetOid(opertup) ;
+ Oid result = operform->oid ;
ReleaseSysCacheList(catlist);
return result;
continue; /* keep previous result */
/* replace previous result */
prevResult->pathpos = pathpos;
- prevResult->oid = HeapTupleGetOid(opertup) ;
+ prevResult->oid = operform->oid ;
continue; /* args are same, of course */
}
}
nextResult += SPACE_PER_OP;
newResult->pathpos = pathpos;
- newResult->oid = HeapTupleGetOid(opertup) ;
+ newResult->oid = operform->oid ;
newResult->nargs = 2;
newResult->nvargs = 0;
newResult->ndargs = 0;
if (namespaceId == myTempNamespace)
continue; /* do not look in temp namespace */
- opcid = GetSysCacheOid3(CLAAMNAMENSP,
+ opcid = GetSysCacheOid3(CLAAMNAMENSP, Anum_pg_opclass_oid,
ObjectIdGetDatum(amid),
PointerGetDatum(opcname),
ObjectIdGetDatum(namespaceId));
if (namespaceId == myTempNamespace)
continue; /* do not look in temp namespace */
- opfid = GetSysCacheOid3(OPFAMILYAMNAMENSP,
+ opfid = GetSysCacheOid3(OPFAMILYAMNAMENSP, Anum_pg_opfamily_oid,
ObjectIdGetDatum(amid),
PointerGetDatum(opfname),
ObjectIdGetDatum(namespaceId));
Form_pg_collation collform;
/* Check for encoding-specific entry (exact match) */
- collid = GetSysCacheOid3(COLLNAMEENCNSP,
+ collid = GetSysCacheOid3(COLLNAMEENCNSP, Anum_pg_collation_oid,
PointerGetDatum(collname),
Int32GetDatum(encoding),
ObjectIdGetDatum(collnamespace));
if (collform->collprovider == COLLPROVIDER_ICU)
{
if (is_encoding_supported_by_icu(encoding))
- collid = HeapTupleGetOid(colltup) ;
+ collid = collform->oid ;
else
collid = InvalidOid;
}
else
{
- collid = HeapTupleGetOid(colltup) ;
+ collid = collform->oid ;
}
ReleaseSysCache(colltup);
return collid;
if (namespaceId == myTempNamespace)
continue; /* do not look in temp namespace */
- conid = GetSysCacheOid2(CONNAMENSP,
+ conid = GetSysCacheOid2(CONNAMENSP, Anum_pg_conversion_oid,
PointerGetDatum(conname),
ObjectIdGetDatum(namespaceId));
if (OidIsValid(conid))
if (missing_ok && !OidIsValid(namespaceId))
stats_oid = InvalidOid;
else
- stats_oid = GetSysCacheOid2(STATEXTNAMENSP,
+ stats_oid = GetSysCacheOid2(STATEXTNAMENSP, Anum_pg_statistic_ext_oid,
PointerGetDatum(stats_name),
ObjectIdGetDatum(namespaceId));
}
if (namespaceId == myTempNamespace)
continue; /* do not look in temp namespace */
- stats_oid = GetSysCacheOid2(STATEXTNAMENSP,
+ stats_oid = GetSysCacheOid2(STATEXTNAMENSP, Anum_pg_statistic_ext_oid,
PointerGetDatum(stats_name),
ObjectIdGetDatum(namespaceId));
if (OidIsValid(stats_oid))
if (missing_ok && !OidIsValid(namespaceId))
prsoid = InvalidOid;
else
- prsoid = GetSysCacheOid2(TSPARSERNAMENSP,
+ prsoid = GetSysCacheOid2(TSPARSERNAMENSP, Anum_pg_ts_parser_oid,
PointerGetDatum(parser_name),
ObjectIdGetDatum(namespaceId));
}
if (namespaceId == myTempNamespace)
continue; /* do not look in temp namespace */
- prsoid = GetSysCacheOid2(TSPARSERNAMENSP,
+ prsoid = GetSysCacheOid2(TSPARSERNAMENSP, Anum_pg_ts_parser_oid,
PointerGetDatum(parser_name),
ObjectIdGetDatum(namespaceId));
if (OidIsValid(prsoid))
if (missing_ok && !OidIsValid(namespaceId))
dictoid = InvalidOid;
else
- dictoid = GetSysCacheOid2(TSDICTNAMENSP,
+ dictoid = GetSysCacheOid2(TSDICTNAMENSP, Anum_pg_ts_dict_oid,
PointerGetDatum(dict_name),
ObjectIdGetDatum(namespaceId));
}
if (namespaceId == myTempNamespace)
continue; /* do not look in temp namespace */
- dictoid = GetSysCacheOid2(TSDICTNAMENSP,
+ dictoid = GetSysCacheOid2(TSDICTNAMENSP, Anum_pg_ts_dict_oid,
PointerGetDatum(dict_name),
ObjectIdGetDatum(namespaceId));
if (OidIsValid(dictoid))
if (missing_ok && !OidIsValid(namespaceId))
tmploid = InvalidOid;
else
- tmploid = GetSysCacheOid2(TSTEMPLATENAMENSP,
+ tmploid = GetSysCacheOid2(TSTEMPLATENAMENSP, Anum_pg_ts_template_oid,
PointerGetDatum(template_name),
ObjectIdGetDatum(namespaceId));
}
if (namespaceId == myTempNamespace)
continue; /* do not look in temp namespace */
- tmploid = GetSysCacheOid2(TSTEMPLATENAMENSP,
+ tmploid = GetSysCacheOid2(TSTEMPLATENAMENSP, Anum_pg_ts_template_oid,
PointerGetDatum(template_name),
ObjectIdGetDatum(namespaceId));
if (OidIsValid(tmploid))
if (missing_ok && !OidIsValid(namespaceId))
cfgoid = InvalidOid;
else
- cfgoid = GetSysCacheOid2(TSCONFIGNAMENSP,
+ cfgoid = GetSysCacheOid2(TSCONFIGNAMENSP, Anum_pg_ts_config_oid,
PointerGetDatum(config_name),
ObjectIdGetDatum(namespaceId));
}
if (namespaceId == myTempNamespace)
continue; /* do not look in temp namespace */
- cfgoid = GetSysCacheOid2(TSCONFIGNAMENSP,
+ cfgoid = GetSysCacheOid2(TSCONFIGNAMENSP, Anum_pg_ts_config_oid,
PointerGetDatum(config_name),
ObjectIdGetDatum(namespaceId));
if (OidIsValid(cfgoid))
{
Oid oid;
- oid = GetSysCacheOid1(NAMESPACENAME, CStringGetDatum(nspname));
+ oid = GetSysCacheOid1(NAMESPACENAME, Anum_pg_namespace_oid,
+ CStringGetDatum(nspname));
if (!OidIsValid(oid) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_SCHEMA),
if (missing_ok && !OidIsValid(namespaceId))
conoid = InvalidOid;
else
- conoid = GetSysCacheOid2(CONNAMENSP,
+ conoid = GetSysCacheOid2(CONNAMENSP, Anum_pg_conversion_oid,
PointerGetDatum(conversion_name),
ObjectIdGetDatum(namespaceId));
}
if (namespaceId == myTempNamespace)
continue; /* do not look in temp namespace */
- conoid = GetSysCacheOid2(CONNAMENSP,
+ conoid = GetSysCacheOid2(CONNAMENSP, Anum_pg_conversion_oid,
PointerGetDatum(conversion_name),
ObjectIdGetDatum(namespaceId));
if (OidIsValid(conoid))
#include "catalog/pg_authid.h"
#include "catalog/pg_cast.h"
#include "catalog/pg_default_acl.h"
+#include "catalog/pg_enum.h"
#include "catalog/pg_event_trigger.h"
#include "catalog/pg_collation.h"
#include "catalog/pg_constraint.h"
int name_catcache_id; /* id of catcache on (name,namespace), or
* (name) if the object does not live in a
* namespace */
+ AttrNumber attnum_oid; /* attribute number of oid column */
AttrNumber attnum_name; /* attnum of name field */
AttrNumber attnum_namespace; /* attnum of namespace field */
AttrNumber attnum_owner; /* attnum of owner field */
AmOidIndexId,
AMOID,
AMNAME,
+ Anum_pg_am_oid,
Anum_pg_am_amname,
InvalidAttrNumber,
InvalidAttrNumber,
CastOidIndexId,
-1,
-1,
+ Anum_pg_cast_oid,
InvalidAttrNumber,
InvalidAttrNumber,
InvalidAttrNumber,
CollationOidIndexId,
COLLOID,
-1, /* COLLNAMEENCNSP also takes encoding */
+ Anum_pg_collation_oid,
Anum_pg_collation_collname,
Anum_pg_collation_collnamespace,
Anum_pg_collation_collowner,
ConstraintOidIndexId,
CONSTROID,
-1,
+ Anum_pg_constraint_oid,
Anum_pg_constraint_conname,
Anum_pg_constraint_connamespace,
InvalidAttrNumber,
ConversionOidIndexId,
CONVOID,
CONNAMENSP,
+ Anum_pg_conversion_oid,
Anum_pg_conversion_conname,
Anum_pg_conversion_connamespace,
Anum_pg_conversion_conowner,
DatabaseOidIndexId,
DATABASEOID,
-1,
+ Anum_pg_database_oid,
Anum_pg_database_datname,
InvalidAttrNumber,
Anum_pg_database_datdba,
ExtensionOidIndexId,
-1,
-1,
+ Anum_pg_extension_oid,
Anum_pg_extension_extname,
InvalidAttrNumber, /* extension doesn't belong to extnamespace */
Anum_pg_extension_extowner,
ForeignDataWrapperOidIndexId,
FOREIGNDATAWRAPPEROID,
FOREIGNDATAWRAPPERNAME,
+ Anum_pg_foreign_data_wrapper_oid,
Anum_pg_foreign_data_wrapper_fdwname,
InvalidAttrNumber,
Anum_pg_foreign_data_wrapper_fdwowner,
ForeignServerOidIndexId,
FOREIGNSERVEROID,
FOREIGNSERVERNAME,
+ Anum_pg_foreign_server_oid,
Anum_pg_foreign_server_srvname,
InvalidAttrNumber,
Anum_pg_foreign_server_srvowner,
ProcedureOidIndexId,
PROCOID,
-1, /* PROCNAMEARGSNSP also takes argument types */
+ Anum_pg_proc_oid,
Anum_pg_proc_proname,
Anum_pg_proc_pronamespace,
Anum_pg_proc_proowner,
LanguageOidIndexId,
LANGOID,
LANGNAME,
+ Anum_pg_language_oid,
Anum_pg_language_lanname,
InvalidAttrNumber,
Anum_pg_language_lanowner,
LargeObjectMetadataOidIndexId,
-1,
-1,
+ Anum_pg_largeobject_metadata_oid,
InvalidAttrNumber,
InvalidAttrNumber,
Anum_pg_largeobject_metadata_lomowner,
OpclassOidIndexId,
CLAOID,
-1, /* CLAAMNAMENSP also takes opcmethod */
+ Anum_pg_opclass_oid,
Anum_pg_opclass_opcname,
Anum_pg_opclass_opcnamespace,
Anum_pg_opclass_opcowner,
OperatorOidIndexId,
OPEROID,
-1, /* OPERNAMENSP also takes left and right type */
+ Anum_pg_operator_oid,
Anum_pg_operator_oprname,
Anum_pg_operator_oprnamespace,
Anum_pg_operator_oprowner,
OpfamilyOidIndexId,
OPFAMILYOID,
-1, /* OPFAMILYAMNAMENSP also takes opfmethod */
+ Anum_pg_opfamily_oid,
Anum_pg_opfamily_opfname,
Anum_pg_opfamily_opfnamespace,
Anum_pg_opfamily_opfowner,
AuthIdOidIndexId,
AUTHOID,
AUTHNAME,
+ Anum_pg_authid_oid,
Anum_pg_authid_rolname,
InvalidAttrNumber,
InvalidAttrNumber,
RewriteOidIndexId,
-1,
-1,
+ Anum_pg_rewrite_oid,
Anum_pg_rewrite_rulename,
InvalidAttrNumber,
InvalidAttrNumber,
NamespaceOidIndexId,
NAMESPACEOID,
NAMESPACENAME,
+ Anum_pg_namespace_oid,
Anum_pg_namespace_nspname,
InvalidAttrNumber,
Anum_pg_namespace_nspowner,
ClassOidIndexId,
RELOID,
RELNAMENSP,
+ Anum_pg_class_oid,
Anum_pg_class_relname,
Anum_pg_class_relnamespace,
Anum_pg_class_relowner,
TablespaceOidIndexId,
TABLESPACEOID,
-1,
+ Anum_pg_tablespace_oid,
Anum_pg_tablespace_spcname,
InvalidAttrNumber,
Anum_pg_tablespace_spcowner,
TransformRelationId,
TransformOidIndexId,
TRFOID,
- InvalidAttrNumber
+ InvalidAttrNumber,
+ Anum_pg_transform_oid
},
{
TriggerRelationId,
TriggerOidIndexId,
-1,
-1,
+ Anum_pg_trigger_oid,
Anum_pg_trigger_tgname,
InvalidAttrNumber,
InvalidAttrNumber,
PolicyOidIndexId,
-1,
-1,
+ Anum_pg_policy_oid,
Anum_pg_policy_polname,
InvalidAttrNumber,
InvalidAttrNumber,
EventTriggerOidIndexId,
EVENTTRIGGEROID,
EVENTTRIGGERNAME,
+ Anum_pg_event_trigger_oid,
Anum_pg_event_trigger_evtname,
InvalidAttrNumber,
Anum_pg_event_trigger_evtowner,
TSConfigOidIndexId,
TSCONFIGOID,
TSCONFIGNAMENSP,
+ Anum_pg_ts_config_oid,
Anum_pg_ts_config_cfgname,
Anum_pg_ts_config_cfgnamespace,
Anum_pg_ts_config_cfgowner,
TSDictionaryOidIndexId,
TSDICTOID,
TSDICTNAMENSP,
+ Anum_pg_ts_dict_oid,
Anum_pg_ts_dict_dictname,
Anum_pg_ts_dict_dictnamespace,
Anum_pg_ts_dict_dictowner,
TSParserOidIndexId,
TSPARSEROID,
TSPARSERNAMENSP,
+ Anum_pg_ts_parser_oid,
Anum_pg_ts_parser_prsname,
Anum_pg_ts_parser_prsnamespace,
InvalidAttrNumber,
TSTemplateOidIndexId,
TSTEMPLATEOID,
TSTEMPLATENAMENSP,
+ Anum_pg_ts_template_oid,
Anum_pg_ts_template_tmplname,
Anum_pg_ts_template_tmplnamespace,
InvalidAttrNumber,
TypeOidIndexId,
TYPEOID,
TYPENAMENSP,
+ Anum_pg_type_oid,
Anum_pg_type_typname,
Anum_pg_type_typnamespace,
Anum_pg_type_typowner,
PublicationObjectIndexId,
PUBLICATIONOID,
PUBLICATIONNAME,
+ Anum_pg_publication_oid,
Anum_pg_publication_pubname,
InvalidAttrNumber,
Anum_pg_publication_pubowner,
SubscriptionObjectIndexId,
SUBSCRIPTIONOID,
SUBSCRIPTIONNAME,
+ Anum_pg_subscription_oid,
Anum_pg_subscription_subname,
InvalidAttrNumber,
Anum_pg_subscription_subowner,
StatisticExtOidIndexId,
STATEXTOID,
STATEXTNAMENSP,
+ Anum_pg_statistic_ext_oid,
Anum_pg_statistic_ext_stxname,
Anum_pg_statistic_ext_stxnamespace,
Anum_pg_statistic_ext_stxowner,
scan = systable_beginscan(attrdef, AttrDefaultIndexId, true,
NULL, 2, keys);
if (HeapTupleIsValid(tup = systable_getnext(scan)))
- defoid = HeapTupleGetOid(tup);
+ {
+ Form_pg_attrdef atdform = (Form_pg_attrdef) GETSTRUCT(tup);
+
+ defoid = atdform->oid;
+ }
systable_endscan(scan);
relation_close(attrdef, AccessShareLock);
}
else
{
- address.objectId = HeapTupleGetOid(tp) ;
+ address.objectId = ((Form_pg_amop) GETSTRUCT(tp))->oid ;
ReleaseSysCache(tp);
}
}
}
else
{
- address.objectId = HeapTupleGetOid(tp) ;
+ address.objectId = ((Form_pg_amproc) GETSTRUCT(tp))->oid ;
ReleaseSysCache(tp);
}
}
username, servername)));
return address;
}
- userid = HeapTupleGetOid(tp) ;
+ userid = ((Form_pg_authid) GETSTRUCT(tp))->oid ;
ReleaseSysCache(tp);
}
return address;
}
- address.objectId = HeapTupleGetOid(tp) ;
+ address.objectId = ((Form_pg_user_mapping) GETSTRUCT(tp))->oid ;
ReleaseSysCache(tp);
/* Find the publication relation mapping in syscache. */
address.objectId =
- GetSysCacheOid2(PUBLICATIONRELMAP,
+ GetSysCacheOid2(PUBLICATIONRELMAP, Anum_pg_publication_rel_oid,
ObjectIdGetDatum(RelationGetRelid(relation)),
ObjectIdGetDatum(pub->oid));
if (!OidIsValid(address.objectId))
CStringGetDatum(username));
if (!HeapTupleIsValid(tp))
goto not_found;
- userid = HeapTupleGetOid(tp) ;
+ userid = ((Form_pg_authid) GETSTRUCT(tp))->oid ;
ReleaseSysCache(tp);
/*
if (!HeapTupleIsValid(tp))
goto not_found;
- address.objectId = HeapTupleGetOid(tp) ;
+ address.objectId = ((Form_pg_default_acl) GETSTRUCT(tp))->oid ;
ReleaseSysCache(tp);
return address;
if (relation)
relation_close(relation, AccessShareLock);
- tupdesc = CreateTemplateTupleDesc(3, false );
+ tupdesc = CreateTemplateTupleDesc(3);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "classid",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "objid",
return prop->name_catcache_id;
}
+AttrNumber
+get_object_attnum_oid(Oid class_id)
+{
+ const ObjectPropertyType *prop = get_object_property_data(class_id);
+
+ return prop->attnum_oid;
+}
+
AttrNumber
get_object_attnum_name(Oid class_id)
{
* We try a syscache first, if available.
*/
HeapTuple
-get_catalog_object_by_oid(Relation catalog, Oid objectId)
+get_catalog_object_by_oid(Relation catalog, AttrNumber oidcol, Oid objectId)
{
HeapTuple tuple;
Oid classId = RelationGetRelid(catalog);
Assert(OidIsValid(oidIndexId));
ScanKeyInit(&skey,
- ObjectIdAttributeNumber ,
+ oidcol ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(objectId));
castDesc = heap_open(CastRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_cast_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
attrdefDesc = heap_open(AttrDefaultRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_attrdef_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_amop_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_amproc_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
ruleDesc = heap_open(RewriteRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_rewrite_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
trigDesc = heap_open(TriggerRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_trigger_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
defaclrel = heap_open(DefaultAclRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_default_acl_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
policy_rel = heap_open(PolicyRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_policy_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
* Construct a tuple descriptor for the result row. This must match this
* function's pg_proc entry!
*/
- tupdesc = CreateTemplateTupleDesc(4, false );
+ tupdesc = CreateTemplateTupleDesc(4);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "type",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "schema",
HeapTuple objtup;
Relation catalog = heap_open(address.classId, AccessShareLock);
- objtup = get_catalog_object_by_oid(catalog, address.objectId);
+ objtup = get_catalog_object_by_oid(catalog,
+ get_object_attnum_oid(address.classId),
+ address.objectId);
if (objtup != NULL)
{
bool isnull;
* Construct a tuple descriptor for the result row. This must match this
* function's pg_proc entry!
*/
- tupdesc = CreateTemplateTupleDesc(3, false );
+ tupdesc = CreateTemplateTupleDesc(3);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "type",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "object_names",
Form_pg_constraint constrForm;
constrRel = heap_open(ConstraintRelationId, AccessShareLock);
- constrTup = get_catalog_object_by_oid(constrRel, constroid);
+ constrTup = get_catalog_object_by_oid(constrRel, Anum_pg_constraint_oid,
+ constroid);
if (!HeapTupleIsValid(constrTup))
elog(ERROR, "cache lookup failed for constraint %u", constroid);
else if (OidIsValid(constrForm->contypid))
appendStringInfoString(buffer, "domain constraint");
else
- elog(ERROR, "invalid constraint %u", HeapTupleGetOid(constrTup) );
+ elog(ERROR, "invalid constraint %u", constrForm->oid );
heap_close(constrRel, AccessShareLock);
}
castRel = heap_open(CastRelationId, AccessShareLock);
- tup = get_catalog_object_by_oid(castRel, object->objectId);
+ tup = get_catalog_object_by_oid(castRel, Anum_pg_cast_oid,
+ object->objectId);
if (!HeapTupleIsValid(tup))
elog(ERROR, "could not find tuple for cast %u",
attrdefDesc = heap_open(AttrDefaultRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_attrdef_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_amop_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_amproc_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
ruleDesc = heap_open(RewriteRelationId, AccessShareLock);
- tup = get_catalog_object_by_oid(ruleDesc, object->objectId);
+ tup = get_catalog_object_by_oid(ruleDesc, Anum_pg_rewrite_oid,
+ object->objectId);
if (!HeapTupleIsValid(tup))
elog(ERROR, "could not find tuple for rule %u",
trigDesc = heap_open(TriggerRelationId, AccessShareLock);
- tup = get_catalog_object_by_oid(trigDesc, object->objectId);
+ tup = get_catalog_object_by_oid(trigDesc, Anum_pg_trigger_oid,
+ object->objectId);
if (!HeapTupleIsValid(tup))
elog(ERROR, "could not find tuple for trigger %u",
defaclrel = heap_open(DefaultAclRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_default_acl_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(object->objectId));
polDesc = heap_open(PolicyRelationId, AccessShareLock);
- tup = get_catalog_object_by_oid(polDesc, object->objectId);
+ tup = get_catalog_object_by_oid(polDesc, Anum_pg_policy_oid,
+ object->objectId);
if (!HeapTupleIsValid(tup))
elog(ERROR, "could not find tuple for policy %u",
transformDesc = heap_open(TransformRelationId, AccessShareLock);
- tup = get_catalog_object_by_oid(transformDesc, object->objectId);
+ tup = get_catalog_object_by_oid(transformDesc,
+ Anum_pg_transform_oid,
+ object->objectId);
if (!HeapTupleIsValid(tup))
elog(ERROR, "could not find tuple for transform %u",
/*
* Okay to create the pg_aggregate entry.
*/
+ aggdesc = heap_open(AggregateRelationId, RowExclusiveLock);
+ tupDesc = aggdesc->rd_att;
/* initialize nulls and values */
for (i = 0; i < Natts_pg_aggregate; i++)
else
nulls[Anum_pg_aggregate_aggminitval - 1] = true;
- aggdesc = heap_open(AggregateRelationId, RowExclusiveLock);
- tupDesc = aggdesc->rd_att;
-
tup = heap_form_tuple(tupDesc, values, nulls);
CatalogTupleInsert(aggdesc, tup);
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/sysattr.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
memset(nulls, 0, sizeof(nulls));
namestrcpy(&name_name, collname);
+ oid = GetNewOidWithIndex(rel, CollationOidIndexId,
+ Anum_pg_collation_oid);
+ values[Anum_pg_collation_oid - 1] = ObjectIdGetDatum(oid);
values[Anum_pg_collation_collname - 1] = NameGetDatum(&name_name);
values[Anum_pg_collation_collnamespace - 1] = ObjectIdGetDatum(collnamespace);
values[Anum_pg_collation_collowner - 1] = ObjectIdGetDatum(collowner);
tup = heap_form_tuple(tupDesc, values, nulls);
/* insert a new tuple */
- oid = CatalogTupleInsert(rel, tup);
+ CatalogTupleInsert(rel, tup);
Assert(OidIsValid(oid));
/* set up dependencies for the new collation */
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
/* create dependency on owner */
- recordDependencyOnOwner(CollationRelationId, HeapTupleGetOid(tup),
- collowner);
+ recordDependencyOnOwner(CollationRelationId, oid, collowner);
/* dependency on extension */
recordDependencyOnCurrentExtension(&myself, false);
rel = heap_open(CollationRelationId, RowExclusiveLock);
ScanKeyInit(&scanKeyData,
- ObjectIdAttributeNumber ,
+ Anum_pg_collation_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(collationOid));
#include "access/sysattr.h"
#include "access/tupconvert.h"
#include "access/xact.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
values[i] = (Datum) NULL;
}
+ conOid = GetNewOidWithIndex(conDesc, ConstraintOidIndexId,
+ Anum_pg_constraint_oid);
+ values[Anum_pg_constraint_oid - 1] = ObjectIdGetDatum(conOid);
values[Anum_pg_constraint_conname - 1] = NameGetDatum(&cname);
values[Anum_pg_constraint_connamespace - 1] = ObjectIdGetDatum(constraintNamespace);
values[Anum_pg_constraint_contype - 1] = CharGetDatum(constraintType);
tup = heap_form_tuple(RelationGetDescr(conDesc), values, nulls);
- conOid = CatalogTupleInsert(conDesc, tup);
+ CatalogTupleInsert(conDesc, tup);
conobject.classId = ConstraintRelationId;
conobject.objectId = conOid;
scan = systable_beginscan(pg_constraint, ConstraintRelidTypidNameIndexId, true,
NULL, 1, &key);
while ((tuple = systable_getnext(scan)) != NULL)
- clone = lappend_oid(clone, HeapTupleGetOid(tuple));
+ {
+ Oid oid = ((Form_pg_constraint) GETSTRUCT(tuple))->oid;
+
+ clone = lappend_oid(clone, oid);
+ }
systable_endscan(scan);
/* Do the actual work, recursing to partitions as needed */
ReleaseSysCache(partcontup);
/* looks good! Attach this constraint */
- ConstraintSetParentConstraint(fk->conoid,
- HeapTupleGetOid(tuple));
+ ConstraintSetParentConstraint(fk->conoid, constrForm->oid);
CommandCounterIncrement();
attach_it = true;
break;
constrForm->condeferrable,
constrForm->condeferred,
constrForm->convalidated,
- HeapTupleGetOid(tuple) ,
+ constrForm->oid ,
RelationGetRelid(partRel),
mapped_conkey,
nelem,
ObjectAddress thisobj;
thisobj.classId = ConstraintRelationId;
- thisobj.objectId = HeapTupleGetOid(tup) ;
+ thisobj.objectId = conform->oid ;
thisobj.objectSubId = 0;
if (object_address_present(&thisobj, objsMoved))
/* There can be at most one matching row */
if (HeapTupleIsValid(tuple = systable_getnext(scan)))
- conOid = HeapTupleGetOid(tuple) ;
+ conOid = ((Form_pg_constraint) GETSTRUCT(tuple))->oid ;
systable_endscan(scan);
Datum adatum;
bool isNull;
- *constraintOid = HeapTupleGetOid(tuple) ;
+ *constraintOid = ((Form_pg_constraint) GETSTRUCT(tuple))->oid ;
/* Extract the conkey array, ie, attnums of constrained columns */
adatum = heap_getattr(tuple, Anum_pg_constraint_conkey,
constrForm = (Form_pg_constraint) GETSTRUCT(tuple);
if (constrForm->conindid == indexId)
{
- constraintId = HeapTupleGetOid(tuple) ;
+ constraintId = constrForm->oid ;
break;
}
}
/* There can be at most one matching row */
if (HeapTupleIsValid(tuple = systable_getnext(scan)))
- conOid = HeapTupleGetOid(tuple) ;
+ conOid = ((Form_pg_constraint) GETSTRUCT(tuple))->oid ;
systable_endscan(scan);
RelationGetDescr(pg_constraint), &isNull);
if (isNull)
elog(ERROR, "null conkey for constraint %u",
- HeapTupleGetOid(tuple) );
+ ((Form_pg_constraint) GETSTRUCT(tuple))->oid );
arr = DatumGetArrayTypeP(adatum); /* ensure not toasted */
numkeys = ARR_DIMS(arr)[0];
if (ARR_NDIM(arr) != 1 ||
pkattnos = bms_add_member(pkattnos,
attnums[i] - FirstLowInvalidHeapAttributeNumber);
}
- *constraintOid = HeapTupleGetOid(tuple) ;
+ *constraintOid = ((Form_pg_constraint) GETSTRUCT(tuple))->oid ;
/* No need to search further */
break;
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/sysattr.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
Relation rel;
TupleDesc tupDesc;
HeapTuple tup;
+ Oid oid;
bool nulls[Natts_pg_conversion];
Datum values[Natts_pg_conversion];
NameData cname;
/* form a tuple */
namestrcpy(&cname, conname);
+ oid = GetNewOidWithIndex(rel, ConversionOidIndexId,
+ Anum_pg_conversion_oid);
+ values[Anum_pg_conversion_oid - 1] = ObjectIdGetDatum(oid);
values[Anum_pg_conversion_conname - 1] = NameGetDatum(&cname);
values[Anum_pg_conversion_connamespace - 1] = ObjectIdGetDatum(connamespace);
values[Anum_pg_conversion_conowner - 1] = ObjectIdGetDatum(conowner);
CatalogTupleInsert(rel, tup);
myself.classId = ConversionRelationId;
- myself.objectId = HeapTupleGetOid(tup) ;
+ myself.objectId = oid ;
myself.objectSubId = 0;
/* create dependency on conversion procedure */
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
/* create dependency on owner */
- recordDependencyOnOwner(ConversionRelationId, HeapTupleGetOid(tup),
- conowner);
+ recordDependencyOnOwner(ConversionRelationId, oid, conowner);
/* dependency on extension */
recordDependencyOnCurrentExtension(&myself, false);
/* Post creation hook for new conversion */
- InvokeObjectPostCreateHook(ConversionRelationId, HeapTupleGetOid(tup) , 0);
+ InvokeObjectPostCreateHook(ConversionRelationId, oid , 0);
heap_freetuple(tup);
heap_close(rel, RowExclusiveLock);
ScanKeyData scanKeyData;
ScanKeyInit(&scanKeyData,
- ObjectIdAttributeNumber ,
+ Anum_pg_conversion_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(conversionOid));
do
{
- new_oid = GetNewOid(pg_enum);
+ new_oid = GetNewOidWithIndex(pg_enum, EnumOidIndexId,
+ Anum_pg_enum_oid);
} while (new_oid & 1);
oids[elemno] = new_oid;
}
errdetail("Labels must be %d characters or less.",
NAMEDATALEN - 1)));
+ values[Anum_pg_enum_oid - 1] = ObjectIdGetDatum(oids[elemno]);
values[Anum_pg_enum_enumtypid - 1] = ObjectIdGetDatum(enumTypeOid);
values[Anum_pg_enum_enumsortorder - 1] = Float4GetDatum(elemno + 1);
namestrcpy(&enumlabel, lab);
values[Anum_pg_enum_enumlabel - 1] = NameGetDatum(&enumlabel);
tup = heap_form_tuple(RelationGetDescr(pg_enum), values, nulls);
- HeapTupleSetOid(tup, oids[elemno]);
CatalogTupleInsert(pg_enum, tup);
heap_freetuple(tup);
bool sorts_ok;
/* Get a new OID (different from all existing pg_enum tuples) */
- newOid = GetNewOid(pg_enum);
+ newOid = GetNewOidWithIndex(pg_enum, EnumOidIndexId,
+ Anum_pg_enum_oid);
/*
* Detect whether it sorts correctly relative to existing
{
HeapTuple exists_tup = existing[i];
Form_pg_enum exists_en = (Form_pg_enum) GETSTRUCT(exists_tup);
- Oid exists_oid = HeapTupleGetOid(exists_tup) ;
+ Oid exists_oid = exists_en->oid ;
if (exists_oid & 1)
continue; /* ignore odd Oids */
/* Create the new pg_enum entry */
memset(nulls, false, sizeof(nulls));
+ values[Anum_pg_enum_oid - 1] = ObjectIdGetDatum(newOid);
values[Anum_pg_enum_enumtypid - 1] = ObjectIdGetDatum(enumTypeOid);
values[Anum_pg_enum_enumsortorder - 1] = Float4GetDatum(newelemorder);
namestrcpy(&enumlabel, newVal);
values[Anum_pg_enum_enumlabel - 1] = NameGetDatum(&enumlabel);
enum_tup = heap_form_tuple(RelationGetDescr(pg_enum), values, nulls);
- HeapTupleSetOid(enum_tup, newOid);
CatalogTupleInsert(pg_enum, enum_tup);
heap_freetuple(enum_tup);
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/sysattr.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/pg_largeobject.h"
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ if (OidIsValid(loid))
+ loid_new = loid;
+ else
+ loid_new = GetNewOidWithIndex(pg_lo_meta,
+ LargeObjectMetadataOidIndexId,
+ Anum_pg_largeobject_metadata_oid);
+
+ values[Anum_pg_largeobject_metadata_oid - 1] = ObjectIdGetDatum(loid_new);
values[Anum_pg_largeobject_metadata_lomowner - 1]
= ObjectIdGetDatum(GetUserId());
nulls[Anum_pg_largeobject_metadata_lomacl - 1] = true;
ntup = heap_form_tuple(RelationGetDescr(pg_lo_meta),
values, nulls);
- if (OidIsValid(loid))
- HeapTupleSetOid(ntup, loid);
- loid_new = CatalogTupleInsert(pg_lo_meta, ntup);
- Assert(!OidIsValid(loid) || loid == loid_new);
+ CatalogTupleInsert(pg_lo_meta, ntup);
heap_freetuple(ntup);
* Delete an entry from pg_largeobject_metadata
*/
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_largeobject_metadata_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(loid));
bool retval = false;
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_largeobject_metadata_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(loid));
#include "access/heapam.h"
#include "access/htup_details.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
else
nspacl = NULL;
+ nspdesc = heap_open(NamespaceRelationId, RowExclusiveLock);
+ tupDesc = nspdesc->rd_att;
+
/* initialize nulls and values */
for (i = 0; i < Natts_pg_namespace; i++)
{
nulls[i] = false;
values[i] = (Datum) NULL;
}
+
+ nspoid = GetNewOidWithIndex(nspdesc, NamespaceOidIndexId,
+ Anum_pg_namespace_oid);
+ values[Anum_pg_namespace_oid - 1] = ObjectIdGetDatum(nspoid);
namestrcpy(&nname, nspName);
values[Anum_pg_namespace_nspname - 1] = NameGetDatum(&nname);
values[Anum_pg_namespace_nspowner - 1] = ObjectIdGetDatum(ownerId);
else
nulls[Anum_pg_namespace_nspacl - 1] = true;
- nspdesc = heap_open(NamespaceRelationId, RowExclusiveLock);
- tupDesc = nspdesc->rd_att;
tup = heap_form_tuple(tupDesc, values, nulls);
- nspoid = CatalogTupleInsert(nspdesc, tup);
+ CatalogTupleInsert(nspdesc, tup);
Assert(OidIsValid(nspoid));
heap_close(nspdesc, RowExclusiveLock);
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/xact.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
ObjectIdGetDatum(operatorNamespace));
if (HeapTupleIsValid(tup))
{
- RegProcedure oprcode = ((Form_pg_operator) GETSTRUCT(tup))->oprcode ;
+ Form_pg_operator oprform = (Form_pg_operator) GETSTRUCT(tup) ;
- operatorObjectId = HeapTupleGetOid(tup) ;
- *defined = RegProcedureIsValid(oprcode);
+ operatorObjectId = oprform->oid ;
+ *defined = RegProcedureIsValid(oprform->opr code);
ReleaseSysCache(tup);
}
else
errmsg("\"%s\" is not a valid operator name",
operatorName)));
+ /*
+ * open pg_operator
+ */
+ pg_operator_desc = heap_open(OperatorRelationId, RowExclusiveLock);
+ tupDesc = pg_operator_desc->rd_att;
+
/*
* initialize our *nulls and *values arrays
*/
* initialize values[] with the operator name and input data types. Note
* that oprcode is set to InvalidOid, indicating it's a shell.
*/
+ operatorObjectId = GetNewOidWithIndex(pg_operator_desc, OperatorOidIndexId,
+ Anum_pg_operator_oid);
+ values[Anum_pg_operator_oid - 1] = ObjectIdGetDatum(operatorObjectId);
namestrcpy(&oname, operatorName);
values[Anum_pg_operator_oprname - 1] = NameGetDatum(&oname);
values[Anum_pg_operator_oprnamespace - 1] = ObjectIdGetDatum(operatorNamespace);
values[Anum_pg_operator_oprrest - 1] = ObjectIdGetDatum(InvalidOid);
values[Anum_pg_operator_oprjoin - 1] = ObjectIdGetDatum(InvalidOid);
- /*
- * open pg_operator
- */
- pg_operator_desc = heap_open(OperatorRelationId, RowExclusiveLock);
- tupDesc = pg_operator_desc->rd_att;
-
/*
* create a new operator tuple
*/
/*
* insert our "shell" operator tuple
*/
- operatorObjectId = CatalogTupleInsert(pg_operator_desc, tup);
+ CatalogTupleInsert(pg_operator_desc, tup);
/* Add dependencies for the entry */
makeOperatorDependencies(tup, false);
elog(ERROR, "cache lookup failed for operator %u",
operatorObjectId);
+ replaces[Anum_pg_operator_oid - 1] = false;
tup = heap_modify_tuple(tup,
RelationGetDescr(pg_operator_desc),
values,
{
isUpdate = false;
+ operatorObjectId = GetNewOidWithIndex(pg_operator_desc,
+ OperatorOidIndexId,
+ Anum_pg_operator_oid);
+ values[Anum_pg_operator_oid - 1] = ObjectIdGetDatum(operatorObjectId);
+
tup = heap_form_tuple(RelationGetDescr(pg_operator_desc),
values, nulls);
- operatorObjectId = CatalogTupleInsert(pg_operator_desc, tup);
+ CatalogTupleInsert(pg_operator_desc, tup);
}
/* Add dependencies for the entry */
referenced;
myself.classId = OperatorRelationId;
- myself.objectId = HeapTupleGetOid(tuple) ;
+ myself.objectId = oper->oid ;
myself.objectSubId = 0;
/*
}
/* Dependency on owner */
- recordDependencyOnOwner(OperatorRelationId, HeapTupleGetOid(tuple) ,
+ recordDependencyOnOwner(OperatorRelationId, oper->oid ,
oper->oprowner);
/* Dependency on extension */
#include "access/htup_details.h"
#include "access/xact.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
(errcode(ERRCODE_DUPLICATE_FUNCTION),
errmsg("function \"%s\" already exists with same argument types",
procedureName)));
- if (!pg_proc_ownercheck(HeapTupleGetOid(oldtup) , proowner))
+ if (!pg_proc_ownercheck(oldproc->oid , proowner))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_FUNCTION,
procedureName);
/* translator: first %s is DROP FUNCTION or DROP PROCEDURE */
errhint("Use %s %s first.",
dropcmd,
- format_procedure(HeapTupleGetOid(oldtup) ))));
+ format_procedure(oldproc->oid ))));
/*
* If it returns RECORD, check for possible change of record type
/* translator: first %s is DROP FUNCTION or DROP PROCEDURE */
errhint("Use %s %s first.",
dropcmd,
- format_procedure(HeapTupleGetOid(oldtup) ))));
+ format_procedure(oldproc->oid ))));
}
/*
/* translator: first %s is DROP FUNCTION or DROP PROCEDURE */
errhint("Use %s %s first.",
dropcmd,
- format_procedure(HeapTupleGetOid(oldtup) ))));
+ format_procedure(oldproc->oid ))));
}
}
/* translator: first %s is DROP FUNCTION or DROP PROCEDURE */
errhint("Use %s %s first.",
dropcmd,
- format_procedure(HeapTupleGetOid(oldtup) ))));
+ format_procedure(oldproc->oid ))));
proargdefaults = SysCacheGetAttr(PROCNAMEARGSNSP, oldtup,
Anum_pg_proc_proargdefaults,
/* translator: first %s is DROP FUNCTION or DROP PROCEDURE */
errhint("Use %s %s first.",
dropcmd,
- format_procedure(HeapTupleGetOid(oldtup) ))));
+ format_procedure(oldproc->oid ))));
newlc = lnext(newlc);
}
}
/*
- * Do not change existing ownership or permissions, either. Note
+ * Do not change existing oid, o wnership or permissions, either. Note
* dependency-update code below has to agree with this decision.
*/
+ replaces[Anum_pg_proc_oid - 1] = false;
replaces[Anum_pg_proc_proowner - 1] = false;
replaces[Anum_pg_proc_proacl - 1] = false;
else
{
/* Creating a new procedure */
+ Oid newOid;
/* First, get default permissions and set up proacl */
proacl = get_user_default_acl(OBJECT_FUNCTION, proowner,
else
nulls[Anum_pg_proc_proacl - 1] = true;
+ newOid = GetNewOidWithIndex(rel, ProcedureOidIndexId,
+ Anum_pg_proc_oid);
+ values[Anum_pg_proc_oid - 1] = ObjectIdGetDatum(newOid);
tup = heap_form_tuple(tupDesc, values, nulls);
CatalogTupleInsert(rel, tup);
is_update = false;
}
- retval = HeapTupleGetOid(tup) ;
+ retval = ((Form_pg_proc) GETSTRUCT(tup))->oid ;
/*
* Create dependencies for the new function. If we are updating an
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ prrelid = GetNewOidWithIndex(rel, PublicationRelObjectIndexId,
+ Anum_pg_publication_rel_oid);
+ values[Anum_pg_publication_rel_oid - 1] = ObjectIdGetDatum(prrelid);
values[Anum_pg_publication_rel_prpubid - 1] =
ObjectIdGetDatum(pubid);
values[Anum_pg_publication_rel_prrelid - 1] =
tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
/* Insert tuple into catalog. */
- prrelid = CatalogTupleInsert(rel, tup);
+ CatalogTupleInsert(rel, tup);
heap_freetuple(tup);
ObjectAddressSet(myself, PublicationRelRelationId, prrelid);
result = NIL;
while (HeapTupleIsValid(tup = systable_getnext(scan)))
- result = lappend_oid(result, HeapTupleGetOid(tup));
+ {
+ Oid oid = ((Form_pg_publication) GETSTRUCT(tup))->oid;
+
+ result = lappend_oid(result, oid);
+ }
systable_endscan(scan);
heap_close(rel, AccessShareLock);
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
- Oid relid = HeapTupleGetOid(tuple);
Form_pg_class relForm = (Form_pg_class) GETSTRUCT(tuple);
+ Oid relid = relForm->oid;
if (is_publishable_class(relid, relForm))
result = lappend_oid(result, relid);
{
Oid oid;
- oid = GetSysCacheOid1(PUBLICATIONNAME, CStringGetDatum(pubname));
+ oid = GetSysCacheOid1(PUBLICATIONNAME, Anum_pg_publication_oid,
+ CStringGetDatum(pubname));
if (!OidIsValid(oid))
{
if (missing_ok)
{
Oid oid;
- oid = GetSysCacheOid1(PUBLICATIONNAME, CStringGetDatum(pubname));
+ oid = GetSysCacheOid1(PUBLICATIONNAME, Anum_pg_publication_oid,
+ CStringGetDatum(pubname));
if (!OidIsValid(oid) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
{
Oid oid;
- oid = GetSysCacheOid2(SUBSCRIPTIONNAME, MyDatabaseI d,
- CStringGetDatum(subname));
+ oid = GetSysCacheOid2(SUBSCRIPTIONNAME, Anum_pg_subscription_oi d,
+ MyDatabaseId, CStringGetDatum(subname));
if (!OidIsValid(oid) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
/*
* Add new state record for a subscription table.
*/
-O id
+vo id
AddSubscriptionRelState(Oid subid, Oid relid, char state,
XLogRecPtr sublsn)
{
Relation rel;
HeapTuple tup;
- Oid subrelid;
bool nulls[Natts_pg_subscription_rel];
Datum values[Natts_pg_subscription_rel];
tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
/* Insert tuple into catalog. */
- subrelid = CatalogTupleInsert(rel, tup);
+ CatalogTupleInsert(rel, tup);
heap_freetuple(tup);
/* Cleanup. */
heap_close(rel, NoLock);
-
- return subrelid;
}
/*
* Update the state of a subscription table.
*/
-O id
+vo id
UpdateSubscriptionRelState(Oid subid, Oid relid, char state,
XLogRecPtr sublsn)
{
Relation rel;
HeapTuple tup;
- Oid subrelid;
bool nulls[Natts_pg_subscription_rel];
Datum values[Natts_pg_subscription_rel];
bool replaces[Natts_pg_subscription_rel];
/* Update the catalog. */
CatalogTupleUpdate(rel, &tup->t_self, tup);
- subrelid = HeapTupleGetOid(tup);
-
/* Cleanup. */
heap_close(rel, NoLock);
-
- return subrelid;
}
/*
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/xact.h"
+#include "catalog/catalog.h"
#include "catalog/binary_upgrade.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
nulls[Anum_pg_type_typdefault - 1] = true;
nulls[Anum_pg_type_typacl - 1] = true;
- /*
- * create a new type tuple
- */
- tup = heap_form_tuple(tupDesc, values, nulls);
-
/* Use binary-upgrade override for pg_type.oid? */
if (IsBinaryUpgrade)
{
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("pg_type OID value not set when in binary upgrade mode")));
- HeapTupleSetOid(tup, binary_upgrade_next_pg_type_oid) ;
+ typoid = binary_upgrade_next_pg_type_oid ;
binary_upgrade_next_pg_type_oid = InvalidOid;
}
+ else
+ {
+ typoid = GetNewOidWithIndex(pg_type_desc, TypeOidIndexId,
+ Anum_pg_type_oid);
+ }
+
+ values[Anum_pg_type_oid - 1] = ObjectIdGetDatum(typoid);
+
+ /*
+ * create a new type tuple
+ */
+ tup = heap_form_tuple(tupDesc, values, nulls);
/*
* insert the tuple in the relation and get the tuple's oid.
*/
- typoid = CatalogTupleInsert(pg_type_desc, tup);
+ CatalogTupleInsert(pg_type_desc, tup);
/*
* Create dependencies. We can/must skip this in bootstrap mode.
ObjectIdGetDatum(typeNamespace));
if (HeapTupleIsValid(tup))
{
+ Form_pg_type typform = (Form_pg_type) GETSTRUCT(tup);
+
/*
* check that the type is not already defined. It may exist as a
* shell type, however.
*/
- if (((Form_pg_type) GETSTRUCT(tup)) ->typisdefined)
+ if (typform ->typisdefined)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("type \"%s\" already exists", typeName)));
/*
* shell type must have been created by same owner
*/
- if (((Form_pg_type) GETSTRUCT(tup)) ->typowner != ownerId)
+ if (typform ->typowner != ownerId)
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_TYPE, typeName);
/* trouble if caller wanted to force the OID */
if (OidIsValid(newTypeOid))
elog(ERROR, "cannot assign new OID to existing shell type");
+ replaces[Anum_pg_type_oid - 1] = false;
+
/*
* Okay to update existing shell type tuple
*/
CatalogTupleUpdate(pg_type_desc, &tup->t_self, tup);
- typeObjectId = HeapTupleGetOid(tup) ;
+ typeObjectId = typform->oid ;
rebuildDeps = true; /* get rid of shell type's dependencies */
}
else
{
- tup = heap_form_tuple(RelationGetDescr(pg_type_desc),
- values,
- nulls);
-
/* Force the OID if requested by caller */
if (OidIsValid(newTypeOid))
- HeapTupleSetOid(tup, newTypeOid) ;
+ typeObjectId = newTypeOid ;
/* Use binary-upgrade override for pg_type.oid, if supplied. */
else if (IsBinaryUpgrade)
{
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("pg_type OID value not set when in binary upgrade mode")));
- HeapTupleSetOid(tup, binary_upgrade_next_pg_type_oid) ;
+ typeObjectId = binary_upgrade_next_pg_type_oid ;
binary_upgrade_next_pg_type_oid = InvalidOid;
}
- /* else allow system to assign oid */
+ else
+ {
+ typeObjectId = GetNewOidWithIndex(pg_type_desc, TypeOidIndexId,
+ Anum_pg_type_oid);
+ }
+
+ values[Anum_pg_type_oid - 1] = ObjectIdGetDatum(typeObjectId);
+
+ tup = heap_form_tuple(RelationGetDescr(pg_type_desc),
+ values, nulls);
- typeObjectId = CatalogTupleInsert(pg_type_desc, tup);
+ CatalogTupleInsert(pg_type_desc, tup);
}
/*
arrayOid = typ->typarray;
/* Check for a conflicting type name. */
- oldTypeOid = GetSysCacheOid2(TYPENAMENSP,
+ oldTypeOid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
CStringGetDatum(newTypeName),
ObjectIdGetDatum(typeNamespace));
"pg_toast_%u_index", relOid);
/* this is pretty painful... need a tuple descriptor */
- tupdesc = CreateTemplateTupleDesc(3, false );
+ tupdesc = CreateTemplateTupleDesc(3);
TupleDescInitEntry(tupdesc, (AttrNumber) 1,
"chunk_id",
OIDOID,
rel->rd_rel->relpersistence,
shared_relation,
mapped_relation,
- true,
- 0,
ONCOMMIT_NOOP,
reloptions,
false,
AlterObjectOwner_internal(Relation rel, Oid objectId, Oid new_ownerId)
{
Oid classId = RelationGetRelid(rel);
+ AttrNumber Anum_oid = get_object_attnum_oid(classId);
AttrNumber Anum_owner = get_object_attnum_owner(classId);
AttrNumber Anum_namespace = get_object_attnum_namespace(classId);
AttrNumber Anum_acl = get_object_attnum_acl(classId);
Oid old_ownerId;
Oid namespaceId = InvalidOid;
- oldtup = get_catalog_object_by_oid(rel, objectId);
+ oldtup = get_catalog_object_by_oid(rel, Anum_oid, objectId);
if (oldtup == NULL)
elog(ERROR, "cache lookup failed for object %u of catalog \"%s\"",
objectId, RelationGetRelationName(rel));
}
else
{
- snprintf(namebuf, sizeof(namebuf), "%u",
- HeapTupleGetOid(oldtup));
+ snprintf(namebuf, sizeof(namebuf), "%u", objectId);
objname = namebuf;
}
aclcheck_error(ACLCHECK_NOT_OWNER, objtype, objname);
/* Update owner dependency reference */
if (classId == LargeObjectMetadataRelationId)
classId = LargeObjectRelationId;
- changeDependencyOnOwner(classId, HeapTupleGetOid(newtup) , new_ownerId);
+ changeDependencyOnOwner(classId, objectId , new_ownerId);
/* Release memory */
pfree(values);
#include "access/heapam.h"
#include "access/htup_details.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/pg_am.h"
errhint("Must be superuser to create an access method.")));
/* Check if name is used */
- amoid = GetSysCacheOid1(AMNAME, CStringGetDatum(stmt->amname));
+ amoid = GetSysCacheOid1(AMNAME, Anum_pg_am_oid,
+ CStringGetDatum(stmt->amname));
if (OidIsValid(amoid))
{
ereport(ERROR,
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ amoid = GetNewOidWithIndex(rel, AmOidIndexId, Anum_pg_am_oid);
+ values[Anum_pg_am_oid - 1] = ObjectIdGetDatum(amoid);
values[Anum_pg_am_amname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(stmt->amname));
values[Anum_pg_am_amhandler - 1] = ObjectIdGetDatum(amhandler);
tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
- amoid = CatalogTupleInsert(rel, tup);
+ CatalogTupleInsert(rel, tup);
heap_freetuple(tup);
myself.classId = AccessMethodRelationId;
NameStr(amform->amname),
get_am_type_string(amtype))));
- oid = HeapTupleGetOid(tup) ;
+ oid = amform->oid ;
ReleaseSysCache(tup);
}
static void reform_and_rewrite_tuple(HeapTuple tuple,
TupleDesc oldTupDesc, TupleDesc newTupDesc,
Datum *values, bool *isnull,
- bool newRelHasOids, RewriteState rwstate);
+ RewriteState rwstate);
/*---------------------------------------------------------------------------
relpersistence,
false,
RelationIsMapped(OldHeap),
- true,
- 0,
ONCOMMIT_NOOP,
reloptions,
false,
reform_and_rewrite_tuple(tuple,
oldTupDesc, newTupDesc,
values, isnull,
- NewHeap->rd_rel->relhasoids, rwstate);
+ rwstate);
}
if (indexScan != NULL)
reform_and_rewrite_tuple(tuple,
oldTupDesc, newTupDesc,
values, isnull,
- NewHeap->rd_rel->relhasoids, rwstate);
+ rwstate);
}
tuplesort_end(tuplesort);
*
* 2. The tuple might not even be legal for the new table; this is
* currently only known to happen as an after-effect of ALTER TABLE
- * SET WITHOUT OIDS.
+ * SET WITHOUT OIDS (in an older version, via pg_upgrade) .
*
* So, we must reconstruct the tuple from component Datums.
*/
reform_and_rewrite_tuple(HeapTuple tuple,
TupleDesc oldTupDesc, TupleDesc newTupDesc,
Datum *values, bool *isnull,
- bool newRelHasOids, RewriteState rwstate)
+ RewriteState rwstate)
{
HeapTuple copiedTuple;
int i;
copiedTuple = heap_form_tuple(newTupDesc, values, isnull);
- /* Preserve OID, if any */
- if (newRelHasOids)
- HeapTupleSetOid(copiedTuple, HeapTupleGetOid(tuple));
-
/* The heap rewrite module does the rest */
rewrite_heap_tuple(rwstate, tuple, copiedTuple);
bool is_program; /* is 'filename' a program to popen? */
copy_data_source_cb data_source_cb; /* function for reading data */
bool binary; /* binary format? */
- bool oids; /* include OIDs? */
bool freeze; /* freeze rows on loading? */
bool csv_mode; /* Comma Separated Value format? */
bool header_line; /* CSV header line? */
* Working state for COPY FROM
*/
AttrNumber num_defaults;
- bool file_has_oids;
FmgrInfo oid_in_function;
Oid oid_typioparam;
FmgrInfo *in_functions; /* array of input functions for each attrs */
static void EndCopyTo(CopyState cstate);
static uint64 DoCopyTo(CopyState cstate);
static uint64 CopyTo(CopyState cstate);
-static void CopyOneRowTo(CopyState cstate, Oid tupleOid,
+static void CopyOneRowTo(CopyState cstate,
Datum *values, bool *nulls);
static void CopyFromInsertBatch(CopyState cstate, EState *estate,
CommandId mycid, int hi_options,
errmsg("COPY format \"%s\" not recognized", fmt),
parser_errposition(pstate, defel->location)));
}
- else if (strcmp(defel->defname, "oids") == 0)
- {
- if (cstate->oids)
- ereport(ERROR,
- (errcode(ERRCODE_SYNTAX_ERROR),
- errmsg("conflicting or redundant options"),
- parser_errposition(pstate, defel->location)));
- cstate->oids = defGetBoolean(defel);
- }
else if (strcmp(defel->defname, "freeze") == 0)
{
if (cstate->freeze)
cstate->rel = rel;
tupDesc = RelationGetDescr(cstate->rel);
-
- /* Don't allow COPY w/ OIDs to or from a table without them */
- if (cstate->oids && !cstate->rel->rd_rel->relhasoids)
- ereport(ERROR,
- (errcode(ERRCODE_UNDEFINED_COLUMN),
- errmsg("table \"%s\" does not have OIDs",
- RelationGetRelationName(cstate->rel))));
}
else
{
Assert(!is_from);
cstate->rel = NULL;
- /* Don't allow COPY w/ OIDs from a query */
- if (cstate->oids)
- ereport(ERROR,
- (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
- errmsg("COPY (query) WITH OIDS is not supported")));
-
/*
* Run parse analysis and rewrite. Note this also acquires sufficient
* locks on the source table(s).
CopySendData(cstate, BinarySignature, 11);
/* Flags field */
tmp = 0;
- if (cstate->oids)
- tmp |= (1 << 16);
CopySendInt32(cstate, tmp);
/* No header extension */
tmp = 0;
heap_deform_tuple(tuple, tupDesc, values, nulls);
/* Format and send the data */
- CopyOneRowTo(cstate, HeapTupleGetOid(tuple), values, nulls);
+ CopyOneRowTo(cstate, values, nulls);
processed++;
}
* Emit one row during CopyTo().
*/
static void
-CopyOneRowTo(CopyState cstate, Oid tupleOid, Datum *values, bool *nulls)
+CopyOneRowTo(CopyState cstate, Datum *values, bool *nulls)
{
bool need_delim = false;
FmgrInfo *out_functions = cstate->out_functions;
{
/* Binary per-tuple header */
CopySendInt16(cstate, list_length(cstate->attnumlist));
- /* Send OID if wanted --- note attnumlist doesn't include it */
- if (cstate->oids)
- {
- /* Hack --- assume Oid is same size as int32 */
- CopySendInt32(cstate, sizeof(int32));
- CopySendInt32(cstate, tupleOid);
- }
- }
- else
- {
- /* Text format has no per-tuple header, but send OID if wanted */
- /* Assume digits don't need any quoting or encoding conversion */
- if (cstate->oids)
- {
- string = DatumGetCString(DirectFunctionCall1(oidout,
- ObjectIdGetDatum(tupleOid)));
- CopySendString(cstate, string);
- need_delim = true;
- }
}
foreach(cur, cstate->attnumlist)
{
TupleTableSlot *slot;
bool skip_tuple;
- Oid loaded_oid = InvalidOid;
CHECK_FOR_INTERRUPTS();
/* Switch into its memory context */
MemoryContextSwitchTo(GetPerTupleMemoryContext(estate));
- if (!NextCopyFrom(cstate, econtext, values, nulls, &loaded_oid ))
+ if (!NextCopyFrom(cstate, econtext, values, nulls))
break;
/* And now we can form the input tuple. */
tuple = heap_form_tuple(tupDesc, values, nulls);
- if (loaded_oid != InvalidOid)
- HeapTupleSetOid(tuple, loaded_oid);
-
/*
* Constraints might reference the tableoid column, so initialize
* t_tableOid before evaluating them.
}
}
- if (!cstate->binary)
- {
- /* must rely on user to tell us... */
- cstate->file_has_oids = cstate->oids;
- }
- else
+ if (cstate->binary)
{
/* Read and verify binary header */
char readSig[11];
ereport(ERROR,
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
errmsg("invalid COPY file header (missing flags)")));
- cstate->file_has_oids = (tmp & (1 << 16)) != 0;
+ if ((tmp & (1 << 16)) != 0)
+ ereport(ERROR,
+ (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
+ errmsg("invalid COPY file header (WITH OIDS)")));
tmp &= ~(1 << 16);
if ((tmp >> 16) != 0)
ereport(ERROR,
}
}
- if (cstate->file_has_oids && cstate->binary)
- {
- getTypeBinaryInputInfo(OIDOID,
- &in_func_oid, &cstate->oid_typioparam);
- fmgr_info(in_func_oid, &cstate->oid_in_function);
- }
-
/* create workspace for CopyReadAttributes results */
if (!cstate->binary)
{
AttrNumber attr_count = list_length(cstate->attnumlist);
- int nfields = cstate->file_has_oids ? (attr_count + 1) : attr_count;
- cstate->max_fields = nfields ;
- cstate->raw_fields = (char **) palloc(nfields * sizeof(char *));
+ cstate->max_fields = attr_count ;
+ cstate->raw_fields = (char **) palloc(attr_count * sizeof(char *));
}
MemoryContextSwitchTo(oldcontext);
*/
bool
NextCopyFrom(CopyState cstate, ExprContext *econtext,
- Datum *values, bool *nulls, Oid *tupleOid )
+ Datum *values, bool *nulls)
{
TupleDesc tupDesc;
AttrNumber num_phys_attrs,
FmgrInfo *in_functions = cstate->in_functions;
Oid *typioparams = cstate->typioparams;
int i;
- int nfields;
- bool isnull;
- bool file_has_oids = cstate->file_has_oids;
int *defmap = cstate->defmap;
ExprState **defexprs = cstate->defexprs;
tupDesc = RelationGetDescr(cstate->rel);
num_phys_attrs = tupDesc->natts;
attr_count = list_length(cstate->attnumlist);
- nfields = file_has_oids ? (attr_count + 1) : attr_count;
/* Initialize all values for row to NULL */
MemSet(values, 0, num_phys_attrs * sizeof(Datum));
return false;
/* check for overflowing fields */
- if (nfields > 0 && fldct > nfields )
+ if (attr_count > 0 && fldct > attr_count )
ereport(ERROR,
(errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
errmsg("extra data after last expected column")));
fieldno = 0;
- /* Read the OID field if present */
- if (file_has_oids)
- {
- if (fieldno >= fldct)
- ereport(ERROR,
- (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- errmsg("missing data for OID column")));
- string = field_strings[fieldno++];
-
- if (string == NULL)
- ereport(ERROR,
- (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- errmsg("null OID in COPY data")));
- else if (cstate->oids && tupleOid != NULL)
- {
- cstate->cur_attname = "oid";
- cstate->cur_attval = string;
- *tupleOid = DatumGetObjectId(DirectFunctionCall1(oidin,
- CStringGetDatum(string)));
- if (*tupleOid == InvalidOid)
- ereport(ERROR,
- (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- errmsg("invalid OID in COPY data")));
- cstate->cur_attname = NULL;
- cstate->cur_attval = NULL;
- }
- }
-
/* Loop to read the user attributes on the line. */
foreach(cur, cstate->attnumlist)
{
cstate->cur_attval = NULL;
}
- Assert(fieldno == nfields );
+ Assert(fieldno == attr_count );
}
else
{
errmsg("row field count is %d, expected %d",
(int) fld_count, attr_count)));
- if (file_has_oids)
- {
- Oid loaded_oid;
-
- cstate->cur_attname = "oid";
- loaded_oid =
- DatumGetObjectId(CopyReadBinaryAttribute(cstate,
- 0,
- &cstate->oid_in_function,
- cstate->oid_typioparam,
- -1,
- &isnull));
- if (isnull || loaded_oid == InvalidOid)
- ereport(ERROR,
- (errcode(ERRCODE_BAD_COPY_FILE_FORMAT),
- errmsg("invalid OID in COPY data")));
- cstate->cur_attname = NULL;
- if (cstate->oids && tupleOid != NULL)
- *tupleOid = loaded_oid;
- }
-
i = 0;
foreach(cur, cstate->attnumlist)
{
slot_getallattrs(slot);
/* And send the data */
- CopyOneRowTo(cstate, InvalidOid, slot->tts_values, slot->tts_isnull);
+ CopyOneRowTo(cstate, slot->tts_values, slot->tts_isnull);
myState->processed++;
return true;
int
GetIntoRelEFlags(IntoClause *intoClause)
{
- int flags;
-
- /*
- * We need to tell the executor whether it has to produce OIDs or not,
- * because it doesn't have enough information to do so itself (since we
- * can't build the target relation until after ExecutorStart).
- *
- * Disallow the OIDS option for materialized views.
- */
- if (interpretOidsOption(intoClause->options,
- (intoClause->viewQuery == NULL)))
- flags = EXEC_FLAG_WITH_OIDS;
- else
- flags = EXEC_FLAG_WITHOUT_OIDS;
+ int flags = 0;
if (intoClause->skipData)
flags |= EXEC_FLAG_WITH_NO_DATA;
*/
tuple = ExecCopySlotHeapTuple(slot);
- /*
- * force assignment of new OID (see comments in ExecInsert)
- */
- if (myState->rel->rd_rel->relhasoids)
- HeapTupleSetOid(tuple, InvalidOid);
-
heap_insert(myState->rel,
tuple,
myState->output_cid,
do
{
- dboid = GetNewOid(pg_database_rel);
+ dboid = GetNewOidWithIndex(pg_database_rel, DatabaseOidIndexId,
+ Anum_pg_database_oid);
} while (check_db_file_conflict(dboid));
/*
MemSet(new_record, 0, sizeof(new_record));
MemSet(new_record_nulls, false, sizeof(new_record_nulls));
+ new_record[Anum_pg_database_oid - 1] = ObjectIdGetDatum(dboid);
new_record[Anum_pg_database_datname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(dbname));
new_record[Anum_pg_database_datdba - 1] = ObjectIdGetDatum(datdba);
tuple = heap_form_tuple(RelationGetDescr(pg_database_rel),
new_record, new_record_nulls);
- HeapTupleSetOid(tuple, dboid);
-
CatalogTupleInsert(pg_database_rel, tuple);
/*
scan = heap_beginscan_catalog(rel, 0, NULL);
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
- Oid srctablespace = HeapTupleGetOid(tuple);
+ Form_pg_tablespace spaceform = (Form_pg_tablespace) GETSTRUCT(tuple);
+ Oid srctablespace = spaceform->oid;
Oid dsttablespace;
char *srcpath;
char *dstpath;
new_record_nulls, new_record_repl);
CatalogTupleUpdate(pgdbrel, &oldtuple->t_self, newtuple);
- InvokeObjectPostAlterHook(DatabaseRelationId,
- HeapTupleGetOid(newtuple), 0);
+ InvokeObjectPostAlterHook(DatabaseRelationId, db_id, 0);
systable_endscan(sysscan);
Oid dboid;
HeapTuple tuple,
newtuple;
+ Form_pg_database datform;
ScanKeyData scankey;
SysScanDesc scan;
ListCell *option;
(errcode(ERRCODE_UNDEFINED_DATABASE),
errmsg("database \"%s\" does not exist", stmt->dbname)));
- dboid = HeapTupleGetOid(tuple);
+ datform = (Form_pg_database) GETSTRUCT(tuple);
+ dboid = datform->oid;
- if (!pg_database_ownercheck(HeapTupleGetOid(tuple) , GetUserId()))
+ if (!pg_database_ownercheck(dboid , GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_DATABASE,
stmt->dbname);
new_record_nulls, new_record_repl);
CatalogTupleUpdate(rel, &tuple->t_self, newtuple);
- InvokeObjectPostAlterHook(DatabaseRelationId,
- HeapTupleGetOid(newtuple), 0);
+ InvokeObjectPostAlterHook(DatabaseRelationId, dboid, 0);
systable_endscan(scan);
(errcode(ERRCODE_UNDEFINED_DATABASE),
errmsg("database \"%s\" does not exist", dbname)));
- db_id = HeapTupleGetOid(tuple);
datForm = (Form_pg_database) GETSTRUCT(tuple);
+ db_id = datForm->oid;
/*
* If the new owner is the same as the existing owner, consider the
HeapTuple newtuple;
/* Otherwise, must be owner of the existing object */
- if (!pg_database_ownercheck(HeapTupleGetOid(tuple) , GetUserId()))
+ if (!pg_database_ownercheck(db_id , GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_DATABASE,
dbname);
heap_freetuple(newtuple);
/* Update owner dependency reference */
- changeDependencyOnOwner(DatabaseRelationId, HeapTupleGetOid(tuple),
- newOwnerId);
+ changeDependencyOnOwner(DatabaseRelationId, db_id, newOwnerId);
}
- InvokeObjectPostAlterHook(DatabaseRelationId, HeapTupleGetOid(tuple) , 0);
+ InvokeObjectPostAlterHook(DatabaseRelationId, db_id , 0);
ObjectAddressSet(address, DatabaseRelationId, db_id);
break;
}
- dbOid = HeapTupleGetOid(tuple) ;
+ dbOid = ((Form_pg_database) GETSTRUCT(tuple))->oid ;
systable_endscan(scan);
scan = heap_beginscan_catalog(rel, 0, NULL);
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
- Oid dsttablespace = HeapTupleGetOid(tuple);
+ Form_pg_tablespace spcform = (Form_pg_tablespace) GETSTRUCT(tuple);
+ Oid dsttablespace = spcform->oid;
char *dstpath;
struct stat st;
scan = heap_beginscan_catalog(rel, 0, NULL);
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
- Oid dsttablespace = HeapTupleGetOid(tuple);
+ Form_pg_tablespace spcform = (Form_pg_tablespace) GETSTRUCT(tuple);
+ Oid dsttablespace = spcform->oid;
char *dstpath;
struct stat st;
/* We assume that there can be at most one matching tuple */
if (HeapTupleIsValid(dbtuple))
- oid = HeapTupleGetOid(dbtuple) ;
+ oid = ((Form_pg_database)GETSTRUCT(dbtuple))->oid ;
else
oid = InvalidOid;
#include "access/htup_details.h"
#include "access/xact.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
tgrel = heap_open(EventTriggerRelationId, RowExclusiveLock);
/* Build the new pg_trigger tuple. */
+ trigoid = GetNewOidWithIndex(tgrel, EventTriggerOidIndexId,
+ Anum_pg_event_trigger_oid);
+ values[Anum_pg_event_trigger_oid - 1] = ObjectIdGetDatum(trigoid);
memset(nulls, false, sizeof(nulls));
namestrcpy(&evtnamedata, trigname);
values[Anum_pg_event_trigger_evtname - 1] = NameGetDatum(&evtnamedata);
/* Insert heap tuple. */
tuple = heap_form_tuple(tgrel->rd_att, values, nulls);
- trigoid = CatalogTupleInsert(tgrel, tuple);
+ CatalogTupleInsert(tgrel, tuple);
heap_freetuple(tuple);
/* Depend on owner. */
errmsg("event trigger \"%s\" does not exist",
stmt->trigname)));
- trigoid = HeapTupleGetOid(tup);
+ evtForm = (Form_pg_event_trigger) GETSTRUCT(tup);
+ trigoid = evtForm->oid;
if (!pg_event_trigger_ownercheck(trigoid, GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EVENT_TRIGGER,
stmt->trigname);
/* tuple is a copy, so we can modify it below */
- evtForm = (Form_pg_event_trigger) GETSTRUCT(tup);
evtForm->evtenabled = tgenabled;
CatalogTupleUpdate(tgrel, &tup->t_self, tup);
{
Oid evtOid;
HeapTuple tup;
+ Form_pg_event_trigger evtForm;
Relation rel;
ObjectAddress address;
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("event trigger \"%s\" does not exist", name)));
- evtOid = HeapTupleGetOid(tup);
+ evtForm = (Form_pg_event_trigger) GETSTRUCT(tup);
+ evtOid = evtForm->oid;
AlterEventTriggerOwner_internal(rel, tup, newOwnerId);
if (form->evtowner == newOwnerId)
return;
- if (!pg_event_trigger_ownercheck(HeapTupleGetOid(tup) , GetUserId()))
+ if (!pg_event_trigger_ownercheck(form->oid , GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_EVENT_TRIGGER,
NameStr(form->evtname));
/* Update owner dependency reference */
changeDependencyOnOwner(EventTriggerRelationId,
- HeapTupleGetOid(tup) ,
+ form->oid ,
newOwnerId);
InvokeObjectPostAlterHook(EventTriggerRelationId,
- HeapTupleGetOid(tup) , 0);
+ form->oid , 0);
}
/*
{
Oid oid;
- oid = GetSysCacheOid1(EVENTTRIGGERNAME, CStringGetDatum(trigname));
+ oid = GetSysCacheOid1(EVENTTRIGGERNAME, Anum_pg_event_trigger_oid,
+ CStringGetDatum(trigname));
if (!OidIsValid(oid) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
HeapTuple tuple;
catalog = heap_open(obj->address.classId, AccessShareLock);
- tuple = get_catalog_object_by_oid(catalog, obj->address.objectId);
+ tuple = get_catalog_object_by_oid(catalog,
+ get_object_attnum_oid(object->classId),
+ obj->address.objectId);
if (tuple)
{
catalog = heap_open(addr.classId, AccessShareLock);
objtup = get_catalog_object_by_oid(catalog,
+ get_object_attnum_oid(addr.classId),
addr.objectId);
if (!HeapTupleIsValid(objtup))
elog(ERROR, "cache lookup failed for object %u/%u",
}
/* Need a tuple descriptor representing a single TEXT or XML column */
- tupdesc = CreateTemplateTupleDesc(1, false );
+ tupdesc = CreateTemplateTupleDesc(1);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "QUERY PLAN",
result_type, -1, 0);
return tupdesc;
#include "access/htup_details.h"
#include "access/sysattr.h"
#include "access/xact.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
/* We assume that there can be at most one matching tuple */
if (HeapTupleIsValid(tuple))
- result = HeapTupleGetOid(tuple) ;
+ result = ((Form_pg_extension) GETSTRUCT(tuple))->oid ;
else
result = InvalidOid;
rel = heap_open(ExtensionRelationId, AccessShareLock);
ScanKeyInit(&entry[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_extension_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(ext_oid));
rel = heap_open(ExtensionRelationId, AccessShareLock);
ScanKeyInit(&entry[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_extension_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(ext_oid));
memset(values, 0, sizeof(values));
memset(nulls, 0, sizeof(nulls));
+ extensionOid = GetNewOidWithIndex(rel, ExtensionOidIndexId,
+ Anum_pg_extension_oid);
+ values[Anum_pg_extension_oid - 1] = ObjectIdGetDatum(extensionOid);
values[Anum_pg_extension_extname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(extName));
values[Anum_pg_extension_extowner - 1] = ObjectIdGetDatum(extOwner);
tuple = heap_form_tuple(rel->rd_att, values, nulls);
- extensionOid = CatalogTupleInsert(rel, tuple);
+ CatalogTupleInsert(rel, tuple);
heap_freetuple(tuple);
heap_close(rel, RowExclusiveLock);
rel = heap_open(ExtensionRelationId, RowExclusiveLock);
ScanKeyInit(&entry[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_extension_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(extId));
scandesc = systable_beginscan(rel, ExtensionOidIndexId, true,
extRel = heap_open(ExtensionRelationId, RowExclusiveLock);
ScanKeyInit(&key[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_extension_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(CurrentExtensionObject));
extRel = heap_open(ExtensionRelationId, RowExclusiveLock);
ScanKeyInit(&key[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_extension_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(extensionoid));
extRel = heap_open(ExtensionRelationId, RowExclusiveLock);
ScanKeyInit(&key[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_extension_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(extensionOid));
errmsg("extension \"%s\" does not exist",
stmt->extname)));
- extensionOid = HeapTupleGetOid(extTup) ;
+ extensionOid = ((Form_pg_extension) GETSTRUCT(extTup))->oid ;
/*
* Determine the existing version we are updating from
extRel = heap_open(ExtensionRelationId, RowExclusiveLock);
ScanKeyInit(&key[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_extension_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(extensionOid));
#include "access/htup_details.h"
#include "access/reloptions.h"
#include "access/xact.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
/* Update owner dependency reference */
changeDependencyOnOwner(ForeignDataWrapperRelationId,
- HeapTupleGetOid(tup) ,
+ form->oid ,
newOwnerId);
}
InvokeObjectPostAlterHook(ForeignDataWrapperRelationId,
- HeapTupleGetOid(tup) , 0);
+ form->oid , 0);
}
/*
HeapTuple tup;
Relation rel;
ObjectAddress address;
+ Form_pg_foreign_data_wrapper form;
+
rel = heap_open(ForeignDataWrapperRelationId, RowExclusiveLock);
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("foreign-data wrapper \"%s\" does not exist", name)));
- fdwId = HeapTupleGetOid(tup);
+ form = (Form_pg_foreign_data_wrapper) GETSTRUCT(tup);
+ fdwId = form->oid;
AlterForeignDataWrapperOwner_internal(rel, tup, newOwnerId);
Oid srvId;
AclResult aclresult;
- srvId = HeapTupleGetOid(tup) ;
+ srvId = form->oid ;
/* Must be owner */
if (!pg_foreign_server_ownercheck(srvId, GetUserId()))
CatalogTupleUpdate(rel, &tup->t_self, tup);
/* Update owner dependency reference */
- changeDependencyOnOwner(ForeignServerRelationId, HeapTupleGetOid(tup) ,
+ changeDependencyOnOwner(ForeignServerRelationId, form->oid ,
newOwnerId);
}
InvokeObjectPostAlterHook(ForeignServerRelationId,
- HeapTupleGetOid(tup) , 0);
+ form->oid , 0);
}
/*
HeapTuple tup;
Relation rel;
ObjectAddress address;
+ Form_pg_foreign_server form;
rel = heap_open(ForeignServerRelationId, RowExclusiveLock);
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("server \"%s\" does not exist", name)));
- servOid = HeapTupleGetOid(tup);
+ form = (Form_pg_foreign_server) GETSTRUCT(tup);
+ servOid = form->oid;
AlterForeignServerOwner_internal(rel, tup, newOwnerId);
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ fdwId = GetNewOidWithIndex(rel, ForeignDataWrapperOidIndexId,
+ Anum_pg_foreign_data_wrapper_oid);
+ values[Anum_pg_foreign_data_wrapper_oid - 1] = ObjectIdGetDatum(fdwId);
values[Anum_pg_foreign_data_wrapper_fdwname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(stmt->fdwname));
values[Anum_pg_foreign_data_wrapper_fdwowner - 1] = ObjectIdGetDatum(ownerId);
tuple = heap_form_tuple(rel->rd_att, values, nulls);
- fdwId = CatalogTupleInsert(rel, tuple);
+ CatalogTupleInsert(rel, tuple);
heap_freetuple(tuple);
errmsg("foreign-data wrapper \"%s\" does not exist", stmt->fdwname)));
fdwForm = (Form_pg_foreign_data_wrapper) GETSTRUCT(tp);
- fdwId = HeapTupleGetOid(tp) ;
+ fdwId = fdwForm->oid ;
memset(repl_val, 0, sizeof(repl_val));
memset(repl_null, false, sizeof(repl_null));
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ srvId = GetNewOidWithIndex(rel, ForeignServerOidIndexId,
+ Anum_pg_foreign_server_oid);
+ values[Anum_pg_foreign_server_oid - 1] = ObjectIdGetDatum(srvId);
values[Anum_pg_foreign_server_srvname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(stmt->servername));
values[Anum_pg_foreign_server_srvowner - 1] = ObjectIdGetDatum(ownerId);
tuple = heap_form_tuple(rel->rd_att, values, nulls);
- srvId = CatalogTupleInsert(rel, tuple);
+ CatalogTupleInsert(rel, tuple);
heap_freetuple(tuple);
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("server \"%s\" does not exist", stmt->servername)));
- srvId = HeapTupleGetOid(tp);
srvForm = (Form_pg_foreign_server) GETSTRUCT(tp);
+ srvId = srvForm->oid;
/*
* Only owner or a superuser can ALTER a SERVER.
/*
* Check that the user mapping is unique within server.
*/
- umId = GetSysCacheOid2(USERMAPPINGUSERSERVER,
+ umId = GetSysCacheOid2(USERMAPPINGUSERSERVER, Anum_pg_user_mapping_oid,
ObjectIdGetDatum(useId),
ObjectIdGetDatum(srv->serverid));
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ umId = GetNewOidWithIndex(rel, UserMappingOidIndexId,
+ Anum_pg_user_mapping_oid);
+ values[Anum_pg_user_mapping_oid - 1] = ObjectIdGetDatum(umId);
values[Anum_pg_user_mapping_umuser - 1] = ObjectIdGetDatum(useId);
values[Anum_pg_user_mapping_umserver - 1] = ObjectIdGetDatum(srv->serverid);
tuple = heap_form_tuple(rel->rd_att, values, nulls);
- umId = CatalogTupleInsert(rel, tuple);
+ CatalogTupleInsert(rel, tuple);
heap_freetuple(tuple);
srv = GetForeignServerByName(stmt->servername, false);
- umId = GetSysCacheOid2(USERMAPPINGUSERSERVER,
+ umId = GetSysCacheOid2(USERMAPPINGUSERSERVER, Anum_pg_user_mapping_oid,
ObjectIdGetDatum(useId),
ObjectIdGetDatum(srv->serverid));
if (!OidIsValid(umId))
return InvalidOid;
}
- umId = GetSysCacheOid2(USERMAPPINGUSERSERVER,
+ umId = GetSysCacheOid2(USERMAPPINGUSERSERVER, Anum_pg_user_mapping_oid,
ObjectIdGetDatum(useId),
ObjectIdGetDatum(srv->serverid));
#include "access/heapam.h"
#include "access/htup_details.h"
#include "access/sysattr.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
(PLTemplateExists(language) ?
errhint("Use CREATE EXTENSION to load the language into the database.") : 0)));
- languageOid = HeapTupleGetOid(languageTuple);
languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
+ languageOid = languageStruct->oid;
if (languageStruct->lanpltrusted)
{
format_type_be(targettypeid))));
/* ready to go */
+ castid = GetNewOidWithIndex(relation, CastOidIndexId, Anum_pg_cast_oid);
+ values[Anum_pg_cast_oid - 1] = ObjectIdGetDatum(castid);
values[Anum_pg_cast_castsource - 1] = ObjectIdGetDatum(sourcetypeid);
values[Anum_pg_cast_casttarget - 1] = ObjectIdGetDatum(targettypeid);
values[Anum_pg_cast_castfunc - 1] = ObjectIdGetDatum(funcid);
tuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
- castid = CatalogTupleInsert(relation, tuple);
+ CatalogTupleInsert(relation, tuple);
/* make dependency entries */
myself.classId = CastRelationId;
{
Oid oid;
- oid = GetSysCacheOid2(CASTSOURCETARGET,
+ oid = GetSysCacheOid2(CASTSOURCETARGET, Anum_pg_cast_oid,
ObjectIdGetDatum(sourcetypeid),
ObjectIdGetDatum(targettypeid));
if (!OidIsValid(oid) && !missing_ok)
relation = heap_open(CastRelationId, RowExclusiveLock);
ScanKeyInit(&scankey,
- ObjectIdAttributeNumber ,
+ Anum_pg_cast_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(castOid));
scan = systable_beginscan(relation, CastOidIndexId, true,
ObjectIdGetDatum(langid));
if (HeapTupleIsValid(tuple))
{
+ Form_pg_transform form = (Form_pg_transform) GETSTRUCT(tuple);
+
if (!stmt->replace)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
newtuple = heap_modify_tuple(tuple, RelationGetDescr(relation), values, nulls, replaces);
CatalogTupleUpdate(relation, &newtuple->t_self, newtuple);
- transformid = HeapTupleGetOid(tuple) ;
+ transformid = form->oid ;
ReleaseSysCache(tuple);
is_replace = true;
}
else
{
+ transformid = GetNewOidWithIndex(relation, TransformOidIndexId,
+ Anum_pg_transform_oid);
+ values[Anum_pg_transform_oid - 1] = ObjectIdGetDatum(transformid);
newtuple = heap_form_tuple(RelationGetDescr(relation), values, nulls);
- transformid = CatalogTupleInsert(relation, newtuple);
+ CatalogTupleInsert(relation, newtuple);
is_replace = false;
}
{
Oid oid;
- oid = GetSysCacheOid2(TRFTYPELANG,
+ oid = GetSysCacheOid2(TRFTYPELANG, Anum_pg_transform_oid,
ObjectIdGetDatum(type_id),
ObjectIdGetDatum(lang_id));
if (!OidIsValid(oid) && !missing_ok)
relation = heap_open(TransformRelationId, RowExclusiveLock);
ScanKeyInit(&scankey,
- ObjectIdAttributeNumber ,
+ Anum_pg_transform_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(transformOid));
scan = systable_beginscan(relation, TransformOidIndexId, true,
(PLTemplateExists(language) ?
errhint("Use CREATE EXTENSION to load the language into the database.") : 0)));
- codeblock->langOid = HeapTupleGetOid(languageTuple);
languageStruct = (Form_pg_language) GETSTRUCT(languageTuple);
+ codeblock->langOid = languageStruct->oid;
codeblock->langIsTrusted = languageStruct->lanpltrusted;
codeblock->atomic = atomic;
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("access method \"%s\" does not exist",
accessMethodName)));
- accessMethodId = HeapTupleGetOid(tuple);
accessMethodForm = (Form_pg_am) GETSTRUCT(tuple);
+ accessMethodId = accessMethodForm->oid;
amRoutine = GetIndexAmRoutine(accessMethodForm->amhandler);
ReleaseSysCache(tuple);
errmsg("access method \"%s\" does not exist",
accessMethodName)));
}
- accessMethodId = HeapTupleGetOid(tuple);
accessMethodForm = (Form_pg_am) GETSTRUCT(tuple);
+ accessMethodId = accessMethodForm->oid;
amRoutine = GetIndexAmRoutine(accessMethodForm->amhandler);
if (stmt->unique && !amRoutine->amcanunique)
/*
- * We disallow indexes on system columns other than OID. They would no t
- * necessarily get updated correctly, and they don't seem useful anyway.
+ * We disallow indexes on system columns. They would not necessarily ge t
+ * updated correctly, and they don't seem useful anyway.
*/
for (i = 0; i < indexInfo->ii_NumIndexAttrs; i++)
{
AttrNumber attno = indexInfo->ii_IndexAttrNumbers[i];
- if (attno < 0 && attno != ObjectIdAttributeNumber )
+ if (attno < 0)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("index creation on system columns is not supported")));
for (i = FirstLowInvalidHeapAttributeNumber + 1; i < 0; i++)
{
- if (i != ObjectIdAttributeNumber &&
- bms_is_member(i - FirstLowInvalidHeapAttributeNumber,
+ if (bms_is_member(i - FirstLowInvalidHeapAttributeNumber,
indexattrs))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
char *schemaname;
char *opcname;
HeapTuple tuple;
+ Form_pg_opclass opform;
Oid opClassId,
opInputType;
* Verify that the index operator class accepts this datatype. Note we
* will accept binary compatibility.
*/
- opClassId = HeapTupleGetOid(tuple);
- opInputType = ((Form_pg_opclass) GETSTRUCT(tuple))->opcintype;
+ opform = (Form_pg_opclass) GETSTRUCT(tuple);
+ opClassId = opform->oid;
+ opInputType = opform->opcintype;
if (!IsBinaryCoercible(attrType, opInputType))
ereport(ERROR,
if (opclass->opcintype == type_id)
{
nexact++;
- result = HeapTupleGetOid(tup) ;
+ result = opclass->oid ;
}
else if (nexact == 0 &&
IsBinaryCoercible(type_id, opclass->opcintype))
if (IsPreferredType(tcategory, opclass->opcintype))
{
ncompatiblepreferred++;
- result = HeapTupleGetOid(tup) ;
+ result = opclass->oid ;
}
else if (ncompatiblepreferred == 0)
{
ncompatible++;
- result = HeapTupleGetOid(tup) ;
+ result = opclass->oid ;
}
}
}
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
Form_pg_class classtuple = (Form_pg_class) GETSTRUCT(tuple);
- Oid relid = HeapTupleGetOid(tuple) ;
+ Oid relid = classtuple->oid ;
/*
* Only regular tables and matviews can have indexes, so ignore any
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("CONCURRENTLY and WITH NO DATA options cannot be used together")));
- /* We don't allow an oid column for a materialized view. */
- Assert(!matviewRel->rd_rel->relhasoids);
-
/*
* Check that everything is correct for a refresh. Problems at this point
* are internal errors, so elog is sufficient.
dest, NULL, NULL, 0);
/* call ExecutorStart to prepare the plan for execution */
- ExecutorStart(queryDesc, EXEC_FLAG_WITHOUT_OIDS );
+ ExecutorStart(queryDesc, 0 );
/* run the plan */
ExecutorRun(queryDesc, ForwardScanDirection, 0L, true);
#include "access/nbtree.h"
#include "access/htup_details.h"
#include "access/sysattr.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
get_opfamily_oid(Oid amID, List *opfamilyname, bool missing_ok)
{
HeapTuple htup;
+ Form_pg_opfamily opfamform;
Oid opfID;
htup = OpFamilyCacheLookup(amID, opfamilyname, missing_ok);
if (!HeapTupleIsValid(htup))
return InvalidOid;
- opfID = HeapTupleGetOid(htup);
+ opfamform = (Form_pg_opfamily) GETSTRUCT(htup);
+ opfID = opfamform->oid;
ReleaseSysCache(htup);
return opfID;
get_opclass_oid(Oid amID, List *opclassname, bool missing_ok)
{
HeapTuple htup;
+ Form_pg_opclass opcform;
Oid opcID;
htup = OpClassCacheLookup(amID, opclassname, missing_ok);
if (!HeapTupleIsValid(htup))
return InvalidOid;
- opcID = HeapTupleGetOid(htup);
+ opcform = (Form_pg_opclass) GETSTRUCT(htup);
+ opcID = opcform->oid;
ReleaseSysCache(htup);
return opcID;
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ opfamilyoid = GetNewOidWithIndex(rel, OpfamilyOidIndexId,
+ Anum_pg_opfamily_oid);
+ values[Anum_pg_opfamily_oid - 1] = ObjectIdGetDatum(opfamilyoid);
values[Anum_pg_opfamily_opfmethod - 1] = ObjectIdGetDatum(amoid);
namestrcpy(&opfName, opfname);
values[Anum_pg_opfamily_opfname - 1] = NameGetDatum(&opfName);
tup = heap_form_tuple(rel->rd_att, values, nulls);
- opfamilyoid = CatalogTupleInsert(rel, tup);
+ CatalogTupleInsert(rel, tup);
heap_freetuple(tup);
ListCell *l;
Relation rel;
HeapTuple tup;
+ Form_pg_am amform;
IndexAmRoutine *amroutine;
Datum values[Natts_pg_opclass];
bool nulls[Natts_pg_opclass];
errmsg("access method \"%s\" does not exist",
stmt->amname)));
- amoid = HeapTupleGetOid(tup);
+ amform = (Form_pg_am) GETSTRUCT(tup);
+ amoid = amform->oid;
amroutine = GetIndexAmRoutineByAmId(amoid, false);
ReleaseSysCache(tup);
ObjectIdGetDatum(namespaceoid));
if (HeapTupleIsValid(tup))
{
- opfamilyoid = HeapTupleGetOid(tup) ;
+ opfamilyoid = ((Form_pg_opfamily) GETSTRUCT(tup))->oid ;
/*
* XXX given the superuser check above, there's no need for an
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ opclassoid = GetNewOidWithIndex(rel, OpclassOidIndexId,
+ Anum_pg_opclass_oid);
+ values[Anum_pg_opclass_oid - 1] = ObjectIdGetDatum(opclassoid);
values[Anum_pg_opclass_opcmethod - 1] = ObjectIdGetDatum(amoid);
namestrcpy(&opcName, opcname);
values[Anum_pg_opclass_opcname - 1] = NameGetDatum(&opcName);
tup = heap_form_tuple(rel->rd_att, values, nulls);
- opclassoid = CatalogTupleInsert(rel, tup);
+ CatalogTupleInsert(rel, tup);
heap_freetuple(tup);
int maxOpNumber, /* amstrategies value */
maxProcNumber; /* amsupport value */
HeapTuple tup;
+ Form_pg_am amform;
IndexAmRoutine *amroutine;
/* Get necessary info about access method */
errmsg("access method \"%s\" does not exist",
stmt->amname)));
- amoid = HeapTupleGetOid(tup);
+ amform = (Form_pg_am) GETSTRUCT(tup);
+ amoid = amform->oid;
amroutine = GetIndexAmRoutineByAmId(amoid, false);
ReleaseSysCache(tup);
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ entryoid = GetNewOidWithIndex(rel, AccessMethodOperatorOidIndexId,
+ Anum_pg_amop_oid);
+ values[Anum_pg_amop_oid - 1] = ObjectIdGetDatum(entryoid);
values[Anum_pg_amop_amopfamily - 1] = ObjectIdGetDatum(opfamilyoid);
values[Anum_pg_amop_amoplefttype - 1] = ObjectIdGetDatum(op->lefttype);
values[Anum_pg_amop_amoprighttype - 1] = ObjectIdGetDatum(op->righttype);
tup = heap_form_tuple(rel->rd_att, values, nulls);
- entryoid = CatalogTupleInsert(rel, tup);
+ CatalogTupleInsert(rel, tup);
heap_freetuple(tup);
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ entryoid = GetNewOidWithIndex(rel, AccessMethodProcedureOidIndexId,
+ Anum_pg_amproc_oid);
+ values[Anum_pg_amproc_oid - 1] = ObjectIdGetDatum(entryoid);
values[Anum_pg_amproc_amprocfamily - 1] = ObjectIdGetDatum(opfamilyoid);
values[Anum_pg_amproc_amproclefttype - 1] = ObjectIdGetDatum(proc->lefttype);
values[Anum_pg_amproc_amprocrighttype - 1] = ObjectIdGetDatum(proc->righttype);
tup = heap_form_tuple(rel->rd_att, values, nulls);
- entryoid = CatalogTupleInsert(rel, tup);
+ CatalogTupleInsert(rel, tup);
heap_freetuple(tup);
Oid amopid;
ObjectAddress object;
- amopid = GetSysCacheOid4(AMOPSTRATEGY,
+ amopid = GetSysCacheOid4(AMOPSTRATEGY, Anum_pg_amop_oid,
ObjectIdGetDatum(opfamilyoid),
ObjectIdGetDatum(op->lefttype),
ObjectIdGetDatum(op->righttype),
Oid amprocid;
ObjectAddress object;
- amprocid = GetSysCacheOid4(AMPROCNUM,
+ amprocid = GetSysCacheOid4(AMPROCNUM, Anum_pg_amproc_oid,
ObjectIdGetDatum(opfamilyoid),
ObjectIdGetDatum(op->lefttype),
ObjectIdGetDatum(op->righttype),
SysScanDesc scan;
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_amop_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(entryOid));
SysScanDesc scan;
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_amproc_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(entryOid));
* Find the policy to delete.
*/
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_policy_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(policy_id));
* Find the policy to update.
*/
ScanKeyInit(&skey[0],
- ObjectIdAttributeNumber ,
+ Anum_pg_policy_oid ,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(policy_id));
errmsg("policy \"%s\" for table \"%s\" already exists",
stmt->policy_name, RelationGetRelationName(target_table))));
+ policy_id = GetNewOidWithIndex(pg_policy_rel, PolicyOidIndexId,
+ Anum_pg_policy_oid);
+ values[Anum_pg_policy_oid - 1] = ObjectIdGetDatum(policy_id);
values[Anum_pg_policy_polrelid - 1] = ObjectIdGetDatum(table_id);
values[Anum_pg_policy_polname - 1] = DirectFunctionCall1(namein,
CStringGetDatum(stmt->policy_name));
policy_tuple = heap_form_tuple(RelationGetDescr(pg_policy_rel), values,
isnull);
- policy_id = CatalogTupleInsert(pg_policy_rel, policy_tuple);
+ CatalogTupleInsert(pg_policy_rel, policy_tuple);
/* Record Dependencies */
target.classId = RelationRelationId;
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("only WITH CHECK expression allowed for INSERT")));
- policy_id = HeapTupleGetOid(policy_tuple) ;
+ policy_id = ((Form_pg_policy) GETSTRUCT(policy_tuple))->oid ;
if (role_ids != NULL)
{
errmsg("policy \"%s\" for table \"%s\" does not exist",
stmt->subname, RelationGetRelationName(target_table))));
- opoloid = HeapTupleGetOid(policy_tuple) ;
+ opoloid = ((Form_pg_policy) GETSTRUCT(policy_tuple))->oid ;
policy_tuple = heap_copytuple(policy_tuple);
CatalogTupleUpdate(pg_policy_rel, &policy_tuple->t_self, policy_tuple);
- InvokeObjectPostAlterHook(PolicyRelationId,
- HeapTupleGetOid(policy_tuple), 0);
+ InvokeObjectPostAlterHook(PolicyRelationId, opoloid, 0);
ObjectAddressSet(address, PolicyRelationId, opoloid);
policy_oid = InvalidOid;
}
else
- policy_oid = HeapTupleGetOid(policy_tuple) ;
+ policy_oid = ((Form_pg_policy) GETSTRUCT(policy_tuple))->oid ;
/* Clean up. */
systable_endscan(sscan);
* build tupdesc for result tuples. This must match the definition of the
* pg_prepared_statements view in system_views.sql
*/
- tupdesc = CreateTemplateTupleDesc(5, false );
+ tupdesc = CreateTemplateTupleDesc(5);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "name",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "statement",
#include "access/genam.h"
#include "access/heapam.h"
#include "access/htup_details.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/objectaccess.h"
NameData langname;
HeapTuple oldtup;
HeapTuple tup;
+ Oid langoid;
bool is_update;
ObjectAddress myself,
referenced;
if (HeapTupleIsValid(oldtup))
{
+ Form_pg_language oldform = (Form_pg_language) GETSTRUCT(oldtup);
+
/* There is one; okay to replace it? */
if (!replace)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("language \"%s\" already exists", languageName)));
- if (!pg_language_ownercheck(HeapTupleGetOid(oldtup) , languageOwner))
+ if (!pg_language_ownercheck(oldform->oid , languageOwner))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_LANGUAGE,
languageName);
/*
- * Do not change existing ownership or permissions. Note
+ * Do not change existing oid, o wnership or permissions. Note
* dependency-update code below has to agree with this decision.
*/
+ replaces[Anum_pg_language_oid - 1] = false;
replaces[Anum_pg_language_lanowner - 1] = false;
replaces[Anum_pg_language_lanacl - 1] = false;
tup = heap_modify_tuple(oldtup, tupDesc, values, nulls, replaces);
CatalogTupleUpdate(rel, &tup->t_self, tup);
+ langoid = oldform->oid;
ReleaseSysCache(oldtup);
is_update = true;
}
else
{
/* Creating a new language */
+ langoid = GetNewOidWithIndex(rel, LanguageOidIndexId,
+ Anum_pg_language_oid);
+ values[Anum_pg_language_oid - 1] = ObjectIdGetDatum(langoid);
tup = heap_form_tuple(tupDesc, values, nulls);
CatalogTupleInsert(rel, tup);
is_update = false;
* shared dependencies do *not* need to change, and we leave them alone.)
*/
myself.classId = LanguageRelationId;
- myself.objectId = HeapTupleGetOid(tup) ;
+ myself.objectId = langoid ;
myself.objectSubId = 0;
if (is_update)
{
Oid oid;
- oid = GetSysCacheOid1(LANGNAME, CStringGetDatum(langname));
+ oid = GetSysCacheOid1(LANGNAME, Anum_pg_language_oid,
+ CStringGetDatum(langname));
if (!OidIsValid(oid) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
rel = heap_open(PublicationRelationId, RowExclusiveLock);
/* Check if name is used */
- puboid = GetSysCacheOid1(PUBLICATIONNAME, CStringGetDatum(stmt->pubname));
+ puboid = GetSysCacheOid1(PUBLICATIONNAME, Anum_pg_publication_oid,
+ CStringGetDatum(stmt->pubname));
if (OidIsValid(puboid))
{
ereport(ERROR,
&publish_update, &publish_delete,
&publish_truncate);
+ puboid = GetNewOidWithIndex(rel, PublicationObjectIndexId,
+ Anum_pg_publication_oid);
+ values[Anum_pg_publication_oid - 1] = ObjectIdGetDatum(puboid);
values[Anum_pg_publication_puballtables - 1] =
BoolGetDatum(stmt->for_all_tables);
values[Anum_pg_publication_pubinsert - 1] =
tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
/* Insert tuple into catalog. */
- puboid = CatalogTupleInsert(rel, tup);
+ CatalogTupleInsert(rel, tup);
heap_freetuple(tup);
recordDependencyOnOwner(PublicationRelationId, puboid, GetUserId());
bool publish_delete;
bool publish_truncate;
ObjectAddress obj;
+ Form_pg_publication pubform;
parse_publication_options(stmt->options,
&publish_given, &publish_insert,
CommandCounterIncrement();
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
+
/* Invalidate the relcache. */
- if (((Form_pg_publication) GETSTRUCT(tup)) ->puballtables)
+ if (pubform ->puballtables)
{
CacheInvalidateRelcacheAll();
}
else
{
- List *relids = GetPublicationRelations(HeapTupleGetOid(tup) );
+ List *relids = GetPublicationRelations(pubform->oid );
/*
* We don't want to send too many individual messages, at some point
CacheInvalidateRelcacheAll();
}
- ObjectAddressSet(obj, PublicationRelationId, HeapTupleGetOid(tup) );
+ ObjectAddressSet(obj, PublicationRelationId, pubform->oid );
EventTriggerCollectSimpleCommand(obj, InvalidObjectAddress,
(Node *) stmt);
- InvokeObjectPostAlterHook(PublicationRelationId, HeapTupleGetOid(tup) , 0);
+ InvokeObjectPostAlterHook(PublicationRelationId, pubform->oid , 0);
}
/*
AlterPublicationTables(AlterPublicationStmt *stmt, Relation rel,
HeapTuple tup)
{
- Oid pubid = HeapTupleGetOid(tup);
List *rels = NIL;
Form_pg_publication pubform = (Form_pg_publication) GETSTRUCT(tup);
+ Oid pubid = pubform->oid;
/* Check that user is allowed to manipulate the publication tables. */
if (pubform->puballtables)
{
Relation rel;
HeapTuple tup;
+ Form_pg_publication pubform;
rel = heap_open(PublicationRelationId, RowExclusiveLock);
errmsg("publication \"%s\" does not exist",
stmt->pubname)));
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
+
/* must be owner */
- if (!pg_publication_ownercheck(HeapTupleGetOid(tup) , GetUserId()))
+ if (!pg_publication_ownercheck(pubform->oid , GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
stmt->pubname);
Relation rel = (Relation) lfirst(lc);
Oid relid = RelationGetRelid(rel);
- prid = GetSysCacheOid2(PUBLICATIONRELMAP, ObjectIdGetDatum(relid),
+ prid = GetSysCacheOid2(PUBLICATIONRELMAP, Anum_pg_publication_rel_oid,
+ ObjectIdGetDatum(relid),
ObjectIdGetDatum(pubid));
if (!OidIsValid(prid))
{
AclResult aclresult;
/* Must be owner */
- if (!pg_publication_ownercheck(HeapTupleGetOid(tup) , GetUserId()))
+ if (!pg_publication_ownercheck(form->oid , GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_PUBLICATION,
NameStr(form->pubname));
/* Update owner dependency reference */
changeDependencyOnOwner(PublicationRelationId,
- HeapTupleGetOid(tup) ,
+ form->oid ,
newOwnerId);
InvokeObjectPostAlterHook(PublicationRelationId,
- HeapTupleGetOid(tup) , 0);
+ form->oid , 0);
}
/*
HeapTuple tup;
Relation rel;
ObjectAddress address;
+ Form_pg_publication pubform;
rel = heap_open(PublicationRelationId, RowExclusiveLock);
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("publication \"%s\" does not exist", name)));
- subid = HeapTupleGetOid(tup);
+ pubform = (Form_pg_publication) GETSTRUCT(tup);
+ subid = pubform->oid;
AlterPublicationOwner_internal(rel, tup, newOwnerId);
Relation rel;
AclResult aclresult;
ObjectAddress address;
+ Form_pg_namespace nspform;
rel = heap_open(NamespaceRelationId, RowExclusiveLock);
(errcode(ERRCODE_UNDEFINED_SCHEMA),
errmsg("schema \"%s\" does not exist", oldname)));
- nspOid = HeapTupleGetOid(tup);
+ nspform = (Form_pg_namespace) GETSTRUCT(tup);
+ nspOid = nspform->oid;
/* make sure the new name doesn't exist */
if (OidIsValid(get_namespace_oid(newname, true)))
errmsg("schema \"%s\" already exists", newname)));
/* must be owner */
- if (!pg_namespace_ownercheck(HeapTupleGetOid(tup) , GetUserId()))
+ if (!pg_namespace_ownercheck(nspOid , GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SCHEMA,
oldname);
errdetail("The prefix \"pg_\" is reserved for system schemas.")));
/* rename */
- namestrcpy(&(((Form_pg_namespace) GETSTRUCT(tup))->nspname) , newname);
+ namestrcpy(&nspform->nspname , newname);
CatalogTupleUpdate(rel, &tup->t_self, tup);
- InvokeObjectPostAlterHook(NamespaceRelationId, HeapTupleGetOid(tup) , 0);
+ InvokeObjectPostAlterHook(NamespaceRelationId, nspOid , 0);
ObjectAddressSet(address, NamespaceRelationId, nspOid);
HeapTuple tup;
Relation rel;
ObjectAddress address;
+ Form_pg_namespace nspform;
rel = heap_open(NamespaceRelationId, RowExclusiveLock);
(errcode(ERRCODE_UNDEFINED_SCHEMA),
errmsg("schema \"%s\" does not exist", name)));
- nspOid = HeapTupleGetOid(tup);
+ nspform = (Form_pg_namespace) GETSTRUCT(tup);
+ nspOid = nspform->oid;
AlterSchemaOwner_internal(tup, rel, newOwnerId);
AclResult aclresult;
/* Otherwise, must be owner of the existing object */
- if (!pg_namespace_ownercheck(HeapTupleGetOid(tup) , GetUserId()))
+ if (!pg_namespace_ownercheck(nspForm->oid , GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SCHEMA,
NameStr(nspForm->nspname));
heap_freetuple(newtuple);
/* Update owner dependency reference */
- changeDependencyOnOwner(NamespaceRelationId, HeapTupleGetOid(tup) ,
+ changeDependencyOnOwner(NamespaceRelationId, nspForm->oid ,
newOwnerId);
}
InvokeObjectPostAlterHook(NamespaceRelationId,
- HeapTupleGetOid(tup) , 0);
+ nspForm->oid , 0);
}
errmsg("permission denied for sequence %s",
get_rel_name(relid))));
- tupdesc = CreateTemplateTupleDesc(7, false );
+ tupdesc = CreateTemplateTupleDesc(7);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "start_value",
INT8OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "minimum_value",
#include "postgres.h"
#include "access/relscan.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
Assert(ntypes > 0 && ntypes <= lengthof(types));
stxkind = construct_array(types, ntypes, CHAROID, 1, true, 'c');
+ statrel = heap_open(StatisticExtRelationId, RowExclusiveLock);
+
/*
* Everything seems fine, so let's build the pg_statistic_ext tuple.
*/
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+
+ statoid = GetNewOidWithIndex(statrel, StatisticExtOidIndexId,
+ Anum_pg_statistic_ext_oid);
+ values[Anum_pg_statistic_ext_oid - 1] = ObjectIdGetDatum(statoid);
values[Anum_pg_statistic_ext_stxrelid - 1] = ObjectIdGetDatum(relid);
values[Anum_pg_statistic_ext_stxname - 1] = NameGetDatum(&stxname);
values[Anum_pg_statistic_ext_stxnamespace - 1] = ObjectIdGetDatum(namespaceId);
nulls[Anum_pg_statistic_ext_stxdependencies - 1] = true;
/* insert it into pg_statistic_ext */
- statrel = heap_open(StatisticExtRelationId, RowExclusiveLock);
htup = heap_form_tuple(statrel->rd_att, values, nulls);
- statoid = CatalogTupleInsert(statrel, htup);
+ CatalogTupleInsert(statrel, htup);
heap_freetuple(htup);
+
relation_close(statrel, RowExclusiveLock);
/*
stxname = makeObjectName(name1, name2, modlabel);
- existingstats = GetSysCacheOid2(STATEXTNAMENSP,
+ existingstats = GetSysCacheOid2(STATEXTNAMENSP, Anum_pg_statistic_ext_oid,
PointerGetDatum(stxname),
ObjectIdGetDatum(namespaceid));
if (!OidIsValid(existingstats))
#include "access/htup_details.h"
#include "access/xact.h"
+#include "catalog/catalog.h"
#include "catalog/dependency.h"
#include "catalog/indexing.h"
#include "catalog/namespace.h"
rel = heap_open(SubscriptionRelationId, RowExclusiveLock);
/* Check if name is used */
- subid = GetSysCacheOid2(SUBSCRIPTIONNAME, MyDatabaseI d,
- CStringGetDatum(stmt->subname));
+ subid = GetSysCacheOid2(SUBSCRIPTIONNAME, Anum_pg_subscription_oi d,
+ MyDatabaseId, CStringGetDatum(stmt->subname));
if (OidIsValid(subid))
{
ereport(ERROR,
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
+ subid = GetNewOidWithIndex(rel, SubscriptionObjectIndexId,
+ Anum_pg_subscription_oid);
+ values[Anum_pg_subscription_oid - 1] = ObjectIdGetDatum(subid);
values[Anum_pg_subscription_subdbid - 1] = ObjectIdGetDatum(MyDatabaseId);
values[Anum_pg_subscription_subname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(stmt->subname));
tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
/* Insert tuple into catalog. */
- subid = CatalogTupleInsert(rel, tup);
+ CatalogTupleInsert(rel, tup);
heap_freetuple(tup);
recordDependencyOnOwner(SubscriptionRelationId, subid, owner);
Oid subid;
bool update_tuple = false;
Subscription *sub;
+ Form_pg_subscription form;
rel = heap_open(SubscriptionRelationId, RowExclusiveLock);
errmsg("subscription \"%s\" does not exist",
stmt->subname)));
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
+
/* must be owner */
- if (!pg_subscription_ownercheck(HeapTupleGetOid(tup) , GetUserId()))
+ if (!pg_subscription_ownercheck(subid , GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
stmt->subname);
- subid = HeapTupleGetOid(tup);
sub = GetSubscription(subid, false);
/* Lock the subscription so nobody else can do anything with it. */
RepOriginId originid;
WalReceiverConn *wrconn = NULL;
StringInfoData cmd;
+ Form_pg_subscription form;
/*
* Lock pg_subscription with AccessExclusiveLock to ensure that the
return;
}
- subid = HeapTupleGetOid(tup);
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
/* must be owner */
if (!pg_subscription_ownercheck(subid, GetUserId()))
if (form->subowner == newOwnerId)
return;
- if (!pg_subscription_ownercheck(HeapTupleGetOid(tup) , GetUserId()))
+ if (!pg_subscription_ownercheck(form->oid , GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, OBJECT_SUBSCRIPTION,
NameStr(form->subname));
/* Update owner dependency reference */
changeDependencyOnOwner(SubscriptionRelationId,
- HeapTupleGetOid(tup) ,
+ form->oid ,
newOwnerId);
InvokeObjectPostAlterHook(SubscriptionRelationId,
- HeapTupleGetOid(tup) , 0);
+ form->oid , 0);
}
/*
HeapTuple tup;
Relation rel;
ObjectAddress address;
+ Form_pg_subscription form;
rel = heap_open(SubscriptionRelationId, RowExclusiveLock);
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("subscription \"%s\" does not exist", name)));
- subid = HeapTupleGetOid(tup);
+ form = (Form_pg_subscription) GETSTRUCT(tup);
+ subid = form->oid;
AlterSubscriptionOwner_internal(rel, tup, newOwnerId);
static void RangeVarCallbackForTruncate(const RangeVar *relation,
Oid relId, Oid oldRelId, void *arg);
static List *MergeAttributes(List *schema, List *supers, char relpersistence,
- bool is_partition, List **supOids, List **supconstr,
- int *supOidCount);
+ bool is_partition, List **supOids, List **supconstr);
static bool MergeCheckConstraint(List *constraints, char *name, Node *expr);
static void MergeAttributesIntoExisting(Relation child_rel, Relation parent_rel);
static void MergeConstraintsIntoExisting(Relation child_rel, Relation parent_rel);
static void ATPrepAddColumn(List **wqueue, Relation rel, bool recurse, bool recursing,
bool is_view, AlterTableCmd *cmd, LOCKMODE lockmode);
static ObjectAddress ATExecAddColumn(List **wqueue, AlteredTableInfo *tab,
- Relation rel, ColumnDef *colDef, bool isOid,
+ Relation rel, ColumnDef *colDef,
bool recurse, bool recursing,
bool if_not_exists, LOCKMODE lockmode);
static bool check_for_column_name_collision(Relation rel, const char *colname,
bool if_not_exists);
static void add_column_datatype_dependency(Oid relid, int32 attnum, Oid typid);
static void add_column_collation_dependency(Oid relid, int32 attnum, Oid collid);
-static void ATPrepAddOids(List **wqueue, Relation rel, bool recurse,
- AlterTableCmd *cmd, LOCKMODE lockmode);
static void ATPrepDropNotNull(Relation rel, bool recurse, bool recursing);
static ObjectAddress ATExecDropNotNull(Relation rel, const char *colName, LOCKMODE lockmode);
static void ATPrepSetNotNull(Relation rel, bool recurse, bool recursing);
TupleDesc descriptor;
List *inheritOids;
List *old_constraints;
- bool localHasOids;
- int parentOidCount;
List *rawDefaults;
List *cookedDefaults;
Datum reloptions;
MergeAttributes(stmt->tableElts, stmt->inhRelations,
stmt->relation->relpersistence,
stmt->partbound != NULL,
- &inheritOids, &old_constraints, &parentOidCount );
+ &inheritOids, &old_constraints);
/*
* Create a tuple descriptor from the relation schema. Note that this
*/
descriptor = BuildDescForRelation(stmt->tableElts);
- /*
- * Notice that we allow OIDs here only for plain tables and partitioned
- * tables, even though some other relkinds can support them. This is
- * necessary because the default_with_oids GUC must apply only to plain
- * tables and not any other relkind; doing otherwise would break existing
- * pg_dump files. We could allow explicit "WITH OIDS" while not allowing
- * default_with_oids to affect other relkinds, but it would complicate
- * interpretOidsOption().
- */
- localHasOids = interpretOidsOption(stmt->options,
- (relkind == RELKIND_RELATION ||
- relkind == RELKIND_PARTITIONED_TABLE));
- descriptor->tdhasoid = (localHasOids || parentOidCount > 0);
-
- /*
- * If a partitioned table doesn't have the system OID column, then none of
- * its partitions should have it.
- */
- if (stmt->partbound && parentOidCount == 0 && localHasOids)
- ereport(ERROR,
- (errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("cannot create table with OIDs as partition of table without OIDs")));
-
/*
* Find columns with default values and prepare for insertion of the
* defaults. Pre-cooked (that is, inherited) defaults go into a list of
stmt->relation->relpersistence,
false,
false,
- localHasOids,
- parentOidCount,
stmt->oncommit,
reloptions,
true,
* 'supOids' receives a list of the OIDs of the parent relations.
* 'supconstr' receives a list of constraints belonging to the parents,
* updated as necessary to be valid for the child.
- * 'supOidCount' is set to the number of parents that have OID columns.
*
* Return value:
* Completed schema list.
*/
static List *
MergeAttributes(List *schema, List *supers, char relpersistence,
- bool is_partition, List **supOids, List **supconstr,
- int *supOidCount)
+ bool is_partition, List **supOids, List **supconstr)
{
ListCell *entry;
List *inhSchema = NIL;
List *parentOids = NIL;
List *constraints = NIL;
- int parentsWithOids = 0;
bool have_bogus_defaults = false;
int child_attno;
static Node bogus_marker = {0}; /* marks conflicting defaults */
parentOids = lappend_oid(parentOids, RelationGetRelid(relation));
- if (relation->rd_rel->relhasoids)
- parentsWithOids++;
-
tupleDesc = RelationGetDescr(relation);
constr = tupleDesc->constr;
*supOids = parentOids;
*supconstr = constraints;
- *supOidCount = parentsWithOids;
return schema;
}
* to SELECT */
case AT_SetTableSpace: /* must rewrite heap */
case AT_AlterColumnType: /* must rewrite heap */
- case AT_AddOids: /* must rewrite heap */
cmd_lockmode = AccessExclusiveLock;
break;
*/
case AT_DropColumn: /* change visible to SELECT */
case AT_AddColumnToView: /* CREATE VIEW */
- case AT_DropOids: /* calls AT_ DropColumn */
+ case AT_DropOids: /* used to equiv to DropColumn */
case AT_EnableAlwaysRule: /* may change SELECT rules */
case AT_EnableReplicaRule: /* may change SELECT rules */
case AT_EnableRule: /* may change SELECT rules */
}
pass = AT_PASS_MISC;
break;
- case AT_AddOids: /* SET WITH OIDS */
- ATSimplePermissions(rel, ATT_TABLE | ATT_FOREIGN_TABLE);
- if (!rel->rd_rel->relhasoids || recursing)
- ATPrepAddOids(wqueue, rel, recurse, cmd, lockmode);
- /* Recursion occurs during execution phase */
- pass = AT_PASS_ADD_COL;
- break;
case AT_DropOids: /* SET WITHOUT OIDS */
ATSimplePermissions(rel, ATT_TABLE | ATT_FOREIGN_TABLE);
- /* Performs own recursion */
- if (rel->rd_rel->relhasoids)
- {
- AlterTableCmd *dropCmd = makeNode(AlterTableCmd);
-
- dropCmd->subtype = AT_DropColumn;
- dropCmd->name = pstrdup("oid");
- dropCmd->behavior = cmd->behavior;
- ATPrepCmd(wqueue, rel, dropCmd, recurse, false, lockmode);
- }
pass = AT_PASS_DROP;
break;
case AT_SetTableSpace: /* SET TABLESPACE */
case AT_AddColumn: /* ADD COLUMN */
case AT_AddColumnToView: /* add column via CREATE OR REPLACE VIEW */
address = ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def,
- false, false, false,
+ false, false,
false, lockmode);
break;
case AT_AddColumnRecurse:
address = ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def,
- false, true, false,
+ true, false,
cmd->missing_ok, lockmode);
break;
case AT_ColumnDefault: /* ALTER COLUMN DEFAULT */
case AT_SetLogged: /* SET LOGGED */
case AT_SetUnLogged: /* SET UNLOGGED */
break;
- case AT_AddOids: /* SET WITH OIDS */
- /* Use the ADD COLUMN code, unless prep decided to do nothing */
- if (cmd->def != NULL)
- address =
- ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def,
- true, false, false,
- cmd->missing_ok, lockmode);
- break;
- case AT_AddOidsRecurse: /* SET WITH OIDS */
- /* Use the ADD COLUMN code, unless prep decided to do nothing */
- if (cmd->def != NULL)
- address =
- ATExecAddColumn(wqueue, tab, rel, (ColumnDef *) cmd->def,
- true, true, false,
- cmd->missing_ok, lockmode);
- break;
case AT_DropOids: /* SET WITHOUT OIDS */
-
- /*
- * Nothing to do here; we'll have generated a DropColumn
- * subcommand to do the real work
- */
+ /* nothing to do here, oid columns don't exist anymore */
break;
case AT_SetTableSpace: /* SET TABLESPACE */
/*
{
if (tab->rewrite > 0)
{
- Oid tupOid = InvalidOid;
-
/* Extract data from old tuple */
heap_deform_tuple(tuple, oldTupDesc, values, isnull);
- if (oldTupDesc->tdhasoid)
- tupOid = HeapTupleGetOid(tuple);
/* Set dropped attributes to null in new tuple */
foreach(lc, dropped_attrs)
*/
tuple = heap_form_tuple(newTupDesc, values, isnull);
- /* Preserve OID, if any */
- if (newTupDesc->tdhasoid)
- HeapTupleSetOid(tuple, tupOid);
-
/*
* Constraints might reference the tableoid column, so
* initialize t_tableOid before evaluating them.
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
+ Form_pg_class classform = (Form_pg_class) GETSTRUCT(tuple);
+
if (behavior == DROP_RESTRICT)
ereport(ERROR,
(errcode(ERRCODE_DEPENDENT_OBJECTS_STILL_EXIST),
typeName),
errhint("Use ALTER ... CASCADE to alter the typed tables too.")));
else
- result = lappend_oid(result, HeapTupleGetOid(tuple) );
+ result = lappend_oid(result, classform->oid );
}
heap_endscan(scan);
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("type %s is not a composite type",
- format_type_be(HeapTupleGetOid(typetuple) ))));
+ format_type_be(typ->oid ))));
}
*/
static ObjectAddress
ATExecAddColumn(List **wqueue, AlteredTableInfo *tab, Relation rel,
- ColumnDef *colDef, bool isOid,
+ ColumnDef *colDef,
bool recurse, bool recursing,
bool if_not_exists, LOCKMODE lockmode)
{
get_collation_name(ccollid),
get_collation_name(childatt->attcollation))));
- /* If it's OID, child column must actually be OID */
- if (isOid && childatt->attnum != ObjectIdAttributeNumber)
- ereport(ERROR,
- (errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("child table \"%s\" has a conflicting \"%s\" column",
- RelationGetRelationName(rel), colDef->colname)));
-
/* Bump the existing child att's inhcount */
childatt->attinhcount++;
CatalogTupleUpdate(attrdesc, &tuple->t_self, tuple);
}
/* Determine the new attribute's number */
- if (isOid)
- newattnum = ObjectIdAttributeNumber;
- else
- {
- newattnum = ((Form_pg_class) GETSTRUCT(reltup))->relnatts + 1;
- if (newattnum > MaxHeapAttributeNumber)
- ereport(ERROR,
- (errcode(ERRCODE_TOO_MANY_COLUMNS),
- errmsg("tables can have at most %d columns",
- MaxHeapAttributeNumber)));
- }
+ newattnum = ((Form_pg_class) GETSTRUCT(reltup))->relnatts + 1;
+ if (newattnum > MaxHeapAttributeNumber)
+ ereport(ERROR,
+ (errcode(ERRCODE_TOO_MANY_COLUMNS),
+ errmsg("tables can have at most %d columns",
+ MaxHeapAttributeNumber)));
typeTuple = typenameType(NULL, colDef->typeName, &typmod);
tform = (Form_pg_type) GETSTRUCT(typeTuple);
- typeOid = HeapTupleGetOid(typeTuple) ;
+ typeOid = tform->oid ;
aclresult = pg_type_aclcheck(typeOid, GetUserId(), ACL_USAGE);
if (aclresult != ACLCHECK_OK)
/*
* Update pg_class tuple as appropriate
*/
- if (isOid)
- ((Form_pg_class) GETSTRUCT(reltup))->relhasoids = true;
- else
- ((Form_pg_class) GETSTRUCT(reltup))->relnatts = newattnum;
+ ((Form_pg_class) GETSTRUCT(reltup))->relnatts = newattnum;
CatalogTupleUpdate(pgclass, &reltup->t_self, reltup);
}
}
- /*
- * If we are adding an OID column, we have to tell Phase 3 to rewrite the
- * table to fix that.
- */
- if (isOid)
- tab->rewrite |= AT_REWRITE_ALTER_OID;
-
/*
* Add needed dependency entries for the new column.
*/
/* Recurse to child; return value is ignored */
ATExecAddColumn(wqueue, childtab, childrel,
- colDef, isOid, recurse, true,
+ colDef, recurse, true,
if_not_exists, lockmode);
heap_close(childrel, NoLock);
}
}
-/*
- * ALTER TABLE SET WITH OIDS
- *
- * Basically this is an ADD COLUMN for the special OID column. We have
- * to cons up a ColumnDef node because the ADD COLUMN code needs one.
- */
-static void
-ATPrepAddOids(List **wqueue, Relation rel, bool recurse, AlterTableCmd *cmd, LOCKMODE lockmode)
-{
- /* If we're recursing to a child table, the ColumnDef is already set up */
- if (cmd->def == NULL)
- {
- ColumnDef *cdef = makeNode(ColumnDef);
-
- cdef->colname = pstrdup("oid");
- cdef->typeName = makeTypeNameFromOid(OIDOID, -1);
- cdef->inhcount = 0;
- cdef->is_local = true;
- cdef->is_not_null = true;
- cdef->storage = 0;
- cdef->location = -1;
- cmd->def = (Node *) cdef;
- }
- ATPrepAddColumn(wqueue, rel, recurse, false, false, cmd, lockmode);
-
- if (recurse)
- cmd->subtype = AT_AddOidsRecurse;
-}
-
/*
* ALTER TABLE ALTER COLUMN DROP NOT NULL
*
attnum = targetatt->attnum;
- /* Can't drop a system attribute, except OID */
- if (attnum <= 0 && attnum != ObjectIdAttributeNumber )
+ /* Can't drop a system attribute */
+ if (attnum <= 0)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot drop system column \"%s\"",
performDeletion(&object, behavior, 0);
- /*
- * If we dropped the OID column, must adjust pg_class.relhasoids and tell
- * Phase 3 to physically get rid of the column. We formerly left the
- * column in place physically, but this caused subtle problems. See
- * http://archives.postgresql.org/pgsql-hackers/2009-02/msg00363.php
- */
- if (attnum == ObjectIdAttributeNumber)
- {
- Relation class_rel;
- Form_pg_class tuple_class;
- AlteredTableInfo *tab;
-
- class_rel = heap_open(RelationRelationId, RowExclusiveLock);
-
- tuple = SearchSysCacheCopy1(RELOID,
- ObjectIdGetDatum(RelationGetRelid(rel)));
- if (!HeapTupleIsValid(tuple))
- elog(ERROR, "cache lookup failed for relation %u",
- RelationGetRelid(rel));
- tuple_class = (Form_pg_class) GETSTRUCT(tuple);
-
- tuple_class->relhasoids = false;
- CatalogTupleUpdate(class_rel, &tuple->t_self, tuple);
-
- heap_close(class_rel, RowExclusiveLock);
-
- /* Find or create work queue entry for this table */
- tab = ATGetQueueEntry(wqueue, rel);
-
- /* Tell Phase 3 to physically remove the OID column */
- tab->rewrite |= AT_REWRITE_ALTER_OID;
- }
-
return object;
}
CatalogTupleUpdate(conrel, ©Tuple->t_self, copyTuple);
InvokeObjectPostAlterHook(ConstraintRelationId,
- HeapTupleGetOid(contuple) , 0);
+ currcon->oid , 0);
heap_freetuple(copyTuple);
ScanKeyInit(&tgkey,
Anum_pg_trigger_tgconstraint,
BTEqualStrategyNumber, F_OIDEQ,
- ObjectIdGetDatum(HeapTupleGetOid(contuple) ));
+ ObjectIdGetDatum(currcon->oid ));
tgscan = systable_beginscan(tgrel, TriggerConstraintIndexId, true,
NULL, 1, &tgkey);
copy_tg->tginitdeferred = cmdcon->initdeferred;
CatalogTupleUpdate(tgrel, ©Tuple->t_self, copyTuple);
- InvokeObjectPostAlterHook(TriggerRelationId,
- HeapTupleGetOid(tgtuple), 0);
+ InvokeObjectPostAlterHook(TriggerRelationId, currcon->oid, 0);
heap_freetuple(copyTuple);
}
CacheInvalidateRelcacheByRelid(lfirst_oid(lc));
}
- ObjectAddressSet(address, ConstraintRelationId,
- HeapTupleGetOid(contuple));
+ ObjectAddressSet(address, ConstraintRelationId, currcon->oid);
}
else
address = InvalidObjectAddress;
validateForeignKeyConstraint(constrName, rel, refrel,
con->conindid,
- HeapTupleGetOid(tuple) );
+ con->oid );
heap_close(refrel, NoLock);
/*
copy_con->convalidated = true;
CatalogTupleUpdate(conrel, ©Tuple->t_self, copyTuple);
- InvokeObjectPostAlterHook(ConstraintRelationId,
- HeapTupleGetOid(tuple), 0);
+ InvokeObjectPostAlterHook(ConstraintRelationId, con->oid, 0);
heap_freetuple(copyTuple);
- ObjectAddressSet(address, ConstraintRelationId,
- HeapTupleGetOid(tuple));
+ ObjectAddressSet(address, ConstraintRelationId, con->oid);
}
else
address = InvalidObjectAddress; /* already validated */
&isnull);
if (isnull)
elog(ERROR, "null conbin for constraint %u",
- HeapTupleGetOid(constrtup) );
+ constrForm->oid );
conbin = TextDatumGetCString(val);
origexpr = (Expr *) stringToNode(conbin);
exprstate = ExecPrepareExpr(origexpr, estate);
* Perform the actual constraint deletion
*/
conobj.classId = ConstraintRelationId;
- conobj.objectId = HeapTupleGetOid(tuple) ;
+ conobj.objectId = con->oid ;
conobj.objectSubId = 0;
performDeletion(&conobj, behavior, 0);
/* Look up the target type (should not fail, since prep found it) */
typeTuple = typenameType(NULL, typeName, &targettypmod);
tform = (Form_pg_type) GETSTRUCT(typeTuple);
- targettype = HeapTupleGetOid(typeTuple) ;
+ targettype = tform->oid ;
/* And the collation */
targetcollid = GetColumnDefCollation(NULL, def, targettype);
scan = heap_beginscan_catalog(rel, 1, key);
while ((tuple = heap_getnext(scan, ForwardScanDirection)) != NULL)
{
- Oid relOid = HeapTupleGetOid(tuple);
- Form_pg_class relForm;
-
- relForm = (Form_pg_class) GETSTRUCT(tuple);
+ Form_pg_class relForm = (Form_pg_class) GETSTRUCT(tuple);
+ Oid relOid = relForm->oid;
/*
* Do not move objects in pg_catalog as part of this, if an admin
parent->relname,
RelationGetRelationName(child_rel))));
- /* If parent has OIDs then child must have OIDs */
- if (parent_rel->rd_rel->relhasoids && !child_rel->rd_rel->relhasoids)
- ereport(ERROR,
- (errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("table \"%s\" without OIDs cannot inherit from table \"%s\" with OIDs",
- RelationGetRelationName(child_rel),
- RelationGetRelationName(parent_rel))));
-
/*
* If child_rel has row-level triggers with transition tables, we
* currently don't allow it to become an inheritance child. See also
con = (Form_pg_constraint) GETSTRUCT(contup);
attr = heap_getattr(contup, Anum_pg_constraint_conbin, tupdesc, &isnull);
if (isnull)
- elog(ERROR, "null conbin for constraint %u", HeapTupleGetOid(contup) );
+ elog(ERROR, "null conbin for constraint %u", con->oid );
expr = DirectFunctionCall2(pg_get_expr, attr,
ObjectIdGetDatum(con->conrelid));
}
}
- /*
- * If the parent has an OID column, so must the child, and we'd better
- * update the child's attinhcount and attislocal the same as for normal
- * columns. We needn't check data type or not-nullness though.
- */
- if (tupleDesc->tdhasoid)
- {
- /*
- * Here we match by column number not name; the match *must* be the
- * system column, not some random column named "oid".
- */
- tuple = SearchSysCacheCopy2(ATTNUM,
- ObjectIdGetDatum(RelationGetRelid(child_rel)),
- Int16GetDatum(ObjectIdAttributeNumber));
- if (HeapTupleIsValid(tuple))
- {
- Form_pg_attribute childatt = (Form_pg_attribute) GETSTRUCT(tuple);
-
- /* See comments above; these changes should be the same */
- childatt->attinhcount++;
-
- if (child_is_partition)
- {
- Assert(childatt->attinhcount == 1);
- childatt->attislocal = false;
- }
-
- CatalogTupleUpdate(attrrel, &tuple->t_self, tuple);
- heap_freetuple(tuple);
- }
- else
- {
- ereport(ERROR,
- (errcode(ERRCODE_DATATYPE_MISMATCH),
- errmsg("child table is missing column \"%s\"",
- "oid")));
- }
- }
-
heap_close(attrrel, RowExclusiveLock);
}
{
Oid relid = RelationGetRelid(rel);
Type typetuple;
+ Form_pg_type typeform;
Oid typeid;
Relation inheritsRelation,
relationRelation;
/* Validate the type. */
typetuple = typenameType(NULL, ofTypename, NULL);
check_of_type(typetuple);
- typeid = HeapTupleGetOid(typetuple);
+ typeform = (Form_pg_type) GETSTRUCT(typetuple);
+ typeid = typeform->oid;
/* Fail if the table has any inheritance parents. */
inheritsRelation = heap_open(InheritsRelationId, AccessShareLock);
/*
* Check the tuple descriptors for compatibility. Unlike inheritance, we
* require that the order also match. However, attnotnull need not match.
- * Also unlike inheritance, we do not require matching relhasoids.
*/
typeTupleDesc = lookup_rowtype_tupdesc(typeid, -1);
tableTupleDesc = RelationGetDescr(rel);
int16 attno = indexRel->rd_index->indkey.values[key];
Form_pg_attribute attr;
- /* Allow OID column to be indexed; it's certainly not nullable */
- if (attno == ObjectIdAttributeNumber)
- continue;
-
/*
* Reject any other system columns. (Going forward, we'll disallow
* indexes containing such columns in the first place, but they might
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("cannot attach temporary relation of another session as partition")));
- /* If parent has OIDs then child must have OIDs */
- if (rel->rd_rel->relhasoids && !attachrel->rd_rel->relhasoids)
- ereport(ERROR,
- (errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("cannot attach table \"%s\" without OIDs as partition of"
- " table \"%s\" with OIDs", RelationGetRelationName(attachrel),
- RelationGetRelationName(rel))));
-
- /* OTOH, if parent doesn't have them, do not allow in attachrel either */
- if (attachrel->rd_rel->relhasoids && !rel->rd_rel->relhasoids)
- ereport(ERROR,
- (errcode(ERRCODE_WRONG_OBJECT_TYPE),
- errmsg("cannot attach table \"%s\" with OIDs as partition of table"
- " \"%s\" without OIDs", RelationGetRelationName(attachrel),
- RelationGetRelationName(rel))));
-
/* Check if there are any columns in attachrel that aren't in the parent */
tupleDesc = RelationGetDescr(attachrel);
natts = tupleDesc->natts;
CreateTrigger(trigStmt, NULL, RelationGetRelid(partition),
trigForm->tgconstrrelid, InvalidOid, InvalidOid,
- trigForm->tgfoid, HeapTupleGetOid(tuple) , qual,
+ trigForm->tgfoid, trigForm->oid , qual,
false, true);
MemoryContextReset(perTupCxt);
MemSet(nulls, false, sizeof(nulls));
+ tablespaceoid = GetNewOidWithIndex(rel, TablespaceOidIndexId,
+ Anum_pg_tablespace_oid);
+ values[Anum_pg_tabl
projects / postgresql.git / commitdiff