Datum
dbms_alert_remove(PG_FUNCTION_ARGS)
{
text *name = PG_GETARG_TEXT_P(0);
alert_event *ev;
int ev_id;
int cycle = 0;
float8 endtime;
float8 timeout = 2;
WATCH_PRE(timeout, endtime, cycle);
if (ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES,MAX_EVENTS,MAX_LOCKS,false))
{
ev = find_event(name, false, &ev_id);
if (NULL != ev)
{
find_and_remove_message_item(ev_id, sid,
false, true, true, NULL, NULL);
unregister_event(ev_id, sid);
}
LWLockRelease(shmem_lock);
PG_RETURN_VOID();
}
WATCH_POST(timeout, endtime, cycle);
LOCK_ERROR();
PG_RETURN_VOID();
}
Datum
dbms_alert_removeall(PG_FUNCTION_ARGS)
{
int i;
int cycle = 0;
float8 endtime;
float8 timeout = 2;
WATCH_PRE(timeout, endtime, cycle);
if (ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES,MAX_EVENTS,MAX_LOCKS,false))
{
for (i = 0; i < MAX_EVENTS; i++)
if (events[i].event_name != NULL)
{
find_and_remove_message_item(i, sid,
false, true, true, NULL, NULL);
unregister_event(i, sid);
}
LWLockRelease(shmem_lock);
PG_RETURN_VOID();
}
WATCH_POST(timeout, endtime, cycle);
LOCK_ERROR();
PG_RETURN_VOID();
}
Datum
dbms_pipe_unique_session_name (PG_FUNCTION_ARGS)
{
StringInfoData strbuf;
text *result;
float8 endtime;
int cycle = 0;
int timeout = 10;
WATCH_PRE(timeout, endtime, cycle);
if (ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES,MAX_EVENTS,MAX_LOCKS,false))
{
initStringInfo(&strbuf);
appendStringInfo(&strbuf,"PG$PIPE$%d$%d",sid, MyProcPid);
result = cstring_to_text_with_len(strbuf.data, strbuf.len);
pfree(strbuf.data);
LWLockRelease(shmem_lockid);
PG_RETURN_TEXT_P(result);
}
WATCH_POST(timeout, endtime, cycle);
LOCK_ERROR();
PG_RETURN_NULL();
}
Datum
dbms_alert_waitone(PG_FUNCTION_ARGS)
{
text *name;
float8 timeout;
TupleDesc tupdesc;
AttInMetadata *attinmeta;
HeapTuple tuple;
Datum result;
int message_id;
char *str[2] = {NULL,"1"};
char *event_name;
int cycle = 0;
float8 endtime;
TupleDesc btupdesc;
if (PG_ARGISNULL(0))
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("event name is NULL"),
errdetail("Eventname may not be NULL.")));
if (PG_ARGISNULL(1))
timeout = TDAYS;
else
timeout = PG_GETARG_FLOAT8(1);
name = PG_GETARG_TEXT_P(0);
WATCH_PRE(timeout, endtime, cycle);
if (ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES, MAX_EVENTS, MAX_LOCKS, false))
{
if (NULL != find_event(name, false, &message_id))
{
str[0] = find_and_remove_message_item(message_id, sid,
false, false, false, NULL, &event_name);
if (event_name != NULL)
{
str[1] = "0";
pfree(event_name);
LWLockRelease(shmem_lock);
break;
}
}
LWLockRelease(shmem_lock);
}
WATCH_POST(timeout, endtime, cycle);
get_call_result_type(fcinfo, NULL, &tupdesc);
btupdesc = BlessTupleDesc(tupdesc);
attinmeta = TupleDescGetAttInMetadata(btupdesc);
tuple = BuildTupleFromCStrings(attinmeta, str);
result = HeapTupleGetDatum(tuple);
if (str[0])
pfree(str[0]);
return result;
}
Datum
dbms_pipe_send_message(PG_FUNCTION_ARGS)
{
text *pipe_name = NULL;
int timeout = ONE_YEAR;
int limit = 0;
bool valid_limit;
int cycle = 0;
float8 endtime;
if (PG_ARGISNULL(0))
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("pipe name is NULL"),
errdetail("Pipename may not be NULL.")));
else
pipe_name = PG_GETARG_TEXT_P(0);
output_buffer = check_buffer(output_buffer, LOCALMSGSZ);
if (!PG_ARGISNULL(1))
timeout = PG_GETARG_INT32(1);
if (PG_ARGISNULL(2))
valid_limit = false;
else
{
limit = PG_GETARG_INT32(2);
valid_limit = true;
}
if (input_buffer != NULL) /* XXX Strange? */
{
pfree(input_buffer);
input_buffer = NULL;
}
WATCH_PRE(timeout, endtime, cycle);
if (add_to_pipe(pipe_name, output_buffer,
limit, valid_limit))
break;
WATCH_POST(timeout, endtime, cycle);
init_buffer(output_buffer, LOCALMSGSZ);
PG_RETURN_INT32(RESULT_DATA);
}
Datum
dbms_alert_waitany(PG_FUNCTION_ARGS)
{
float8 timeout;
TupleDesc tupdesc;
AttInMetadata *attinmeta;
HeapTuple tuple;
Datum result;
char *str[3] = {NULL, NULL, "1"};
int cycle = 0;
float8 endtime;
TupleDesc btupdesc;
if (PG_ARGISNULL(0))
timeout = TDAYS;
else
timeout = PG_GETARG_FLOAT8(0);
WATCH_PRE(timeout, endtime, cycle);
if (ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES, MAX_EVENTS, MAX_LOCKS, false))
{
str[1] = find_and_remove_message_item(-1, sid,
true, false, false, NULL, &str[0]);
if (str[0])
{
str[2] = "0";
LWLockRelease(shmem_lock);
break;
}
LWLockRelease(shmem_lock);
}
WATCH_POST(timeout, endtime, cycle);
get_call_result_type(fcinfo, NULL, &tupdesc);
btupdesc = BlessTupleDesc(tupdesc);
attinmeta = TupleDescGetAttInMetadata(btupdesc);
tuple = BuildTupleFromCStrings(attinmeta, str);
result = HeapTupleGetDatum(tuple);
if (str[0])
pfree(str[0]);
if (str[1])
pfree(str[1]);
return result;
}
Datum
dbms_alert_register(PG_FUNCTION_ARGS)
{
text *name = PG_GETARG_TEXT_P(0);
int cycle = 0;
float8 endtime;
float8 timeout = 2;
WATCH_PRE(timeout, endtime, cycle);
if (ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES, MAX_EVENTS, MAX_LOCKS, false))
{
register_event(name);
LWLockRelease(shmem_lock);
PG_RETURN_VOID();
}
WATCH_POST(timeout, endtime, cycle);
LOCK_ERROR();
PG_RETURN_VOID();
}
Datum
dbms_pipe_receive_message(PG_FUNCTION_ARGS)
{
text *pipe_name = NULL;
int timeout = ONE_YEAR;
int cycle = 0;
float8 endtime;
bool found = false;
if (PG_ARGISNULL(0))
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("pipe name is NULL"),
errdetail("Pipename may not be NULL.")));
else
pipe_name = PG_GETARG_TEXT_P(0);
if (!PG_ARGISNULL(1))
timeout = PG_GETARG_INT32(1);
if (input_buffer != NULL)
{
pfree(input_buffer);
input_buffer = NULL;
}
WATCH_PRE(timeout, endtime, cycle);
if (NULL != (input_buffer = get_from_pipe(pipe_name, &found)))
{
input_buffer->next = message_buffer_get_content(input_buffer);
break;
}
/* found empty message */
if (found)
break;
WATCH_POST(timeout, endtime, cycle);
PG_RETURN_INT32(RESULT_DATA);
}
Datum
dbms_pipe_remove_pipe (PG_FUNCTION_ARGS)
{
text *pipe_name = PG_GETARG_TEXT_P(0);
float8 endtime;
int cycle = 0;
int timeout = 10;
WATCH_PRE(timeout, endtime, cycle);
if (ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES,MAX_EVENTS,MAX_LOCKS,false))
{
remove_pipe(pipe_name, false);
LWLockRelease(shmem_lockid);
PG_RETURN_VOID();
}
WATCH_POST(timeout, endtime, cycle);
LOCK_ERROR();
PG_RETURN_VOID();
}
Datum
dbms_alert_defered_signal(PG_FUNCTION_ARGS)
{
TriggerData *trigdata = (TriggerData *) fcinfo->context;
TupleDesc tupdesc;
HeapTuple rettuple;
char *relname;
text *name;
text *message;
int event_col;
int message_col;
Datum datum;
bool isnull;
int cycle = 0;
float8 endtime;
float8 timeout = 2;
if (!CALLED_AS_TRIGGER(fcinfo))
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
errmsg("not called by trigger manager")));
if (!TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
errmsg("not called on valid event")));
if (SPI_connect() < 0)
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
errmsg("SPI_connect failed")));
if (strcmp((relname = SPI_getrelname(trigdata->tg_relation)), "ora_alerts") != 0)
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
errmsg("not called with valid relation")));
rettuple = trigdata->tg_trigtuple;
tupdesc = trigdata->tg_relation->rd_att;
if (SPI_ERROR_NOATTRIBUTE == (event_col = SPI_fnumber(tupdesc, "event")))
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
errmsg("attribute event not found")));
if (SPI_ERROR_NOATTRIBUTE == (message_col = SPI_fnumber(tupdesc, "message")))
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
errmsg("attribute message not found")));
datum = SPI_getbinval(rettuple, tupdesc, event_col, &isnull);
if (isnull)
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("event name is NULL"),
errdetail("Eventname may not be NULL.")));
name = DatumGetTextP(datum);
datum = SPI_getbinval(rettuple, tupdesc, message_col, &isnull);
if (isnull)
message = NULL;
else
message = DatumGetTextP(datum);
WATCH_PRE(timeout, endtime, cycle);
if (ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES, MAX_EVENTS, MAX_LOCKS, false))
{
ItemPointer tid;
Oid argtypes[1] = {TIDOID};
char nulls[1] = {' '};
Datum values[1];
void *plan;
create_message(name, message);
LWLockRelease(shmem_lock);
tid = &rettuple->t_data->t_ctid;
if (!(plan = SPI_prepare("DELETE FROM ora_alerts WHERE ctid = $1", 1, argtypes)))
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
errmsg("SPI_prepare failed")));
values[0] = ItemPointerGetDatum(tid);
if (SPI_OK_DELETE != SPI_execute_plan(plan, values, nulls, false, 1))
ereport(ERROR,
(errcode(ERRCODE_TRIGGERED_ACTION_EXCEPTION),
errmsg("can't execute sql")));
SPI_finish();
return PointerGetDatum(rettuple);
}
WATCH_POST(timeout, endtime, cycle);
LOCK_ERROR();
PG_RETURN_NULL();
}
Datum
dbms_pipe_create_pipe (PG_FUNCTION_ARGS)
{
text *pipe_name = NULL;
int limit = 0;
bool is_private;
bool limit_is_valid = false;
bool created;
float8 endtime;
int cycle = 0;
int timeout = 10;
if (PG_ARGISNULL(0))
ereport(ERROR,
(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
errmsg("pipe name is NULL"),
errdetail("Pipename may not be NULL.")));
else
pipe_name = PG_GETARG_TEXT_P(0);
if (!PG_ARGISNULL(1))
{
limit = PG_GETARG_INT32(1);
limit_is_valid = true;
}
is_private = PG_ARGISNULL(2) ? false : PG_GETARG_BOOL(2);
WATCH_PRE(timeout, endtime, cycle);
if (ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES,MAX_EVENTS,MAX_LOCKS,false))
{
pipe *p;
if (NULL != (p = find_pipe(pipe_name, &created, false)))
{
if (!created)
{
LWLockRelease(shmem_lockid);
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("pipe creation error"),
errdetail("Pipe is registered.")));
}
if (is_private)
{
char *user;
p->uid = GetUserId();
#if PG_VERSION_NUM >= 90500
user = (char*)DirectFunctionCall1(namein,
CStringGetDatum(GetUserNameFromId(p->uid, false)));
#else
user = (char*)DirectFunctionCall1(namein, CStringGetDatum(GetUserNameFromId(p->uid)));
#endif
p->creator = ora_sstrcpy(user);
pfree(user);
}
p->limit = limit_is_valid ? limit : -1;
p->registered = true;
LWLockRelease(shmem_lockid);
PG_RETURN_VOID();
}
}
WATCH_POST(timeout, endtime, cycle);
LOCK_ERROR();
PG_RETURN_VOID();
}
Datum
dbms_pipe_list_pipes(PG_FUNCTION_ARGS)
{
FuncCallContext *funcctx;
TupleDesc tupdesc;
AttInMetadata *attinmeta;
PipesFctx *fctx;
float8 endtime;
int cycle = 0;
int timeout = 10;
if (SRF_IS_FIRSTCALL())
{
int i;
MemoryContext oldcontext;
bool has_lock = false;
WATCH_PRE(timeout, endtime, cycle);
if (ora_lock_shmem(SHMEMMSGSZ, MAX_PIPES, MAX_EVENTS, MAX_LOCKS, false))
{
has_lock = true;
break;
}
WATCH_POST(timeout, endtime, cycle);
if (!has_lock)
LOCK_ERROR();
funcctx = SRF_FIRSTCALL_INIT();
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
fctx = palloc(sizeof(PipesFctx));
funcctx->user_fctx = fctx;
fctx->pipe_nth = 0;
#if PG_VERSION_NUM >= 120000
tupdesc = CreateTemplateTupleDesc(DB_PIPES_COLS);
#else
tupdesc = CreateTemplateTupleDesc(DB_PIPES_COLS, false);
#endif
i = 0;
TupleDescInitEntry(tupdesc, ++i, "name", VARCHAROID, -1, 0);
TupleDescInitEntry(tupdesc, ++i, "items", INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, ++i, "size", INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, ++i, "limit", INT4OID, -1, 0);
TupleDescInitEntry(tupdesc, ++i, "private", BOOLOID, -1, 0);
TupleDescInitEntry(tupdesc, ++i, "owner", VARCHAROID, -1, 0);
Assert(i == DB_PIPES_COLS);
attinmeta = TupleDescGetAttInMetadata(tupdesc);
funcctx->attinmeta = attinmeta;
MemoryContextSwitchTo(oldcontext);
}
funcctx = SRF_PERCALL_SETUP();
fctx = (PipesFctx *) funcctx->user_fctx;
while (fctx->pipe_nth < MAX_PIPES)
{
if (pipes[fctx->pipe_nth].is_valid)
{
Datum result;
HeapTuple tuple;
char *values[DB_PIPES_COLS];
char items[16];
char size[16];
char limit[16];
/* name */
values[0] = pipes[fctx->pipe_nth].pipe_name;
/* items */
snprintf(items, lengthof(items), "%d", pipes[fctx->pipe_nth].count);
values[1] = items;
/* items */
snprintf(size, lengthof(size), "%d", pipes[fctx->pipe_nth].size);
values[2] = size;
/* limit */
if (pipes[fctx->pipe_nth].limit != -1)
{
snprintf(limit, lengthof(limit), "%d", pipes[fctx->pipe_nth].limit);
values[3] = limit;
}
else
values[3] = NULL;
/* private */
values[4] = (pipes[fctx->pipe_nth].creator ? "true" : "false");
/* owner */
values[5] = pipes[fctx->pipe_nth].creator;
tuple = BuildTupleFromCStrings(funcctx->attinmeta, values);
result = HeapTupleGetDatum(tuple);
fctx->pipe_nth += 1;
SRF_RETURN_NEXT(funcctx, result);
}
fctx->pipe_nth += 1;
}
LWLockRelease(shmem_lockid);
SRF_RETURN_DONE(funcctx);
}
