/*
* GetUniqueMatRelName
*
* Returns a unique name for the given CV's underlying materialization table
*/
char *
GetUniqueMatRelName(char *cvname, char* nspname)
{
char *relname = palloc0(NAMEDATALEN);
int i = 0;
StringInfoData suffix;
Oid nspoid;
if (nspname != NULL)
nspoid = GetSysCacheOid1(NAMESPACENAME, CStringGetDatum(nspname));
else
nspoid = InvalidOid;
initStringInfo(&suffix);
strcpy(relname, cvname);
while (true)
{
appendStringInfo(&suffix, "%s%d", CQ_TABLE_SUFFIX, i);
append_suffix(relname, suffix.data, NAMEDATALEN);
resetStringInfo(&suffix);
if (!OidIsValid(get_relname_relid(relname, nspoid)))
break;
}
return relname;
}
static void getExtensionLoadPath()
{
MemoryContext curr;
Datum dtm;
bool isnull;
/*
* Check whether sqlj.loadpath exists before querying it. I would more
* happily just PG_CATCH() the error and compare to ERRCODE_UNDEFINED_TABLE
* but what's required to make that work right is "not terribly well
* documented, but the exception-block handling in plpgsql provides a
* working model" and that code is a lot more fiddly than you would guess.
*/
if ( InvalidOid == get_relname_relid("loadpath",
GetSysCacheOid1(NAMESPACENAME, CStringGetDatum("sqlj"))) )
return;
SPI_connect();
curr = CurrentMemoryContext;
if ( SPI_OK_SELECT == SPI_execute(
"SELECT path, exnihilo FROM sqlj.loadpath", true, 1)
&& 1 == SPI_processed )
{
MemoryContextSwitchTo(TopMemoryContext);
pljavaLoadPath = (char const *)SPI_getvalue(
SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 1);
MemoryContextSwitchTo(curr);
dtm = SPI_getbinval(SPI_tuptable->vals[0], SPI_tuptable->tupdesc, 2,
&isnull);
if ( isnull )
elog(ERROR, "defect in CREATE EXTENSION script");
extensionExNihilo = DatumGetBool(dtm);
}
SPI_finish();
}
/*
* get_language_oid - given a language name, look up the OID
*
* If missing_ok is false, throw an error if language name not found. If
* true, just return InvalidOid.
*/
Oid
get_language_oid(const char *langname, bool missing_ok)
{
Oid oid;
oid = GetSysCacheOid1(LANGNAME, CStringGetDatum(langname));
if (!OidIsValid(oid) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("language \"%s\" does not exist", langname)));
return oid;
}
/*
* get_publication_oid - given a publication name, look up the OID
*
* If missing_ok is false, throw an error if name not found. If true, just
* return InvalidOid.
*/
Oid
get_publication_oid(const char *pubname, bool missing_ok)
{
Oid oid;
oid = GetSysCacheOid1(PUBLICATIONNAME, Anum_pg_publication_oid,
CStringGetDatum(pubname));
if (!OidIsValid(oid) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("publication \"%s\" does not exist", pubname)));
return oid;
}
static
Oid get_role_oid(const char *name, bool missing_ok)
{
Oid oid;
oid = GetSysCacheOid1(AUTHNAME, CStringGetDatum(name));
if (!missing_ok && !OidIsValid(oid))
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("role \"%s\" does not exist", name)));
return oid;
}
/*
* GetForeignDataWrapperOidByName - look up the foreign-data wrapper
* OID by name.
*/
Oid
GetForeignDataWrapperOidByName(const char *fdwname, bool missing_ok)
{
Oid fdwId;
fdwId = GetSysCacheOid1(FOREIGNDATAWRAPPERNAME, CStringGetDatum(fdwname));
if (!OidIsValid(fdwId) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("foreign-data wrapper \"%s\" does not exist", fdwname)));
return fdwId;
}
/*
* GetForeignServerByName - look up the foreign server oid by name.
*/
Oid
GetForeignServerOidByName(const char *srvname, bool missing_ok)
{
Oid serverid;
serverid = GetSysCacheOid1(FOREIGNSERVERNAME, CStringGetDatum(srvname));
if (!OidIsValid(serverid) && !missing_ok)
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("server \"%s\" does not exist", srvname)));
return serverid;
}
/*
* Get Publication using name.
*/
Publication *
GetPublicationByName(const char *pubname, bool missing_ok)
{
Oid oid;
oid = GetSysCacheOid1(PUBLICATIONNAME, Anum_pg_publication_oid,
CStringGetDatum(pubname));
if (!OidIsValid(oid))
{
if (missing_ok)
return NULL;
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_OBJECT),
errmsg("publication \"%s\" does not exist", pubname)));
}
return GetPublication(oid);
}
/*
* CreateAcessMethod
* Registers a new access method.
*/
ObjectAddress
CreateAccessMethod(CreateAmStmt *stmt)
{
Relation rel;
ObjectAddress myself;
ObjectAddress referenced;
Oid amoid;
Oid amhandler;
bool nulls[Natts_pg_am];
Datum values[Natts_pg_am];
HeapTuple tup;
rel = heap_open(AccessMethodRelationId, RowExclusiveLock);
/* Must be super user */
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
errmsg("permission denied to create access method \"%s\"",
stmt->amname),
errhint("Must be superuser to create an access method.")));
/* Check if name is used */
amoid = GetSysCacheOid1(AMNAME, CStringGetDatum(stmt->amname));
if (OidIsValid(amoid))
{
ereport(ERROR,
(errcode(ERRCODE_DUPLICATE_OBJECT),
errmsg("access method \"%s\" already exists",
stmt->amname)));
}
/*
* Get the handler function oid, verifying the AM type while at it.
*/
amhandler = lookup_index_am_handler_func(stmt->handler_name, stmt->amtype);
/*
* Insert tuple into pg_am.
*/
memset(values, 0, sizeof(values));
memset(nulls, false, sizeof(nulls));
values[Anum_pg_am_amname - 1] =
DirectFunctionCall1(namein, CStringGetDatum(stmt->amname));
values[Anum_pg_am_amhandler - 1] = ObjectIdGetDatum(amhandler);
values[Anum_pg_am_amtype - 1] = CharGetDatum(stmt->amtype);
tup = heap_form_tuple(RelationGetDescr(rel), values, nulls);
amoid = simple_heap_insert(rel, tup);
CatalogUpdateIndexes(rel, tup);
heap_freetuple(tup);
myself.classId = AccessMethodRelationId;
myself.objectId = amoid;
myself.objectSubId = 0;
/* Record dependency on handler function */
referenced.classId = ProcedureRelationId;
referenced.objectId = amhandler;
referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
recordDependencyOnCurrentExtension(&myself, false);
heap_close(rel, RowExclusiveLock);
return myself;
}
static void
grab_ExecutorEnd(QueryDesc * queryDesc)
{
Datum values[10];
bool nulls[10] = {false, false, false, false, false, false, false, false, false, false};
Relation dump_heap;
RangeVar *dump_table_rv;
HeapTuple tuple;
Oid namespaceId;
/* lookup schema */
namespaceId = GetSysCacheOid1(NAMESPACENAME, CStringGetDatum(EXTENSION_SCHEMA));
if (OidIsValid(namespaceId)) {
/* lookup table */
if (OidIsValid(get_relname_relid(EXTENSION_LOG_TABLE, namespaceId))) {
/* get table heap */
dump_table_rv = makeRangeVar(EXTENSION_SCHEMA, EXTENSION_LOG_TABLE, -1);
dump_heap = heap_openrv(dump_table_rv, RowExclusiveLock);
/* transaction info */
values[0] = Int32GetDatum(GetCurrentTransactionId());
values[1] = Int32GetDatum(GetCurrentCommandId(false));
values[2] = Int32GetDatum(MyProcPid);
values[3] = Int32GetDatum(GetUserId());
/* query timing */
if (queryDesc->totaltime != NULL) {
InstrEndLoop(queryDesc->totaltime);
values[4] = TimestampGetDatum(
TimestampTzPlusMilliseconds(GetCurrentTimestamp(),
(queryDesc->totaltime->total * -1000.0)));
values[5] = Float8GetDatum(queryDesc->totaltime->total);
} else {
nulls[4] = true;
nulls[5] = true;
}
/* query command type */
values[6] = Int32GetDatum(queryDesc->operation);
/* query text */
values[7] = CStringGetDatum(
cstring_to_text(queryDesc->sourceText));
/* query params */
if (queryDesc->params != NULL) {
int numParams = queryDesc->params->numParams;
Oid out_func_oid, ptype;
Datum pvalue;
bool isvarlena;
FmgrInfo *out_functions;
bool arr_nulls[numParams];
size_t arr_nelems = (size_t) numParams;
Datum *arr_val_elems = palloc(sizeof(Datum) * arr_nelems);
Datum *arr_typ_elems = palloc(sizeof(Datum) * arr_nelems);
char elem_val_byval, elem_val_align, elem_typ_byval,
elem_typ_align;
int16 elem_val_len, elem_typ_len;
int elem_dims[1], elem_lbs[1];
int paramno;
/* init */
out_functions = (FmgrInfo *) palloc(
(numParams) * sizeof(FmgrInfo));
get_typlenbyvalalign(TEXTOID, &elem_val_len, &elem_val_byval, &elem_val_align);
get_typlenbyvalalign(REGTYPEOID, &elem_typ_len, &elem_typ_byval, &elem_typ_align);
elem_dims[0] = arr_nelems;
elem_lbs[0] = 1;
for (paramno = 0; paramno < numParams; paramno++) {
pvalue = queryDesc->params->params[paramno].value;
ptype = queryDesc->params->params[paramno].ptype;
getTypeOutputInfo(ptype, &out_func_oid, &isvarlena);
fmgr_info(out_func_oid, &out_functions[paramno]);
arr_typ_elems[paramno] = ptype;
arr_nulls[paramno] = true;
if (!queryDesc->params->params[paramno].isnull) {
arr_nulls[paramno] = false;
arr_val_elems[paramno] = PointerGetDatum(
cstring_to_text(
OutputFunctionCall(&out_functions[paramno], pvalue)));
}
}
values[8] = PointerGetDatum(
construct_md_array(
arr_val_elems,
arr_nulls,
1,
elem_dims,
elem_lbs,
TEXTOID,
elem_val_len,
elem_val_byval,
elem_val_align));
values[9] = PointerGetDatum(
construct_array(
arr_typ_elems,
arr_nelems,
REGTYPEOID,
elem_typ_len,
elem_typ_byval,
elem_typ_align));
pfree(out_functions);
pfree(arr_val_elems);
} else {
nulls[8] = true;
nulls[9] = true;
}
/* insert */
tuple = heap_form_tuple(dump_heap->rd_att, values, nulls);
simple_heap_insert(dump_heap, tuple);
heap_close(dump_heap, RowExclusiveLock);
}
}
if (prev_ExecutorEnd)
prev_ExecutorEnd(queryDesc);
else
standard_ExecutorEnd(queryDesc);
}
