/*
* pg_lock_status - produce a view with one row per held or awaited lock mode
*/
Datum
pg_lock_status(PG_FUNCTION_ARGS)
{
FuncCallContext *funcctx;
PG_Lock_Status *mystatus;
LockData *lockData;
if (SRF_IS_FIRSTCALL())
{
TupleDesc tupdesc;
MemoryContext oldcontext;
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
/*
* switch to memory context appropriate for multiple function calls
*/
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
/* build tupdesc for result tuples */
/* this had better match pg_locks view in system_views.sql */
tupdesc = CreateTemplateTupleDesc(16, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "locktype",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "database",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 3, "relation",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 4, "page",
INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 5, "tuple",
INT2OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 6, "transactionid",
XIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 7, "classid",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 8, "objid",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 9, "objsubid",
INT2OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 10, "transaction",
XIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 11, "pid",
INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 12, "mode",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 13, "granted",
BOOLOID, -1, 0);
/*
* These next columns are specific to GPDB
*/
TupleDescInitEntry(tupdesc, (AttrNumber) 14, "mppSessionId",
INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 15, "mppIsWriter",
BOOLOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 16, "gp_segment_id",
INT4OID, -1, 0);
funcctx->tuple_desc = BlessTupleDesc(tupdesc);
/*
* Collect all the locking information that we will format and send
* out as a result set.
*/
mystatus = (PG_Lock_Status *) palloc(sizeof(PG_Lock_Status));
funcctx->user_fctx = (void *) mystatus;
mystatus->lockData = GetLockStatusData();
mystatus->currIdx = 0;
mystatus->numSegLocks = 0;
mystatus->numsegresults = 0;
mystatus->segresults = NULL;
/*
* Seeing the locks just from the masterDB isn't enough to know what is locked,
* or if there is a deadlock. That's because the segDBs also take locks.
* Some locks show up only on the master, some only on the segDBs, and some on both.
*
* So, let's collect the lock information from all the segDBs. Sure, this means
* there are a lot more rows coming back from pg_locks than before, since most locks
* on the segDBs happen across all the segDBs at the same time. But not always,
* so let's play it safe and get them all.
*/
if (Gp_role == GP_ROLE_DISPATCH)
{
int resultCount = 0;
struct pg_result **results = NULL;
StringInfoData buffer;
StringInfoData errbuf;
int i;
initStringInfo(&buffer);
/*
* This query has to match the tupledesc we just made above.
*/
appendStringInfo(&buffer,
"SELECT * FROM pg_lock_status() L "
" (locktype text, database oid, relation oid, page int4, tuple int2,"
" transactionid xid, classid oid, objid oid, objsubid int2,"
" transaction xid, pid int4, mode text, granted boolean, "
" mppSessionId int4, mppIsWriter boolean, gp_segment_id int4) ");
initStringInfo(&errbuf);
/*
* Why dispatch something here, rather than do a UNION ALL in pg_locks view, and
* a join to gp_dist_random('gp_id')? There are several important reasons.
*
* The union all method is much slower, and requires taking locks on gp_id.
* More importantly, applications such as pgAdmin do queries of this view that
* involve a correlated subqueries joining to other catalog tables,
* which works if we do it this way, but fails
* if the view includes the union all. That completely breaks the server status
* display in pgAdmin.
*
* Why dispatch this way, rather than via SPI? There are several advantages.
* First, it's easy to get "writer gang is busy" errors if we use SPI.
*
* Second, this should be much faster, as it doesn't require setting up
* the interconnect, and doesn't need to touch any actual data tables to be
* able to get the gp_segment_id.
*
* The downside is we get n result sets, where n == number of segDBs.
*
* It would be better yet if we sent a plan tree rather than a text string,
* so the segDBs don't need to parse it. That would also avoid taking any relation locks
* on the segDB to get this info (normally need to get an accessShareLock on pg_locks on the segDB
* to make sure it doesn't go away during parsing). But the only safe way I know to do this
* is to hand-build the plan tree, and I'm to lazy to do it right now. It's just a matter of
* building a function scan node, and filling it in with our result set info (from the tupledesc).
*
* One thing to note: it's OK to join pg_locks with any catalog table or master-only table,
* but joining to a distributed table will result in "writer gang busy: possible attempt to
* execute volatile function in unsupported context" errors, because
* the scan of the distributed table might already be running on the writer gang
* when we want to dispatch this.
*
* This could be fixed by allocating a reader gang and dispatching to that, but the cost
* of setting up a new gang is high, and I've never seen anyone need to join this to a
* distributed table.
*
*/
results = cdbdisp_dispatchRMCommand(buffer.data, true, &errbuf, &resultCount);
if (errbuf.len > 0)
ereport(ERROR, (errmsg("pg_lock internal error (gathered %d results from cmd '%s')", resultCount, buffer.data),
errdetail("%s", errbuf.data)));
/*
* I don't think resultCount can ever be zero if errbuf isn't set.
* But check to be sure.
*/
if (resultCount == 0)
elog(ERROR, "pg_locks didn't get back any data from the segDBs");
for (i = 0; i < resultCount; i++)
{
/*
* Any error here should have propagated into errbuf, so we shouldn't
* ever see anything other that tuples_ok here. But, check to be
* sure.
*/
if (PQresultStatus(results[i]) != PGRES_TUPLES_OK)
{
elog(ERROR,"pg_locks: resultStatus not tuples_Ok");
}
else
{
/*
* numSegLocks needs to be the total size we are returning to
* the application. At the start of this loop, it has the count
* for the masterDB locks. Add each of the segDB lock counts.
*/
mystatus->numSegLocks += PQntuples(results[i]);
}
}
pfree(errbuf.data);
mystatus->numsegresults = resultCount;
/*
* cdbdisp_dispatchRMCommand copies the result sets into our memory, which
* will still exist on the subsequent calls.
*/
mystatus->segresults = results;
MemoryContextSwitchTo(oldcontext);
}
}
funcctx = SRF_PERCALL_SETUP();
mystatus = (PG_Lock_Status *) funcctx->user_fctx;
lockData = mystatus->lockData;
/*
* This loop returns all the local lock data from the segment we are running on.
*/
while (mystatus->currIdx < lockData->nelements)
{
PROCLOCK *proclock;
LOCK *lock;
PGPROC *proc;
bool granted;
LOCKMODE mode = 0;
const char *locktypename;
char tnbuf[32];
Datum values[16];
bool nulls[16];
HeapTuple tuple;
Datum result;
proclock = &(lockData->proclocks[mystatus->currIdx]);
lock = &(lockData->locks[mystatus->currIdx]);
proc = &(lockData->procs[mystatus->currIdx]);
/*
* Look to see if there are any held lock modes in this PROCLOCK. If
* so, report, and destructively modify lockData so we don't report
* again.
*/
granted = false;
if (proclock->holdMask)
{
for (mode = 0; mode < MAX_LOCKMODES; mode++)
{
if (proclock->holdMask & LOCKBIT_ON(mode))
{
granted = true;
proclock->holdMask &= LOCKBIT_OFF(mode);
break;
}
}
}
/*
* If no (more) held modes to report, see if PROC is waiting for a
* lock on this lock.
*/
if (!granted)
{
if (proc->waitLock == proclock->tag.myLock)
{
/* Yes, so report it with proper mode */
mode = proc->waitLockMode;
/*
* We are now done with this PROCLOCK, so advance pointer to
* continue with next one on next call.
*/
mystatus->currIdx++;
}
else
{
/*
* Okay, we've displayed all the locks associated with this
* PROCLOCK, proceed to the next one.
*/
mystatus->currIdx++;
continue;
}
}
/*
* Form tuple with appropriate data.
*/
MemSet(values, 0, sizeof(values));
MemSet(nulls, false, sizeof(nulls));
if (lock->tag.locktag_type <= LOCKTAG_ADVISORY)
locktypename = LockTagTypeNames[lock->tag.locktag_type];
else
{
snprintf(tnbuf, sizeof(tnbuf), "unknown %d",
(int) lock->tag.locktag_type);
locktypename = tnbuf;
}
values[0] = CStringGetTextDatum(locktypename);
switch (lock->tag.locktag_type)
{
case LOCKTAG_RELATION:
case LOCKTAG_RELATION_EXTEND:
case LOCKTAG_RELATION_RESYNCHRONIZE:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
break;
case LOCKTAG_PAGE:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[3] = UInt32GetDatum(lock->tag.locktag_field3);
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
break;
case LOCKTAG_TUPLE:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[3] = UInt32GetDatum(lock->tag.locktag_field3);
values[4] = UInt16GetDatum(lock->tag.locktag_field4);
nulls[5] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
break;
case LOCKTAG_TRANSACTION:
values[5] = TransactionIdGetDatum(lock->tag.locktag_field1);
nulls[1] = true;
nulls[2] = true;
nulls[3] = true;
nulls[4] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
break;
case LOCKTAG_RELATION_APPENDONLY_SEGMENT_FILE:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[7] = ObjectIdGetDatum(lock->tag.locktag_field3);
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
nulls[8] = true;
break;
case LOCKTAG_RESOURCE_QUEUE:
values[1] = ObjectIdGetDatum(proc->databaseId);
values[7] = ObjectIdGetDatum(lock->tag.locktag_field1);
nulls[2] = true;
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
nulls[8] = true;
break;
case LOCKTAG_OBJECT:
case LOCKTAG_USERLOCK:
case LOCKTAG_ADVISORY:
default: /* treat unknown locktags like OBJECT */
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[6] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[7] = ObjectIdGetDatum(lock->tag.locktag_field3);
values[8] = Int16GetDatum(lock->tag.locktag_field4);
nulls[2] = true;
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
break;
}
values[9] = TransactionIdGetDatum(proc->xid);
if (proc->pid != 0)
values[10] = Int32GetDatum(proc->pid);
else
nulls[10] = true;
values[11] = DirectFunctionCall1(textin,
CStringGetDatum((char *) GetLockmodeName(LOCK_LOCKMETHOD(*lock),
mode)));
values[12] = BoolGetDatum(granted);
values[13] = Int32GetDatum(proc->mppSessionId);
values[14] = Int32GetDatum(proc->mppIsWriter);
values[15] = Int32GetDatum(Gp_segment);
tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
}
/*
* This loop only executes on the masterDB and only in dispatch mode, because that
* is the only time we dispatched to the segDBs.
*/
while (mystatus->currIdx >= lockData->nelements && mystatus->currIdx < lockData->nelements + mystatus->numSegLocks)
{
HeapTuple tuple;
Datum result;
Datum values[16];
bool nulls[16];
int i;
int whichresultset = 0;
int whichelement = mystatus->currIdx - lockData->nelements;
int whichrow = whichelement;
Assert(Gp_role == GP_ROLE_DISPATCH);
/*
* Because we have one result set per segDB (rather than one big result set with everything),
* we need to figure out which result set we are on, and which row within that result set
* we are returning.
*
* So, we walk through all the result sets and all the rows in each one, in order.
*/
while(whichrow >= PQntuples(mystatus->segresults[whichresultset]))
{
whichrow -= PQntuples(mystatus->segresults[whichresultset]);
whichresultset++;
if (whichresultset >= mystatus->numsegresults)
break;
}
/*
* If this condition is true, we have already sent everything back,
* and we just want to do the SRF_RETURN_DONE
*/
if (whichresultset >= mystatus->numsegresults)
break;
mystatus->currIdx++;
/*
* Form tuple with appropriate data we got from the segDBs
*/
MemSet(values, 0, sizeof(values));
MemSet(nulls, false, sizeof(nulls));
/*
* For each column, extract out the value (which comes out in text).
* Convert it to the appropriate datatype to match our tupledesc,
* and put that in values.
* The columns look like this (from select statement earlier):
*
* " (locktype text, database oid, relation oid, page int4, tuple int2,"
* " transactionid xid, classid oid, objid oid, objsubid int2,"
* " transaction xid, pid int4, mode text, granted boolean, "
* " mppSessionId int4, mppIsWriter boolean, gp_segment_id int4) ,"
*/
values[0] = CStringGetTextDatum(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 0));
values[1] = ObjectIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 1)));
values[2] = ObjectIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 2)));
values[3] = UInt32GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 3)));
values[4] = UInt16GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 4)));
values[5] = TransactionIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 5)));
values[6] = ObjectIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 6)));
values[7] = ObjectIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 7)));
values[8] = UInt16GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 8)));
values[9] = TransactionIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 9)));
values[10] = UInt32GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow,10)));
values[11] = CStringGetTextDatum(PQgetvalue(mystatus->segresults[whichresultset], whichrow,11));
values[12] = BoolGetDatum(strncmp(PQgetvalue(mystatus->segresults[whichresultset], whichrow,12),"t",1)==0);
values[13] = Int32GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow,13)));
values[14] = BoolGetDatum(strncmp(PQgetvalue(mystatus->segresults[whichresultset], whichrow,14),"t",1)==0);
values[15] = Int32GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow,15)));
/*
* Copy the null info over. It should all match properly.
*/
for (i=0; i<16; i++)
{
nulls[i] = PQgetisnull(mystatus->segresults[whichresultset], whichrow, i);
}
tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
}
/*
* if we dispatched to the segDBs, free up the memory holding the result sets.
* Otherwise we might leak this memory each time we got called (does it automatically
* get freed by the pool being deleted? Probably, but this is safer).
*/
if (mystatus->segresults != NULL)
{
int i;
for (i = 0; i < mystatus->numsegresults; i++)
PQclear(mystatus->segresults[i]);
free(mystatus->segresults);
}
SRF_RETURN_DONE(funcctx);
}
/* ----------------------------------------------------------------
* TypeCreate
*
* This does all the necessary work needed to define a new type.
*
* Returns the OID assigned to the new type. If newTypeOid is
* zero (the normal case), a new OID is created; otherwise we
* use exactly that OID.
* ----------------------------------------------------------------
*/
Oid
TypeCreate(Oid newTypeOid,
const char *typeName,
Oid typeNamespace,
Oid relationOid, /* only for relation rowtypes */
char relationKind, /* ditto */
Oid ownerId,
int16 internalSize,
char typeType,
char typeCategory,
bool typePreferred,
char typDelim,
Oid inputProcedure,
Oid outputProcedure,
Oid receiveProcedure,
Oid sendProcedure,
Oid typmodinProcedure,
Oid typmodoutProcedure,
Oid analyzeProcedure,
Oid elementType,
bool isImplicitArray,
Oid arrayType,
Oid baseType,
const char *defaultTypeValue, /* human readable rep */
char *defaultTypeBin, /* cooked rep */
bool passedByValue,
char alignment,
char storage,
int32 typeMod,
int32 typNDims, /* Array dimensions for baseType */
bool typeNotNull,
Oid typeCollation)
{
Relation pg_type_desc;
Oid typeObjectId;
bool rebuildDeps = false;
HeapTuple tup;
bool nulls[Natts_pg_type];
bool replaces[Natts_pg_type];
Datum values[Natts_pg_type];
NameData name;
int i;
Acl *typacl = NULL;
/*
* We assume that the caller validated the arguments individually, but did
* not check for bad combinations.
*
* Validate size specifications: either positive (fixed-length) or -1
* (varlena) or -2 (cstring).
*/
if (!(internalSize > 0 ||
internalSize == -1 ||
internalSize == -2))
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("invalid type internal size %d",
internalSize)));
if (passedByValue)
{
/*
* Pass-by-value types must have a fixed length that is one of the
* values supported by fetch_att() and store_att_byval(); and the
* alignment had better agree, too. All this code must match
* access/tupmacs.h!
*/
if (internalSize == (int16) sizeof(char))
{
if (alignment != 'c')
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("alignment \"%c\" is invalid for passed-by-value type of size %d",
alignment, internalSize)));
}
else if (internalSize == (int16) sizeof(int16))
{
if (alignment != 's')
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("alignment \"%c\" is invalid for passed-by-value type of size %d",
alignment, internalSize)));
}
else if (internalSize == (int16) sizeof(int32))
{
if (alignment != 'i')
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("alignment \"%c\" is invalid for passed-by-value type of size %d",
alignment, internalSize)));
}
#if SIZEOF_DATUM == 8
else if (internalSize == (int16) sizeof(Datum))
{
if (alignment != 'd')
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("alignment \"%c\" is invalid for passed-by-value type of size %d",
alignment, internalSize)));
}
#endif
else
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("internal size %d is invalid for passed-by-value type",
internalSize)));
}
else
{
/* varlena types must have int align or better */
if (internalSize == -1 && !(alignment == 'i' || alignment == 'd'))
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("alignment \"%c\" is invalid for variable-length type",
alignment)));
/* cstring must have char alignment */
if (internalSize == -2 && !(alignment == 'c'))
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("alignment \"%c\" is invalid for variable-length type",
alignment)));
}
/* Only varlena types can be toasted */
if (storage != 'p' && internalSize != -1)
ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("fixed-size types must have storage PLAIN")));
/*
* initialize arrays needed for heap_form_tuple or heap_modify_tuple
*/
for (i = 0; i < Natts_pg_type; ++i)
{
nulls[i] = false;
replaces[i] = true;
values[i] = (Datum) 0;
}
/*
* insert data values
*/
namestrcpy(&name, typeName);
values[Anum_pg_type_typname - 1] = NameGetDatum(&name);
values[Anum_pg_type_typnamespace - 1] = ObjectIdGetDatum(typeNamespace);
values[Anum_pg_type_typowner - 1] = ObjectIdGetDatum(ownerId);
values[Anum_pg_type_typlen - 1] = Int16GetDatum(internalSize);
values[Anum_pg_type_typbyval - 1] = BoolGetDatum(passedByValue);
values[Anum_pg_type_typtype - 1] = CharGetDatum(typeType);
values[Anum_pg_type_typcategory - 1] = CharGetDatum(typeCategory);
values[Anum_pg_type_typispreferred - 1] = BoolGetDatum(typePreferred);
values[Anum_pg_type_typisdefined - 1] = BoolGetDatum(true);
values[Anum_pg_type_typdelim - 1] = CharGetDatum(typDelim);
values[Anum_pg_type_typrelid - 1] = ObjectIdGetDatum(relationOid);
values[Anum_pg_type_typelem - 1] = ObjectIdGetDatum(elementType);
values[Anum_pg_type_typarray - 1] = ObjectIdGetDatum(arrayType);
values[Anum_pg_type_typinput - 1] = ObjectIdGetDatum(inputProcedure);
values[Anum_pg_type_typoutput - 1] = ObjectIdGetDatum(outputProcedure);
values[Anum_pg_type_typreceive - 1] = ObjectIdGetDatum(receiveProcedure);
values[Anum_pg_type_typsend - 1] = ObjectIdGetDatum(sendProcedure);
values[Anum_pg_type_typmodin - 1] = ObjectIdGetDatum(typmodinProcedure);
values[Anum_pg_type_typmodout - 1] = ObjectIdGetDatum(typmodoutProcedure);
values[Anum_pg_type_typanalyze - 1] = ObjectIdGetDatum(analyzeProcedure);
values[Anum_pg_type_typalign - 1] = CharGetDatum(alignment);
values[Anum_pg_type_typstorage - 1] = CharGetDatum(storage);
values[Anum_pg_type_typnotnull - 1] = BoolGetDatum(typeNotNull);
values[Anum_pg_type_typbasetype - 1] = ObjectIdGetDatum(baseType);
values[Anum_pg_type_typtypmod - 1] = Int32GetDatum(typeMod);
values[Anum_pg_type_typndims - 1] = Int32GetDatum(typNDims);
values[Anum_pg_type_typcollation - 1] = ObjectIdGetDatum(typeCollation);
/*
* initialize the default binary value for this type. Check for nulls of
* course.
*/
if (defaultTypeBin)
values[Anum_pg_type_typdefaultbin - 1] = CStringGetTextDatum(defaultTypeBin);
else
nulls[Anum_pg_type_typdefaultbin - 1] = true;
/*
* initialize the default value for this type.
*/
if (defaultTypeValue)
values[Anum_pg_type_typdefault - 1] = CStringGetTextDatum(defaultTypeValue);
else
nulls[Anum_pg_type_typdefault - 1] = true;
typacl = get_user_default_acl(ACL_OBJECT_TYPE, ownerId,
typeNamespace);
if (typacl != NULL)
values[Anum_pg_type_typacl - 1] = PointerGetDatum(typacl);
else
nulls[Anum_pg_type_typacl - 1] = true;
/*
* open pg_type and prepare to insert or update a row.
*
* NOTE: updating will not work correctly in bootstrap mode; but we don't
* expect to be overwriting any shell types in bootstrap mode.
*/
pg_type_desc = heap_open(TypeRelationId, RowExclusiveLock);
tup = SearchSysCacheCopy2(TYPENAMENSP,
CStringGetDatum(typeName),
ObjectIdGetDatum(typeNamespace));
if (HeapTupleIsValid(tup))
{
/*
* check that the type is not already defined. It may exist as a
* shell type, however.
*/
if (((Form_pg_type) GETSTRUCT(tup))->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)
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_TYPE, typeName);
/* trouble if caller wanted to force the OID */
if (OidIsValid(newTypeOid))
elog(ERROR, "cannot assign new OID to existing shell type");
/*
* Okay to update existing shell type tuple
*/
tup = heap_modify_tuple(tup,
RelationGetDescr(pg_type_desc),
values,
nulls,
replaces);
simple_heap_update(pg_type_desc, &tup->t_self, tup);
typeObjectId = HeapTupleGetOid(tup);
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);
/* Use binary-upgrade override for pg_type.oid, if supplied. */
else if (IsBinaryUpgrade && OidIsValid(binary_upgrade_next_pg_type_oid))
{
HeapTupleSetOid(tup, binary_upgrade_next_pg_type_oid);
binary_upgrade_next_pg_type_oid = InvalidOid;
}
/* else allow system to assign oid */
typeObjectId = simple_heap_insert(pg_type_desc, tup);
}
/* Update indexes */
CatalogUpdateIndexes(pg_type_desc, tup);
/*
* Create dependencies. We can/must skip this in bootstrap mode.
*/
if (!IsBootstrapProcessingMode())
GenerateTypeDependencies(typeNamespace,
typeObjectId,
relationOid,
relationKind,
ownerId,
inputProcedure,
outputProcedure,
receiveProcedure,
sendProcedure,
typmodinProcedure,
typmodoutProcedure,
analyzeProcedure,
elementType,
isImplicitArray,
baseType,
typeCollation,
(defaultTypeBin ?
stringToNode(defaultTypeBin) :
NULL),
rebuildDeps);
/* Post creation hook for new type */
InvokeObjectAccessHook(OAT_POST_CREATE,
TypeRelationId, typeObjectId, 0, NULL);
/*
* finish up
*/
heap_close(pg_type_desc, RowExclusiveLock);
return typeObjectId;
}
Datum
gist_point_consistent(PG_FUNCTION_ARGS)
{
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
bool result;
bool *recheck = (bool *) PG_GETARG_POINTER(4);
StrategyNumber strategyGroup = strategy / GeoStrategyNumberOffset;
switch (strategyGroup)
{
case PointStrategyNumberGroup:
result = gist_point_consistent_internal(strategy % GeoStrategyNumberOffset,
GIST_LEAF(entry),
DatumGetBoxP(entry->key),
PG_GETARG_POINT_P(1));
*recheck = false;
break;
case BoxStrategyNumberGroup:
result = DatumGetBool(DirectFunctionCall5(
gist_box_consistent,
PointerGetDatum(entry),
PG_GETARG_DATUM(1),
Int16GetDatum(RTOverlapStrategyNumber),
0, PointerGetDatum(recheck)));
break;
case PolygonStrategyNumberGroup:
{
POLYGON *query = PG_GETARG_POLYGON_P(1);
result = DatumGetBool(DirectFunctionCall5(
gist_poly_consistent,
PointerGetDatum(entry),
PolygonPGetDatum(query),
Int16GetDatum(RTOverlapStrategyNumber),
0, PointerGetDatum(recheck)));
if (GIST_LEAF(entry) && result)
{
/*
* We are on leaf page and quick check shows overlapping
* of polygon's bounding box and point
*/
BOX *box = DatumGetBoxP(entry->key);
Assert(box->high.x == box->low.x
&& box->high.y == box->low.y);
result = DatumGetBool(DirectFunctionCall2(
poly_contain_pt,
PolygonPGetDatum(query),
PointPGetDatum(&box->high)));
*recheck = false;
}
}
break;
case CircleStrategyNumberGroup:
{
CIRCLE *query = PG_GETARG_CIRCLE_P(1);
result = DatumGetBool(DirectFunctionCall5(
gist_circle_consistent,
PointerGetDatum(entry),
CirclePGetDatum(query),
Int16GetDatum(RTOverlapStrategyNumber),
0, PointerGetDatum(recheck)));
if (GIST_LEAF(entry) && result)
{
/*
* We are on leaf page and quick check shows overlapping
* of polygon's bounding box and point
*/
BOX *box = DatumGetBoxP(entry->key);
Assert(box->high.x == box->low.x
&& box->high.y == box->low.y);
result = DatumGetBool(DirectFunctionCall2(
circle_contain_pt,
CirclePGetDatum(query),
PointPGetDatum(&box->high)));
*recheck = false;
}
}
break;
default:
result = false; /* silence compiler warning */
elog(ERROR, "unknown strategy number: %d", strategy);
}
PG_RETURN_BOOL(result);
}
/*
* CreateConstraintEntry
* Create a constraint table entry.
*
* Subsidiary records (such as triggers or indexes to implement the
* constraint) are *not* created here. But we do make dependency links
* from the constraint to the things it depends on.
*
* The new constraint's OID is returned.
*/
Oid
CreateConstraintEntry(const char *constraintName,
Oid constraintNamespace,
char constraintType,
bool isDeferrable,
bool isDeferred,
bool isValidated,
Oid relId,
const int16 *constraintKey,
int constraintNKeys,
Oid domainId,
Oid indexRelId,
Oid foreignRelId,
const int16 *foreignKey,
const Oid *pfEqOp,
const Oid *ppEqOp,
const Oid *ffEqOp,
int foreignNKeys,
char foreignUpdateType,
char foreignDeleteType,
char foreignMatchType,
const Oid *exclOp,
Node *conExpr,
const char *conBin,
const char *conSrc,
bool conIsLocal,
int conInhCount,
bool conNoInherit,
bool is_internal)
{
Relation conDesc;
Oid conOid;
HeapTuple tup;
bool nulls[Natts_pg_constraint];
Datum values[Natts_pg_constraint];
ArrayType *conkeyArray;
ArrayType *confkeyArray;
ArrayType *conpfeqopArray;
ArrayType *conppeqopArray;
ArrayType *conffeqopArray;
ArrayType *conexclopArray;
NameData cname;
int i;
ObjectAddress conobject;
conDesc = heap_open(ConstraintRelationId, RowExclusiveLock);
Assert(constraintName);
namestrcpy(&cname, constraintName);
/*
* Convert C arrays into Postgres arrays.
*/
if (constraintNKeys > 0)
{
Datum *conkey;
conkey = (Datum *) palloc(constraintNKeys * sizeof(Datum));
for (i = 0; i < constraintNKeys; i++)
conkey[i] = Int16GetDatum(constraintKey[i]);
conkeyArray = construct_array(conkey, constraintNKeys,
INT2OID, 2, true, 's');
}
else
conkeyArray = NULL;
if (foreignNKeys > 0)
{
Datum *fkdatums;
fkdatums = (Datum *) palloc(foreignNKeys * sizeof(Datum));
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = Int16GetDatum(foreignKey[i]);
confkeyArray = construct_array(fkdatums, foreignNKeys,
INT2OID, 2, true, 's');
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = ObjectIdGetDatum(pfEqOp[i]);
conpfeqopArray = construct_array(fkdatums, foreignNKeys,
OIDOID, sizeof(Oid), true, 'i');
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = ObjectIdGetDatum(ppEqOp[i]);
conppeqopArray = construct_array(fkdatums, foreignNKeys,
OIDOID, sizeof(Oid), true, 'i');
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = ObjectIdGetDatum(ffEqOp[i]);
conffeqopArray = construct_array(fkdatums, foreignNKeys,
OIDOID, sizeof(Oid), true, 'i');
}
else
{
confkeyArray = NULL;
conpfeqopArray = NULL;
conppeqopArray = NULL;
conffeqopArray = NULL;
}
if (exclOp != NULL)
{
Datum *opdatums;
opdatums = (Datum *) palloc(constraintNKeys * sizeof(Datum));
for (i = 0; i < constraintNKeys; i++)
opdatums[i] = ObjectIdGetDatum(exclOp[i]);
conexclopArray = construct_array(opdatums, constraintNKeys,
OIDOID, sizeof(Oid), true, 'i');
}
else
conexclopArray = NULL;
/* initialize nulls and values */
for (i = 0; i < Natts_pg_constraint; i++)
{
nulls[i] = false;
values[i] = (Datum) NULL;
}
values[Anum_pg_constraint_conname - 1] = NameGetDatum(&cname);
values[Anum_pg_constraint_connamespace - 1] = ObjectIdGetDatum(constraintNamespace);
values[Anum_pg_constraint_contype - 1] = CharGetDatum(constraintType);
values[Anum_pg_constraint_condeferrable - 1] = BoolGetDatum(isDeferrable);
values[Anum_pg_constraint_condeferred - 1] = BoolGetDatum(isDeferred);
values[Anum_pg_constraint_convalidated - 1] = BoolGetDatum(isValidated);
values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(relId);
values[Anum_pg_constraint_contypid - 1] = ObjectIdGetDatum(domainId);
values[Anum_pg_constraint_conindid - 1] = ObjectIdGetDatum(indexRelId);
values[Anum_pg_constraint_confrelid - 1] = ObjectIdGetDatum(foreignRelId);
values[Anum_pg_constraint_confupdtype - 1] = CharGetDatum(foreignUpdateType);
values[Anum_pg_constraint_confdeltype - 1] = CharGetDatum(foreignDeleteType);
values[Anum_pg_constraint_confmatchtype - 1] = CharGetDatum(foreignMatchType);
values[Anum_pg_constraint_conislocal - 1] = BoolGetDatum(conIsLocal);
values[Anum_pg_constraint_coninhcount - 1] = Int32GetDatum(conInhCount);
values[Anum_pg_constraint_connoinherit - 1] = BoolGetDatum(conNoInherit);
if (conkeyArray)
values[Anum_pg_constraint_conkey - 1] = PointerGetDatum(conkeyArray);
else
nulls[Anum_pg_constraint_conkey - 1] = true;
if (confkeyArray)
values[Anum_pg_constraint_confkey - 1] = PointerGetDatum(confkeyArray);
else
nulls[Anum_pg_constraint_confkey - 1] = true;
if (conpfeqopArray)
values[Anum_pg_constraint_conpfeqop - 1] = PointerGetDatum(conpfeqopArray);
else
nulls[Anum_pg_constraint_conpfeqop - 1] = true;
if (conppeqopArray)
values[Anum_pg_constraint_conppeqop - 1] = PointerGetDatum(conppeqopArray);
else
nulls[Anum_pg_constraint_conppeqop - 1] = true;
if (conffeqopArray)
values[Anum_pg_constraint_conffeqop - 1] = PointerGetDatum(conffeqopArray);
else
nulls[Anum_pg_constraint_conffeqop - 1] = true;
if (conexclopArray)
values[Anum_pg_constraint_conexclop - 1] = PointerGetDatum(conexclopArray);
else
nulls[Anum_pg_constraint_conexclop - 1] = true;
/*
* initialize the binary form of the check constraint.
*/
if (conBin)
values[Anum_pg_constraint_conbin - 1] = CStringGetTextDatum(conBin);
else
nulls[Anum_pg_constraint_conbin - 1] = true;
/*
* initialize the text form of the check constraint
*/
if (conSrc)
values[Anum_pg_constraint_consrc - 1] = CStringGetTextDatum(conSrc);
else
nulls[Anum_pg_constraint_consrc - 1] = true;
tup = heap_form_tuple(RelationGetDescr(conDesc), values, nulls);
conOid = simple_heap_insert(conDesc, tup);
/* update catalog indexes */
CatalogUpdateIndexes(conDesc, tup);
conobject.classId = ConstraintRelationId;
conobject.objectId = conOid;
conobject.objectSubId = 0;
heap_close(conDesc, RowExclusiveLock);
if (OidIsValid(relId))
{
/*
* Register auto dependency from constraint to owning relation, or to
* specific column(s) if any are mentioned.
*/
ObjectAddress relobject;
relobject.classId = RelationRelationId;
relobject.objectId = relId;
if (constraintNKeys > 0)
{
for (i = 0; i < constraintNKeys; i++)
{
relobject.objectSubId = constraintKey[i];
recordDependencyOn(&conobject, &relobject, DEPENDENCY_AUTO);
}
}
else
{
relobject.objectSubId = 0;
recordDependencyOn(&conobject, &relobject, DEPENDENCY_AUTO);
}
}
if (OidIsValid(domainId))
{
/*
* Register auto dependency from constraint to owning domain
*/
ObjectAddress domobject;
domobject.classId = TypeRelationId;
domobject.objectId = domainId;
domobject.objectSubId = 0;
recordDependencyOn(&conobject, &domobject, DEPENDENCY_AUTO);
}
if (OidIsValid(foreignRelId))
{
/*
* Register normal dependency from constraint to foreign relation, or
* to specific column(s) if any are mentioned.
*/
ObjectAddress relobject;
relobject.classId = RelationRelationId;
relobject.objectId = foreignRelId;
if (foreignNKeys > 0)
{
for (i = 0; i < foreignNKeys; i++)
{
relobject.objectSubId = foreignKey[i];
recordDependencyOn(&conobject, &relobject, DEPENDENCY_NORMAL);
}
}
else
{
relobject.objectSubId = 0;
recordDependencyOn(&conobject, &relobject, DEPENDENCY_NORMAL);
}
}
if (OidIsValid(indexRelId) && constraintType == CONSTRAINT_FOREIGN)
{
/*
* Register normal dependency on the unique index that supports a
* foreign-key constraint. (Note: for indexes associated with unique
* or primary-key constraints, the dependency runs the other way, and
* is not made here.)
*/
ObjectAddress relobject;
relobject.classId = RelationRelationId;
relobject.objectId = indexRelId;
relobject.objectSubId = 0;
recordDependencyOn(&conobject, &relobject, DEPENDENCY_NORMAL);
}
if (foreignNKeys > 0)
{
/*
* Register normal dependencies on the equality operators that support
* a foreign-key constraint. If the PK and FK types are the same then
* all three operators for a column are the same; otherwise they are
* different.
*/
ObjectAddress oprobject;
oprobject.classId = OperatorRelationId;
oprobject.objectSubId = 0;
for (i = 0; i < foreignNKeys; i++)
{
oprobject.objectId = pfEqOp[i];
recordDependencyOn(&conobject, &oprobject, DEPENDENCY_NORMAL);
if (ppEqOp[i] != pfEqOp[i])
{
oprobject.objectId = ppEqOp[i];
recordDependencyOn(&conobject, &oprobject, DEPENDENCY_NORMAL);
}
if (ffEqOp[i] != pfEqOp[i])
{
oprobject.objectId = ffEqOp[i];
recordDependencyOn(&conobject, &oprobject, DEPENDENCY_NORMAL);
}
}
}
/*
* We don't bother to register dependencies on the exclusion operators of
* an exclusion constraint. We assume they are members of the opclass
* supporting the index, so there's an indirect dependency via that. (This
* would be pretty dicey for cross-type operators, but exclusion operators
* can never be cross-type.)
*/
if (conExpr != NULL)
{
/*
* Register dependencies from constraint to objects mentioned in CHECK
* expression.
*/
recordDependencyOnSingleRelExpr(&conobject, conExpr, relId,
DEPENDENCY_NORMAL,
DEPENDENCY_NORMAL);
}
/* Post creation hook for new constraint */
InvokeObjectPostCreateHookArg(ConstraintRelationId, conOid, 0,
is_internal);
return conOid;
}
/*
* pg_lock_status - produce a view with one row per held or awaited lock mode
*/
Datum
pg_lock_status(PG_FUNCTION_ARGS)
{
FuncCallContext *funcctx;
PG_Lock_Status *mystatus;
LockData *lockData;
if (SRF_IS_FIRSTCALL())
{
TupleDesc tupdesc;
MemoryContext oldcontext;
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
/*
* switch to memory context appropriate for multiple function calls
*/
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
/* build tupdesc for result tuples */
/* this had better match pg_locks view in system_views.sql */
tupdesc = CreateTemplateTupleDesc(16, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "locktype",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "database",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 3, "relation",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 4, "page",
INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 5, "tuple",
INT2OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 6, "transactionid",
XIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 7, "classid",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 8, "objid",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 9, "objsubid",
INT2OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 10, "transaction",
XIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 11, "pid",
INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 12, "mode",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 13, "granted",
BOOLOID, -1, 0);
/*
* These next columns are specific to GPDB
*/
TupleDescInitEntry(tupdesc, (AttrNumber) 14, "mppSessionId",
INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 15, "mppIsWriter",
BOOLOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 16, "gp_segment_id",
INT4OID, -1, 0);
funcctx->tuple_desc = BlessTupleDesc(tupdesc);
/*
* Collect all the locking information that we will format and send
* out as a result set.
*/
mystatus = (PG_Lock_Status *) palloc(sizeof(PG_Lock_Status));
funcctx->user_fctx = (void *) mystatus;
mystatus->lockData = GetLockStatusData();
mystatus->currIdx = 0;
mystatus->numSegLocks = 0;
mystatus->numsegresults = 0;
mystatus->segresults = NULL;
}
funcctx = SRF_PERCALL_SETUP();
mystatus = (PG_Lock_Status *) funcctx->user_fctx;
lockData = mystatus->lockData;
/*
* This loop returns all the local lock data from the segment we are running on.
*/
while (mystatus->currIdx < lockData->nelements)
{
PROCLOCK *proclock;
LOCK *lock;
PGPROC *proc;
bool granted;
LOCKMODE mode = 0;
const char *locktypename;
char tnbuf[32];
Datum values[16];
bool nulls[16];
HeapTuple tuple;
Datum result;
proclock = &(lockData->proclocks[mystatus->currIdx]);
lock = &(lockData->locks[mystatus->currIdx]);
proc = &(lockData->procs[mystatus->currIdx]);
/*
* Look to see if there are any held lock modes in this PROCLOCK. If
* so, report, and destructively modify lockData so we don't report
* again.
*/
granted = false;
if (proclock->holdMask)
{
for (mode = 0; mode < MAX_LOCKMODES; mode++)
{
if (proclock->holdMask & LOCKBIT_ON(mode))
{
granted = true;
proclock->holdMask &= LOCKBIT_OFF(mode);
break;
}
}
}
/*
* If no (more) held modes to report, see if PROC is waiting for a
* lock on this lock.
*/
if (!granted)
{
if (proc->waitLock == proclock->tag.myLock)
{
/* Yes, so report it with proper mode */
mode = proc->waitLockMode;
/*
* We are now done with this PROCLOCK, so advance pointer to
* continue with next one on next call.
*/
mystatus->currIdx++;
}
else
{
/*
* Okay, we've displayed all the locks associated with this
* PROCLOCK, proceed to the next one.
*/
mystatus->currIdx++;
continue;
}
}
/*
* Form tuple with appropriate data.
*/
MemSet(values, 0, sizeof(values));
MemSet(nulls, false, sizeof(nulls));
if (lock->tag.locktag_type <= LOCKTAG_ADVISORY)
locktypename = LockTagTypeNames[lock->tag.locktag_type];
else
{
snprintf(tnbuf, sizeof(tnbuf), "unknown %d",
(int) lock->tag.locktag_type);
locktypename = tnbuf;
}
values[0] = CStringGetTextDatum(locktypename);
switch (lock->tag.locktag_type)
{
case LOCKTAG_RELATION:
case LOCKTAG_RELATION_EXTEND:
case LOCKTAG_RELATION_RESYNCHRONIZE:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
break;
case LOCKTAG_PAGE:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[3] = UInt32GetDatum(lock->tag.locktag_field3);
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
break;
case LOCKTAG_TUPLE:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[3] = UInt32GetDatum(lock->tag.locktag_field3);
values[4] = UInt16GetDatum(lock->tag.locktag_field4);
nulls[5] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
break;
case LOCKTAG_TRANSACTION:
values[5] = TransactionIdGetDatum(lock->tag.locktag_field1);
nulls[1] = true;
nulls[2] = true;
nulls[3] = true;
nulls[4] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
break;
case LOCKTAG_RELATION_APPENDONLY_SEGMENT_FILE:
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[2] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[7] = ObjectIdGetDatum(lock->tag.locktag_field3);
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
nulls[8] = true;
break;
case LOCKTAG_RESOURCE_QUEUE:
values[1] = ObjectIdGetDatum(proc->databaseId);
values[7] = ObjectIdGetDatum(lock->tag.locktag_field1);
nulls[2] = true;
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
nulls[8] = true;
break;
case LOCKTAG_OBJECT:
case LOCKTAG_USERLOCK:
case LOCKTAG_ADVISORY:
default: /* treat unknown locktags like OBJECT */
values[1] = ObjectIdGetDatum(lock->tag.locktag_field1);
values[6] = ObjectIdGetDatum(lock->tag.locktag_field2);
values[7] = ObjectIdGetDatum(lock->tag.locktag_field3);
values[8] = Int16GetDatum(lock->tag.locktag_field4);
nulls[2] = true;
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
break;
}
values[9] = TransactionIdGetDatum(proc->xid);
if (proc->pid != 0)
values[10] = Int32GetDatum(proc->pid);
else
nulls[10] = true;
values[11] = DirectFunctionCall1(textin,
CStringGetDatum((char *) GetLockmodeName(LOCK_LOCKMETHOD(*lock),
mode)));
values[12] = BoolGetDatum(granted);
values[13] = Int32GetDatum(proc->mppSessionId);
values[14] = Int32GetDatum(proc->mppIsWriter);
values[15] = Int32GetDatum(Gp_segment);
tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
}
/*
* This loop only executes on the masterDB and only in dispatch mode, because that
* is the only time we dispatched to the segDBs.
*/
while (mystatus->currIdx >= lockData->nelements && mystatus->currIdx < lockData->nelements + mystatus->numSegLocks)
{
HeapTuple tuple;
Datum result;
Datum values[16];
bool nulls[16];
int i;
int whichresultset = 0;
int whichelement = mystatus->currIdx - lockData->nelements;
int whichrow = whichelement;
Assert(Gp_role == GP_ROLE_DISPATCH);
/*
* Because we have one result set per segDB (rather than one big result set with everything),
* we need to figure out which result set we are on, and which row within that result set
* we are returning.
*
* So, we walk through all the result sets and all the rows in each one, in order.
*/
while(whichrow >= PQntuples(mystatus->segresults[whichresultset]))
{
whichrow -= PQntuples(mystatus->segresults[whichresultset]);
whichresultset++;
if (whichresultset >= mystatus->numsegresults)
break;
}
/*
* If this condition is true, we have already sent everything back,
* and we just want to do the SRF_RETURN_DONE
*/
if (whichresultset >= mystatus->numsegresults)
break;
mystatus->currIdx++;
/*
* Form tuple with appropriate data we got from the segDBs
*/
MemSet(values, 0, sizeof(values));
MemSet(nulls, false, sizeof(nulls));
/*
* For each column, extract out the value (which comes out in text).
* Convert it to the appropriate datatype to match our tupledesc,
* and put that in values.
* The columns look like this (from select statement earlier):
*
* " (locktype text, database oid, relation oid, page int4, tuple int2,"
* " transactionid xid, classid oid, objid oid, objsubid int2,"
* " transaction xid, pid int4, mode text, granted boolean, "
* " mppSessionId int4, mppIsWriter boolean, gp_segment_id int4) ,"
*/
values[0] = CStringGetTextDatum(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 0));
values[1] = ObjectIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 1)));
values[2] = ObjectIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 2)));
values[3] = UInt32GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 3)));
values[4] = UInt16GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 4)));
values[5] = TransactionIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 5)));
values[6] = ObjectIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 6)));
values[7] = ObjectIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 7)));
values[8] = UInt16GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 8)));
values[9] = TransactionIdGetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow, 9)));
values[10] = UInt32GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow,10)));
values[11] = CStringGetTextDatum(PQgetvalue(mystatus->segresults[whichresultset], whichrow,11));
values[12] = BoolGetDatum(strncmp(PQgetvalue(mystatus->segresults[whichresultset], whichrow,12),"t",1)==0);
values[13] = Int32GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow,13)));
values[14] = BoolGetDatum(strncmp(PQgetvalue(mystatus->segresults[whichresultset], whichrow,14),"t",1)==0);
values[15] = Int32GetDatum(atoi(PQgetvalue(mystatus->segresults[whichresultset], whichrow,15)));
/*
* Copy the null info over. It should all match properly.
*/
for (i=0; i<16; i++)
{
nulls[i] = PQgetisnull(mystatus->segresults[whichresultset], whichrow, i);
}
tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
}
/*
* if we dispatched to the segDBs, free up the memory holding the result sets.
* Otherwise we might leak this memory each time we got called (does it automatically
* get freed by the pool being deleted? Probably, but this is safer).
*/
if (mystatus->segresults != NULL)
{
int i;
for (i = 0; i < mystatus->numsegresults; i++)
PQclear(mystatus->segresults[i]);
free(mystatus->segresults);
}
SRF_RETURN_DONE(funcctx);
}
/*
* InsertRule -
* takes the arguments and inserts them as a row into the system
* relation "pg_rewrite"
*/
static Oid
InsertRule(char *rulname,
int evtype,
Oid eventrel_oid,
AttrNumber evslot_index,
bool evinstead,
Node *event_qual,
List *action,
bool replace,
Oid ruleOid)
{
char *evqual = nodeToString(event_qual);
char *actiontree = nodeToString((Node *) action);
int i;
Datum values[Natts_pg_rewrite];
bool nulls[Natts_pg_rewrite];
bool replaces[Natts_pg_rewrite];
NameData rname;
HeapTuple tup,
oldtup;
Oid rewriteObjectId;
ObjectAddress myself,
referenced;
bool is_update = false;
cqContext *pcqCtx;
/*
* Set up *nulls and *values arrays
*/
MemSet(nulls, false, sizeof(nulls));
i = 0;
namestrcpy(&rname, rulname);
values[i++] = NameGetDatum(&rname); /* rulename */
values[i++] = ObjectIdGetDatum(eventrel_oid); /* ev_class */
values[i++] = Int16GetDatum(evslot_index); /* ev_attr */
values[i++] = CharGetDatum(evtype + '0'); /* ev_type */
values[i++] = BoolGetDatum(evinstead); /* is_instead */
values[i++] = CStringGetTextDatum(evqual); /* ev_qual */
values[i++] = CStringGetTextDatum(actiontree); /* ev_action */
/*
* Ready to store new pg_rewrite tuple
*/
/*
* Check to see if we are replacing an existing tuple
*/
pcqCtx = caql_beginscan(
NULL,
cql("SELECT * FROM pg_rewrite "
" WHERE ev_class = :1 "
" AND rulename = :2 "
" FOR UPDATE ",
ObjectIdGetDatum(eventrel_oid),
CStringGetDatum(rulname)));
oldtup = caql_getnext(pcqCtx);
if (HeapTupleIsValid(oldtup))
{
if (!replace)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("rule \"%s\" for relation \"%s\" already exists",
rulname, get_rel_name(eventrel_oid))));
/*
* When replacing, we don't need to replace every attribute
*/
MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_rewrite_ev_attr - 1] = true;
replaces[Anum_pg_rewrite_ev_type - 1] = true;
replaces[Anum_pg_rewrite_is_instead - 1] = true;
replaces[Anum_pg_rewrite_ev_qual - 1] = true;
replaces[Anum_pg_rewrite_ev_action - 1] = true;
tup = caql_modify_current(pcqCtx,
values, nulls, replaces);
caql_update_current(pcqCtx, tup);
/* and Update indexes (implicit) */
rewriteObjectId = HeapTupleGetOid(tup);
is_update = true;
}
else
{
tup = caql_form_tuple(pcqCtx, values, nulls);
if (OidIsValid(ruleOid))
HeapTupleSetOid(tup, ruleOid);
rewriteObjectId = caql_insert(pcqCtx, tup);
/* and Update indexes (implicit) */
}
heap_freetuple(tup);
/* If replacing, get rid of old dependencies and make new ones */
if (is_update)
deleteDependencyRecordsFor(RewriteRelationId, rewriteObjectId);
/*
* Install dependency on rule's relation to ensure it will go away on
* relation deletion. If the rule is ON SELECT, make the dependency
* implicit --- this prevents deleting a view's SELECT rule. Other kinds
* of rules can be AUTO.
*/
myself.classId = RewriteRelationId;
myself.objectId = rewriteObjectId;
myself.objectSubId = 0;
referenced.classId = RelationRelationId;
referenced.objectId = eventrel_oid;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced,
(evtype == CMD_SELECT) ? DEPENDENCY_INTERNAL : DEPENDENCY_AUTO);
/*
* Also install dependencies on objects referenced in action and qual.
*/
recordDependencyOnExpr(&myself, (Node *) action, NIL,
DEPENDENCY_NORMAL);
if (event_qual != NULL)
{
/* Find query containing OLD/NEW rtable entries */
Query *qry = (Query *) linitial(action);
qry = getInsertSelectQuery(qry, NULL);
recordDependencyOnExpr(&myself, event_qual, qry->rtable,
DEPENDENCY_NORMAL);
}
caql_endscan(pcqCtx);
return rewriteObjectId;
}
/* MPP-6923: */
static
List *
AlterResqueueCapabilityEntry(
List *stmtOptIdList,
Oid queueid,
ListCell *initcell,
bool bCreate)
{
ListCell *lc;
List *elems = NIL;
List *dropelems = NIL;
List *dupcheck = NIL;
HeapTuple tuple;
cqContext *pcqCtx;
cqContext cqc;
Relation rel = NULL;
bool bWithout = false;
TupleDesc tupdesc = NULL;
#ifdef USE_ASSERT_CHECKING
{
DefElem *defel = (DefElem *) lfirst(initcell);
Assert(0 == strcmp(defel->defname, "withliststart"));
}
#endif
initcell = lnext(initcell);
/* walk the original list and build a list of valid entries */
for_each_cell(lc, initcell)
{
DefElem *defel = (DefElem *) lfirst(lc);
Oid resTypeOid = InvalidOid;
int resTypeInt = 0;
List *pentry = NIL;
Value *pKeyVal = NULL;
Value *pStrVal = NULL;
if (!bWithout && (strcmp(defel->defname, "withoutliststart") == 0))
{
bWithout = true;
rel = heap_open(ResourceTypeRelationId, RowExclusiveLock);
tupdesc = RelationGetDescr(rel);
goto L_loop_cont;
}
/* ignore the basic threshold entries -- should already be processed */
if (strcmp(defel->defname, "active_statements") == 0)
goto L_loop_cont;
if (strcmp(defel->defname, "max_cost") == 0)
goto L_loop_cont;
if (strcmp(defel->defname, "cost_overcommit") == 0)
goto L_loop_cont;
if (strcmp(defel->defname, "min_cost") == 0)
goto L_loop_cont;
if (!GetResourceTypeByName(defel->defname, &resTypeInt, &resTypeOid))
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("option \"%s\" is not a valid resource type",
defel->defname)));
pKeyVal = makeString(defel->defname);
/* WITHOUT clause value determined in pg_resourcetype */
if (!bWithout)
pStrVal = makeString(defGetString(defel));
else
{
pStrVal = NULL; /* if NULL, delete entry from
* pg_resqueuecapability
*/
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), rel),
cql("SELECT * FROM pg_resourcetype"
" WHERE restypid = :1 FOR UPDATE",
Int16GetDatum(resTypeInt)));
while (HeapTupleIsValid(tuple = caql_getnext(pcqCtx)))
{
text *shutoff_text = NULL;
char *shutoff_str = NULL;
Datum shutoff_datum;
bool isnull = false;
Form_pg_resourcetype rtyp =
(Form_pg_resourcetype)GETSTRUCT(tuple);
if (!rtyp->reshasdisable)
{
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("option \"%s\" cannot be disabled",
defel->defname)));
}
/* required type must have a default value if it can
* be disabled
*/
if (!rtyp->reshasdefault)
{
if (!rtyp->resrequired)
/* optional resource without a default is
* turned off by removing entry from
* pg_resqueuecapability
*/
break;
else
{
/* XXX XXX */
Assert(0);
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("required option \"%s\" cannot be disabled",
defel->defname)));
}
}
/* get the shutoff string */
shutoff_datum =
heap_getattr(tuple,
Anum_pg_resourcetype_resdisabledsetting,
tupdesc,
&isnull);
Assert(!isnull);
shutoff_text = DatumGetTextP(shutoff_datum);
shutoff_str =
DatumGetCString(
DirectFunctionCall1(
textout,
PointerGetDatum(shutoff_text)));
pStrVal = makeString(shutoff_str);
break;
} /* end while heaptuple is valid */
caql_endscan(pcqCtx);
}
/* check for duplicate key specifications */
if (list_member(dupcheck, pKeyVal))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("conflicting or redundant option for \"%s\"",
defel->defname)));
dupcheck = lappend(dupcheck, pKeyVal);
pentry = list_make2(
makeInteger(resTypeInt),
pStrVal);
/* list of lists - (resource type, resource setting) */
if (bWithout)
{
/* if the "without" entry has an "off" value, then treat
* it as a regular "with" item and update it in
* pg_resqueuecapability, else remove its entry
*/
if (!pStrVal)
dropelems = lappend(dropelems, pentry);
else
elems = lappend(elems, pentry);
}
else
elems = lappend(elems, pentry);
L_loop_cont:
resTypeInt = 0; /* make compiler happy */
}
/*
* This tests operators and orderby
*/
void
test__caql_switch7(void **state)
{
const char *query = "SELECT * FROM pg_class "
"WHERE oid < :1 AND relnatts > :2 AND "
"relfilenode <= :3 AND relpages >= :4 "
"ORDER BY oid, relnatts, relfilenode";
struct caql_hash_cookie *hash_cookie;
cqContext context = {0}, *pCtx;
Datum keys[] = {ObjectIdGetDatum(10000),
Int16GetDatum(10),
ObjectIdGetDatum(10000),
Int32GetDatum(5)};
cq_list *pcql = CaQL(query, 1, keys);
RelationData dummyrel;
SysScanDescData dummydesc;
dummyrel.rd_id = RelationRelationId;
hash_cookie = cq_lookup(query, strlen(query), pcql);
pCtx = caql_snapshot(cqclr(&context), SnapshotDirty);
/* setup heap_open */
expect__heap_open(RelationRelationId, true,
AccessShareLock, true,
&dummyrel);
/* setup ScanKeyInit */
expect__ScanKeyInit(NULL, false,
ObjectIdAttributeNumber, true,
BTLessStrategyNumber, true,
F_OIDLT, true,
NULL, false);
expect__ScanKeyInit(NULL, false,
Anum_pg_class_relnatts, true,
BTGreaterStrategyNumber, true,
F_INT2GT, true,
NULL, false);
expect__ScanKeyInit(NULL, false,
Anum_pg_class_relfilenode, true,
BTLessEqualStrategyNumber, true,
F_OIDLE, true,
NULL, false);
expect__ScanKeyInit(NULL, false,
Anum_pg_class_relpages, true,
BTGreaterEqualStrategyNumber, true,
F_INT4GE, true,
NULL, false);
/* setup systable_beginscan */
expect__systable_beginscan(&dummyrel, true,
InvalidOid, false,
false, true,
SnapshotDirty, true,
4, true,
NULL, false,
&dummydesc);
pCtx = caql_switch(hash_cookie, pCtx, pcql);
assert_true(pCtx != NULL);
assert_true(!pCtx->cq_usesyscache);
assert_true(pCtx->cq_heap_rel->rd_id == RelationRelationId);
assert_true(!pCtx->cq_useidxOK);
}
/*
* get_attribute_options
* Fetch attribute options for a specified table OID.
*/
AttributeOpts *
get_attribute_options(Oid attrelid, int attnum)
{
AttoptCacheKey key;
AttoptCacheEntry *attopt;
AttributeOpts *result;
HeapTuple tp;
/* Find existing cache entry, if any. */
if (!AttoptCacheHash)
InitializeAttoptCache();
memset(&key, 0, sizeof(key)); /* make sure any padding bits are
* unset */
key.attrelid = attrelid;
key.attnum = attnum;
attopt =
(AttoptCacheEntry *) hash_search(AttoptCacheHash,
(void *) &key,
HASH_FIND,
NULL);
/* Not found in Attopt cache. Construct new cache entry. */
if (!attopt)
{
AttributeOpts *opts;
tp = SearchSysCache2(ATTNUM,
ObjectIdGetDatum(attrelid),
Int16GetDatum(attnum));
/*
* If we don't find a valid HeapTuple, it must mean someone has
* managed to request attribute details for a non-existent attribute.
* We treat that case as if no options were specified.
*/
if (!HeapTupleIsValid(tp))
opts = NULL;
else
{
Datum datum;
bool isNull;
datum = SysCacheGetAttr(ATTNUM,
tp,
Anum_pg_attribute_attoptions,
&isNull);
if (isNull)
opts = NULL;
else
{
bytea *bytea_opts = attribute_reloptions(datum, false);
opts = MemoryContextAlloc(CacheMemoryContext,
VARSIZE(bytea_opts));
memcpy(opts, bytea_opts, VARSIZE(bytea_opts));
}
ReleaseSysCache(tp);
}
/*
* It's important to create the actual cache entry only after reading
* pg_attribute, since the read could cause a cache flush.
*/
attopt = (AttoptCacheEntry *) hash_search(AttoptCacheHash,
(void *) &key,
HASH_ENTER,
NULL);
attopt->opts = opts;
}
/* Return results in caller's memory context. */
if (attopt->opts == NULL)
return NULL;
result = palloc(VARSIZE(attopt->opts));
memcpy(result, attopt->opts, VARSIZE(attopt->opts));
return result;
}
void GpPersistentRelationNode_SetDatumValues(
Datum *values,
Oid tablespaceOid,
Oid databaseOid,
Oid relfilenodeOid,
int32 segmentFileNum,
PersistentFileSysRelStorageMgr relationStorageManager,
PersistentFileSysState persistentState,
int64 createMirrorDataLossTrackingSessionNum,
MirroredObjectExistenceState mirrorExistenceState,
MirroredRelDataSynchronizationState mirrorDataSynchronizationState,
bool mirrorBufpoolMarkedForScanIncrementalResync,
int64 mirrorBufpoolResyncChangedPageCount,
XLogRecPtr *mirrorBufpoolResyncCkptLoc,
BlockNumber mirrorBufpoolResyncCkptBlockNum,
int64 mirrorAppendOnlyLossEof,
int64 mirrorAppendOnlyNewEof,
PersistentFileSysRelBufpoolKind relBufpoolKind,
TransactionId parentXid,
int64 persistentSerialNum)
{
if (persistentState != PersistentFileSysState_Free && !PersistentFileSysRelStorageMgr_IsValid(relationStorageManager))
elog(ERROR, "Invalid value for relation storage manager (%d)",
relationStorageManager);
values[Anum_gp_persistent_relation_node_tablespace_oid - 1] =
ObjectIdGetDatum(tablespaceOid);
values[Anum_gp_persistent_relation_node_database_oid - 1] =
ObjectIdGetDatum(databaseOid);
values[Anum_gp_persistent_relation_node_relfilenode_oid - 1] =
ObjectIdGetDatum(relfilenodeOid);
values[Anum_gp_persistent_relation_node_segment_file_num - 1] =
Int32GetDatum(segmentFileNum);
values[Anum_gp_persistent_relation_node_relation_storage_manager - 1] =
Int16GetDatum(relationStorageManager);
values[Anum_gp_persistent_relation_node_persistent_state - 1] =
Int16GetDatum(persistentState);
values[Anum_gp_persistent_relation_node_create_mirror_data_loss_tracking_session_num - 1] =
Int64GetDatum(createMirrorDataLossTrackingSessionNum);
values[Anum_gp_persistent_relation_node_mirror_existence_state - 1] =
Int16GetDatum(mirrorExistenceState);
values[Anum_gp_persistent_relation_node_mirror_data_synchronization_state - 1] =
Int16GetDatum(mirrorDataSynchronizationState);
values[Anum_gp_persistent_relation_node_mirror_bufpool_marked_for_scan_incremental_resync - 1] =
BoolGetDatum(mirrorBufpoolMarkedForScanIncrementalResync);
values[Anum_gp_persistent_relation_node_mirror_bufpool_resync_changed_page_count - 1] =
Int64GetDatum(mirrorBufpoolResyncChangedPageCount);
values[Anum_gp_persistent_relation_node_mirror_bufpool_resync_ckpt_loc - 1] =
PointerGetDatum(mirrorBufpoolResyncCkptLoc);
values[Anum_gp_persistent_relation_node_mirror_bufpool_resync_ckpt_block_num - 1] =
Int32GetDatum(mirrorBufpoolResyncCkptBlockNum);
values[Anum_gp_persistent_relation_node_mirror_append_only_loss_eof - 1] =
Int64GetDatum(mirrorAppendOnlyLossEof);
values[Anum_gp_persistent_relation_node_mirror_append_only_new_eof - 1] =
Int64GetDatum(mirrorAppendOnlyNewEof);
values[Anum_gp_persistent_relation_node_relation_bufpool_kind - 1] =
Int32GetDatum((int32)relBufpoolKind);
values[Anum_gp_persistent_relation_node_parent_xid - 1] =
Int32GetDatum(parentXid);
values[Anum_gp_persistent_relation_node_persistent_serial_num - 1] =
Int64GetDatum(persistentSerialNum);
}
void GpPersistentFilespaceNode_SetDatumValues(
Datum *values,
Oid filespaceOid,
int16 dbId1,
char locationBlankPadded1[FilespaceLocationBlankPaddedWithNullTermLen],
int16 dbId2,
char locationBlankPadded2[FilespaceLocationBlankPaddedWithNullTermLen],
PersistentFileSysState persistentState,
int64 createMirrorDataLossTrackingSessionNum,
MirroredObjectExistenceState mirrorExistenceState,
int32 reserved,
TransactionId parentXid,
int64 persistentSerialNum)
{
int locationLen;
locationLen = strlen(locationBlankPadded1);
if (locationLen != FilespaceLocationBlankPaddedWithNullTermLen - 1)
elog(ERROR, "Expected filespace location 1 to be %d characters and found %d",
FilespaceLocationBlankPaddedWithNullTermLen - 1,
locationLen);
locationLen = strlen(locationBlankPadded2);
if (locationLen != FilespaceLocationBlankPaddedWithNullTermLen - 1)
elog(ERROR, "Expected filespace location 2 to be %d characters and found %d",
FilespaceLocationBlankPaddedWithNullTermLen - 1,
locationLen);
values[Anum_gp_persistent_filespace_node_filespace_oid - 1] =
ObjectIdGetDatum(filespaceOid);
values[Anum_gp_persistent_filespace_node_db_id_1 - 1] =
Int16GetDatum(dbId1);
values[Anum_gp_persistent_filespace_node_location_1 - 1] =
CStringGetTextDatum(locationBlankPadded1);
values[Anum_gp_persistent_filespace_node_db_id_2 - 1] =
Int16GetDatum(dbId2);
values[Anum_gp_persistent_filespace_node_location_2 - 1] =
CStringGetTextDatum(locationBlankPadded2);
values[Anum_gp_persistent_filespace_node_persistent_state - 1] =
Int16GetDatum(persistentState);
values[Anum_gp_persistent_filespace_node_create_mirror_data_loss_tracking_session_num - 1] =
Int64GetDatum(createMirrorDataLossTrackingSessionNum);
values[Anum_gp_persistent_filespace_node_mirror_existence_state - 1] =
Int16GetDatum(mirrorExistenceState);
values[Anum_gp_persistent_filespace_node_reserved - 1] =
Int32GetDatum(reserved);
values[Anum_gp_persistent_filespace_node_parent_xid - 1] =
Int32GetDatum(parentXid);
values[Anum_gp_persistent_filespace_node_persistent_serial_num - 1] =
Int64GetDatum(persistentSerialNum);
}
TupleTableSlot* BuildModelInfoTupleTableSlot(ModelInfo *modelInfo){
TupleTableSlot *resultSlot;
HeapTuple tuple;
TupleDesc tdesc;
Datum *values;
bool *isNull;
Form_pg_attribute *attrs;
// open the relation pg_model to lend the TupleDescriptor from it
Relation rel = heap_open(ModelRelationId, 0);
// we have to copy the lent TupleDesc, otherwise the relation pg_model won't talk to us later
tdesc = CreateTupleDescCopy(rel->rd_att);
/*hsdesc = heap_beginscan(rel, SnapshotNow, 0, NULL);
tuple = heap_getnext(hsdesc, ForwardScanDirection);
resultSlot = MakeSingleTupleTableSlot(tdesc);*/
attrs = palloc(sizeof(FormData_pg_attribute)*7);
attrs[0] = tdesc->attrs[0]; //name
attrs[1] = tdesc->attrs[4]; //algorithm
attrs[2] = tdesc->attrs[2]; //time
attrs[3] = tdesc->attrs[3]; //measure
attrs[4] = tdesc->attrs[6]; //aggtype
attrs[5] = tdesc->attrs[5]; //granularity
attrs[6] = tdesc->attrs[9]; //timestamp
tdesc = CreateTupleDesc(7, false, attrs);
resultSlot = MakeSingleTupleTableSlot(tdesc);
values = (Datum *)palloc(sizeof(Datum)*7);
isNull = (bool *)palloc0(sizeof(bool)*7);
if(modelInfo->modelName){
values[0] = PointerGetDatum(modelInfo->modelName);
}else{
// if a model is not stored, it has no name
isNull[0] = true;
}
values[1] = PointerGetDatum(getModelTypeAsString((ModelType)(modelInfo->forecastMethod)));
isNull[1] = false;
values[2] = Int16GetDatum(modelInfo->time->resorigcol);
isNull[2] = false;
values[3] = Int16GetDatum(modelInfo->measure->resorigcol);
isNull[3] = false;
values[4] = ObjectIdGetDatum(modelInfo->aggType);
isNull[4] = false;
values[5] = Int16GetDatum(modelInfo->granularity);
isNull[5] = false;
values[6] = Int32GetDatum(modelInfo->timestamp);
isNull[6] = false;
tuple = heap_form_tuple(tdesc, values, isNull);
if(tuple){
ExecStoreTuple(tuple, resultSlot, InvalidBuffer, false);
}
// if(hsdesc){
// heap_endscan(hsdesc);
// }
heap_close(rel, 0);
return resultSlot;
}
Datum
gp_build_logical_index_info(PG_FUNCTION_ARGS)
{
Oid relid = PG_GETARG_OID(0);
FuncCallContext *funcctx;
MemoryContext oldcontext;
TupleDesc tupdesc;
HeapTuple tuple;
bool nulls[NUM_COLS];
LogicalIndexes *partsLI;
if (SRF_IS_FIRSTCALL())
{
/* create a function context */
funcctx = SRF_FIRSTCALL_INIT();
/* switch memory context for multiple function calls */
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
/* build tupdesc for result tuples */
tupdesc = CreateTemplateTupleDesc(NUM_COLS, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "logicalIndexId",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "nColumns",
INT2OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 3, "indexKeys",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 4, "indIsUnique",
BOOLOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 5, "indPred",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 6, "indExprs",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 7, "partConsBin",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 8, "defaultLevels",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 9, "indType",
INT2OID, -1, 0);
funcctx->tuple_desc = BlessTupleDesc(tupdesc);
partsLI = (LogicalIndexes *)palloc(sizeof(LogicalIndexes));
funcctx->user_fctx = (void *) partsLI;
/* do the actual work */
partsLI = BuildLogicalIndexInfo(relid);
funcctx->user_fctx = (void *) partsLI;
if (partsLI)
funcctx->max_calls = partsLI->numLogicalIndexes;
MemoryContextSwitchTo(oldcontext);
}
funcctx = SRF_PERCALL_SETUP();
partsLI = (LogicalIndexes *)funcctx->user_fctx;
if (funcctx->call_cntr < funcctx->max_calls)
{
/* fetch each tuple, and return */
Datum values[NUM_COLS];
Datum result;
char *c;
text *t;
StringInfoData keys;
int i;
LogicalIndexInfo *li = partsLI->logicalIndexInfo[funcctx->call_cntr];
for (int i = 0; i < NUM_COLS; i++)
nulls[i] = false;
values[0] = ObjectIdGetDatum(li->logicalIndexOid);
values[1] = Int16GetDatum(li->nColumns);
initStringInfo(&keys);
for (i = 0; i < li->nColumns; i++)
appendStringInfo(&keys, "%d ",li->indexKeys[i]);
t = cstring_to_text(keys.data);
values[2] = PointerGetDatum(t);
values[3] = BoolGetDatum(li->indIsUnique);
if (li->indPred)
{
c = nodeToString(li->indPred);
t = cstring_to_text(c);
values[4] = PointerGetDatum(t);
}
else
nulls[4] = true;
if (li->indExprs)
{
c = nodeToString(li->indExprs);
t = cstring_to_text(c);
values[5] = PointerGetDatum(t);
}
else
nulls[5] = true;
if (li->partCons)
{
/* get the expr form -- for readability */
c = deparse_expression(li->partCons,
deparse_context_for(get_rel_name(relid),
relid),
false, false);
t = cstring_to_text(c);
values[6] = PointerGetDatum(t);
}
else
nulls[6] = true;
if (li->defaultLevels)
{
c = nodeToString(li->defaultLevels);
t = cstring_to_text(c);
values[7] = PointerGetDatum(t);
}
else
nulls[7] = true;
values[8] = li->indType;
nulls[8] = false;
/* build tuple */
tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
/* make the tuple into a datum */
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
}
else
{
SRF_RETURN_DONE(funcctx);
}
}
uint64 memReservedForParquetScan(Oid rel_oid, List* attr_list) {
uint64 rowgroupsize = 0;
char *compresstype = NULL;
uint64 memReserved = 0;
int attrNum = get_relnatts(rel_oid); /*Get the total attribute number of the relation*/
uint64 attsWidth = 0; /*the sum width of attributes to be scanned*/
uint64 recordWidth = 0; /*the average width of one record in the relation*/
/* The width array for all the attributes in the relation*/
int32 *attWidth = (int32*)palloc0(attrNum * sizeof(int32));
/** The variables for traversing through attribute list*/
ListCell *cell;
/* Get rowgroup size and compress type */
AppendOnlyEntry *aoEntry = GetAppendOnlyEntry(rel_oid, SnapshotNow);
rowgroupsize = aoEntry->blocksize;
compresstype = aoEntry->compresstype;
/** For each column in the relation, get the column width
* 1) Get the column width from pg_attribute, estimate column width for to-be-scanned columns:
* If fixed column width, the attlen is the column width; if not fixed, refer to typmod
* 2) Get the average column width for variable length type column from table pg_statistic, if the
* stawidth not equals 0, set it as the column width.
*/
for(int i = 0; i < attrNum; i++){
int att_id = i + 1;
HeapTuple attTuple = caql_getfirst(NULL, cql("SELECT * FROM pg_attribute"
" WHERE attrelid = :1 "
" AND attnum = :2 ",
ObjectIdGetDatum(rel_oid),
Int16GetDatum(att_id)));
if (HeapTupleIsValid(attTuple)) {
/*Step1: estimate attwidth according to pg_attributes*/
Form_pg_attribute att = (Form_pg_attribute) GETSTRUCT(attTuple);
estimateColumnWidth(attWidth, &i, att, false);
i--;
int32 stawidth = 0;
/*Step2: adjust addwidth according to pg_statistic*/
switch (att->atttypid)
{
case HAWQ_TYPE_VARCHAR:
case HAWQ_TYPE_TEXT:
case HAWQ_TYPE_XML:
case HAWQ_TYPE_PATH:
case HAWQ_TYPE_POLYGON:
stawidth = get_attavgwidth(rel_oid, att_id);
if(stawidth != 0)
attWidth[i] = stawidth;
break;
case HAWQ_TYPE_VARBIT:
stawidth = get_attavgwidth(rel_oid, att_id);
if(stawidth != 0)
attWidth[i] = stawidth + 4;
break;
default:
break;
}
}
recordWidth += attWidth[i];
}
/* Reverse through the to-be-scanned attribute list, sum up the width */
Assert (1 <= list_length(attr_list));
foreach(cell, attr_list)
{
AttrNumber att_id = lfirst_int(cell);
Assert(1 <= att_id);
Assert(att_id <= attrNum);
attsWidth += attWidth[att_id - 1]; /*sum up the attribute width in the to-be-scanned list*/
}
/*
* Sets the policy of a table into the gp_distribution_policy table
* from a GpPolicy structure.
*
*/
void
GpPolicyReplace(Oid tbloid, const GpPolicy *policy)
{
Relation gp_policy_rel;
HeapTuple gp_policy_tuple = NULL;
cqContext cqc;
cqContext *pcqCtx;
ArrayType *attrnums;
bool nulls[2];
Datum values[2];
bool repl[2];
Insist(policy->ptype == POLICYTYPE_PARTITIONED);
/*
* Open and lock the gp_distribution_policy catalog.
*/
gp_policy_rel = heap_open(GpPolicyRelationId, RowExclusiveLock);
pcqCtx = caql_addrel(cqclr(&cqc), gp_policy_rel);
/*
* Convert C arrays into Postgres arrays.
*/
if (policy->nattrs > 0)
{
int i;
Datum *akey;
akey = (Datum *) palloc(policy->nattrs * sizeof(Datum));
for (i = 0; i < policy->nattrs; i++)
akey[i] = Int16GetDatum(policy->attrs[i]);
attrnums = construct_array(akey, policy->nattrs,
INT2OID, 2, true, 's');
}
else
{
attrnums = NULL;
}
nulls[0] = false;
nulls[1] = false;
values[0] = ObjectIdGetDatum(tbloid);
if (attrnums)
values[1] = PointerGetDatum(attrnums);
else
nulls[1] = true;
repl[0] = false;
repl[1] = true;
/*
* Select by value of the localoid field
*/
gp_policy_tuple = caql_getfirst(
pcqCtx,
cql("SELECT * FROM gp_distribution_policy "
" WHERE localoid = :1 "
" FOR UPDATE ",
ObjectIdGetDatum(tbloid)));
/*
* Read first (and only ) tuple
*/
if (HeapTupleIsValid(gp_policy_tuple))
{
HeapTuple newtuple = caql_modify_current(pcqCtx, values,
nulls, repl);
caql_update_current(pcqCtx, newtuple);
/* and Update indexes (implicit) */
heap_freetuple(newtuple);
}
else
{
gp_policy_tuple = caql_form_tuple(pcqCtx, values, nulls);
caql_insert(pcqCtx, gp_policy_tuple);
/* and Update indexes (implicit) */
}
/*
* Close the gp_distribution_policy relcache entry without unlocking.
* We have updated the catalog: consequently the lock must be held until
* end of transaction.
*/
heap_close(gp_policy_rel, NoLock);
} /* GpPolicyReplace */
Datum
gp_inject_fault(PG_FUNCTION_ARGS)
{
char *faultName = TextDatumGetCString(PG_GETARG_DATUM(0));
char *type = TextDatumGetCString(PG_GETARG_DATUM(1));
char *ddlStatement = TextDatumGetCString(PG_GETARG_DATUM(2));
char *databaseName = TextDatumGetCString(PG_GETARG_DATUM(3));
char *tableName = TextDatumGetCString(PG_GETARG_DATUM(4));
int numOccurrences = PG_GETARG_INT32(5);
int sleepTimeSeconds = PG_GETARG_INT32(6);
int dbid = PG_GETARG_INT32(7);
StringInfo faultmsg = makeStringInfo();
/* Fast path if injecting fault in our postmaster. */
if (GpIdentity.dbid == dbid)
{
appendStringInfo(faultmsg, "%s\n%s\n%s\n%s\n%s\n%d\n%d\n",
faultName, type, ddlStatement, databaseName,
tableName, numOccurrences, sleepTimeSeconds);
int offset = 0;
char *response =
processTransitionRequest_faultInject(
faultmsg->data, &offset, faultmsg->len);
if (!response)
elog(ERROR, "failed to inject fault locally (dbid %d)", dbid);
if (strncmp(response, "Success:", strlen("Success:")) != 0)
elog(ERROR, "%s", response);
elog(NOTICE, "%s", response);
PG_RETURN_DATUM(true);
}
/* Obtain host and port of the requested dbid */
HeapTuple tuple;
Relation rel = heap_open(GpSegmentConfigRelationId, AccessShareLock);
ScanKeyData scankey;
SysScanDesc sscan;
ScanKeyInit(&scankey,
Anum_gp_segment_configuration_dbid,
BTEqualStrategyNumber, F_INT2EQ,
Int16GetDatum((int16) dbid));
sscan = systable_beginscan(rel, GpSegmentConfigDbidIndexId, true,
GetTransactionSnapshot(), 1, &scankey);
tuple = systable_getnext(sscan);
if (!HeapTupleIsValid(tuple))
elog(ERROR, "cannot find dbid %d", dbid);
bool isnull;
Datum datum = heap_getattr(tuple, Anum_gp_segment_configuration_hostname,
RelationGetDescr(rel), &isnull);
char *hostname;
if (!isnull)
hostname =
DatumGetCString(DirectFunctionCall1(textout, datum));
else
elog(ERROR, "hostname is null for dbid %d", dbid);
int port = DatumGetInt32(heap_getattr(tuple,
Anum_gp_segment_configuration_port,
RelationGetDescr(rel), &isnull));
systable_endscan(sscan);
heap_close(rel, NoLock);
struct addrinfo *addrList = NULL;
struct addrinfo hint;
int ret;
/* Initialize hint structure */
MemSet(&hint, 0, sizeof(hint));
hint.ai_socktype = SOCK_STREAM;
hint.ai_family = AF_UNSPEC;
char portStr[100];
if (snprintf(portStr, sizeof(portStr), "%d", port) >= sizeof(portStr))
elog(ERROR, "port number too long for dbid %d", dbid);
/* Use pg_getaddrinfo_all() to resolve the address */
ret = pg_getaddrinfo_all(hostname, portStr, &hint, &addrList);
if (ret || !addrList)
{
if (addrList)
pg_freeaddrinfo_all(hint.ai_family, addrList);
elog(ERROR, "could not translate host name \"%s\" to address: %s\n",
hostname, gai_strerror(ret));
}
PrimaryMirrorTransitionClientInfo client;
client.receivedDataCallbackFn = transitionReceivedDataFn;
client.errorLogFn = transitionErrorLogFn;
client.checkForNeedToExitFn = checkForNeedToExitFn;
transitionMsgErrors = makeStringInfo();
appendStringInfo(faultmsg, "%s\n%s\n%s\n%s\n%s\n%s\n%d\n%d\n",
"faultInject", faultName, type, ddlStatement,
databaseName, tableName, numOccurrences,
sleepTimeSeconds);
if (sendTransitionMessage(&client, addrList, faultmsg->data, faultmsg->len,
1 /* retries */, 60 /* timeout */) !=
TRANS_ERRCODE_SUCCESS)
{
pg_freeaddrinfo_all(hint.ai_family, addrList);
ereport(ERROR, (errmsg("failed to inject %s fault in dbid %d",
faultName, dbid),
errdetail("%s", transitionMsgErrors->data)));
}
pg_freeaddrinfo_all(hint.ai_family, addrList);
PG_RETURN_DATUM(BoolGetDatum(true));
}
/*
* gistindex_keytest() -- does this index tuple satisfy the scan key(s)?
*
* The index tuple might represent either a heap tuple or a lower index page,
* depending on whether the containing page is a leaf page or not.
*
* On success return for a heap tuple, *recheck_p is set to indicate whether
* the quals need to be rechecked. We recheck if any of the consistent()
* functions request it. recheck is not interesting when examining a non-leaf
* entry, since we must visit the lower index page if there's any doubt.
* Similarly, *recheck_distances_p is set to indicate whether the distances
* need to be rechecked, and it is also ignored for non-leaf entries.
*
* If we are doing an ordered scan, so->distances[] is filled with distance
* data from the distance() functions before returning success.
*
* We must decompress the key in the IndexTuple before passing it to the
* sk_funcs (which actually are the opclass Consistent or Distance methods).
*
* Note that this function is always invoked in a short-lived memory context,
* so we don't need to worry about cleaning up allocated memory, either here
* or in the implementation of any Consistent or Distance methods.
*/
static bool
gistindex_keytest(IndexScanDesc scan,
IndexTuple tuple,
Page page,
OffsetNumber offset,
bool *recheck_p,
bool *recheck_distances_p)
{
GISTScanOpaque so = (GISTScanOpaque) scan->opaque;
GISTSTATE *giststate = so->giststate;
ScanKey key = scan->keyData;
int keySize = scan->numberOfKeys;
double *distance_p;
Relation r = scan->indexRelation;
*recheck_p = false;
*recheck_distances_p = false;
/*
* If it's a leftover invalid tuple from pre-9.1, treat it as a match with
* minimum possible distances. This means we'll always follow it to the
* referenced page.
*/
if (GistTupleIsInvalid(tuple))
{
int i;
if (GistPageIsLeaf(page)) /* shouldn't happen */
elog(ERROR, "invalid GiST tuple found on leaf page");
for (i = 0; i < scan->numberOfOrderBys; i++)
so->distances[i] = -get_float8_infinity();
return true;
}
/* Check whether it matches according to the Consistent functions */
while (keySize > 0)
{
Datum datum;
bool isNull;
datum = index_getattr(tuple,
key->sk_attno,
giststate->tupdesc,
&isNull);
if (key->sk_flags & SK_ISNULL)
{
/*
* On non-leaf page we can't conclude that child hasn't NULL
* values because of assumption in GiST: union (VAL, NULL) is VAL.
* But if on non-leaf page key IS NULL, then all children are
* NULL.
*/
if (key->sk_flags & SK_SEARCHNULL)
{
if (GistPageIsLeaf(page) && !isNull)
return false;
}
else
{
Assert(key->sk_flags & SK_SEARCHNOTNULL);
if (isNull)
return false;
}
}
else if (isNull)
{
return false;
}
else
{
Datum test;
bool recheck;
GISTENTRY de;
gistdentryinit(giststate, key->sk_attno - 1, &de,
datum, r, page, offset,
false, isNull);
/*
* Call the Consistent function to evaluate the test. The
* arguments are the index datum (as a GISTENTRY*), the comparison
* datum, the comparison operator's strategy number and subtype
* from pg_amop, and the recheck flag.
*
* (Presently there's no need to pass the subtype since it'll
* always be zero, but might as well pass it for possible future
* use.)
*
* We initialize the recheck flag to true (the safest assumption)
* in case the Consistent function forgets to set it.
*/
recheck = true;
test = FunctionCall5Coll(&key->sk_func,
key->sk_collation,
PointerGetDatum(&de),
key->sk_argument,
Int16GetDatum(key->sk_strategy),
ObjectIdGetDatum(key->sk_subtype),
PointerGetDatum(&recheck));
if (!DatumGetBool(test))
return false;
*recheck_p |= recheck;
}
key++;
keySize--;
}
/* OK, it passes --- now let's compute the distances */
key = scan->orderByData;
distance_p = so->distances;
keySize = scan->numberOfOrderBys;
while (keySize > 0)
{
Datum datum;
bool isNull;
datum = index_getattr(tuple,
key->sk_attno,
giststate->tupdesc,
&isNull);
if ((key->sk_flags & SK_ISNULL) || isNull)
{
/* Assume distance computes as null and sorts to the end */
*distance_p = get_float8_infinity();
}
else
{
Datum dist;
bool recheck;
GISTENTRY de;
gistdentryinit(giststate, key->sk_attno - 1, &de,
datum, r, page, offset,
false, isNull);
/*
* Call the Distance function to evaluate the distance. The
* arguments are the index datum (as a GISTENTRY*), the comparison
* datum, the ordering operator's strategy number and subtype from
* pg_amop, and the recheck flag.
*
* (Presently there's no need to pass the subtype since it'll
* always be zero, but might as well pass it for possible future
* use.)
*
* If the function sets the recheck flag, the returned distance is
* a lower bound on the true distance and needs to be rechecked.
* We initialize the flag to 'false'. This flag was added in
* version 9.5; distance functions written before that won't know
* about the flag, but are expected to never be lossy.
*/
recheck = false;
dist = FunctionCall5Coll(&key->sk_func,
key->sk_collation,
PointerGetDatum(&de),
key->sk_argument,
Int16GetDatum(key->sk_strategy),
ObjectIdGetDatum(key->sk_subtype),
PointerGetDatum(&recheck));
*recheck_distances_p |= recheck;
*distance_p = DatumGetFloat8(dist);
}
key++;
distance_p++;
keySize--;
}
return true;
}
/*
* CreateConstraintEntry
* Create a constraint table entry.
*
* Subsidiary records (such as triggers or indexes to implement the
* constraint) are *not* created here. But we do make dependency links
* from the constraint to the things it depends on.
*/
Oid
CreateConstraintEntry(const char *constraintName,
Oid constraintNamespace,
char constraintType,
bool isDeferrable,
bool isDeferred,
Oid relId,
const int16 *constraintKey,
int constraintNKeys,
Oid domainId,
Oid foreignRelId,
const int16 *foreignKey,
const Oid *pfEqOp,
const Oid *ppEqOp,
const Oid *ffEqOp,
int foreignNKeys,
char foreignUpdateType,
char foreignDeleteType,
char foreignMatchType,
Oid indexRelId,
Node *conExpr,
const char *conBin,
const char *conSrc)
{
Relation conDesc;
Oid conOid;
HeapTuple tup;
bool nulls[Natts_pg_constraint];
Datum values[Natts_pg_constraint];
ArrayType *conkeyArray;
ArrayType *confkeyArray;
ArrayType *conpfeqopArray;
ArrayType *conppeqopArray;
ArrayType *conffeqopArray;
NameData cname;
int i;
ObjectAddress conobject;
conDesc = heap_open(ConstraintRelationId, RowExclusiveLock);
Assert(constraintName);
namestrcpy(&cname, constraintName);
/*
* Convert C arrays into Postgres arrays.
*/
if (constraintNKeys > 0)
{
Datum *conkey;
conkey = (Datum *) palloc(constraintNKeys * sizeof(Datum));
for (i = 0; i < constraintNKeys; i++)
conkey[i] = Int16GetDatum(constraintKey[i]);
conkeyArray = construct_array(conkey, constraintNKeys,
INT2OID, 2, true, 's');
}
else
conkeyArray = NULL;
if (foreignNKeys > 0)
{
Datum *fkdatums;
fkdatums = (Datum *) palloc(foreignNKeys * sizeof(Datum));
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = Int16GetDatum(foreignKey[i]);
confkeyArray = construct_array(fkdatums, foreignNKeys,
INT2OID, 2, true, 's');
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = ObjectIdGetDatum(pfEqOp[i]);
conpfeqopArray = construct_array(fkdatums, foreignNKeys,
OIDOID, sizeof(Oid), true, 'i');
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = ObjectIdGetDatum(ppEqOp[i]);
conppeqopArray = construct_array(fkdatums, foreignNKeys,
OIDOID, sizeof(Oid), true, 'i');
for (i = 0; i < foreignNKeys; i++)
fkdatums[i] = ObjectIdGetDatum(ffEqOp[i]);
conffeqopArray = construct_array(fkdatums, foreignNKeys,
OIDOID, sizeof(Oid), true, 'i');
}
else
{
confkeyArray = NULL;
conpfeqopArray = NULL;
conppeqopArray = NULL;
conffeqopArray = NULL;
}
/* initialize nulls and values */
for (i = 0; i < Natts_pg_constraint; i++)
{
nulls[i] = false;
values[i] = (Datum) 0;
}
values[Anum_pg_constraint_conname - 1] = NameGetDatum(&cname);
values[Anum_pg_constraint_connamespace - 1] = ObjectIdGetDatum(constraintNamespace);
values[Anum_pg_constraint_contype - 1] = CharGetDatum(constraintType);
values[Anum_pg_constraint_condeferrable - 1] = BoolGetDatum(isDeferrable);
values[Anum_pg_constraint_condeferred - 1] = BoolGetDatum(isDeferred);
values[Anum_pg_constraint_conrelid - 1] = ObjectIdGetDatum(relId);
values[Anum_pg_constraint_contypid - 1] = ObjectIdGetDatum(domainId);
values[Anum_pg_constraint_confrelid - 1] = ObjectIdGetDatum(foreignRelId);
values[Anum_pg_constraint_confupdtype - 1] = CharGetDatum(foreignUpdateType);
values[Anum_pg_constraint_confdeltype - 1] = CharGetDatum(foreignDeleteType);
values[Anum_pg_constraint_confmatchtype - 1] = CharGetDatum(foreignMatchType);
if (conkeyArray)
values[Anum_pg_constraint_conkey - 1] = PointerGetDatum(conkeyArray);
else
nulls[Anum_pg_constraint_conkey - 1] = true;
if (confkeyArray)
values[Anum_pg_constraint_confkey - 1] = PointerGetDatum(confkeyArray);
else
nulls[Anum_pg_constraint_confkey - 1] = true;
if (conpfeqopArray)
values[Anum_pg_constraint_conpfeqop - 1] = PointerGetDatum(conpfeqopArray);
else
nulls[Anum_pg_constraint_conpfeqop - 1] = 'n';
if (conppeqopArray)
values[Anum_pg_constraint_conppeqop - 1] = PointerGetDatum(conppeqopArray);
else
nulls[Anum_pg_constraint_conppeqop - 1] = 'n';
if (conffeqopArray)
values[Anum_pg_constraint_conffeqop - 1] = PointerGetDatum(conffeqopArray);
else
nulls[Anum_pg_constraint_conffeqop - 1] = 'n';
/*
* initialize the binary form of the check constraint.
*/
if (conBin)
values[Anum_pg_constraint_conbin - 1] = DirectFunctionCall1(textin,
CStringGetDatum((char *) conBin));
else
nulls[Anum_pg_constraint_conbin - 1] = true;
/*
* initialize the text form of the check constraint
*/
if (conSrc)
values[Anum_pg_constraint_consrc - 1] = DirectFunctionCall1(textin,
CStringGetDatum((char *) conSrc));
else
nulls[Anum_pg_constraint_consrc - 1] = true;
tup = heap_form_tuple(RelationGetDescr(conDesc), values, nulls);
conOid = simple_heap_insert(conDesc, tup);
/* update catalog indexes */
CatalogUpdateIndexes(conDesc, tup);
conobject.classId = ConstraintRelationId;
conobject.objectId = conOid;
conobject.objectSubId = 0;
heap_close(conDesc, RowExclusiveLock);
if (OidIsValid(relId))
{
/*
* Register auto dependency from constraint to owning relation, or to
* specific column(s) if any are mentioned.
*/
ObjectAddress relobject;
relobject.classId = RelationRelationId;
relobject.objectId = relId;
if (constraintNKeys > 0)
{
for (i = 0; i < constraintNKeys; i++)
{
relobject.objectSubId = constraintKey[i];
recordDependencyOn(&conobject, &relobject, DEPENDENCY_AUTO);
}
}
else
{
relobject.objectSubId = 0;
recordDependencyOn(&conobject, &relobject, DEPENDENCY_AUTO);
}
}
if (OidIsValid(domainId))
{
/*
* Register auto dependency from constraint to owning domain
*/
ObjectAddress domobject;
domobject.classId = TypeRelationId;
domobject.objectId = domainId;
domobject.objectSubId = 0;
recordDependencyOn(&conobject, &domobject, DEPENDENCY_AUTO);
}
if (OidIsValid(foreignRelId))
{
/*
* Register normal dependency from constraint to foreign relation, or
* to specific column(s) if any are mentioned.
*/
ObjectAddress relobject;
relobject.classId = RelationRelationId;
relobject.objectId = foreignRelId;
if (foreignNKeys > 0)
{
for (i = 0; i < foreignNKeys; i++)
{
relobject.objectSubId = foreignKey[i];
recordDependencyOn(&conobject, &relobject, DEPENDENCY_NORMAL);
}
}
else
{
relobject.objectSubId = 0;
recordDependencyOn(&conobject, &relobject, DEPENDENCY_NORMAL);
}
}
if (OidIsValid(indexRelId))
{
/*
* Register normal dependency on the unique index that supports a
* foreign-key constraint.
*/
ObjectAddress relobject;
relobject.classId = RelationRelationId;
relobject.objectId = indexRelId;
relobject.objectSubId = 0;
recordDependencyOn(&conobject, &relobject, DEPENDENCY_NORMAL);
}
if (foreignNKeys > 0)
{
/*
* Register normal dependencies on the equality operators that support
* a foreign-key constraint. If the PK and FK types are the same then
* all three operators for a column are the same; otherwise they are
* different.
*/
ObjectAddress oprobject;
oprobject.classId = OperatorRelationId;
oprobject.objectSubId = 0;
for (i = 0; i < foreignNKeys; i++)
{
oprobject.objectId = pfEqOp[i];
recordDependencyOn(&conobject, &oprobject, DEPENDENCY_NORMAL);
if (ppEqOp[i] != pfEqOp[i])
{
oprobject.objectId = ppEqOp[i];
recordDependencyOn(&conobject, &oprobject, DEPENDENCY_NORMAL);
}
if (ffEqOp[i] != pfEqOp[i])
{
oprobject.objectId = ffEqOp[i];
recordDependencyOn(&conobject, &oprobject, DEPENDENCY_NORMAL);
}
}
}
if (conExpr != NULL)
{
/*
* Register dependencies from constraint to objects mentioned in CHECK
* expression.
*/
recordDependencyOnSingleRelExpr(&conobject, conExpr, relId,
DEPENDENCY_NORMAL,
DEPENDENCY_NORMAL);
}
return conOid;
}
/*
* AggregateCreate
*/
ObjectAddress
AggregateCreate(const char *aggName,
Oid aggNamespace,
char aggKind,
int numArgs,
int numDirectArgs,
oidvector *parameterTypes,
Datum allParameterTypes,
Datum parameterModes,
Datum parameterNames,
List *parameterDefaults,
Oid variadicArgType,
List *aggtransfnName,
List *aggfinalfnName,
List *aggcombinefnName,
List *aggserialfnName,
List *aggdeserialfnName,
List *aggmtransfnName,
List *aggminvtransfnName,
List *aggmfinalfnName,
bool finalfnExtraArgs,
bool mfinalfnExtraArgs,
char finalfnModify,
char mfinalfnModify,
List *aggsortopName,
Oid aggTransType,
int32 aggTransSpace,
Oid aggmTransType,
int32 aggmTransSpace,
const char *agginitval,
const char *aggminitval,
char proparallel)
{
Relation aggdesc;
HeapTuple tup;
bool nulls[Natts_pg_aggregate];
Datum values[Natts_pg_aggregate];
Form_pg_proc proc;
Oid transfn;
Oid finalfn = InvalidOid; /* can be omitted */
Oid combinefn = InvalidOid; /* can be omitted */
Oid serialfn = InvalidOid; /* can be omitted */
Oid deserialfn = InvalidOid; /* can be omitted */
Oid mtransfn = InvalidOid; /* can be omitted */
Oid minvtransfn = InvalidOid; /* can be omitted */
Oid mfinalfn = InvalidOid; /* can be omitted */
Oid sortop = InvalidOid; /* can be omitted */
Oid *aggArgTypes = parameterTypes->values;
bool hasPolyArg;
bool hasInternalArg;
bool mtransIsStrict = false;
Oid rettype;
Oid finaltype;
Oid fnArgs[FUNC_MAX_ARGS];
int nargs_transfn;
int nargs_finalfn;
Oid procOid;
TupleDesc tupDesc;
int i;
ObjectAddress myself,
referenced;
AclResult aclresult;
/* sanity checks (caller should have caught these) */
if (!aggName)
elog(ERROR, "no aggregate name supplied");
if (!aggtransfnName)
elog(ERROR, "aggregate must have a transition function");
if (numDirectArgs < 0 || numDirectArgs > numArgs)
elog(ERROR, "incorrect number of direct args for aggregate");
/*
* Aggregates can have at most FUNC_MAX_ARGS-1 args, else the transfn
* and/or finalfn will be unrepresentable in pg_proc. We must check now
* to protect fixed-size arrays here and possibly in called functions.
*/
if (numArgs < 0 || numArgs > FUNC_MAX_ARGS - 1)
ereport(ERROR,
(errcode(ERRCODE_TOO_MANY_ARGUMENTS),
errmsg_plural("aggregates cannot have more than %d argument",
"aggregates cannot have more than %d arguments",
FUNC_MAX_ARGS - 1,
FUNC_MAX_ARGS - 1)));
/* check for polymorphic and INTERNAL arguments */
hasPolyArg = false;
hasInternalArg = false;
for (i = 0; i < numArgs; i++)
{
if (IsPolymorphicType(aggArgTypes[i]))
hasPolyArg = true;
else if (aggArgTypes[i] == INTERNALOID)
hasInternalArg = true;
}
/*
* If transtype is polymorphic, must have polymorphic argument also; else
* we will have no way to deduce the actual transtype.
*/
if (IsPolymorphicType(aggTransType) && !hasPolyArg)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("cannot determine transition data type"),
errdetail("An aggregate using a polymorphic transition type must have at least one polymorphic argument.")));
/*
* Likewise for moving-aggregate transtype, if any
*/
if (OidIsValid(aggmTransType) &&
IsPolymorphicType(aggmTransType) && !hasPolyArg)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("cannot determine transition data type"),
errdetail("An aggregate using a polymorphic transition type must have at least one polymorphic argument.")));
/*
* An ordered-set aggregate that is VARIADIC must be VARIADIC ANY. In
* principle we could support regular variadic types, but it would make
* things much more complicated because we'd have to assemble the correct
* subsets of arguments into array values. Since no standard aggregates
* have use for such a case, we aren't bothering for now.
*/
if (AGGKIND_IS_ORDERED_SET(aggKind) && OidIsValid(variadicArgType) &&
variadicArgType != ANYOID)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("a variadic ordered-set aggregate must use VARIADIC type ANY")));
/*
* If it's a hypothetical-set aggregate, there must be at least as many
* direct arguments as aggregated ones, and the last N direct arguments
* must match the aggregated ones in type. (We have to check this again
* when the aggregate is called, in case ANY is involved, but it makes
* sense to reject the aggregate definition now if the declared arg types
* don't match up.) It's unconditionally OK if numDirectArgs == numArgs,
* indicating that the grammar merged identical VARIADIC entries from both
* lists. Otherwise, if the agg is VARIADIC, then we had VARIADIC only on
* the aggregated side, which is not OK. Otherwise, insist on the last N
* parameter types on each side matching exactly.
*/
if (aggKind == AGGKIND_HYPOTHETICAL &&
numDirectArgs < numArgs)
{
int numAggregatedArgs = numArgs - numDirectArgs;
if (OidIsValid(variadicArgType) ||
numDirectArgs < numAggregatedArgs ||
memcmp(aggArgTypes + (numDirectArgs - numAggregatedArgs),
aggArgTypes + numDirectArgs,
numAggregatedArgs * sizeof(Oid)) != 0)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("a hypothetical-set aggregate must have direct arguments matching its aggregated arguments")));
}
/*
* Find the transfn. For ordinary aggs, it takes the transtype plus all
* aggregate arguments. For ordered-set aggs, it takes the transtype plus
* all aggregated args, but not direct args. However, we have to treat
* specially the case where a trailing VARIADIC item is considered to
* cover both direct and aggregated args.
*/
if (AGGKIND_IS_ORDERED_SET(aggKind))
{
if (numDirectArgs < numArgs)
nargs_transfn = numArgs - numDirectArgs + 1;
else
{
/* special case with VARIADIC last arg */
Assert(variadicArgType != InvalidOid);
nargs_transfn = 2;
}
fnArgs[0] = aggTransType;
memcpy(fnArgs + 1, aggArgTypes + (numArgs - (nargs_transfn - 1)),
(nargs_transfn - 1) * sizeof(Oid));
}
else
{
nargs_transfn = numArgs + 1;
fnArgs[0] = aggTransType;
memcpy(fnArgs + 1, aggArgTypes, numArgs * sizeof(Oid));
}
transfn = lookup_agg_function(aggtransfnName, nargs_transfn,
fnArgs, variadicArgType,
&rettype);
/*
* Return type of transfn (possibly after refinement by
* enforce_generic_type_consistency, if transtype isn't polymorphic) must
* exactly match declared transtype.
*
* In the non-polymorphic-transtype case, it might be okay to allow a
* rettype that's binary-coercible to transtype, but I'm not quite
* convinced that it's either safe or useful. When transtype is
* polymorphic we *must* demand exact equality.
*/
if (rettype != aggTransType)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("return type of transition function %s is not %s",
NameListToString(aggtransfnName),
format_type_be(aggTransType))));
tup = SearchSysCache1(PROCOID, ObjectIdGetDatum(transfn));
if (!HeapTupleIsValid(tup))
elog(ERROR, "cache lookup failed for function %u", transfn);
proc = (Form_pg_proc) GETSTRUCT(tup);
/*
* If the transfn is strict and the initval is NULL, make sure first input
* type and transtype are the same (or at least binary-compatible), so
* that it's OK to use the first input value as the initial transValue.
*/
if (proc->proisstrict && agginitval == NULL)
{
if (numArgs < 1 ||
!IsBinaryCoercible(aggArgTypes[0], aggTransType))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("must not omit initial value when transition function is strict and transition type is not compatible with input type")));
}
ReleaseSysCache(tup);
/* handle moving-aggregate transfn, if supplied */
if (aggmtransfnName)
{
/*
* The arguments are the same as for the regular transfn, except that
* the transition data type might be different. So re-use the fnArgs
* values set up above, except for that one.
*/
Assert(OidIsValid(aggmTransType));
fnArgs[0] = aggmTransType;
mtransfn = lookup_agg_function(aggmtransfnName, nargs_transfn,
fnArgs, variadicArgType,
&rettype);
/* As above, return type must exactly match declared mtranstype. */
if (rettype != aggmTransType)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("return type of transition function %s is not %s",
NameListToString(aggmtransfnName),
format_type_be(aggmTransType))));
tup = SearchSysCache1(PROCOID, ObjectIdGetDatum(mtransfn));
if (!HeapTupleIsValid(tup))
elog(ERROR, "cache lookup failed for function %u", mtransfn);
proc = (Form_pg_proc) GETSTRUCT(tup);
/*
* If the mtransfn is strict and the minitval is NULL, check first
* input type and mtranstype are binary-compatible.
*/
if (proc->proisstrict && aggminitval == NULL)
{
if (numArgs < 1 ||
!IsBinaryCoercible(aggArgTypes[0], aggmTransType))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("must not omit initial value when transition function is strict and transition type is not compatible with input type")));
}
/* Remember if mtransfn is strict; we may need this below */
mtransIsStrict = proc->proisstrict;
ReleaseSysCache(tup);
}
/* handle minvtransfn, if supplied */
if (aggminvtransfnName)
{
/*
* This must have the same number of arguments with the same types as
* the forward transition function, so just re-use the fnArgs data.
*/
Assert(aggmtransfnName);
minvtransfn = lookup_agg_function(aggminvtransfnName, nargs_transfn,
fnArgs, variadicArgType,
&rettype);
/* As above, return type must exactly match declared mtranstype. */
if (rettype != aggmTransType)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("return type of inverse transition function %s is not %s",
NameListToString(aggminvtransfnName),
format_type_be(aggmTransType))));
tup = SearchSysCache1(PROCOID, ObjectIdGetDatum(minvtransfn));
if (!HeapTupleIsValid(tup))
elog(ERROR, "cache lookup failed for function %u", minvtransfn);
proc = (Form_pg_proc) GETSTRUCT(tup);
/*
* We require the strictness settings of the forward and inverse
* transition functions to agree. This saves having to handle
* assorted special cases at execution time.
*/
if (proc->proisstrict != mtransIsStrict)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("strictness of aggregate's forward and inverse transition functions must match")));
ReleaseSysCache(tup);
}
/* handle finalfn, if supplied */
if (aggfinalfnName)
{
/*
* If finalfnExtraArgs is specified, the transfn takes the transtype
* plus all args; otherwise, it just takes the transtype plus any
* direct args. (Non-direct args are useless at runtime, and are
* actually passed as NULLs, but we may need them in the function
* signature to allow resolution of a polymorphic agg's result type.)
*/
Oid ffnVariadicArgType = variadicArgType;
fnArgs[0] = aggTransType;
memcpy(fnArgs + 1, aggArgTypes, numArgs * sizeof(Oid));
if (finalfnExtraArgs)
nargs_finalfn = numArgs + 1;
else
{
nargs_finalfn = numDirectArgs + 1;
if (numDirectArgs < numArgs)
{
/* variadic argument doesn't affect finalfn */
ffnVariadicArgType = InvalidOid;
}
}
finalfn = lookup_agg_function(aggfinalfnName, nargs_finalfn,
fnArgs, ffnVariadicArgType,
&finaltype);
/*
* When finalfnExtraArgs is specified, the finalfn will certainly be
* passed at least one null argument, so complain if it's strict.
* Nothing bad would happen at runtime (you'd just get a null result),
* but it's surely not what the user wants, so let's complain now.
*/
if (finalfnExtraArgs && func_strict(finalfn))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("final function with extra arguments must not be declared STRICT")));
}
else
{
/*
* If no finalfn, aggregate result type is type of the state value
*/
finaltype = aggTransType;
}
Assert(OidIsValid(finaltype));
/* handle the combinefn, if supplied */
if (aggcombinefnName)
{
Oid combineType;
/*
* Combine function must have 2 arguments, each of which is the trans
* type. VARIADIC doesn't affect it.
*/
fnArgs[0] = aggTransType;
fnArgs[1] = aggTransType;
combinefn = lookup_agg_function(aggcombinefnName, 2,
fnArgs, InvalidOid,
&combineType);
/* Ensure the return type matches the aggregate's trans type */
if (combineType != aggTransType)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("return type of combine function %s is not %s",
NameListToString(aggcombinefnName),
format_type_be(aggTransType))));
/*
* A combine function to combine INTERNAL states must accept nulls and
* ensure that the returned state is in the correct memory context. We
* cannot directly check the latter, but we can check the former.
*/
if (aggTransType == INTERNALOID && func_strict(combinefn))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("combine function with transition type %s must not be declared STRICT",
format_type_be(aggTransType))));
}
/*
* Validate the serialization function, if present.
*/
if (aggserialfnName)
{
/* signature is always serialize(internal) returns bytea */
fnArgs[0] = INTERNALOID;
serialfn = lookup_agg_function(aggserialfnName, 1,
fnArgs, InvalidOid,
&rettype);
if (rettype != BYTEAOID)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("return type of serialization function %s is not %s",
NameListToString(aggserialfnName),
format_type_be(BYTEAOID))));
}
/*
* Validate the deserialization function, if present.
*/
if (aggdeserialfnName)
{
/* signature is always deserialize(bytea, internal) returns internal */
fnArgs[0] = BYTEAOID;
fnArgs[1] = INTERNALOID; /* dummy argument for type safety */
deserialfn = lookup_agg_function(aggdeserialfnName, 2,
fnArgs, InvalidOid,
&rettype);
if (rettype != INTERNALOID)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("return type of deserialization function %s is not %s",
NameListToString(aggdeserialfnName),
format_type_be(INTERNALOID))));
}
/*
* If finaltype (i.e. aggregate return type) is polymorphic, inputs must
* be polymorphic also, else parser will fail to deduce result type.
* (Note: given the previous test on transtype and inputs, this cannot
* happen, unless someone has snuck a finalfn definition into the catalogs
* that itself violates the rule against polymorphic result with no
* polymorphic input.)
*/
if (IsPolymorphicType(finaltype) && !hasPolyArg)
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("cannot determine result data type"),
errdetail("An aggregate returning a polymorphic type "
"must have at least one polymorphic argument.")));
/*
* Also, the return type can't be INTERNAL unless there's at least one
* INTERNAL argument. This is the same type-safety restriction we enforce
* for regular functions, but at the level of aggregates. We must test
* this explicitly because we allow INTERNAL as the transtype.
*/
if (finaltype == INTERNALOID && !hasInternalArg)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("unsafe use of pseudo-type \"internal\""),
errdetail("A function returning \"internal\" must have at least one \"internal\" argument.")));
/*
* If a moving-aggregate implementation is supplied, look up its finalfn
* if any, and check that the implied aggregate result type matches the
* plain implementation.
*/
if (OidIsValid(aggmTransType))
{
/* handle finalfn, if supplied */
if (aggmfinalfnName)
{
/*
* The arguments are figured the same way as for the regular
* finalfn, but using aggmTransType and mfinalfnExtraArgs.
*/
Oid ffnVariadicArgType = variadicArgType;
fnArgs[0] = aggmTransType;
memcpy(fnArgs + 1, aggArgTypes, numArgs * sizeof(Oid));
if (mfinalfnExtraArgs)
nargs_finalfn = numArgs + 1;
else
{
nargs_finalfn = numDirectArgs + 1;
if (numDirectArgs < numArgs)
{
/* variadic argument doesn't affect finalfn */
ffnVariadicArgType = InvalidOid;
}
}
mfinalfn = lookup_agg_function(aggmfinalfnName, nargs_finalfn,
fnArgs, ffnVariadicArgType,
&rettype);
/* As above, check strictness if mfinalfnExtraArgs is given */
if (mfinalfnExtraArgs && func_strict(mfinalfn))
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("final function with extra arguments must not be declared STRICT")));
}
else
{
/*
* If no finalfn, aggregate result type is type of the state value
*/
rettype = aggmTransType;
}
Assert(OidIsValid(rettype));
if (rettype != finaltype)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("moving-aggregate implementation returns type %s, but plain implementation returns type %s",
format_type_be(aggmTransType),
format_type_be(aggTransType))));
}
/* handle sortop, if supplied */
if (aggsortopName)
{
if (numArgs != 1)
ereport(ERROR,
(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),
errmsg("sort operator can only be specified for single-argument aggregates")));
sortop = LookupOperName(NULL, aggsortopName,
aggArgTypes[0], aggArgTypes[0],
false, -1);
}
/*
* permission checks on used types
*/
for (i = 0; i < numArgs; i++)
{
aclresult = pg_type_aclcheck(aggArgTypes[i], GetUserId(), ACL_USAGE);
if (aclresult != ACLCHECK_OK)
aclcheck_error_type(aclresult, aggArgTypes[i]);
}
aclresult = pg_type_aclcheck(aggTransType, GetUserId(), ACL_USAGE);
if (aclresult != ACLCHECK_OK)
aclcheck_error_type(aclresult, aggTransType);
if (OidIsValid(aggmTransType))
{
aclresult = pg_type_aclcheck(aggmTransType, GetUserId(), ACL_USAGE);
if (aclresult != ACLCHECK_OK)
aclcheck_error_type(aclresult, aggmTransType);
}
aclresult = pg_type_aclcheck(finaltype, GetUserId(), ACL_USAGE);
if (aclresult != ACLCHECK_OK)
aclcheck_error_type(aclresult, finaltype);
/*
* Everything looks okay. Try to create the pg_proc entry for the
* aggregate. (This could fail if there's already a conflicting entry.)
*/
myself = ProcedureCreate(aggName,
aggNamespace,
false, /* no replacement */
false, /* doesn't return a set */
finaltype, /* returnType */
GetUserId(), /* proowner */
INTERNALlanguageId, /* languageObjectId */
InvalidOid, /* no validator */
"aggregate_dummy", /* placeholder proc */
NULL, /* probin */
PROKIND_AGGREGATE,
false, /* security invoker (currently not
* definable for agg) */
false, /* isLeakProof */
false, /* isStrict (not needed for agg) */
PROVOLATILE_IMMUTABLE, /* volatility (not needed
* for agg) */
proparallel,
parameterTypes, /* paramTypes */
allParameterTypes, /* allParamTypes */
parameterModes, /* parameterModes */
parameterNames, /* parameterNames */
parameterDefaults, /* parameterDefaults */
PointerGetDatum(NULL), /* trftypes */
PointerGetDatum(NULL), /* proconfig */
1, /* procost */
0); /* prorows */
procOid = myself.objectId;
/*
* 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++)
{
nulls[i] = false;
values[i] = (Datum) NULL;
}
values[Anum_pg_aggregate_aggfnoid - 1] = ObjectIdGetDatum(procOid);
values[Anum_pg_aggregate_aggkind - 1] = CharGetDatum(aggKind);
values[Anum_pg_aggregate_aggnumdirectargs - 1] = Int16GetDatum(numDirectArgs);
values[Anum_pg_aggregate_aggtransfn - 1] = ObjectIdGetDatum(transfn);
values[Anum_pg_aggregate_aggfinalfn - 1] = ObjectIdGetDatum(finalfn);
values[Anum_pg_aggregate_aggcombinefn - 1] = ObjectIdGetDatum(combinefn);
values[Anum_pg_aggregate_aggserialfn - 1] = ObjectIdGetDatum(serialfn);
values[Anum_pg_aggregate_aggdeserialfn - 1] = ObjectIdGetDatum(deserialfn);
values[Anum_pg_aggregate_aggmtransfn - 1] = ObjectIdGetDatum(mtransfn);
values[Anum_pg_aggregate_aggminvtransfn - 1] = ObjectIdGetDatum(minvtransfn);
values[Anum_pg_aggregate_aggmfinalfn - 1] = ObjectIdGetDatum(mfinalfn);
values[Anum_pg_aggregate_aggfinalextra - 1] = BoolGetDatum(finalfnExtraArgs);
values[Anum_pg_aggregate_aggmfinalextra - 1] = BoolGetDatum(mfinalfnExtraArgs);
values[Anum_pg_aggregate_aggfinalmodify - 1] = CharGetDatum(finalfnModify);
values[Anum_pg_aggregate_aggmfinalmodify - 1] = CharGetDatum(mfinalfnModify);
values[Anum_pg_aggregate_aggsortop - 1] = ObjectIdGetDatum(sortop);
values[Anum_pg_aggregate_aggtranstype - 1] = ObjectIdGetDatum(aggTransType);
values[Anum_pg_aggregate_aggtransspace - 1] = Int32GetDatum(aggTransSpace);
values[Anum_pg_aggregate_aggmtranstype - 1] = ObjectIdGetDatum(aggmTransType);
values[Anum_pg_aggregate_aggmtransspace - 1] = Int32GetDatum(aggmTransSpace);
if (agginitval)
values[Anum_pg_aggregate_agginitval - 1] = CStringGetTextDatum(agginitval);
else
nulls[Anum_pg_aggregate_agginitval - 1] = true;
if (aggminitval)
values[Anum_pg_aggregate_aggminitval - 1] = CStringGetTextDatum(aggminitval);
else
nulls[Anum_pg_aggregate_aggminitval - 1] = true;
tup = heap_form_tuple(tupDesc, values, nulls);
CatalogTupleInsert(aggdesc, tup);
heap_close(aggdesc, RowExclusiveLock);
/*
* Create dependencies for the aggregate (above and beyond those already
* made by ProcedureCreate). Note: we don't need an explicit dependency
* on aggTransType since we depend on it indirectly through transfn.
* Likewise for aggmTransType using the mtransfunc, if it exists.
*/
/* Depends on transition function */
referenced.classId = ProcedureRelationId;
referenced.objectId = transfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
/* Depends on final function, if any */
if (OidIsValid(finalfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = finalfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on combine function, if any */
if (OidIsValid(combinefn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = combinefn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on serialization function, if any */
if (OidIsValid(serialfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = serialfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on deserialization function, if any */
if (OidIsValid(deserialfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = deserialfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on forward transition function, if any */
if (OidIsValid(mtransfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = mtransfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on inverse transition function, if any */
if (OidIsValid(minvtransfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = minvtransfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on final function, if any */
if (OidIsValid(mfinalfn))
{
referenced.classId = ProcedureRelationId;
referenced.objectId = mfinalfn;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
/* Depends on sort operator, if any */
if (OidIsValid(sortop))
{
referenced.classId = OperatorRelationId;
referenced.objectId = sortop;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
}
return myself;
}
bool array_next(array_iter *iter, Datum *value, bool *isna)
{
bits8 *nulls;
if (iter->index >= iter->max)
{
*value = (Datum) 0;
*isna = true;
return false;
}
if (iter->index < 0)
{
*value = (Datum) 0;
*isna = true;
iter->index++;
return true;
}
nulls = ARR_NULLBITMAP(iter->array);
if (nulls && !(nulls[iter->index / 8] & (1 << (iter->index % 8))))
{
*value = (Datum) 0;
*isna = true;
iter->index++;
return true;
}
*isna = false;
if (iter->typlen > 0)
{ /* fixed length */
if (iter->typlen <= 8)
{
switch (iter->typlen)
{
case 1:
*value = Int8GetDatum(*((int8*) iter->ptr));
break;
case 2:
*value = Int16GetDatum(*((int16*) iter->ptr));
break;
case 4:
*value = Int32GetDatum(*((int16*) iter->ptr));
break;
case 8:
*value = Int64GetDatum(*((int16*) iter->ptr));
break;
default:
elog(ERROR, "unexpected data type");
break;
}
}
else
{
*value = PointerGetDatum(iter->ptr);
}
iter->ptr += iter->typlen;
}
else
{ /* variable length */
*value = PointerGetDatum(iter->ptr);
iter->ptr += VARSIZE(iter->ptr);
}
iter->ptr = (char*) att_align(iter->ptr, iter->typalign);
iter->index++;
return true;
}
/*
* sepgsql_attribute_post_create
*
* This routine assigns a default security label on a newly defined
* column, using ALTER TABLE ... ADD COLUMN.
* Note that this routine is not invoked in the case of CREATE TABLE,
* although it also defines columns in addition to table.
*/
void
sepgsql_attribute_post_create(Oid relOid, AttrNumber attnum)
{
Relation rel;
ScanKeyData skey[2];
SysScanDesc sscan;
HeapTuple tuple;
char *scontext;
char *tcontext;
char *ncontext;
char audit_name[2 * NAMEDATALEN + 20];
ObjectAddress object;
Form_pg_attribute attForm;
/*
* Only attributes within regular relation have individual security
* labels.
*/
if (get_rel_relkind(relOid) != RELKIND_RELATION)
return;
/*
* Compute a default security label of the new column underlying the
* specified relation, and check permission to create it.
*/
rel = heap_open(AttributeRelationId, AccessShareLock);
ScanKeyInit(&skey[0],
Anum_pg_attribute_attrelid,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(relOid));
ScanKeyInit(&skey[1],
Anum_pg_attribute_attnum,
BTEqualStrategyNumber, F_INT2EQ,
Int16GetDatum(attnum));
sscan = systable_beginscan(rel, AttributeRelidNumIndexId, true,
SnapshotSelf, 2, &skey[0]);
tuple = systable_getnext(sscan);
if (!HeapTupleIsValid(tuple))
elog(ERROR, "catalog lookup failed for column %d of relation %u",
attnum, relOid);
attForm = (Form_pg_attribute) GETSTRUCT(tuple);
scontext = sepgsql_get_client_label();
tcontext = sepgsql_get_label(RelationRelationId, relOid, 0);
ncontext = sepgsql_compute_create(scontext, tcontext,
SEPG_CLASS_DB_COLUMN);
/*
* check db_column:{create} permission
*/
snprintf(audit_name, sizeof(audit_name), "table %s column %s",
get_rel_name(relOid), NameStr(attForm->attname));
sepgsql_avc_check_perms_label(ncontext,
SEPG_CLASS_DB_COLUMN,
SEPG_DB_COLUMN__CREATE,
audit_name,
true);
/*
* Assign the default security label on a new procedure
*/
object.classId = RelationRelationId;
object.objectId = relOid;
object.objectSubId = attnum;
SetSecurityLabel(&object, SEPGSQL_LABEL_TAG, ncontext);
systable_endscan(sscan);
heap_close(rel, AccessShareLock);
pfree(tcontext);
pfree(ncontext);
}
static Datum
leftmostvalue_int2(void)
{
return Int16GetDatum(SHRT_MIN);
}
CdbComponentDatabaseInfo *
dbid_get_dbinfo(int16 dbid)
{
HeapTuple tuple;
Relation rel;
cqContext cqc;
bool bOnly;
CdbComponentDatabaseInfo *i = NULL;
/*
* Can only run on a master node, this restriction is due to the reliance
* on the gp_segment_configuration table. This may be able to be relaxed
* by switching to a different method of checking.
*/
if (GpIdentity.segindex != MASTER_CONTENT_ID)
elog(ERROR, "dbid_get_dbinfo() executed on execution segment");
rel = heap_open(GpSegmentConfigRelationId, AccessShareLock);
tuple = caql_getfirst_only(
caql_addrel(cqclr(&cqc), rel),
&bOnly,
cql("SELECT * FROM gp_segment_configuration "
" WHERE dbid = :1 ",
Int16GetDatum(dbid)));
if (HeapTupleIsValid(tuple))
{
Datum attr;
bool isNull;
i = palloc(sizeof(CdbComponentDatabaseInfo));
/*
* dbid
*/
attr = heap_getattr(tuple, Anum_gp_segment_configuration_dbid,
RelationGetDescr(rel), &isNull);
Assert(!isNull);
i->dbid = DatumGetInt16(attr);
/*
* content
*/
attr = heap_getattr(tuple, Anum_gp_segment_configuration_content,
RelationGetDescr(rel), &isNull);
Assert(!isNull);
i->segindex = DatumGetInt16(attr);
/*
* role
*/
attr = heap_getattr(tuple, Anum_gp_segment_configuration_role,
RelationGetDescr(rel), &isNull);
Assert(!isNull);
i->role = DatumGetChar(attr);
/*
* preferred-role
*/
attr = heap_getattr(tuple,
Anum_gp_segment_configuration_preferred_role,
RelationGetDescr(rel), &isNull);
Assert(!isNull);
i->preferred_role = DatumGetChar(attr);
/*
* mode
*/
attr = heap_getattr(tuple, Anum_gp_segment_configuration_mode,
RelationGetDescr(rel), &isNull);
Assert(!isNull);
i->mode = DatumGetChar(attr);
/*
* status
*/
attr = heap_getattr(tuple, Anum_gp_segment_configuration_status,
RelationGetDescr(rel), &isNull);
Assert(!isNull);
i->status = DatumGetChar(attr);
/*
* hostname
*/
attr = heap_getattr(tuple, Anum_gp_segment_configuration_hostname,
RelationGetDescr(rel), &isNull);
Assert(!isNull);
i->hostname = TextDatumGetCString(attr);
/*
* address
*/
attr = heap_getattr(tuple, Anum_gp_segment_configuration_address,
RelationGetDescr(rel), &isNull);
Assert(!isNull);
i->address = TextDatumGetCString(attr);
/*
* port
*/
attr = heap_getattr(tuple, Anum_gp_segment_configuration_port,
RelationGetDescr(rel), &isNull);
Assert(!isNull);
i->port = DatumGetInt32(attr);
/*
* Filerep_port
*/
attr = heap_getattr(tuple, Anum_gp_segment_configuration_replication_port,
RelationGetDescr(rel), &isNull);
if (!isNull)
i->filerep_port = DatumGetInt32(attr);
else
i->filerep_port = -1;
Assert(bOnly); /* should be only 1 */
}
else
{
elog(ERROR, "could not find configuration entry for dbid %i", dbid);
}
heap_close(rel, NoLock);
return i;
}
/*
* Test whether an object exists.
*/
static bool
object_exists(ObjectAddress address)
{
int cache = -1;
Oid indexoid = InvalidOid;
Relation rel;
ScanKeyData skey[1];
SysScanDesc sd;
bool found;
/* Sub-objects require special treatment. */
if (address.objectSubId != 0)
{
HeapTuple atttup;
/* Currently, attributes are the only sub-objects. */
Assert(address.classId == RelationRelationId);
atttup = SearchSysCache2(ATTNUM, ObjectIdGetDatum(address.objectId),
Int16GetDatum(address.objectSubId));
if (!HeapTupleIsValid(atttup))
found = false;
else
{
found = ((Form_pg_attribute) GETSTRUCT(atttup))->attisdropped;
ReleaseSysCache(atttup);
}
return found;
}
/*
* For object types that have a relevant syscache, we use it; for
* everything else, we'll have to do an index-scan. This switch
* sets either the cache to be used for the syscache lookup, or the
* index to be used for the index scan.
*/
switch (address.classId)
{
case RelationRelationId:
cache = RELOID;
break;
case RewriteRelationId:
indexoid = RewriteOidIndexId;
break;
case TriggerRelationId:
indexoid = TriggerOidIndexId;
break;
case ConstraintRelationId:
cache = CONSTROID;
break;
case DatabaseRelationId:
cache = DATABASEOID;
break;
case TableSpaceRelationId:
cache = TABLESPACEOID;
break;
case AuthIdRelationId:
cache = AUTHOID;
break;
case NamespaceRelationId:
cache = NAMESPACEOID;
break;
case LanguageRelationId:
cache = LANGOID;
break;
case TypeRelationId:
cache = TYPEOID;
break;
case ProcedureRelationId:
cache = PROCOID;
break;
case OperatorRelationId:
cache = OPEROID;
break;
case CollationRelationId:
cache = COLLOID;
break;
case ConversionRelationId:
cache = CONVOID;
break;
case OperatorClassRelationId:
cache = CLAOID;
break;
case OperatorFamilyRelationId:
cache = OPFAMILYOID;
break;
case LargeObjectRelationId:
/*
* Weird backward compatibility hack: ObjectAddress notation uses
* LargeObjectRelationId for large objects, but since PostgreSQL
* 9.0, the relevant catalog is actually
* LargeObjectMetadataRelationId.
*/
address.classId = LargeObjectMetadataRelationId;
indexoid = LargeObjectMetadataOidIndexId;
break;
case CastRelationId:
indexoid = CastOidIndexId;
break;
case ForeignDataWrapperRelationId:
cache = FOREIGNDATAWRAPPEROID;
break;
case ForeignServerRelationId:
cache = FOREIGNSERVEROID;
break;
case TSParserRelationId:
cache = TSPARSEROID;
break;
case TSDictionaryRelationId:
cache = TSDICTOID;
break;
case TSTemplateRelationId:
cache = TSTEMPLATEOID;
break;
case TSConfigRelationId:
cache = TSCONFIGOID;
break;
case ExtensionRelationId:
indexoid = ExtensionOidIndexId;
break;
default:
elog(ERROR, "unrecognized classid: %u", address.classId);
}
/* Found a syscache? */
if (cache != -1)
return SearchSysCacheExists1(cache, ObjectIdGetDatum(address.objectId));
/* No syscache, so examine the table directly. */
Assert(OidIsValid(indexoid));
ScanKeyInit(&skey[0],
ObjectIdAttributeNumber,
BTEqualStrategyNumber, F_OIDEQ,
ObjectIdGetDatum(address.objectId));
rel = heap_open(address.classId, AccessShareLock);
sd = systable_beginscan(rel, indexoid, true, SnapshotNow, 1, skey);
found = HeapTupleIsValid(systable_getnext(sd));
systable_endscan(sd);
heap_close(rel, AccessShareLock);
return found;
}
/*
* pg_lock_status - produce a view with one row per held or awaited lock mode
*/
Datum
pg_lock_status(PG_FUNCTION_ARGS)
{
FuncCallContext *funcctx;
PG_Lock_Status *mystatus;
LockData *lockData;
PredicateLockData *predLockData;
if (SRF_IS_FIRSTCALL())
{
TupleDesc tupdesc;
MemoryContext oldcontext;
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
/*
* switch to memory context appropriate for multiple function calls
*/
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
/* build tupdesc for result tuples */
/* this had better match pg_locks view in system_views.sql */
tupdesc = CreateTemplateTupleDesc(NUM_LOCK_STATUS_COLUMNS, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "locktype",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "database",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 3, "relation",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 4, "page",
INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 5, "tuple",
INT2OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 6, "virtualxid",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 7, "transactionid",
XIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 8, "classid",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 9, "objid",
OIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 10, "objsubid",
INT2OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 11, "virtualtransaction",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 12, "pid",
INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 13, "mode",
TEXTOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 14, "granted",
BOOLOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 15, "fastpath",
BOOLOID, -1, 0);
funcctx->tuple_desc = BlessTupleDesc(tupdesc);
/*
* Collect all the locking information that we will format and send
* out as a result set.
*/
mystatus = (PG_Lock_Status *) palloc(sizeof(PG_Lock_Status));
funcctx->user_fctx = (void *) mystatus;
mystatus->lockData = GetLockStatusData();
mystatus->currIdx = 0;
mystatus->predLockData = GetPredicateLockStatusData();
mystatus->predLockIdx = 0;
MemoryContextSwitchTo(oldcontext);
}
funcctx = SRF_PERCALL_SETUP();
mystatus = (PG_Lock_Status *) funcctx->user_fctx;
lockData = mystatus->lockData;
while (mystatus->currIdx < lockData->nelements)
{
bool granted;
LOCKMODE mode = 0;
const char *locktypename;
char tnbuf[32];
Datum values[NUM_LOCK_STATUS_COLUMNS];
bool nulls[NUM_LOCK_STATUS_COLUMNS];
HeapTuple tuple;
Datum result;
LockInstanceData *instance;
instance = &(lockData->locks[mystatus->currIdx]);
/*
* Look to see if there are any held lock modes in this PROCLOCK. If
* so, report, and destructively modify lockData so we don't report
* again.
*/
granted = false;
if (instance->holdMask)
{
for (mode = 0; mode < MAX_LOCKMODES; mode++)
{
if (instance->holdMask & LOCKBIT_ON(mode))
{
granted = true;
instance->holdMask &= LOCKBIT_OFF(mode);
break;
}
}
}
/*
* If no (more) held modes to report, see if PROC is waiting for a
* lock on this lock.
*/
if (!granted)
{
if (instance->waitLockMode != NoLock)
{
/* Yes, so report it with proper mode */
mode = instance->waitLockMode;
/*
* We are now done with this PROCLOCK, so advance pointer to
* continue with next one on next call.
*/
mystatus->currIdx++;
}
else
{
/*
* Okay, we've displayed all the locks associated with this
* PROCLOCK, proceed to the next one.
*/
mystatus->currIdx++;
continue;
}
}
/*
* Form tuple with appropriate data.
*/
MemSet(values, 0, sizeof(values));
MemSet(nulls, false, sizeof(nulls));
if (instance->locktag.locktag_type <= LOCKTAG_LAST_TYPE)
locktypename = LockTagTypeNames[instance->locktag.locktag_type];
else
{
snprintf(tnbuf, sizeof(tnbuf), "unknown %d",
(int) instance->locktag.locktag_type);
locktypename = tnbuf;
}
values[0] = CStringGetTextDatum(locktypename);
switch ((LockTagType) instance->locktag.locktag_type)
{
case LOCKTAG_RELATION:
case LOCKTAG_RELATION_EXTEND:
values[1] = ObjectIdGetDatum(instance->locktag.locktag_field1);
values[2] = ObjectIdGetDatum(instance->locktag.locktag_field2);
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
nulls[9] = true;
break;
case LOCKTAG_PAGE:
values[1] = ObjectIdGetDatum(instance->locktag.locktag_field1);
values[2] = ObjectIdGetDatum(instance->locktag.locktag_field2);
values[3] = UInt32GetDatum(instance->locktag.locktag_field3);
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
nulls[9] = true;
break;
case LOCKTAG_TUPLE:
values[1] = ObjectIdGetDatum(instance->locktag.locktag_field1);
values[2] = ObjectIdGetDatum(instance->locktag.locktag_field2);
values[3] = UInt32GetDatum(instance->locktag.locktag_field3);
values[4] = UInt16GetDatum(instance->locktag.locktag_field4);
nulls[5] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
nulls[9] = true;
break;
case LOCKTAG_TRANSACTION:
values[6] =
TransactionIdGetDatum(instance->locktag.locktag_field1);
nulls[1] = true;
nulls[2] = true;
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
nulls[7] = true;
nulls[8] = true;
nulls[9] = true;
break;
case LOCKTAG_VIRTUALTRANSACTION:
values[5] = VXIDGetDatum(instance->locktag.locktag_field1,
instance->locktag.locktag_field2);
nulls[1] = true;
nulls[2] = true;
nulls[3] = true;
nulls[4] = true;
nulls[6] = true;
nulls[7] = true;
nulls[8] = true;
nulls[9] = true;
break;
case LOCKTAG_OBJECT:
case LOCKTAG_USERLOCK:
case LOCKTAG_ADVISORY:
default: /* treat unknown locktags like OBJECT */
values[1] = ObjectIdGetDatum(instance->locktag.locktag_field1);
values[7] = ObjectIdGetDatum(instance->locktag.locktag_field2);
values[8] = ObjectIdGetDatum(instance->locktag.locktag_field3);
values[9] = Int16GetDatum(instance->locktag.locktag_field4);
nulls[2] = true;
nulls[3] = true;
nulls[4] = true;
nulls[5] = true;
nulls[6] = true;
break;
}
values[10] = VXIDGetDatum(instance->backend, instance->lxid);
if (instance->pid != 0)
values[11] = Int32GetDatum(instance->pid);
else
nulls[11] = true;
values[12] = CStringGetTextDatum(GetLockmodeName(instance->locktag.locktag_lockmethodid, mode));
values[13] = BoolGetDatum(granted);
values[14] = BoolGetDatum(instance->fastpath);
tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
}
/*
* Have returned all regular locks. Now start on the SIREAD predicate
* locks.
*/
predLockData = mystatus->predLockData;
if (mystatus->predLockIdx < predLockData->nelements)
{
PredicateLockTargetType lockType;
PREDICATELOCKTARGETTAG *predTag = &(predLockData->locktags[mystatus->predLockIdx]);
SERIALIZABLEXACT *xact = &(predLockData->xacts[mystatus->predLockIdx]);
Datum values[NUM_LOCK_STATUS_COLUMNS];
bool nulls[NUM_LOCK_STATUS_COLUMNS];
HeapTuple tuple;
Datum result;
mystatus->predLockIdx++;
/*
* Form tuple with appropriate data.
*/
MemSet(values, 0, sizeof(values));
MemSet(nulls, false, sizeof(nulls));
/* lock type */
lockType = GET_PREDICATELOCKTARGETTAG_TYPE(*predTag);
values[0] = CStringGetTextDatum(PredicateLockTagTypeNames[lockType]);
/* lock target */
values[1] = GET_PREDICATELOCKTARGETTAG_DB(*predTag);
values[2] = GET_PREDICATELOCKTARGETTAG_RELATION(*predTag);
if (lockType == PREDLOCKTAG_TUPLE)
values[4] = GET_PREDICATELOCKTARGETTAG_OFFSET(*predTag);
else
nulls[4] = true;
if ((lockType == PREDLOCKTAG_TUPLE) ||
(lockType == PREDLOCKTAG_PAGE))
values[3] = GET_PREDICATELOCKTARGETTAG_PAGE(*predTag);
else
nulls[3] = true;
/* these fields are targets for other types of locks */
nulls[5] = true; /* virtualxid */
nulls[6] = true; /* transactionid */
nulls[7] = true; /* classid */
nulls[8] = true; /* objid */
nulls[9] = true; /* objsubid */
/* lock holder */
values[10] = VXIDGetDatum(xact->vxid.backendId,
xact->vxid.localTransactionId);
if (xact->pid != 0)
values[11] = Int32GetDatum(xact->pid);
else
nulls[11] = true;
/*
* Lock mode. Currently all predicate locks are SIReadLocks, which are
* always held (never waiting) and have no fast path
*/
values[12] = CStringGetTextDatum("SIReadLock");
values[13] = BoolGetDatum(true);
values[14] = BoolGetDatum(false);
tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
}
SRF_RETURN_DONE(funcctx);
}
/*
* gistproperty() -- Check boolean properties of indexes.
*
* This is optional for most AMs, but is required for GiST because the core
* property code doesn't support AMPROP_DISTANCE_ORDERABLE. We also handle
* AMPROP_RETURNABLE here to save opening the rel to call gistcanreturn.
*/
bool
gistproperty(Oid index_oid, int attno,
IndexAMProperty prop, const char *propname,
bool *res, bool *isnull)
{
Oid opclass,
opfamily,
opcintype;
int16 procno;
/* Only answer column-level inquiries */
if (attno == 0)
return false;
/*
* Currently, GiST distance-ordered scans require that there be a distance
* function in the opclass with the default types (i.e. the one loaded
* into the relcache entry, see initGISTstate). So we assume that if such
* a function exists, then there's a reason for it (rather than grubbing
* through all the opfamily's operators to find an ordered one).
*
* Essentially the same code can test whether we support returning the
* column data, since that's true if the opclass provides a fetch proc.
*/
switch (prop)
{
case AMPROP_DISTANCE_ORDERABLE:
procno = GIST_DISTANCE_PROC;
break;
case AMPROP_RETURNABLE:
procno = GIST_FETCH_PROC;
break;
default:
return false;
}
/* First we need to know the column's opclass. */
opclass = get_index_column_opclass(index_oid, attno);
if (!OidIsValid(opclass))
{
*isnull = true;
return true;
}
/* Now look up the opclass family and input datatype. */
if (!get_opclass_opfamily_and_input_type(opclass, &opfamily, &opcintype))
{
*isnull = true;
return true;
}
/* And now we can check whether the function is provided. */
*res = SearchSysCacheExists4(AMPROCNUM,
ObjectIdGetDatum(opfamily),
ObjectIdGetDatum(opcintype),
ObjectIdGetDatum(opcintype),
Int16GetDatum(procno));
/*
* Special case: even without a fetch function, AMPROP_RETURNABLE is true
* if the opclass has no compress function.
*/
if (prop == AMPROP_RETURNABLE && !*res)
{
*res = !SearchSysCacheExists4(AMPROCNUM,
ObjectIdGetDatum(opfamily),
ObjectIdGetDatum(opcintype),
ObjectIdGetDatum(opcintype),
Int16GetDatum(GIST_COMPRESS_PROC));
}
*isnull = false;
return true;
}
/* ----------------------------------------------------------------
* TypeShellMake
*
* This procedure inserts a "shell" tuple into the pg_type relation.
* The type tuple inserted has valid but dummy values, and its
* "typisdefined" field is false indicating it's not really defined.
*
* This is used so that a tuple exists in the catalogs. The I/O
* functions for the type will link to this tuple. When the full
* CREATE TYPE command is issued, the bogus values will be replaced
* with correct ones, and "typisdefined" will be set to true.
* ----------------------------------------------------------------
*/
Oid
TypeShellMake(const char *typeName, Oid typeNamespace, Oid ownerId)
{
Relation pg_type_desc;
TupleDesc tupDesc;
int i;
HeapTuple tup;
Datum values[Natts_pg_type];
bool nulls[Natts_pg_type];
Oid typoid;
NameData name;
Assert(PointerIsValid(typeName));
/*
* open pg_type
*/
pg_type_desc = heap_open(TypeRelationId, RowExclusiveLock);
tupDesc = pg_type_desc->rd_att;
/*
* initialize our *nulls and *values arrays
*/
for (i = 0; i < Natts_pg_type; ++i)
{
nulls[i] = false;
values[i] = (Datum) NULL; /* redundant, but safe */
}
/*
* initialize *values with the type name and dummy values
*
* The representational details are the same as int4 ... it doesn't really
* matter what they are so long as they are consistent. Also note that we
* give it typtype = TYPTYPE_PSEUDO as extra insurance that it won't be
* mistaken for a usable type.
*/
namestrcpy(&name, typeName);
values[Anum_pg_type_typname - 1] = NameGetDatum(&name);
values[Anum_pg_type_typnamespace - 1] = ObjectIdGetDatum(typeNamespace);
values[Anum_pg_type_typowner - 1] = ObjectIdGetDatum(ownerId);
values[Anum_pg_type_typlen - 1] = Int16GetDatum(sizeof(int32));
values[Anum_pg_type_typbyval - 1] = BoolGetDatum(true);
values[Anum_pg_type_typtype - 1] = CharGetDatum(TYPTYPE_PSEUDO);
values[Anum_pg_type_typcategory - 1] = CharGetDatum(TYPCATEGORY_PSEUDOTYPE);
values[Anum_pg_type_typispreferred - 1] = BoolGetDatum(false);
values[Anum_pg_type_typisdefined - 1] = BoolGetDatum(false);
values[Anum_pg_type_typdelim - 1] = CharGetDatum(DEFAULT_TYPDELIM);
values[Anum_pg_type_typrelid - 1] = ObjectIdGetDatum(InvalidOid);
values[Anum_pg_type_typelem - 1] = ObjectIdGetDatum(InvalidOid);
values[Anum_pg_type_typarray - 1] = ObjectIdGetDatum(InvalidOid);
values[Anum_pg_type_typinput - 1] = ObjectIdGetDatum(F_SHELL_IN);
values[Anum_pg_type_typoutput - 1] = ObjectIdGetDatum(F_SHELL_OUT);
values[Anum_pg_type_typreceive - 1] = ObjectIdGetDatum(InvalidOid);
values[Anum_pg_type_typsend - 1] = ObjectIdGetDatum(InvalidOid);
values[Anum_pg_type_typmodin - 1] = ObjectIdGetDatum(InvalidOid);
values[Anum_pg_type_typmodout - 1] = ObjectIdGetDatum(InvalidOid);
values[Anum_pg_type_typanalyze - 1] = ObjectIdGetDatum(InvalidOid);
values[Anum_pg_type_typalign - 1] = CharGetDatum('i');
values[Anum_pg_type_typstorage - 1] = CharGetDatum('p');
values[Anum_pg_type_typnotnull - 1] = BoolGetDatum(false);
values[Anum_pg_type_typbasetype - 1] = ObjectIdGetDatum(InvalidOid);
values[Anum_pg_type_typtypmod - 1] = Int32GetDatum(-1);
values[Anum_pg_type_typndims - 1] = Int32GetDatum(0);
values[Anum_pg_type_typcollation - 1] = ObjectIdGetDatum(InvalidOid);
nulls[Anum_pg_type_typdefaultbin - 1] = true;
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 supplied. */
if (IsBinaryUpgrade && OidIsValid(binary_upgrade_next_pg_type_oid))
{
HeapTupleSetOid(tup, binary_upgrade_next_pg_type_oid);
binary_upgrade_next_pg_type_oid = InvalidOid;
}
/*
* insert the tuple in the relation and get the tuple's oid.
*/
typoid = simple_heap_insert(pg_type_desc, tup);
CatalogUpdateIndexes(pg_type_desc, tup);
/*
* Create dependencies. We can/must skip this in bootstrap mode.
*/
if (!IsBootstrapProcessingMode())
GenerateTypeDependencies(typeNamespace,
typoid,
InvalidOid,
0,
ownerId,
F_SHELL_IN,
F_SHELL_OUT,
InvalidOid,
InvalidOid,
InvalidOid,
InvalidOid,
InvalidOid,
InvalidOid,
false,
InvalidOid,
InvalidOid,
NULL,
false);
/* Post creation hook for new shell type */
InvokeObjectAccessHook(OAT_POST_CREATE,
TypeRelationId, typoid, 0, NULL);
/*
* clean up and return the type-oid
*/
heap_freetuple(tup);
heap_close(pg_type_desc, RowExclusiveLock);
return typoid;
}
/*
* Sets the policy of a table into the gp_distribution_policy table
* from a GpPolicy structure.
*
*/
void
GpPolicyStore(Oid tbloid, const GpPolicy *policy)
{
Relation gp_policy_rel;
HeapTuple gp_policy_tuple = NULL;
ArrayType *attrnums;
bool nulls[2];
Datum values[2];
cqContext cqc;
cqContext *pcqCtx;
Insist(policy->ptype == POLICYTYPE_PARTITIONED);
/*
* Open and lock the gp_distribution_policy catalog.
*/
gp_policy_rel = heap_open(GpPolicyRelationId, RowExclusiveLock);
pcqCtx = caql_beginscan(
caql_addrel(cqclr(&cqc), gp_policy_rel),
cql("INSERT INTO gp_distribution_policy ",
NULL));
/*
* Convert C arrays into Postgres arrays.
*/
if (policy->nattrs > 0)
{
int i;
Datum *akey;
akey = (Datum *) palloc(policy->nattrs * sizeof(Datum));
for (i = 0; i < policy->nattrs; i++)
akey[i] = Int16GetDatum(policy->attrs[i]);
attrnums = construct_array(akey, policy->nattrs,
INT2OID, 2, true, 's');
}
else
{
attrnums = NULL;
}
nulls[0] = false;
nulls[1] = false;
values[0] = ObjectIdGetDatum(tbloid);
if (attrnums)
values[1] = PointerGetDatum(attrnums);
else
nulls[1] = true;
gp_policy_tuple = caql_form_tuple(pcqCtx, values, nulls);
/* Insert tuple into the relation */
caql_insert(pcqCtx, gp_policy_tuple); /* implicit update of index as well*/
/*
* Close the gp_distribution_policy relcache entry without unlocking.
* We have updated the catalog: consequently the lock must be held until
* end of transaction.
*/
caql_endscan(pcqCtx);
heap_close(gp_policy_rel, NoLock);
} /* GpPolicyStore */
/*
* InsertRule -
* takes the arguments and inserts them as a row into the system
* relation "pg_rewrite"
*/
static Oid
InsertRule(char *rulname,
int evtype,
Oid eventrel_oid,
AttrNumber evslot_index,
bool evinstead,
Node *event_qual,
List *action,
bool replace)
{
char *evqual = nodeToString(event_qual);
char *actiontree = nodeToString((Node *) action);
int i;
Datum values[Natts_pg_rewrite];
bool nulls[Natts_pg_rewrite];
bool replaces[Natts_pg_rewrite];
NameData rname;
Relation pg_rewrite_desc;
HeapTuple tup,
oldtup;
Oid rewriteObjectId;
ObjectAddress myself,
referenced;
bool is_update = false;
/*
* Set up *nulls and *values arrays
*/
MemSet(nulls, false, sizeof(nulls));
i = 0;
namestrcpy(&rname, rulname);
values[i++] = NameGetDatum(&rname); /* rulename */
values[i++] = ObjectIdGetDatum(eventrel_oid); /* ev_class */
values[i++] = Int16GetDatum(evslot_index); /* ev_attr */
values[i++] = CharGetDatum(evtype + '0'); /* ev_type */
values[i++] = CharGetDatum(RULE_FIRES_ON_ORIGIN); /* ev_enabled */
values[i++] = BoolGetDatum(evinstead); /* is_instead */
values[i++] = CStringGetTextDatum(evqual); /* ev_qual */
values[i++] = CStringGetTextDatum(actiontree); /* ev_action */
/*
* Ready to store new pg_rewrite tuple
*/
pg_rewrite_desc = heap_open(RewriteRelationId, RowExclusiveLock);
/*
* Check to see if we are replacing an existing tuple
*/
oldtup = SearchSysCache2(RULERELNAME,
ObjectIdGetDatum(eventrel_oid),
PointerGetDatum(rulname));
if (HeapTupleIsValid(oldtup))
{
if (!replace)
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("rule \"%s\" for relation \"%s\" already exists",
rulname, get_rel_name(eventrel_oid))));
/*
* When replacing, we don't need to replace every attribute
*/
MemSet(replaces, false, sizeof(replaces));
replaces[Anum_pg_rewrite_ev_attr - 1] = true;
replaces[Anum_pg_rewrite_ev_type - 1] = true;
replaces[Anum_pg_rewrite_is_instead - 1] = true;
replaces[Anum_pg_rewrite_ev_qual - 1] = true;
replaces[Anum_pg_rewrite_ev_action - 1] = true;
tup = heap_modify_tuple(oldtup, RelationGetDescr(pg_rewrite_desc),
values, nulls, replaces);
simple_heap_update(pg_rewrite_desc, &tup->t_self, tup);
ReleaseSysCache(oldtup);
rewriteObjectId = HeapTupleGetOid(tup);
is_update = true;
}
else
{
tup = heap_form_tuple(pg_rewrite_desc->rd_att, values, nulls);
rewriteObjectId = simple_heap_insert(pg_rewrite_desc, tup);
}
/* Need to update indexes in either case */
CatalogUpdateIndexes(pg_rewrite_desc, tup);
heap_freetuple(tup);
/* If replacing, get rid of old dependencies and make new ones */
if (is_update)
deleteDependencyRecordsFor(RewriteRelationId, rewriteObjectId, false);
/*
* Install dependency on rule's relation to ensure it will go away on
* relation deletion. If the rule is ON SELECT, make the dependency
* implicit --- this prevents deleting a view's SELECT rule. Other kinds
* of rules can be AUTO.
*/
myself.classId = RewriteRelationId;
myself.objectId = rewriteObjectId;
myself.objectSubId = 0;
referenced.classId = RelationRelationId;
referenced.objectId = eventrel_oid;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced,
(evtype == CMD_SELECT) ? DEPENDENCY_INTERNAL : DEPENDENCY_AUTO);
/*
* Also install dependencies on objects referenced in action and qual.
*/
recordDependencyOnExpr(&myself, (Node *) action, NIL,
DEPENDENCY_NORMAL);
if (event_qual != NULL)
{
/* Find query containing OLD/NEW rtable entries */
Query *qry = (Query *) linitial(action);
qry = getInsertSelectQuery(qry, NULL);
recordDependencyOnExpr(&myself, event_qual, qry->rtable,
DEPENDENCY_NORMAL);
}
/* Post creation hook for new rule */
InvokeObjectAccessHook(OAT_POST_CREATE,
RewriteRelationId, rewriteObjectId, 0);
heap_close(pg_rewrite_desc, RowExclusiveLock);
return rewriteObjectId;
}
/*
* pgdatabasev - produce a view of gp_transaction_log that combines
* information from the local clog and the distributed log.
*/
Datum
gp_transaction_log(PG_FUNCTION_ARGS)
{
typedef struct Context
{
TransactionId indexXid;
} Context;
FuncCallContext *funcctx;
Context *context;
if (SRF_IS_FIRSTCALL())
{
TupleDesc tupdesc;
MemoryContext oldcontext;
/* create a function context for cross-call persistence */
funcctx = SRF_FIRSTCALL_INIT();
/*
* switch to memory context appropriate for multiple function
* calls
*/
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
/* build tupdesc for result tuples */
/* this had better match gp_distributed_xacts view in system_views.sql */
tupdesc = CreateTemplateTupleDesc(4, false);
TupleDescInitEntry(tupdesc, (AttrNumber) 1, "segment_id",
INT2OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 2, "dbid",
INT2OID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 3, "transaction",
XIDOID, -1, 0);
TupleDescInitEntry(tupdesc, (AttrNumber) 4, "status",
TEXTOID, -1, 0);
funcctx->tuple_desc = BlessTupleDesc(tupdesc);
/*
* Collect all the locking information that we will format and send
* out as a result set.
*/
context = (Context *) palloc(sizeof(Context));
funcctx->user_fctx = (void *) context;
context->indexXid = ShmemVariableCache->nextXid;
// Start with last possible + 1.
funcctx->user_fctx = (void *) context;
MemoryContextSwitchTo(oldcontext);
}
funcctx = SRF_PERCALL_SETUP();
context = (Context *) funcctx->user_fctx;
/*
* Go backwards until we don't find a clog log page
*/
while (true)
{
XidStatus status;
char *statusStr = NULL;
Datum values[4];
bool nulls[4];
HeapTuple tuple;
Datum result;
if (context->indexXid < FirstNormalTransactionId)
break;
if (!CLOGScanForPrevStatus(&context->indexXid,
&status))
break;
/*
* Form tuple with appropriate data.
*/
MemSet(values, 0, sizeof(values));
MemSet(nulls, false, sizeof(nulls));
values[0] = Int16GetDatum((int16)Gp_segment);
values[1] = Int16GetDatum((int16)GpIdentity.dbid);
values[2] = TransactionIdGetDatum(context->indexXid);
if (status == TRANSACTION_STATUS_IN_PROGRESS)
statusStr = "InProgress";
else if (status == TRANSACTION_STATUS_COMMITTED)
statusStr = "Committed";
else if (status == TRANSACTION_STATUS_ABORTED)
statusStr = "Aborted";
else if (status == TRANSACTION_STATUS_SUB_COMMITTED)
statusStr = "SubXactCommitted";
else
elog(ERROR, "Unexpected transaction status %d",
status);
values[3] =
DirectFunctionCall1(textin,
CStringGetDatum(statusStr));
tuple = heap_form_tuple(funcctx->tuple_desc, values, nulls);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
}
SRF_RETURN_DONE(funcctx);
}
