/*
* Get next block number to read or InvalidBlockNumber if we are at the
* end of the relation.
*/
Datum
tsm_bernoulli_nextblock(PG_FUNCTION_ARGS)
{
TableSampleDesc *tsdesc = (TableSampleDesc *) PG_GETARG_POINTER(0);
BernoulliSamplerData *sampler =
(BernoulliSamplerData *) tsdesc->tsmdata;
/*
* Bernoulli sampling scans all blocks on the table and supports
* syncscan so loop from startblock to startblock instead of
* from 0 to nblocks.
*/
if (sampler->blockno == InvalidBlockNumber)
sampler->blockno = sampler->startblock;
else
{
sampler->blockno++;
if (sampler->blockno >= sampler->nblocks)
sampler->blockno = 0;
if (sampler->blockno == sampler->startblock)
PG_RETURN_UINT32(InvalidBlockNumber);
}
PG_RETURN_UINT32(sampler->blockno);
}
/* Returns the task status of an already existing task. */
Datum
task_tracker_task_status(PG_FUNCTION_ARGS)
{
uint64 jobId = PG_GETARG_INT64(0);
uint32 taskId = PG_GETARG_UINT32(1);
WorkerTask *workerTask = NULL;
uint32 taskStatus = 0;
bool taskTrackerRunning = TaskTrackerRunning();
if (taskTrackerRunning)
{
LWLockAcquire(&WorkerTasksSharedState->taskHashLock, LW_SHARED);
workerTask = WorkerTasksHashFind(jobId, taskId);
if (workerTask == NULL)
{
ereport(ERROR, (errmsg("could not find the worker task"),
errdetail("Task jobId: " UINT64_FORMAT " and taskId: %u",
jobId, taskId)));
}
taskStatus = (uint32) workerTask->taskStatus;
LWLockRelease(&WorkerTasksSharedState->taskHashLock);
}
else
{
ereport(ERROR, (errcode(ERRCODE_CANNOT_CONNECT_NOW),
errmsg("the task tracker has been disabled or shut down")));
}
PG_RETURN_UINT32(taskStatus);
}
/*
* Get next block number or InvalidBlockNumber when we're done.
*
* Uses linear probing algorithm for picking next block.
*/
Datum
tsm_system_time_nextblock(PG_FUNCTION_ARGS)
{
TableSampleDesc *tsdesc = (TableSampleDesc *) PG_GETARG_POINTER(0);
SystemSamplerData *sampler = (SystemSamplerData *) tsdesc->tsmdata;
sampler->lb = (sampler->lb + sampler->step) % sampler->nblocks;
sampler->doneblocks++;
/* All blocks have been read, we're done */
if (sampler->doneblocks > sampler->nblocks)
PG_RETURN_UINT32(InvalidBlockNumber);
/*
* Update the estimations for time limit at least 10 times per estimated
* number of returned blocks to handle variations in block read speed.
*/
if (sampler->doneblocks % Max(sampler->estblocks/10, 1) == 0)
{
TimestampTz now = GetCurrentTimestamp();
long secs;
int usecs;
int usecs_remaining;
int time_per_block;
TimestampDifference(sampler->start_time, now, &secs, &usecs);
usecs += (int) secs * 1000000;
time_per_block = usecs / sampler->doneblocks;
/* No time left, end. */
TimestampDifference(now, sampler->end_time, &secs, &usecs);
if (secs <= 0 && usecs <= 0)
PG_RETURN_UINT32(InvalidBlockNumber);
/* Remaining microseconds */
usecs_remaining = usecs + (int) secs * 1000000;
/* Recalculate estimated returned number of blocks */
if (time_per_block < usecs_remaining && time_per_block > 0)
sampler->estblocks = sampler->time * time_per_block;
}
PG_RETURN_UINT32(sampler->lb);
}
Datum
hashfloat8(PG_FUNCTION_ARGS)
{
float8 key = PG_GETARG_FLOAT8(0);
/*
* On IEEE-float machines, minus zero and zero have different bit
* patterns but should compare as equal. We must ensure that they
* have the same hash value, which is most easily done this way:
*/
if (key == (float8) 0)
PG_RETURN_UINT32(0);
return hash_any((unsigned char *) &key, sizeof(key));
}
Datum
DumpQueryToFile(PG_FUNCTION_ARGS)
{
char *szSql = textToString(PG_GETARG_TEXT_P(0));
char *szFilename = textToString(PG_GETARG_TEXT_P(1));
size_t iQueryStringLen = -1;
char *pcQuery = getQueryBinary(szSql, &iQueryStringLen);
CFileWriter fw;
fw.Open(szFilename, S_IRUSR | S_IWUSR);
fw.Write(reinterpret_cast<const BYTE*>(&iQueryStringLen), sizeof(iQueryStringLen));
fw.Write(reinterpret_cast<const BYTE*>(pcQuery), iQueryStringLen);
fw.Close();
PG_RETURN_UINT32( (ULONG) iQueryStringLen);
}
Datum
DumpPlanToFile(PG_FUNCTION_ARGS)
{
char *szSql = text_to_cstring(PG_GETARG_TEXT_P(0));
char *szFilename = text_to_cstring(PG_GETARG_TEXT_P(1));
size_t iBinaryLen = -1;
char *pcBinary = getPlannedStmtBinary(szSql, &iBinaryLen);
CFileWriter fw;
fw.Open(szFilename, S_IRUSR | S_IWUSR);
fw.Write(reinterpret_cast<const BYTE*>(&iBinaryLen), sizeof(iBinaryLen));
fw.Write(reinterpret_cast<const BYTE*>(pcBinary), iBinaryLen);
fw.Close();
PG_RETURN_UINT32((ULONG) iBinaryLen);
}
Datum
acl_check_access_int4_current_user(PG_FUNCTION_ARGS)
{
ArrayType *acl;
uint32 mask;
bool implicit_allow;
Oid who;
if (!check_access_extract_args(fcinfo, &acl, &mask, NULL, &implicit_allow,
false, false))
PG_RETURN_NULL();
who = GetUserId();
PG_RETURN_UINT32(check_access(acl, ACL_TYPE_LENGTH, ACL_TYPE_ALIGNMENT,
extract_acl_entry_base, mask,
(intptr_t) who, who_matches,
implicit_allow));
}
Datum
acl_check_access_int4_oid(PG_FUNCTION_ARGS)
{
ArrayType *acl;
uint32 mask;
Oid who;
bool implicit_allow;
if (!check_access_extract_args(fcinfo, &acl, &mask, NULL, &implicit_allow,
false, true))
PG_RETURN_NULL();
if (PG_ARGISNULL(2))
PG_RETURN_NULL();
who = PG_GETARG_OID(2);
PG_RETURN_UINT32(check_access(acl, ACL_TYPE_LENGTH, ACL_TYPE_ALIGNMENT,
extract_acl_entry_base, mask,
(intptr_t) who, who_matches,
implicit_allow));
}
Datum
hashoid(PG_FUNCTION_ARGS)
{
PG_RETURN_UINT32(~((uint32) PG_GETARG_OID(0)));
}
Datum
hashint8(PG_FUNCTION_ARGS)
{
/* we just use the low 32 bits... */
PG_RETURN_UINT32(~((uint32) PG_GETARG_INT64(0)));
}
Datum
hashint4(PG_FUNCTION_ARGS)
{
PG_RETURN_UINT32(~PG_GETARG_UINT32(0));
}
Datum
hashint2(PG_FUNCTION_ARGS)
{
PG_RETURN_UINT32(~((uint32) PG_GETARG_INT16(0)));
}
/* Note: this is used for both "char" and boolean datatypes */
Datum
hashchar(PG_FUNCTION_ARGS)
{
PG_RETURN_UINT32(~((uint32) PG_GETARG_CHAR(0)));
}
