/* --------------------------------------------------------
* pg_relpages()
*
* Get the number of pages of the table/index.
*
* Usage: SELECT pg_relpages('t1');
* SELECT pg_relpages('t1_pkey');
*
* Must keep superuser() check, see above.
* --------------------------------------------------------
*/
Datum
pg_relpages(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_PP(0);
int64 relpages;
Relation rel;
RangeVar *relrv;
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use pgstattuple functions"))));
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
/* only some relkinds have storage */
check_relation_relkind(rel);
/* note: this will work OK on non-local temp tables */
relpages = RelationGetNumberOfBlocks(rel);
relation_close(rel, AccessShareLock);
PG_RETURN_INT64(relpages);
}
Datum
currtid_byrelname(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
ItemPointer tid = PG_GETARG_ITEMPOINTER(1);
ItemPointer result;
RangeVar *relrv;
Relation rel;
AclResult aclresult;
Snapshot snapshot;
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = heap_openrv(relrv, AccessShareLock);
aclresult = pg_class_aclcheck(RelationGetRelid(rel), GetUserId(),
ACL_SELECT);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_CLASS,
RelationGetRelationName(rel));
if (rel->rd_rel->relkind == RELKIND_VIEW || rel->rd_rel->relkind == RELKIND_CONTVIEW)
return currtid_for_view(rel, tid);
result = (ItemPointer) palloc(sizeof(ItemPointerData));
ItemPointerCopy(tid, result);
snapshot = RegisterSnapshot(GetLatestSnapshot());
heap_get_latest_tid(rel, snapshot, result);
UnregisterSnapshot(snapshot);
heap_close(rel, AccessShareLock);
PG_RETURN_ITEMPOINTER(result);
}
Datum
get_raw_page(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
uint32 blkno = PG_GETARG_UINT32(1);
Relation rel;
RangeVar *relrv;
bytea *raw_page;
char *raw_page_data;
Buffer buf;
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use raw functions"))));
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
/* Check that this relation has storage */
if (rel->rd_rel->relkind == RELKIND_VIEW)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("cannot get raw page from view \"%s\"",
RelationGetRelationName(rel))));
if (rel->rd_rel->relkind == RELKIND_COMPOSITE_TYPE)
ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("cannot get raw page from composite type \"%s\"",
RelationGetRelationName(rel))));
if (blkno >= RelationGetNumberOfBlocks(rel))
elog(ERROR, "block number %u is out of range for relation \"%s\"",
blkno, RelationGetRelationName(rel));
/* Initialize buffer to copy to */
raw_page = (bytea *) palloc(BLCKSZ + VARHDRSZ);
SET_VARSIZE(raw_page, BLCKSZ + VARHDRSZ);
raw_page_data = VARDATA(raw_page);
/* Take a verbatim copy of the page */
buf = ReadBuffer(rel, blkno);
LockBuffer(buf, BUFFER_LOCK_SHARE);
memcpy(raw_page_data, BufferGetPage(buf), BLCKSZ);
LockBuffer(buf, BUFFER_LOCK_UNLOCK);
ReleaseBuffer(buf);
relation_close(rel, AccessShareLock);
PG_RETURN_BYTEA_P(raw_page);
}
Datum
gp_aovisimap_entry_name(PG_FUNCTION_ARGS)
{
RangeVar *parentrv;
text *relname = PG_GETARG_TEXT_P(0);
Oid relid;
parentrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
relid = RangeVarGetRelid(parentrv, false);
return gp_aovisimap_entry_internal(fcinfo, relid);
}
/*
* As of pgstattuple version 1.5, we no longer need to check if the user
* is a superuser because we REVOKE EXECUTE on the function from PUBLIC.
* Users can then grant access to it based on their policies.
*
* Otherwise identical to pgstatindex (above).
*/
Datum
pgstatindex_v1_5(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_PP(0);
Relation rel;
RangeVar *relrv;
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
PG_RETURN_DATUM(pgstatindex_impl(rel, fcinfo));
}
/*
* text_regclass: convert text to regclass
*/
Datum
text_regclass(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
Oid result;
RangeVar *rv;
rv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
result = RangeVarGetRelid(rv, false, true /*allowHcatalog*/);
PG_RETURN_OID(result);
}
/*
* text_regclass: convert text to regclass
*
* This could be replaced by CoerceViaIO, except that we need to treat
* text-to-regclass as an implicit cast to support legacy forms of nextval()
* and related functions.
*/
Datum
text_regclass(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
Oid result;
RangeVar *rv;
rv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
/* We might not even have permissions on this relation; don't lock it. */
result = RangeVarGetRelid(rv, NoLock, false);
PG_RETURN_OID(result);
}
/* Finds the relationId from a potentially qualified relation name. */
Oid
ResolveRelationId(text *relationName)
{
List *relationNameList = NIL;
RangeVar *relation = NULL;
Oid relationId = InvalidOid;
bool failOK = false; /* error if relation cannot be found */
/* resolve relationId from passed in schema and relation name */
relationNameList = textToQualifiedNameList(relationName);
relation = makeRangeVarFromNameList(relationNameList);
relationId = RangeVarGetRelid(relation, NoLock, failOK);
return relationId;
}
Datum
pgstattuple(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
RangeVar *relrv;
Relation rel;
Datum result;
/* open relation */
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = heap_openrv(relrv, AccessShareLock);
result = pgstattuple_real(rel, fcinfo);
PG_RETURN_DATUM(result);
}
Datum
row_security_active_name(PG_FUNCTION_ARGS)
{
/* By qualified name */
text *tablename = PG_GETARG_TEXT_P(0);
RangeVar *tablerel;
Oid tableoid;
int rls_status;
/* Look up table name. Can't lock it - we might not have privileges. */
tablerel = makeRangeVarFromNameList(textToQualifiedNameList(tablename));
tableoid = RangeVarGetRelid(tablerel, NoLock, false);
rls_status = check_enable_rls(tableoid, InvalidOid, true);
PG_RETURN_BOOL(rls_status == RLS_ENABLED);
}
Datum
relation_size(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
RangeVar *relrv;
Relation relation;
Oid relnode;
int64 totalsize;
unsigned int segcount;
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname,
"relation_size"));
relation = heap_openrv(relrv, AccessShareLock);
relnode = relation->rd_rel->relfilenode;
totalsize = 0;
segcount = 0;
for (;;)
{
char *fullname;
struct stat statbuf;
if (segcount == 0)
fullname = psnprintf(25, "%u", (unsigned) relnode);
else
fullname = psnprintf(50, "%u.%u", (unsigned) relnode, segcount);
if (stat(fullname, &statbuf) == -1)
{
if (errno == ENOENT)
break;
else
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not stat \"%s\": %m", fullname)));
}
totalsize += statbuf.st_size;
pfree(fullname);
segcount++;
}
heap_close(relation, AccessShareLock);
PG_RETURN_INT64(totalsize);
}
/* ------------------------------------------------------
* pgstatindex()
*
* Usage: SELECT * FROM pgstatindex('t1_pkey');
* ------------------------------------------------------
*/
Datum
pgstatindex(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
Relation rel;
RangeVar *relrv;
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use pgstattuple functions"))));
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
PG_RETURN_DATUM(pgstatindex_impl(rel, fcinfo));
}
Datum
pg_relation_size_name(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
RangeVar *relrv;
Relation rel;
int64 size;
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
size = calculate_relation_size(&(rel->rd_node));
relation_close(rel, AccessShareLock);
PG_RETURN_INT64(size);
}
Datum
relation_size(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
RangeVar *relrv;
Relation relation;
Oid relnodeOid;
Oid tblspcOid;
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname,
"relation_size"));
relation = relation_openrv(relrv, AccessShareLock);
tblspcOid = relation->rd_rel->reltablespace;
relnodeOid = relation->rd_rel->relfilenode;
relation_close(relation, AccessShareLock);
PG_RETURN_INT64(calculate_relation_size(tblspcOid, relnodeOid));
}
/*
* Note: nextval with a text argument is no longer exported as a pg_proc
* entry, but we keep it around to ease porting of C code that may have
* called the function directly.
*/
Datum
nextval(PG_FUNCTION_ARGS)
{
text *seqin = PG_GETARG_TEXT_P(0);
RangeVar *sequence;
Oid relid;
sequence = makeRangeVarFromNameList(textToQualifiedNameList(seqin));
/*
* XXX: This is not safe in the presence of concurrent DDL, but acquiring
* a lock here is more expensive than letting nextval_internal do it,
* since the latter maintains a cache that keeps us from hitting the lock
* manager more than once per transaction. It's not clear whether the
* performance penalty is material in practice, but for now, we do it this
* way.
*/
relid = RangeVarGetRelid(sequence, NoLock, false);
PG_RETURN_INT64(nextval_internal(relid));
}
/* No need for superuser checks in v1.5, see above */
Datum
pg_relpages_v1_5(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_PP(0);
int64 relpages;
Relation rel;
RangeVar *relrv;
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
/* only some relkinds have storage */
check_relation_relkind(rel);
/* note: this will work OK on non-local temp tables */
relpages = RelationGetNumberOfBlocks(rel);
relation_close(rel, AccessShareLock);
PG_RETURN_INT64(relpages);
}
Datum
ts_token_type_byname(PG_FUNCTION_ARGS)
{
FuncCallContext *funcctx;
Datum result;
if (SRF_IS_FIRSTCALL())
{
text *prsname = PG_GETARG_TEXT_P(0);
Oid prsId;
funcctx = SRF_FIRSTCALL_INIT();
prsId = get_ts_parser_oid(textToQualifiedNameList(prsname), false);
tt_setup_firstcall(funcctx, prsId);
}
funcctx = SRF_PERCALL_SETUP();
if ((result = tt_process_call(funcctx)) != (Datum) 0)
SRF_RETURN_NEXT(funcctx, result);
SRF_RETURN_DONE(funcctx);
}
/* --------------------------------------------------------
* pg_relpages()
*
* Get a number of pages of the table/index.
*
* Usage: SELECT pg_relpages('t1');
* SELECT pg_relpages('t1_pkey');
* --------------------------------------------------------
*/
Datum
pg_relpages(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
Relation rel;
RangeVar *relrv;
int4 relpages;
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use pgstattuple functions"))));
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
relpages = RelationGetNumberOfBlocks(rel);
relation_close(rel, AccessShareLock);
PG_RETURN_INT32(relpages);
}
Datum
currtid_byrelname(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
ItemPointer tid = PG_GETARG_ITEMPOINTER(1);
ItemPointer result;
RangeVar *relrv;
Relation rel;
AclResult aclresult;
/*
* Immediately inform client that the function is not supported
*/
elog(ERROR, "Function currtid2 is not supported by GPDB");
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = heap_openrv(relrv, AccessShareLock);
aclresult = pg_class_aclcheck(RelationGetRelid(rel), GetUserId(),
ACL_SELECT);
if (aclresult != ACLCHECK_OK)
aclcheck_error(aclresult, ACL_KIND_CLASS,
RelationGetRelationName(rel));
if (rel->rd_rel->relkind == RELKIND_VIEW)
return currtid_for_view(rel, tid);
result = (ItemPointer) palloc(sizeof(ItemPointerData));
ItemPointerCopy(tid, result);
heap_get_latest_tid(rel, SnapshotNow, result);
heap_close(rel, AccessShareLock);
PG_RETURN_ITEMPOINTER(result);
}
Datum
currtid_byrelname(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
ItemPointer tid = PG_GETARG_ITEMPOINTER(1);
ItemPointer result;
RangeVar *relrv;
Relation rel;
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname,
"currtid_byrelname"));
rel = heap_openrv(relrv, AccessShareLock);
if (rel->rd_rel->relkind == RELKIND_VIEW)
return currtid_for_view(rel, tid);
result = (ItemPointer) palloc(sizeof(ItemPointerData));
ItemPointerCopy(tid, result);
heap_get_latest_tid(rel, SnapshotNow, result);
heap_close(rel, AccessShareLock);
PG_RETURN_ITEMPOINTER(result);
}
Datum
pg_relation_size_name(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
RangeVar *relrv;
Relation rel;
int64 size;
if (GP_ROLE_EXECUTE == Gp_role)
{
ereport(ERROR,
(errcode(ERRCODE_GP_COMMAND_ERROR),
errmsg("pg_relation_size: cannot be executed in segment")));
}
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = try_relation_openrv(relrv, AccessShareLock, false);
/*
* While we scan pg_class with an MVCC snapshot,
* someone else might drop the table. It's better to return NULL for
* already-dropped tables than throw an error and abort the whole query.
*/
if (!RelationIsValid(rel))
PG_RETURN_NULL();
if (rel->rd_node.relNode == 0)
size = 0;
else
size = calculate_relation_size(rel);
relation_close(rel, AccessShareLock);
PG_RETURN_INT64(size);
}
/* -----------------------------------------------
* bt_page()
*
* Usage: SELECT * FROM bt_page('t1_pkey', 1);
* -----------------------------------------------
*/
datum_t
bt_page_stats(PG_FUNC_ARGS)
{
text *relname = ARG_TEXT_P(0);
uint32 blkno = ARG_UINT32(1);
buf_id_t buffer;
struct relation * rel;
range_var_n *relrv;
datum_t result;
struct heap_tuple * tuple;
struct tuple *tupleDesc;
int j;
char *values[11];
BTPageStat stat;
if (!superuser())
ereport(ERROR,
(errcode(E_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use pageinspect functions"))));
relrv = nl_to_range_var(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, ACCESS_SHR_LOCK);
if (!IS_INDEX(rel) || !IS_BTREE(rel))
elog(ERROR, "relation \"%s\" is not a btree index",
REL_NAME(rel));
/*
* Reject attempts to read non-local temporary relations; we would be
* likely to get wrong data since we have no visibility into the owning
* session's local buffers.
*/
if (REL_IS_OTHER_TMP(rel))
ereport(ERROR,
(errcode(E_FEATURE_NOT_SUPPORTED),
errmsg("cannot access temporary tables of other sessions")));
if (blkno == 0)
elog(ERROR, "block 0 is a meta page");
CHECK_RELATION_BLOCK_RANGE(rel, blkno);
buffer = read_buf(rel, blkno);
/* keep compiler quiet */
stat.btpo_prev = stat.btpo_next = INVALID_BLK_NR;
stat.btpo_flags = stat.free_size = stat.avg_item_size = 0;
GetBTPageStatistics(blkno, buffer, &stat);
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
j = 0;
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", stat.blkno);
values[j] = palloc(32);
snprintf(values[j++], 32, "%c", stat.type);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", stat.live_items);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", stat.dead_items);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", stat.avg_item_size);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", stat.page_size);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", stat.free_size);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", stat.btpo_prev);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", stat.btpo_next);
values[j] = palloc(32);
if (stat.type == 'd')
snprintf(values[j++], 32, "%d", stat.btpo.xact);
else
snprintf(values[j++], 32, "%d", stat.btpo.level);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", stat.btpo_flags);
tuple = build_tuple_from_cstrings(TupleDescGetAttInMetadata(tupleDesc),
values);
result = HeapTupleGetDatum(tuple);
release_buf(buffer);
relation_close(rel, ACCESS_SHR_LOCK);
RET_DATUM(result);
}
/* -----------------------------------------------
* bt_page_stats()
*
* Usage: SELECT * FROM bt_page_stats('t1_pkey', 1);
* -----------------------------------------------
*/
Datum
bt_page_stats(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_PP(0);
uint32 blkno = PG_GETARG_UINT32(1);
Buffer buffer;
Relation rel;
RangeVar *relrv;
Datum result;
HeapTuple tuple;
TupleDesc tupleDesc;
int j;
char *values[11];
BTPageStat stat;
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use pageinspect functions"))));
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
if (!IS_INDEX(rel) || !IS_BTREE(rel))
elog(ERROR, "relation \"%s\" is not a btree index",
RelationGetRelationName(rel));
/*
* Reject attempts to read non-local temporary relations; we would be
* likely to get wrong data since we have no visibility into the owning
* session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot access temporary tables of other sessions")));
if (blkno == 0)
elog(ERROR, "block 0 is a meta page");
CHECK_RELATION_BLOCK_RANGE(rel, blkno);
buffer = ReadBuffer(rel, blkno);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
/* keep compiler quiet */
stat.btpo_prev = stat.btpo_next = InvalidBlockNumber;
stat.btpo_flags = stat.free_size = stat.avg_item_size = 0;
GetBTPageStatistics(blkno, buffer, &stat);
UnlockReleaseBuffer(buffer);
relation_close(rel, AccessShareLock);
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
j = 0;
values[j++] = psprintf("%d", stat.blkno);
values[j++] = psprintf("%c", stat.type);
values[j++] = psprintf("%d", stat.live_items);
values[j++] = psprintf("%d", stat.dead_items);
values[j++] = psprintf("%d", stat.avg_item_size);
values[j++] = psprintf("%d", stat.page_size);
values[j++] = psprintf("%d", stat.free_size);
values[j++] = psprintf("%d", stat.btpo_prev);
values[j++] = psprintf("%d", stat.btpo_next);
values[j++] = psprintf("%d", (stat.type == 'd') ? stat.btpo.xact : stat.btpo.level);
values[j++] = psprintf("%d", stat.btpo_flags);
tuple = BuildTupleFromCStrings(TupleDescGetAttInMetadata(tupleDesc),
values);
result = HeapTupleGetDatum(tuple);
PG_RETURN_DATUM(result);
}
Datum
kafka_consume_begin_tr(PG_FUNCTION_ARGS)
{
text *topic;
text *qualified_name;
RangeVar *relname;
Relation rel;
Relation consumers;
Oid id;
bool result;
text *format;
text *delimiter;
text *quote;
text *escape;
int batchsize;
int parallelism;
int64 offset;
KafkaConsumer consumer;
if (PG_ARGISNULL(0))
elog(ERROR, "topic cannot be null");
if (PG_ARGISNULL(1))
elog(ERROR, "relation cannot be null");
if (PG_ARGISNULL(2))
elog(ERROR, "format cannot be null");
topic = PG_GETARG_TEXT_P(0);
qualified_name = PG_GETARG_TEXT_P(1);
format = PG_GETARG_TEXT_P(2);
if (PG_ARGISNULL(3))
delimiter = NULL;
else
delimiter = PG_GETARG_TEXT_P(3);
if (PG_ARGISNULL(4))
quote = NULL;
else
quote = PG_GETARG_TEXT_P(4);
if (PG_ARGISNULL(5))
escape = NULL;
else
escape = PG_GETARG_TEXT_P(5);
if (PG_ARGISNULL(6))
batchsize = 1000;
else
batchsize = PG_GETARG_INT32(6);
if (PG_ARGISNULL(7))
parallelism = 1;
else
parallelism = PG_GETARG_INT32(7);
if (PG_ARGISNULL(8))
offset = RD_KAFKA_OFFSET_NULL;
else
offset = PG_GETARG_INT64(8);
/* there's no point in progressing if there aren't any brokers */
if (!get_all_brokers())
elog(ERROR, "add at least one broker with kafka_add_broker");
/* verify that the target relation actually exists */
relname = makeRangeVarFromNameList(textToQualifiedNameList(qualified_name));
rel = heap_openrv(relname, NoLock);
if (IsInferredStream(RelationGetRelid(rel)))
ereport(ERROR,
(errmsg("target stream must be static"),
errhint("Use CREATE STREAM to create a stream that can consume a Kafka topic.")));
heap_close(rel, NoLock);
consumers = open_pipeline_kafka_consumers();
id = create_or_update_consumer(consumers, qualified_name, topic, format,
delimiter, quote, escape, batchsize, parallelism);
load_consumer_state(id, &consumer);
result = launch_consumer_group(consumers, &consumer, offset);
heap_close(consumers, NoLock);
if (result)
RETURN_SUCCESS();
else
RETURN_FAILURE();
}
/*
* load_consumer_state
*
* Read consumer state from pipeline_kafka_consumers into the given struct
*/
static void
load_consumer_state(Oid worker_id, KafkaConsumer *consumer)
{
ScanKeyData skey[1];
HeapTuple tup = NULL;
HeapScanDesc scan;
Relation consumers = open_pipeline_kafka_consumers();
TupleTableSlot *slot = MakeSingleTupleTableSlot(RelationGetDescr(consumers));
Datum d;
bool isnull;
text *qualified;
MemoryContext old;
MemSet(consumer, 0, sizeof(KafkaConsumer));
ScanKeyInit(&skey[0], -2, BTEqualStrategyNumber, F_OIDEQ, ObjectIdGetDatum(worker_id));
scan = heap_beginscan(consumers, GetTransactionSnapshot(), 1, skey);
tup = heap_getnext(scan, ForwardScanDirection);
if (!HeapTupleIsValid(tup))
elog(ERROR, "kafka consumer %d not found", worker_id);
ExecStoreTuple(tup, slot, InvalidBuffer, false);
consumer->id = HeapTupleGetOid(tup);
d = slot_getattr(slot, CONSUMER_ATTR_RELATION, &isnull);
/* we don't want anything that's palloc'd to get freed when we commit */
old = MemoryContextSwitchTo(CacheMemoryContext);
/* target relation */
qualified = (text *) DatumGetPointer(d);
consumer->rel = makeRangeVarFromNameList(textToQualifiedNameList(qualified));
/* topic */
d = slot_getattr(slot, CONSUMER_ATTR_TOPIC, &isnull);
consumer->topic = TextDatumGetCString(d);
/* format */
d = slot_getattr(slot, CONSUMER_ATTR_FORMAT, &isnull);
consumer->format = TextDatumGetCString(d);
/* delimiter */
d = slot_getattr(slot, CONSUMER_ATTR_DELIMITER, &isnull);
if (!isnull)
consumer->delimiter = TextDatumGetCString(d);
else
consumer->delimiter = NULL;
/* quote character */
d = slot_getattr(slot, CONSUMER_ATTR_QUOTE, &isnull);
if (!isnull)
consumer->quote = TextDatumGetCString(d);
else
consumer->quote = NULL;
/* escape character */
d = slot_getattr(slot, CONSUMER_ATTR_ESCAPE, &isnull);
if (!isnull)
consumer->escape = TextDatumGetCString(d);
else
consumer->escape = NULL;
/* now load all brokers */
consumer->brokers = get_all_brokers();
MemoryContextSwitchTo(old);
d = slot_getattr(slot, CONSUMER_ATTR_PARALLELISM, &isnull);
consumer->parallelism = DatumGetInt32(d);
/* batch size */
d = slot_getattr(slot, CONSUMER_ATTR_BATCH_SIZE, &isnull);
consumer->batch_size = DatumGetInt32(d);
ExecDropSingleTupleTableSlot(slot);
heap_endscan(scan);
heap_close(consumers, NoLock);
}
/*-------------------------------------------------------
* bt_page_items()
*
* Get IndexTupleData set in a btree page
*
* Usage: SELECT * FROM bt_page_items('t1_pkey', 1);
*-------------------------------------------------------
*/
Datum
bt_page_items(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_PP(0);
uint32 blkno = PG_GETARG_UINT32(1);
Datum result;
FuncCallContext *fctx;
MemoryContext mctx;
struct user_args *uargs;
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use pageinspect functions"))));
if (SRF_IS_FIRSTCALL())
{
RangeVar *relrv;
Relation rel;
Buffer buffer;
BTPageOpaque opaque;
TupleDesc tupleDesc;
fctx = SRF_FIRSTCALL_INIT();
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
if (!IS_INDEX(rel) || !IS_BTREE(rel))
elog(ERROR, "relation \"%s\" is not a btree index",
RelationGetRelationName(rel));
/*
* Reject attempts to read non-local temporary relations; we would be
* likely to get wrong data since we have no visibility into the
* owning session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot access temporary tables of other sessions")));
if (blkno == 0)
elog(ERROR, "block 0 is a meta page");
CHECK_RELATION_BLOCK_RANGE(rel, blkno);
buffer = ReadBuffer(rel, blkno);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
/*
* We copy the page into local storage to avoid holding pin on the
* buffer longer than we must, and possibly failing to release it at
* all if the calling query doesn't fetch all rows.
*/
mctx = MemoryContextSwitchTo(fctx->multi_call_memory_ctx);
uargs = palloc(sizeof(struct user_args));
uargs->page = palloc(BLCKSZ);
memcpy(uargs->page, BufferGetPage(buffer), BLCKSZ);
UnlockReleaseBuffer(buffer);
relation_close(rel, AccessShareLock);
uargs->offset = FirstOffsetNumber;
opaque = (BTPageOpaque) PageGetSpecialPointer(uargs->page);
if (P_ISDELETED(opaque))
elog(NOTICE, "page is deleted");
fctx->max_calls = PageGetMaxOffsetNumber(uargs->page);
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
fctx->attinmeta = TupleDescGetAttInMetadata(tupleDesc);
fctx->user_fctx = uargs;
MemoryContextSwitchTo(mctx);
}
fctx = SRF_PERCALL_SETUP();
uargs = fctx->user_fctx;
if (fctx->call_cntr < fctx->max_calls)
{
result = bt_page_print_tuples(fctx, uargs->page, uargs->offset);
uargs->offset++;
SRF_RETURN_NEXT(fctx, result);
}
else
{
pfree(uargs->page);
pfree(uargs);
SRF_RETURN_DONE(fctx);
}
}
/* ------------------------------------------------
* bt_metap()
*
* Get a btree's meta-page information
*
* Usage: SELECT * FROM bt_metap('t1_pkey')
* ------------------------------------------------
*/
datum_t
bt_metap(PG_FUNC_ARGS)
{
text *relname = ARG_TEXT_P(0);
datum_t result;
struct relation * rel;
range_var_n *relrv;
struct bt_meta_page *metad;
struct tuple * tupleDesc;
int j;
char *values[6];
buf_id_t buffer;
page_p page;
struct heap_tuple * tuple;
if (!superuser())
ereport(ERROR,
(errcode(E_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use pageinspect functions"))));
relrv = nl_to_range_var(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, ACCESS_SHR_LOCK);
if (!IS_INDEX(rel) || !IS_BTREE(rel))
elog(ERROR, "relation \"%s\" is not a btree index",
REL_NAME(rel));
/*
* Reject attempts to read non-local temporary relations; we would be
* likely to get wrong data since we have no visibility into the owning
* session's local buffers.
*/
if (REL_IS_OTHER_TMP(rel))
ereport(ERROR,
(errcode(E_FEATURE_NOT_SUPPORTED),
errmsg("cannot access temporary tables of other sessions")));
buffer = read_buf(rel, 0);
page = BUF_PAGE(buffer);
metad = BT_PAGE_META(page);
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
j = 0;
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", metad->btm_magic);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", metad->btm_version);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", metad->btm_root);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", metad->btm_level);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", metad->btm_fastroot);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", metad->btm_fastlevel);
tuple = build_tuple_from_cstrings(TupleDescGetAttInMetadata(tupleDesc),
values);
result = HeapTupleGetDatum(tuple);
release_buf(buffer);
relation_close(rel, ACCESS_SHR_LOCK);
RET_DATUM(result);
}
datum_t
bt_page_items(PG_FUNC_ARGS)
{
text *relname = ARG_TEXT_P(0);
uint32 blkno = ARG_UINT32(1);
datum_t result;
char *values[6];
struct heap_tuple * tuple;
struct fcall_ctx *fctx;
struct mctx * mctx;
struct user_args *uargs;
if (!superuser())
ereport(ERROR,
(errcode(E_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use pageinspect functions"))));
if (SRF_IS_FIRSTCALL())
{
range_var_n *relrv;
struct relation * rel;
buf_id_t buffer;
struct bt_page_opaque * opaque;
struct tuple * tupleDesc;
fctx = SRF_FIRSTCALL_INIT();
relrv = nl_to_range_var(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, ACCESS_SHR_LOCK);
if (!IS_INDEX(rel) || !IS_BTREE(rel))
elog(ERROR, "relation \"%s\" is not a btree index",
REL_NAME(rel));
/*
* Reject attempts to read non-local temporary relations; we would be
* likely to get wrong data since we have no visibility into the
* owning session's local buffers.
*/
if (REL_IS_OTHER_TMP(rel))
ereport(ERROR,
(errcode(E_FEATURE_NOT_SUPPORTED),
errmsg("cannot access temporary tables of other sessions")));
if (blkno == 0)
elog(ERROR, "block 0 is a meta page");
CHECK_RELATION_BLOCK_RANGE(rel, blkno);
buffer = read_buf(rel, blkno);
/*
* We copy the page into local storage to avoid holding pin on the
* buffer longer than we must, and possibly failing to release it at
* all if the calling query doesn't fetch all rows.
*/
mctx = mctx_switch(fctx->multi_call_memory_ctx);
uargs = palloc(sizeof(struct user_args));
uargs->page = palloc(BLK_SZ);
memcpy(uargs->page, BUF_PAGE(buffer), BLK_SZ);
release_buf(buffer);
relation_close(rel, ACCESS_SHR_LOCK);
uargs->offset = FIRST_ITEM_ID;
opaque = (struct bt_page_opaque *) PAGE_SPECIAL_PTR(uargs->page);
if (P_ISDELETED(opaque))
elog(NOTICE, "page is deleted");
fctx->max_calls = PAGE_MAX_ITEM_ID(uargs->page);
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
fctx->attinmeta = TupleDescGetAttInMetadata(tupleDesc);
fctx->user_fctx = uargs;
mctx_switch(mctx);
}
fctx = SRF_PERCALL_SETUP();
uargs = fctx->user_fctx;
if (fctx->call_cntr < fctx->max_calls)
{
struct item_id * id;
struct index_tuple * itup;
int j;
int off;
int dlen;
char *dump;
char *ptr;
id = PAGE_ITEM_ID(uargs->page, uargs->offset);
if (!ITEMID_VALID(id))
elog(ERROR, "invalid ItemId");
itup = (struct index_tuple *) PAGE_GET_ITEM(uargs->page, id);
j = 0;
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", uargs->offset);
values[j] = palloc(32);
snprintf(values[j++], 32, "(%u,%u)",
BLK_ID_TO_BLK_NR(&(itup->t_tid.ip_blkid)),
itup->t_tid.ip_posid);
values[j] = palloc(32);
snprintf(values[j++], 32, "%d", (int) INDEX_TUPLE_SZ(itup));
values[j] = palloc(32);
snprintf(values[j++], 32, "%c", INDEX_TUPLE_HAS_NULLS(itup) ? 't' : 'f');
values[j] = palloc(32);
snprintf(values[j++], 32, "%c", INDEX_TUPLE_HAS_VAR(itup) ? 't' : 'f');
ptr = (char *) itup + INDEX_TUPLE_DATA_OFFSET(itup->t_info);
dlen = INDEX_TUPLE_SZ(itup) - INDEX_TUPLE_DATA_OFFSET(itup->t_info);
dump = pzalloc(dlen * 3 + 1);
values[j] = dump;
for (off = 0; off < dlen; off++)
{
if (off > 0)
*dump++ = ' ';
sprintf(dump, "%02x", *(ptr + off) & 0xff);
dump += 2;
}
tuple = build_tuple_from_cstrings(fctx->attinmeta, values);
result = HeapTupleGetDatum(tuple);
uargs->offset = uargs->offset + 1;
SRF_RETURN_NEXT(fctx, result);
}
else
{
pfree(uargs->page);
pfree(uargs);
SRF_RETURN_DONE(fctx);
}
}
/* ------------------------------------------------
* bt_metap()
*
* Get a btree's meta-page information
*
* Usage: SELECT * FROM bt_metap('t1_pkey')
* ------------------------------------------------
*/
Datum
bt_metap(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_PP(0);
Datum result;
Relation rel;
RangeVar *relrv;
BTMetaPageData *metad;
TupleDesc tupleDesc;
int j;
char *values[6];
Buffer buffer;
Page page;
HeapTuple tuple;
if (!superuser())
ereport(ERROR,
(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
(errmsg("must be superuser to use pageinspect functions"))));
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
rel = relation_openrv(relrv, AccessShareLock);
if (!IS_INDEX(rel) || !IS_BTREE(rel))
elog(ERROR, "relation \"%s\" is not a btree index",
RelationGetRelationName(rel));
/*
* Reject attempts to read non-local temporary relations; we would be
* likely to get wrong data since we have no visibility into the owning
* session's local buffers.
*/
if (RELATION_IS_OTHER_TEMP(rel))
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("cannot access temporary tables of other sessions")));
buffer = ReadBuffer(rel, 0);
LockBuffer(buffer, BUFFER_LOCK_SHARE);
page = BufferGetPage(buffer);
metad = BTPageGetMeta(page);
/* Build a tuple descriptor for our result type */
if (get_call_result_type(fcinfo, NULL, &tupleDesc) != TYPEFUNC_COMPOSITE)
elog(ERROR, "return type must be a row type");
j = 0;
values[j++] = psprintf("%d", metad->btm_magic);
values[j++] = psprintf("%d", metad->btm_version);
values[j++] = psprintf("%d", metad->btm_root);
values[j++] = psprintf("%d", metad->btm_level);
values[j++] = psprintf("%d", metad->btm_fastroot);
values[j++] = psprintf("%d", metad->btm_fastlevel);
tuple = BuildTupleFromCStrings(TupleDescGetAttInMetadata(tupleDesc),
values);
result = HeapTupleGetDatum(tuple);
UnlockReleaseBuffer(buffer);
relation_close(rel, AccessShareLock);
PG_RETURN_DATUM(result);
}
Datum
pipeline_stream_insert(PG_FUNCTION_ARGS)
{
TriggerData *trigdata = (TriggerData *) fcinfo->context;
Trigger *trig = trigdata->tg_trigger;
HeapTuple tup;
List *fdw_private;
int i;
ResultRelInfo rinfo;
if (trig->tgnargs < 1)
elog(ERROR, "pipeline_stream_insert: must be provided a stream name");
/* make sure it's called as a trigger */
if (!CALLED_AS_TRIGGER(fcinfo))
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
errmsg("pipeline_stream_insert: must be called as trigger")));
/* and that it's called on update or insert */
if (!TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event) && !TRIGGER_FIRED_BY_INSERT(trigdata->tg_event))
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
errmsg("pipeline_stream_insert: must be called on insert or update")));
/* and that it's called for each row */
if (!TRIGGER_FIRED_FOR_ROW(trigdata->tg_event))
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
errmsg("pipeline_stream_insert: must be called for each row")));
/* and that it's called after insert or update */
if (!TRIGGER_FIRED_AFTER(trigdata->tg_event))
ereport(ERROR,
(errcode(ERRCODE_E_R_I_E_TRIGGER_PROTOCOL_VIOLATED),
errmsg("pipeline_stream_insert: must be called after insert or update")));
if (TRIGGER_FIRED_BY_UPDATE(trigdata->tg_event))
tup = trigdata->tg_newtuple;
else
tup = trigdata->tg_trigtuple;
fdw_private = list_make1(RelationGetDescr(trigdata->tg_relation));
MemSet(&rinfo, 0, sizeof(ResultRelInfo));
rinfo.ri_RangeTableIndex = 1; /* dummy */
rinfo.ri_TrigDesc = NULL;
for (i = 0; i < trig->tgnargs; i++)
{
RangeVar *stream;
Relation rel;
StreamInsertState *sis;
stream = makeRangeVarFromNameList(textToQualifiedNameList(cstring_to_text(trig->tgargs[i])));
rel = heap_openrv(stream, AccessShareLock);
rinfo.ri_RelationDesc = rel;
BeginStreamModify(NULL, &rinfo, fdw_private, 0, 0);
sis = (StreamInsertState *) rinfo.ri_FdwState;
Assert(sis);
if (sis->queries)
{
TupleTableSlot *slot = MakeSingleTupleTableSlot(RelationGetDescr(rel));
ExecStoreTuple(tup, slot, InvalidBuffer, false);
ExecStreamInsert(NULL, &rinfo, slot, NULL);
ExecClearTuple(slot);
ExecDropSingleTupleTableSlot(slot);
pgstat_report_streamstat(true);
}
EndStreamModify(NULL, &rinfo);
heap_close(rel, AccessShareLock);
}
return PointerGetDatum(tup);
}
