本文整理汇总了C++中RelationGetRelid函数的典型用法代码示例。如果您正苦于以下问题:C++ RelationGetRelid函数的具体用法?C++ RelationGetRelid怎么用?C++ RelationGetRelid使用的例子?那么, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了RelationGetRelid函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: RelationInitLockInfo
/*
* RelationInitLockInfo
* Initializes the lock information in a relation descriptor.
*
* relcache.c must call this during creation of any reldesc.
*/
void
RelationInitLockInfo(Relation relation)
{
Assert(RelationIsValid(relation));
Assert(OidIsValid(RelationGetRelid(relation)));
relation->rd_lockInfo.lockRelId.relId = RelationGetRelid(relation);
if (relation->rd_rel->relisshared)
relation->rd_lockInfo.lockRelId.dbId = InvalidOid;
else
relation->rd_lockInfo.lockRelId.dbId = MyDatabaseId;
}
示例2: hashbuild
/*
* hashbuild() -- build a new hash index.
*
* We use a global variable to record the fact that we're creating
* a new index. This is used to avoid high-concurrency locking,
* since the index won't be visible until this transaction commits
* and since building is guaranteed to be single-threaded.
*/
Datum
hashbuild(PG_FUNCTION_ARGS)
{
Relation heap = (Relation) PG_GETARG_POINTER(0);
Relation index = (Relation) PG_GETARG_POINTER(1);
IndexInfo *indexInfo = (IndexInfo *) PG_GETARG_POINTER(2);
double reltuples;
HashBuildState buildstate;
/*
* We expect to be called exactly once for any index relation. If
* that's not the case, big trouble's what we have.
*/
if (RelationGetNumberOfBlocks(index) != 0)
elog(ERROR, "index \"%s\" already contains data",
RelationGetRelationName(index));
/* initialize the hash index metadata page */
_hash_metapinit(index);
/* build the index */
buildstate.indtuples = 0;
/* do the heap scan */
reltuples = IndexBuildHeapScan(heap, index, indexInfo,
hashbuildCallback, (void *) &buildstate);
/*
* Since we just counted the tuples in the heap, we update its stats
* in pg_class to guarantee that the planner takes advantage of the
* index we just created. But, only update statistics during normal
* index definitions, not for indices on system catalogs created
* during bootstrap processing. We must close the relations before
* updating statistics to guarantee that the relcache entries are
* flushed when we increment the command counter in UpdateStats(). But
* we do not release any locks on the relations; those will be held
* until end of transaction.
*/
if (IsNormalProcessingMode())
{
Oid hrelid = RelationGetRelid(heap);
Oid irelid = RelationGetRelid(index);
heap_close(heap, NoLock);
index_close(index);
UpdateStats(hrelid, reltuples);
UpdateStats(irelid, buildstate.indtuples);
}
PG_RETURN_VOID();
}
示例3: IsErrorTable
/*
* IsErrorTable
*
* Returns true if relid is used as an error table, which has dependent object
* that is an external table. Though it's not great we didn't have a clear
* definition of Error Table, it satisfies the current requirements.
*/
bool
IsErrorTable(Relation rel)
{
cqContext *pcqCtx, *pcqCtxExt, ctxExt;
HeapTuple tup;
Relation extrel;
bool result = false;
/* fast path to quick check */
if (!RelationIsHeap(rel))
return false;
/*
* Otherwise, go deeper and play with pg_depend...
*/
pcqCtx = caql_beginscan(NULL,
cql("SELECT * FROM pg_depend "
" WHERE refclassid = :1 "
" AND refobjid = :2 "
" AND refobjsubid = :3 ",
ObjectIdGetDatum(RelationRelationId),
ObjectIdGetDatum(RelationGetRelid(rel)),
Int32GetDatum(0)));
extrel = relation_open(ExtTableRelationId, AccessShareLock);
pcqCtxExt = caql_addrel(cqclr(&ctxExt), extrel);
while (HeapTupleIsValid(tup = caql_getnext(pcqCtx)))
{
Form_pg_depend dep = (Form_pg_depend) GETSTRUCT(tup);
Oid fmterrtbl;
fmterrtbl = caql_getoid(pcqCtxExt,
cql("SELECT fmterrtbl FROM pg_exttable "
" WHERE reloid = :1",
ObjectIdGetDatum(dep->objid)));
if (RelationGetRelid(rel) == fmterrtbl)
{
result = true;
break;
}
}
relation_close(extrel, AccessShareLock);
caql_endscan(pcqCtx);
return result;
}
示例4: UpdateRelationRelation
/* ----------------------------------------------------------------
* UpdateRelationRelation
* ----------------------------------------------------------------
*/
static void
UpdateRelationRelation(Relation indexRelation)
{
Relation pg_class;
HeapTuple tuple;
pg_class = heap_openr(RelationRelationName, RowExclusiveLock);
/* XXX Natts_pg_class_fixed is a hack - see pg_class.h */
tuple = heap_addheader(Natts_pg_class_fixed,
true,
CLASS_TUPLE_SIZE,
(void *) indexRelation->rd_rel);
/*
* the new tuple must have the oid already chosen for the index. sure
* would be embarrassing to do this sort of thing in polite company.
*/
HeapTupleSetOid(tuple, RelationGetRelid(indexRelation));
simple_heap_insert(pg_class, tuple);
/* update the system catalog indexes */
CatalogUpdateIndexes(pg_class, tuple);
heap_freetuple(tuple);
heap_close(pg_class, RowExclusiveLock);
}
示例5: create_estate_for_relation
/*
* Executor state preparation for evaluation of constraint expressions,
* indexes and triggers.
*
* This is based on similar code in copy.c
*/
static EState *
create_estate_for_relation(LogicalRepRelMapEntry *rel)
{
EState *estate;
ResultRelInfo *resultRelInfo;
RangeTblEntry *rte;
estate = CreateExecutorState();
rte = makeNode(RangeTblEntry);
rte->rtekind = RTE_RELATION;
rte->relid = RelationGetRelid(rel->localrel);
rte->relkind = rel->localrel->rd_rel->relkind;
estate->es_range_table = list_make1(rte);
resultRelInfo = makeNode(ResultRelInfo);
InitResultRelInfo(resultRelInfo, rel->localrel, 1, NULL, 0);
estate->es_result_relations = resultRelInfo;
estate->es_num_result_relations = 1;
estate->es_result_relation_info = resultRelInfo;
estate->es_output_cid = GetCurrentCommandId(true);
/* Triggers might need a slot */
if (resultRelInfo->ri_TrigDesc)
estate->es_trig_tuple_slot = ExecInitExtraTupleSlot(estate, NULL);
/* Prepare to catch AFTER triggers. */
AfterTriggerBeginQuery();
return estate;
}
示例6: ForeignNext
/* ----------------------------------------------------------------
* ForeignNext
*
* This is a workhorse for ExecForeignScan
* ----------------------------------------------------------------
*/
static TupleTableSlot *
ForeignNext(ForeignScanState *node)
{
TupleTableSlot *slot;
ForeignScan *plan = (ForeignScan *) node->ss.ps.plan;
ExprContext *econtext = node->ss.ps.ps_ExprContext;
MemoryContext oldcontext;
/* Call the Iterate function in short-lived context */
oldcontext = MemoryContextSwitchTo(econtext->ecxt_per_tuple_memory);
slot = node->fdwroutine->IterateForeignScan(node);
MemoryContextSwitchTo(oldcontext);
/*
* If any system columns are requested, we have to force the tuple into
* physical-tuple form to avoid "cannot extract system attribute from
* virtual tuple" errors later. We also insert a valid value for
* tableoid, which is the only actually-useful system column.
*/
if (plan->fsSystemCol && !TupIsNull(slot))
{
HeapTuple tup = ExecMaterializeSlot(slot);
tup->t_tableOid = RelationGetRelid(node->ss.ss_currentRelation);
}
return slot;
}
示例7: pglogical_write_rel
/*
* Write relation description to the output stream.
*/
static void
pglogical_write_rel(StringInfo out, PGLogicalOutputData *data, Relation rel)
{
const char *nspname;
uint8 nspnamelen;
const char *relname;
uint8 relnamelen;
Oid relid;
if (MtmIsFilteredTxn) {
return;
}
relid = RelationGetRelid(rel);
pq_sendbyte(out, 'R'); /* sending RELATION */
pq_sendint(out, relid, sizeof relid); /* use Oid as relation identifier */
nspname = get_namespace_name(rel->rd_rel->relnamespace);
if (nspname == NULL)
elog(ERROR, "cache lookup failed for namespace %u",
rel->rd_rel->relnamespace);
nspnamelen = strlen(nspname) + 1;
relname = NameStr(rel->rd_rel->relname);
relnamelen = strlen(relname) + 1;
pq_sendbyte(out, nspnamelen); /* schema name length */
pq_sendbytes(out, nspname, nspnamelen);
pq_sendbyte(out, relnamelen); /* table name length */
pq_sendbytes(out, relname, relnamelen);
}
示例8: get_object_address_attribute
/*
* Find the ObjectAddress for an attribute.
*/
static ObjectAddress
get_object_address_attribute(ObjectType objtype, List *objname,
Relation *relp, LOCKMODE lockmode)
{
ObjectAddress address;
List *relname;
Oid reloid;
Relation relation;
const char *attname;
/* Extract relation name and open relation. */
attname = strVal(lfirst(list_tail(objname)));
relname = list_truncate(list_copy(objname), list_length(objname) - 1);
relation = relation_openrv(makeRangeVarFromNameList(relname), lockmode);
reloid = RelationGetRelid(relation);
/* Look up attribute and construct return value. */
address.classId = RelationRelationId;
address.objectId = reloid;
address.objectSubId = get_attnum(reloid, attname);
if (address.objectSubId == InvalidAttrNumber)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_COLUMN),
errmsg("column \"%s\" of relation \"%s\" does not exist",
attname, RelationGetRelationName(relation))));
*relp = relation;
return address;
}
示例9: brinvacuumcleanup
/*
* This routine is in charge of "vacuuming" a BRIN index: we just summarize
* ranges that are currently unsummarized.
*/
Datum
brinvacuumcleanup(PG_FUNCTION_ARGS)
{
IndexVacuumInfo *info = (IndexVacuumInfo *) PG_GETARG_POINTER(0);
IndexBulkDeleteResult *stats =
(IndexBulkDeleteResult *) PG_GETARG_POINTER(1);
Relation heapRel;
/* No-op in ANALYZE ONLY mode */
if (info->analyze_only)
PG_RETURN_POINTER(stats);
if (!stats)
stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
stats->num_pages = RelationGetNumberOfBlocks(info->index);
/* rest of stats is initialized by zeroing */
heapRel = heap_open(IndexGetRelation(RelationGetRelid(info->index), false),
AccessShareLock);
brinsummarize(info->index, heapRel,
&stats->num_index_tuples, &stats->num_index_tuples);
heap_close(heapRel, AccessShareLock);
PG_RETURN_POINTER(stats);
}
示例10: parquet_insert_init
/**
* Initialize and get ready for inserting values into the parquet table. If the
* parquet insert descriptor is not created, NULL is returned.
*
* @rel the relation to insert
* @segno the segment number
*/
ParquetInsertDesc parquet_insert_init(Relation rel, ResultRelSegFileInfo *segfileinfo) {
ParquetInsertDesc parquetInsertDesc = NULL;
AppendOnlyEntry *aoentry = NULL;
MemoryContext oldMemoryContext = NULL;
StringInfoData titleBuf;
int relNameLen = 0;
/*
* Get the pg_appendonly information for this table
*/
aoentry = GetAppendOnlyEntry(RelationGetRelid(rel), SnapshotNow);
/* The parquet entry must exist and is at right version. The version number
is hard coded when the entry is created. */
Assert(aoentry != NULL);
Assert(aoentry->majorversion == 1 && aoentry->minorversion == 0);
parquetInsertDesc = (ParquetInsertDesc) palloc0(sizeof(ParquetInsertDescData));
parquetInsertDesc->memoryContext = CurrentMemoryContext;
oldMemoryContext = MemoryContextSwitchTo(parquetInsertDesc->memoryContext);
parquetInsertDesc->parquet_rel = rel;
relNameLen = strlen(rel->rd_rel->relname.data);
parquetInsertDesc->relname = (char*)palloc0(relNameLen + 1);
memcpy(parquetInsertDesc->relname, rel->rd_rel->relname.data, relNameLen);
parquetInsertDesc->parquetMetaDataSnapshot = SnapshotNow;
parquetInsertDesc->parquet_file = -1;
parquetInsertDesc->parquetFilePathNameMaxLen = AOSegmentFilePathNameLen(rel) + 1;
parquetInsertDesc->parquetFilePathName =
(char*) palloc0(parquetInsertDesc->parquetFilePathNameMaxLen);
parquetInsertDesc->parquetFilePathName[0] = '\0';
parquetInsertDesc->footerProtocol = NULL;
Assert(segfileinfo->segno >= 0);
parquetInsertDesc->cur_segno = segfileinfo->segno;
parquetInsertDesc->aoEntry = aoentry;
parquetInsertDesc->insertCount = 0;
initStringInfo(&titleBuf);
appendStringInfo(&titleBuf, "Write of Parquet relation '%s'",
RelationGetRelationName(parquetInsertDesc->parquet_rel));
parquetInsertDesc->title = titleBuf.data;
parquetInsertDesc->mirroredOpen = (MirroredAppendOnlyOpen *)
palloc0(sizeof(MirroredAppendOnlyOpen));
parquetInsertDesc->mirroredOpen->isActive = FALSE;
parquetInsertDesc->mirroredOpen->segmentFileNum = 0;
parquetInsertDesc->mirroredOpen->primaryFile = -1;
parquetInsertDesc->previous_rowgroupcnt = 0;
/* open our current relation file segment for write */
SetCurrentFileSegForWrite(parquetInsertDesc, segfileinfo);
/* Allocation is done. Go back to caller memory-context. */
MemoryContextSwitchTo(oldMemoryContext);
return parquetInsertDesc;
}
示例11: AddDefaultRelationAttributeOptions
/*
* Given a WITH(...) clause and no other column encoding directives -- such as
* in the case of CREATE TABLE WITH () AS SELECT -- fill in the column encoding
* catalog entries for that relation.
*/
void
AddDefaultRelationAttributeOptions(Relation rel, List *options)
{
Datum opts;
AttrNumber attno;
List *ce;
/* only supported on AOCO at this stage */
if (true)
return;
ce = form_default_storage_directive(options);
if (!ce)
ce = default_column_encoding_clause();
ce = transformStorageEncodingClause(ce);
opts = transformRelOptions(PointerGetDatum(NULL), ce, true, false);
for (attno = 1; attno <= RelationGetNumberOfAttributes(rel); attno++)
add_attribute_encoding_entry(RelationGetRelid(rel),
attno,
opts);
CommandCounterIncrement();
}
示例12: OpenErrorTable
/*
* OpenErrorTable
*
* Open the error table for this operation, and perform all necessary checks.
*/
void OpenErrorTable(CdbSreh *cdbsreh, RangeVar *errortable)
{
AclResult aclresult;
AclMode required_access = ACL_INSERT;
Oid relOid;
/* Open and lock the error relation, using the appropriate lock type. */
cdbsreh->errtbl = heap_openrv(errortable, RowExclusiveLock);
relOid = RelationGetRelid(cdbsreh->errtbl);
/* Check relation permissions. */
aclresult = pg_class_aclcheck(relOid,
GetUserId(),
required_access);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_CLASS,
RelationGetRelationName(cdbsreh->errtbl));
/* check read-only transaction */
if (XactReadOnly &&
!isTempNamespace(RelationGetNamespace(cdbsreh->errtbl)))
ereport(ERROR,
(errcode(ERRCODE_READ_ONLY_SQL_TRANSACTION),
errmsg("transaction is read-only")));
/* make sure this is a regular relation */
if (cdbsreh->errtbl->rd_rel->relkind != RELKIND_RELATION)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("\"%s\" exists in the database but is a non table relation",
RelationGetRelationName(cdbsreh->errtbl))));
}
示例13: AlterConversionOwner_internal
/*
* AlterConversionOwner_internal
*
* Internal routine for changing the owner. rel must be pg_conversion, already
* open and suitably locked; it will not be closed.
*/
static void
AlterConversionOwner_internal(Relation rel, Oid conversionOid, Oid newOwnerId)
{
Form_pg_conversion convForm;
HeapTuple tup;
Assert(RelationGetRelid(rel) == ConversionRelationId);
tup = SearchSysCacheCopy(CONOID,
ObjectIdGetDatum(conversionOid),
0, 0, 0);
if (!HeapTupleIsValid(tup)) /* should not happen */
elog(ERROR, "cache lookup failed for conversion %u", conversionOid);
convForm = (Form_pg_conversion) GETSTRUCT(tup);
/*
* If the new owner is the same as the existing owner, consider the
* command to have succeeded. This is for dump restoration purposes.
*/
if (convForm->conowner != newOwnerId)
{
AclResult aclresult;
/* Superusers can always do it */
if (!superuser())
{
/* Otherwise, must be owner of the existing object */
if (!pg_conversion_ownercheck(HeapTupleGetOid(tup), GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_CONVERSION,
NameStr(convForm->conname));
/* Must be able to become new owner */
check_is_member_of_role(GetUserId(), newOwnerId);
/* New owner must have CREATE privilege on namespace */
aclresult = pg_namespace_aclcheck(convForm->connamespace,
newOwnerId,
ACL_CREATE);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_NAMESPACE,
get_namespace_name(convForm->connamespace));
}
/*
* Modify the owner --- okay to scribble on tup because it's a copy
*/
convForm->conowner = newOwnerId;
simple_heap_update(rel, &tup->t_self, tup);
CatalogUpdateIndexes(rel, tup);
/* Update owner dependency reference */
changeDependencyOnOwner(ConversionRelationId, conversionOid,
newOwnerId);
}
heap_freetuple(tup);
}
示例14: AppendOnlyCompaction_IsRelationEmpty
/*
* Returns true if the relation has no tuples. Prepare phase of
* compaction invokes this function on each QE.
*
* Examples of empty tables:
* 1. parent of a partitioned table
* 2. table that is created but no tuples have been inserted yet
* 3. table from which all existing tuples are deleted and the table
* is vacuumed. This is a special case in which pg_aoseg_<oid> has
* non-zero number of rows but tupcount value is zero for all rows.
*/
bool
AppendOnlyCompaction_IsRelationEmpty(Relation aorel)
{
AppendOnlyEntry *aoEntry;
Relation pg_aoseg_rel;
TupleDesc pg_aoseg_dsc;
HeapTuple tuple;
HeapScanDesc aoscan;
int Anum_tupcount;
bool empty = true;
Assert(RelationIsAoRows(aorel) || RelationIsAoCols(aorel));
aoEntry = GetAppendOnlyEntry(RelationGetRelid(aorel), SnapshotNow);
pg_aoseg_rel = heap_open(aoEntry->segrelid, AccessShareLock);
pg_aoseg_dsc = RelationGetDescr(pg_aoseg_rel);
aoscan = heap_beginscan(pg_aoseg_rel, SnapshotNow, 0, NULL);
Anum_tupcount = RelationIsAoRows(aorel)? Anum_pg_aoseg_tupcount: Anum_pg_aocs_tupcount;
while ((tuple = heap_getnext(aoscan, ForwardScanDirection)) != NULL &&
empty)
{
if (0 < fastgetattr(tuple, Anum_tupcount,
pg_aoseg_dsc, NULL))
empty = false;
}
heap_endscan(aoscan);
heap_close(pg_aoseg_rel, AccessShareLock);
return empty;
}
示例15: DynamicScan_ObtainRelations
/*
* DynamicScan_ObtainRelations
* Returns old and new relations for a new part oid
*/
static void
DynamicScan_ObtainRelations(ScanState *scanState, Oid newOid, Relation *outOldRelation, Relation *outNewRelation)
{
Relation oldRelation = NULL;
Relation newRelation = NULL;
Oid oldOid = InvalidOid;
if (NULL != scanState->ss_currentRelation)
{
oldOid = RelationGetRelid(scanState->ss_currentRelation);
oldRelation = scanState->ss_currentRelation;
}
else
{
/* Must be the initial state */
Assert(SCAN_INIT == scanState->scan_state);
oldOid = DynamicScan_GetOriginalRelationOid(scanState);
Assert(OidIsValid(oldOid));
oldRelation = OpenScanRelationByOid(oldOid);
}
if (oldOid == newOid)
{
newRelation = oldRelation;
}
else
{
newRelation = OpenScanRelationByOid(newOid);
}
Assert(NULL != oldRelation);
Assert(NULL != newRelation);
*outOldRelation = oldRelation;
*outNewRelation = newRelation;
}