/*
* Performs a dispatch to all the non-Master segments to perform
* DB specific PersistentCat verifications
*/
void
Persistent_PostDTMRecv_DBSpecificPTCatVerification(void)
{
PGresult **pgresultSets = NULL;
StringInfoData errmsgbuf;
PGresult *rs = NULL;
int i =0;
const char *cmdbuf = "select * from gp_dbspecific_ptcat_verification()";
initStringInfo(&errmsgbuf);
/* call to all QE to perform verifications */
pgresultSets = cdbdisp_dispatchRMCommand(cmdbuf, /* withSnapshot */false,
&errmsgbuf, NULL);
/* display error messages */
if (errmsgbuf.len > 0)
{
ereport(ERROR, (errcode(ERRCODE_GP_INTERCONNECTION_ERROR),
errmsg("Failure seen during non-db specific verification"),
errdetail("%s", errmsgbuf.data)));
pfree(errmsgbuf.data);
}
rs = pgresultSets[0];
i=0;
do
{
PQclear(rs);
} while ((rs = pgresultSets[++i]) != NULL);
pfree(errmsgbuf.data);
free(pgresultSets);
}
static Oid
get_max_oid_from_segDBs(void)
{
Oid oid = 0;
int i;
int resultCount = 0;
struct pg_result **results = NULL;
StringInfoData buffer;
StringInfoData errbuf;
initStringInfo(&buffer);
appendStringInfo(&buffer, "select pg_highest_oid()");
initStringInfo(&errbuf);
results = cdbdisp_dispatchRMCommand(buffer.data, true, &errbuf, &resultCount);
if (errbuf.len > 0)
ereport(ERROR, (errmsg("pg_highest_oid error (gathered %d results from cmd '%s')", resultCount, buffer.data),
errdetail("%s", errbuf.data)));
for (i = 0; i < resultCount; i++)
{
if (PQresultStatus(results[i]) != PGRES_TUPLES_OK)
{
elog(ERROR,"dboid: resultStatus not tuples_Ok");
}
else
{
/*
* Due to funkyness in the current dispatch agent code, instead of 1 result
* per QE with 1 row each, we can get back 1 result per dispatch agent, with
* one row per QE controlled by that agent.
*/
int j;
for (j = 0; j < PQntuples(results[i]); j++)
{
Oid tempoid = 0;
tempoid = atol(PQgetvalue(results[i], j, 0));
if (tempoid > oid)
oid = tempoid;
}
}
}
pfree(errbuf.data);
for (i = 0; i < resultCount; i++)
PQclear(results[i]);
free(results);
return oid;
}
static Oid
get_max_oid_from_segDBs(void)
{
Oid oid = 0;
Oid tempoid = 0;
int i;
int resultCount = 0;
struct pg_result **results = NULL;
StringInfoData buffer;
StringInfoData errbuf;
initStringInfo(&buffer);
appendStringInfo(&buffer, "select pg_highest_oid()");
initStringInfo(&errbuf);
results = cdbdisp_dispatchRMCommand(buffer.data, true, &errbuf, &resultCount);
if (errbuf.len > 0)
ereport(ERROR, (errmsg("pg_highest_oid error (gathered %d results from cmd '%s')", resultCount, buffer.data),
errdetail("%s", errbuf.data)));
for (i = 0; i < resultCount; i++)
{
if (PQresultStatus(results[i]) != PGRES_TUPLES_OK)
{
elog(ERROR,"dboid: resultStatus not tuples_Ok");
}
else
{
Assert(PQntuples(results[i]) == 1);
tempoid = atol(PQgetvalue(results[i], 0, 0));
if (tempoid > oid)
oid = tempoid;
}
}
pfree(errbuf.data);
for (i = 0; i < resultCount; i++)
PQclear(results[i]);
free(results);
return oid;
}
/*
* 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);
}
/*
* Delete error log of the specified relation. This returns true from master
* iif all segments and master find the relation.
*/
Datum
gp_truncate_error_log(PG_FUNCTION_ARGS)
{
text *relname;
char *relname_str;
RangeVar *relrv;
Oid relid;
bool allResults = true;
relname = PG_GETARG_TEXT_P(0);
/*
* Dispatch the work to segments.
*/
if (Gp_role == GP_ROLE_DISPATCH)
{
int i, resultCount = 0;
StringInfoData sql, errbuf;
PGresult **results;
initStringInfo(&sql);
initStringInfo(&errbuf);
appendStringInfo(&sql,
"SELECT pg_catalog.gp_truncate_error_log('%s')",
text_to_cstring(relname));
results = cdbdisp_dispatchRMCommand(sql.data, true, &errbuf,
&resultCount);
if (errbuf.len > 0)
elog(ERROR, "%s", errbuf.data);
Assert(resultCount > 0);
for (i = 0; i < resultCount; i++)
{
Datum value;
bool isnull;
if (PQresultStatus(results[i]) != PGRES_TUPLES_OK)
ereport(ERROR,
(errmsg("unexpected result from segment: %d",
PQresultStatus(results[i]))));
value = ResultToDatum(results[i], 0, 0, boolin, &isnull);
allResults &= (!isnull && DatumGetBool(value));
PQclear(results[i]);
}
pfree(errbuf.data);
pfree(sql.data);
}
relname_str = text_to_cstring(relname);
if (strcmp(relname_str, "*.*") == 0)
{
/*
* Only superuser is allowed to delete log files across database.
*/
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to delete all error log files"))));
ErrorLogDelete(InvalidOid, InvalidOid);
}
else if (strcmp(relname_str, "*") == 0)
{
/*
* Database owner can delete error log files.
*/
if (!pg_database_ownercheck(MyDatabaseId, GetUserId()))
aclcheck_error(ACLCHECK_NOT_OWNER, ACL_KIND_DATABASE,
get_database_name(MyDatabaseId));
ErrorLogDelete(MyDatabaseId, InvalidOid);
}
else
{
AclResult aclresult;
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
relid = RangeVarGetRelid(relrv, true);
/* Return false if the relation does not exist. */
if (!OidIsValid(relid))
PG_RETURN_BOOL(false);
/*
* Allow only the table owner to truncate error log.
*/
aclresult = pg_class_aclcheck(relid, GetUserId(), ACL_TRUNCATE);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_CLASS, relrv->relname);
/* We don't care if this fails or not. */
ErrorLogDelete(MyDatabaseId, relid);
}
/* Return true iif all segments return true. */
PG_RETURN_BOOL(allResults);
}
/*
* gp_read_error_log
*
* Returns set of error log tuples.
*/
Datum
gp_read_error_log(PG_FUNCTION_ARGS)
{
FuncCallContext *funcctx;
ReadErrorLogContext *context;
HeapTuple tuple;
Datum result;
/*
* First call setup
*/
if (SRF_IS_FIRSTCALL())
{
MemoryContext oldcontext;
FILE *fp;
text *relname;
funcctx = SRF_FIRSTCALL_INIT();
relname = PG_GETARG_TEXT_P(0);
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
context = palloc0(sizeof(ReadErrorLogContext));
funcctx->user_fctx = (void *) context;
funcctx->tuple_desc = BlessTupleDesc(GetErrorTupleDesc());
/*
* Though this function is usually executed on segment, we dispatch
* the execution if it happens to be on QD, and combine the results
* into one set.
*/
if (Gp_role == GP_ROLE_DISPATCH)
{
int resultCount = 0;
PGresult **results = NULL;
StringInfoData sql;
StringInfoData errbuf;
int i;
initStringInfo(&sql);
initStringInfo(&errbuf);
/*
* construct SQL
*/
appendStringInfo(&sql,
"SELECT * FROM pg_catalog.gp_read_error_log(%s) ",
quote_literal_internal(text_to_cstring(relname)));
results = cdbdisp_dispatchRMCommand(sql.data, true, &errbuf,
&resultCount);
if (errbuf.len > 0)
elog(ERROR, "%s", errbuf.data);
Assert(resultCount > 0);
for (i = 0; i < resultCount; i++)
{
if (PQresultStatus(results[i]) != PGRES_TUPLES_OK)
elog(ERROR, "unexpected result from segment: %d",
PQresultStatus(results[i]));
context->numTuples += PQntuples(results[i]);
}
pfree(errbuf.data);
pfree(sql.data);
context->segResults = results;
context->numSegResults = resultCount;
}
else
{
/*
* In QE, read the error log.
*/
RangeVar *relrv;
Oid relid;
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
relid = RangeVarGetRelid(relrv, true);
/*
* If the relation has gone, silently return no tuples.
*/
if (OidIsValid(relid))
{
AclResult aclresult;
/*
* Requires SELECT priv to read error log.
*/
aclresult = pg_class_aclcheck(relid, GetUserId(), ACL_SELECT);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_CLASS, relrv->relname);
ErrorLogFileName(context->filename, MyDatabaseId, relid);
fp = AllocateFile(context->filename, "r");
context->fp = fp;
}
}
MemoryContextSwitchTo(oldcontext);
if (Gp_role != GP_ROLE_DISPATCH && !context->fp)
{
pfree(context);
SRF_RETURN_DONE(funcctx);
}
}
funcctx = SRF_PERCALL_SETUP();
context = (ReadErrorLogContext *) funcctx->user_fctx;
/*
* Read error log, probably on segments. We don't check Gp_role, however,
* in case master also wants to read the file.
*/
if (context->fp)
{
pg_crc32 crc, written_crc;
tuple = ErrorLogRead(context->fp, &written_crc);
/*
* CRC check.
*/
if (HeapTupleIsValid(tuple))
{
INIT_CRC32C(crc);
COMP_CRC32C(crc, tuple->t_data, tuple->t_len);
FIN_CRC32C(crc);
if (!EQ_CRC32C(crc, written_crc))
{
elog(LOG, "incorrect checksum in error log %s",
context->filename);
tuple = NULL;
}
}
/*
* If we found a valid tuple, return it. Otherwise, fall through
* in the DONE routine.
*/
if (HeapTupleIsValid(tuple))
{
/*
* We need to set typmod for the executor to understand
* its type we just blessed.
*/
HeapTupleHeaderSetTypMod(tuple->t_data,
funcctx->tuple_desc->tdtypmod);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
}
}
/*
* If we got results from dispatch, return all the tuples.
*/
while (context->currentResult < context->numSegResults)
{
Datum values[NUM_ERRORTABLE_ATTR];
bool isnull[NUM_ERRORTABLE_ATTR];
PGresult *segres = context->segResults[context->currentResult];
int row = context->currentRow;
if (row >= PQntuples(segres))
{
context->currentRow = 0;
context->currentResult++;
continue;
}
context->currentRow++;
MemSet(isnull, false, sizeof(isnull));
values[0] = ResultToDatum(segres, row, 0, timestamptz_in, &isnull[0]);
values[1] = ResultToDatum(segres, row, 1, textin, &isnull[1]);
values[2] = ResultToDatum(segres, row, 2, textin, &isnull[2]);
values[3] = ResultToDatum(segres, row, 3, int4in, &isnull[3]);
values[4] = ResultToDatum(segres, row, 4, int4in, &isnull[4]);
values[5] = ResultToDatum(segres, row, 5, textin, &isnull[5]);
values[6] = ResultToDatum(segres, row, 6, textin, &isnull[6]);
values[7] = ResultToDatum(segres, row, 7, byteain, &isnull[7]);
tuple = heap_form_tuple(funcctx->tuple_desc, values, isnull);
result = HeapTupleGetDatum(tuple);
SRF_RETURN_NEXT(funcctx, result);
}
if (context->segResults != NULL)
{
int i;
for (i = 0; i < context->numSegResults; i++)
PQclear(context->segResults[i]);
/* XXX: better to copy to palloc'ed area */
free(context->segResults[i]);
}
/*
* Close the file, if we have opened it.
*/
if (context->fp != NULL)
{
FreeFile(context->fp);
context->fp = NULL;
}
SRF_RETURN_DONE(funcctx);
}
int64 cdbRelSize(Relation rel)
{
int64 size = 0;
int i;
int resultCount = 0;
struct pg_result **results = NULL;
StringInfoData errbuf;
StringInfoData buffer;
char *schemaName;
char *relName;
if (last_cache_entry >= 0)
{
for (i=0; i < relsize_cache_size; i++)
{
if (relsize_cache[i].relOid == RelationGetRelid(rel))
return relsize_cache[i].size;
}
}
/*
* Let's ask the QEs for the size of the relation
*/
initStringInfo(&buffer);
initStringInfo(&errbuf);
schemaName = get_namespace_name(RelationGetNamespace(rel));
if (schemaName == NULL)
elog(ERROR, "cache lookup failed for namespace %d",
RelationGetNamespace(rel));
relName = RelationGetRelationName(rel);
/*
* Safer to pass names than oids, just in case they get out of sync between QD and QE,
* which might happen with a toast table or index, I think (but maybe not)
*/
appendStringInfo(&buffer, "select pg_relation_size('%s.%s')",
quote_identifier(schemaName), quote_identifier(relName));
/*
* In the future, it would be better to send the command to only one QE for the optimizer's needs,
* but for ALTER TABLE, we need to be sure if the table has any rows at all.
*/
results = cdbdisp_dispatchRMCommand(buffer.data, true, &errbuf, &resultCount);
if (errbuf.len > 0)
{
ereport(WARNING, (errmsg("cdbRelSize error (gathered %d results from cmd '%s')", resultCount, buffer.data),
errdetail("%s", errbuf.data)));
pfree(errbuf.data);
pfree(buffer.data);
return -1;
}
else
{
for (i = 0; i < resultCount; i++)
{
if (PQresultStatus(results[i]) != PGRES_TUPLES_OK)
{
elog(ERROR,"cdbRelSize: resultStatus not tuples_Ok: %s %s",PQresStatus(PQresultStatus(results[i])),PQresultErrorMessage(results[i]));
}
else
{
/*
* Due to funkyness in the current dispatch agent code, instead of 1 result
* per QE with 1 row each, we can get back 1 result per dispatch agent, with
* one row per QE controlled by that agent.
*/
int j;
for (j = 0; j < PQntuples(results[i]); j++)
{
int64 tempsize = 0;
(void) scanint8(PQgetvalue(results[i], j, 0), false, &tempsize);
if (tempsize > size)
size = tempsize;
}
}
}
pfree(errbuf.data);
pfree(buffer.data);
for (i = 0; i < resultCount; i++)
PQclear(results[i]);
free(results);
}
if (size >= 0) /* Cache the size even if it is zero, as table might be empty */
{
if (last_cache_entry < 0)
last_cache_entry = 0;
relsize_cache[last_cache_entry].relOid = RelationGetRelid(rel);
relsize_cache[last_cache_entry].size = size;
last_cache_entry = (last_cache_entry+1) % relsize_cache_size;
}
return size;
}
