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; }