static HeapTuple
FormErrorTuple(CdbSreh *cdbsreh)
{
bool nulls[NUM_ERRORTABLE_ATTR];
Datum values[NUM_ERRORTABLE_ATTR];
MemoryContext oldcontext;
oldcontext = MemoryContextSwitchTo(cdbsreh->badrowcontext);
/* Initialize all values for row to NULL */
MemSet(values, 0, NUM_ERRORTABLE_ATTR * sizeof(Datum));
MemSet(nulls, true, NUM_ERRORTABLE_ATTR * sizeof(bool));
/* command start time */
values[errtable_cmdtime - 1] = TimestampTzGetDatum(GetCurrentStatementStartTimestamp());
nulls[errtable_cmdtime - 1] = false;
/* line number */
if (cdbsreh->linenumber > 0)
{
values[errtable_linenum - 1] = Int64GetDatum(cdbsreh->linenumber);
nulls[errtable_linenum - 1] = false;
}
if(cdbsreh->is_server_enc)
{
/* raw data */
values[errtable_rawdata - 1] = DirectFunctionCall1(textin, CStringGetDatum(cdbsreh->rawdata));
nulls[errtable_rawdata - 1] = false;
}
else
{
/* raw bytes */
PreprocessByteaData(cdbsreh->rawdata);
values[errtable_rawbytes - 1] = DirectFunctionCall1(byteain, CStringGetDatum(cdbsreh->rawdata));
nulls[errtable_rawbytes - 1] = false;
}
/* file name */
values[errtable_filename - 1] = DirectFunctionCall1(textin, CStringGetDatum(cdbsreh->filename));
nulls[errtable_filename - 1] = false;
/* relation name */
values[errtable_relname - 1] = DirectFunctionCall1(textin, CStringGetDatum(cdbsreh->relname));
nulls[errtable_relname - 1] = false;
/* error message */
values[errtable_errmsg - 1] = DirectFunctionCall1(textin, CStringGetDatum(cdbsreh->errmsg));
nulls[errtable_errmsg - 1] = false;
MemoryContextSwitchTo(oldcontext);
/*
* And now we can form the input tuple.
*/
return heap_form_tuple(GetErrorTupleDesc(), values, nulls);
}
Datum
orafce_sysdate(PG_FUNCTION_ARGS)
{
Datum sysdate;
Datum sysdate_scaled;
sysdate = DirectFunctionCall2(timestamptz_zone,
CStringGetTextDatum(orafce_timezone),
TimestampTzGetDatum(GetCurrentStatementStartTimestamp()));
/* necessary to cast to timestamp(0) to emulate Oracle's date */
sysdate_scaled = DirectFunctionCall2(timestamp_scale,
sysdate,
Int32GetDatum(0));
PG_RETURN_DATUM(sysdate_scaled);
}
/*
* MemoryAccounting_SaveToFile
* Saves the current memory accounting tree into a CSV file
*
* currentSliceId: The currently executing slice ID
*/
void
MemoryAccounting_SaveToFile(int currentSliceId)
{
StringInfoData prefix;
StringInfoData memBuf;
initStringInfo(&prefix);
initStringInfo(&memBuf);
/* run_id, dataset_id, query_id, scale_factor, gp_session_id, current_statement_timestamp, slice_id, segment_idx, */
appendStringInfo(&prefix, "%s,%s,%s,%u,%u,%d,%" PRIu64 ",%d,%d",
memory_profiler_run_id, memory_profiler_dataset_id, memory_profiler_query_id,
memory_profiler_dataset_size, statement_mem, gp_session_id, GetCurrentStatementStartTimestamp(),
currentSliceId, GpIdentity.segindex);
MemoryAccounting_ToCSV(MemoryAccountTreeLogicalRoot, &memBuf, prefix.data);
SaveMemoryBufToDisk(&memBuf, prefix.data);
pfree(prefix.data);
pfree(memBuf.data);
}
/*
* Enable the SIGALRM interrupt to fire after the specified delay
*
* Delay is given in milliseconds. Caller should be sure a SIGALRM
* signal handler is installed before this is called.
*
* This code properly handles nesting of deadlock timeout alarms within
* statement timeout alarms.
*
* Returns TRUE if okay, FALSE on failure.
*/
bool
enable_sig_alarm(int delayms, bool is_statement_timeout)
{
TimestampTz fin_time;
struct itimerval timeval;
if (is_statement_timeout)
{
/*
* Begin statement-level timeout
*
* Note that we compute statement_fin_time with reference to the
* statement_timestamp, but apply the specified delay without any
* correction; that is, we ignore whatever time has elapsed since
* statement_timestamp was set. In the normal case only a small
* interval will have elapsed and so this doesn't matter, but there
* are corner cases (involving multi-statement query strings with
* embedded COMMIT or ROLLBACK) where we might re-initialize the
* statement timeout long after initial receipt of the message. In
* such cases the enforcement of the statement timeout will be a bit
* inconsistent. This annoyance is judged not worth the cost of
* performing an additional gettimeofday() here.
*/
Assert(!deadlock_timeout_active);
fin_time = GetCurrentStatementStartTimestamp();
fin_time = TimestampTzPlusMilliseconds(fin_time, delayms);
statement_fin_time = fin_time;
cancel_from_timeout = false;
statement_timeout_active = true;
}
else if (statement_timeout_active)
{
/*
* Begin deadlock timeout with statement-level timeout active
*
* Here, we want to interrupt at the closer of the two timeout times.
* If fin_time >= statement_fin_time then we need not touch the
* existing timer setting; else set up to interrupt at the deadlock
* timeout time.
*
* NOTE: in this case it is possible that this routine will be
* interrupted by the previously-set timer alarm. This is okay
* because the signal handler will do only what it should do according
* to the state variables. The deadlock checker may get run earlier
* than normal, but that does no harm.
*/
fin_time = GetCurrentTimestamp();
fin_time = TimestampTzPlusMilliseconds(fin_time, delayms);
deadlock_timeout_active = true;
if (fin_time >= statement_fin_time)
return true;
}
else
{
/* Begin deadlock timeout with no statement-level timeout */
deadlock_timeout_active = true;
}
/* If we reach here, okay to set the timer interrupt */
MemSet(&timeval, 0, sizeof(struct itimerval));
timeval.it_value.tv_sec = delayms / 1000;
timeval.it_value.tv_usec = (delayms % 1000) * 1000;
if (setitimer(ITIMER_REAL, &timeval, NULL))
return false;
return true;
}