Datum
pg_relation_size(PG_FUNCTION_ARGS)
{
Oid relOid = PG_GETARG_OID(0);
text *forkName = PG_GETARG_TEXT_P(1);
Relation rel;
int64 size;
rel = try_relation_open(relOid, AccessShareLock);
/*
* Before 9.2, we used to throw an error if the relation didn't exist, but
* that makes queries like "SELECT pg_relation_size(oid) FROM pg_class"
* less robust, because 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 (rel == NULL)
PG_RETURN_NULL();
size = calculate_relation_size(&(rel->rd_node), rel->rd_backend,
forkname_to_number(text_to_cstring(forkName)));
relation_close(rel, AccessShareLock);
PG_RETURN_INT64(size);
}
/*
* DistributedTableSize is helper function for each kind of citus size functions.
* It first checks whether the table is distributed and size query can be run on
* it. Connection to each node has to be established to get the size of the table.
*/
static uint64
DistributedTableSize(Oid relationId, char *sizeQuery)
{
Relation relation = NULL;
List *workerNodeList = NULL;
ListCell *workerNodeCell = NULL;
uint64 totalRelationSize = 0;
if (XactModificationLevel == XACT_MODIFICATION_DATA)
{
ereport(ERROR, (errcode(ERRCODE_ACTIVE_SQL_TRANSACTION),
errmsg("citus size functions cannot be called in transaction"
" blocks which contain multi-shard data modifications")));
}
relation = try_relation_open(relationId, AccessShareLock);
if (relation == NULL)
{
ereport(ERROR,
(errmsg("could not compute table size: relation does not exist")));
}
ErrorIfNotSuitableToGetSize(relationId);
workerNodeList = ActiveReadableNodeList();
foreach(workerNodeCell, workerNodeList)
{
WorkerNode *workerNode = (WorkerNode *) lfirst(workerNodeCell);
uint64 relationSizeOnNode = DistributedTableSizeOnWorker(workerNode, relationId,
sizeQuery);
totalRelationSize += relationSizeOnNode;
}
Datum
pg_relation_size_oid(PG_FUNCTION_ARGS)
{
Oid relOid = PG_GETARG_OID(0);
Relation rel;
int64 size = 0;
if (GP_ROLE_EXECUTE == Gp_role)
{
ereport(ERROR,
(errcode(ERRCODE_GP_COMMAND_ERROR),
errmsg("pg_relation_size: cannot be executed in segment")));
}
rel = try_relation_open(relOid, 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 (relOid == 0 || rel->rd_node.relNode == 0)
size = 0;
else
size = calculate_relation_size(rel);
relation_close(rel, AccessShareLock);
PG_RETURN_INT64(size);
}
/*
* create_distributed_table gets a table name, distribution column,
* distribution method and colocate_with option, then it creates a
* distributed table.
*/
Datum
create_distributed_table(PG_FUNCTION_ARGS)
{
Oid relationId = InvalidOid;
text *distributionColumnText = NULL;
Oid distributionMethodOid = InvalidOid;
text *colocateWithTableNameText = NULL;
Relation relation = NULL;
char *distributionColumnName = NULL;
Var *distributionColumn = NULL;
char distributionMethod = 0;
char *colocateWithTableName = NULL;
bool viaDeprecatedAPI = false;
CheckCitusVersion(ERROR);
EnsureCoordinator();
relationId = PG_GETARG_OID(0);
distributionColumnText = PG_GETARG_TEXT_P(1);
distributionMethodOid = PG_GETARG_OID(2);
colocateWithTableNameText = PG_GETARG_TEXT_P(3);
/*
* Lock target relation with an exclusive lock - there's no way to make
* sense of this table until we've committed, and we don't want multiple
* backends manipulating this relation.
*/
relation = try_relation_open(relationId, ExclusiveLock);
if (relation == NULL)
{
ereport(ERROR, (errmsg("could not create distributed table: "
"relation does not exist")));
}
/*
* We should do this check here since the codes in the following lines rely
* on this relation to have a supported relation kind. More extensive checks
* will be performed in CreateDistributedTable.
*/
EnsureRelationKindSupported(relationId);
distributionColumnName = text_to_cstring(distributionColumnText);
distributionColumn = BuildDistributionKeyFromColumnName(relation,
distributionColumnName);
distributionMethod = LookupDistributionMethod(distributionMethodOid);
colocateWithTableName = text_to_cstring(colocateWithTableNameText);
CreateDistributedTable(relationId, distributionColumn, distributionMethod,
colocateWithTableName, viaDeprecatedAPI);
relation_close(relation, NoLock);
PG_RETURN_VOID();
}
/*
* Compute the on-disk size of files for the relation according to the
* stat function, including heap data, index data, toast data, aoseg data,
* aoblkdir data, and aovisimap data.
*/
static int64
calculate_total_relation_size(Oid Relid)
{
Relation heapRel;
Oid toastOid;
int64 size;
ListCell *cell;
ForkNumber forkNum;
heapRel = try_relation_open(Relid, AccessShareLock, false);
if (!RelationIsValid(heapRel))
return 0;
toastOid = heapRel->rd_rel->reltoastrelid;
/* Get the heap size */
if (Relid == 0 || heapRel->rd_node.relNode == 0)
size = 0;
else
{
size = 0;
for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
size += calculate_relation_size(heapRel, forkNum);
}
/* Include any dependent indexes */
if (heapRel->rd_rel->relhasindex)
{
List *index_oids = RelationGetIndexList(heapRel);
foreach(cell, index_oids)
{
Oid idxOid = lfirst_oid(cell);
Relation iRel;
iRel = try_relation_open(idxOid, AccessShareLock, false);
if (RelationIsValid(iRel))
{
for (forkNum = 0; forkNum <= MAX_FORKNUM; forkNum++)
size += calculate_relation_size(iRel, forkNum);
relation_close(iRel, AccessShareLock);
}
}
/**
* Given the oid of a relation, this method calculates reltuples, relpages. This only looks up
* local information (on master or segments). It produces meaningful values for AO and
* heap tables and returns [0.0,0.0] for all other relations.
* Input:
* relationoid
* Output:
* array of two values [reltuples,relpages]
*/
Datum
gp_statistics_estimate_reltuples_relpages_oid(PG_FUNCTION_ARGS)
{
float4 relpages = 0.0;
float4 reltuples = 0.0;
Oid relOid = PG_GETARG_OID(0);
Datum values[2];
ArrayType *result;
Relation rel = try_relation_open(relOid, AccessShareLock, false);
if (rel != NULL)
{
if (rel->rd_rel->relkind == RELKIND_RELATION)
{
if (RelationIsHeap(rel))
{
gp_statistics_estimate_reltuples_relpages_heap(rel, &reltuples, &relpages);
}
else if (RelationIsAoRows(rel))
{
gp_statistics_estimate_reltuples_relpages_ao_rows(rel, &reltuples, &relpages);
}
else if (RelationIsAoCols(rel))
{
gp_statistics_estimate_reltuples_relpages_ao_cs(rel, &reltuples, &relpages);
}
}
else if (rel->rd_rel->relkind == RELKIND_INDEX)
{
reltuples = 1.0;
relpages = RelationGetNumberOfBlocks(rel);
}
else
{
/**
* Should we silently return [0.0,0.0] or error out? Currently, we choose option 1.
*/
}
relation_close(rel, AccessShareLock);
}
else
{
/**
* Should we silently return [0.0,0.0] or error out? Currently, we choose option 1.
*/
}
values[0] = Float4GetDatum(reltuples);
values[1] = Float4GetDatum(relpages);
result = construct_array(values, 2,
FLOAT4OID,
sizeof(float4), true, 'i');
PG_RETURN_ARRAYTYPE_P(result);
}
/*
* Compute the on-disk size of files for the relation according to the
* stat function, including heap data, index data, toast data, aoseg data,
* aoblkdir data, and aovisimap data.
*/
static int64
calculate_total_relation_size(Oid Relid)
{
Relation heapRel;
Oid toastOid;
AppendOnlyEntry *aoEntry = NULL;
int64 size;
ListCell *cell;
heapRel = try_relation_open(Relid, AccessShareLock, false);
if (!RelationIsValid(heapRel))
return 0;
toastOid = heapRel->rd_rel->reltoastrelid;
if (RelationIsAoRows(heapRel) || RelationIsAoCols(heapRel))
aoEntry = GetAppendOnlyEntry(Relid, SnapshotNow);
/* Get the heap size */
if (Relid == 0 || heapRel->rd_node.relNode == 0)
size = 0;
else
size = calculate_relation_size(heapRel);
/* Include any dependent indexes */
if (heapRel->rd_rel->relhasindex)
{
List *index_oids = RelationGetIndexList(heapRel);
foreach(cell, index_oids)
{
Oid idxOid = lfirst_oid(cell);
Relation iRel;
iRel = try_relation_open(idxOid, AccessShareLock, false);
if (RelationIsValid(iRel))
{
size += calculate_relation_size(iRel);
relation_close(iRel, AccessShareLock);
}
}
Datum
pg_relation_size(PG_FUNCTION_ARGS)
{
Oid relOid = PG_GETARG_OID(0);
text *forkName = PG_GETARG_TEXT_P(1);
Relation rel;
int64 size = 0;
/**
* This function is peculiar in that it does its own dispatching.
* It does not work on entry db since we do not support dispatching
* from entry-db currently.
*/
if (Gp_role == GP_ROLE_EXECUTE && Gp_segment == -1)
elog(ERROR, "This query is not currently supported by GPDB.");
rel = try_relation_open(relOid, 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 (relOid == 0 || rel->rd_node.relNode == 0)
size = 0;
else
size = calculate_relation_size(rel,
forkname_to_number(text_to_cstring(forkName)));
if (Gp_role == GP_ROLE_DISPATCH)
{
StringInfoData buffer;
char *schemaName;
char *relName;
schemaName = get_namespace_name(get_rel_namespace(relOid));
if (schemaName == NULL)
elog(ERROR, "Cannot find schema for oid %d", relOid);
relName = get_rel_name(relOid);
if (relName == NULL)
elog(ERROR, "Cannot find relation for oid %d", relOid);
initStringInfo(&buffer);
appendStringInfo(&buffer, "select sum(pg_relation_size('%s.%s'))::int8 from gp_dist_random('gp_id');", quote_identifier(schemaName), quote_identifier(relName));
size += get_size_from_segDBs(buffer.data);
}
relation_close(rel, AccessShareLock);
PG_RETURN_INT64(size);
}
Datum
pg_relation_size(PG_FUNCTION_ARGS)
{
Oid relOid = PG_GETARG_OID(0);
text *forkName = PG_GETARG_TEXT_P(1);
ForkNumber forkNumber;
Relation rel;
int64 size = 0;
/**
* This function is peculiar in that it does its own dispatching.
* It does not work on entry db since we do not support dispatching
* from entry-db currently.
*/
if (Gp_role == GP_ROLE_EXECUTE && IS_QUERY_DISPATCHER())
elog(ERROR, "This query is not currently supported by GPDB.");
rel = try_relation_open(relOid, AccessShareLock, false);
/*
* Before 9.2, we used to throw an error if the relation didn't exist, but
* that makes queries like "SELECT pg_relation_size(oid) FROM pg_class"
* less robust, because 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 (rel == NULL)
PG_RETURN_NULL();
forkNumber = forkname_to_number(text_to_cstring(forkName));
if (relOid == 0 || rel->rd_node.relNode == 0)
size = 0;
else
size = calculate_relation_size(rel, forkNumber);
if (Gp_role == GP_ROLE_DISPATCH)
{
char *sql;
sql = psprintf("select pg_catalog.pg_relation_size(%u, '%s')", relOid,
forkNames[forkNumber]);
size += get_size_from_segDBs(sql);
}
relation_close(rel, AccessShareLock);
PG_RETURN_INT64(size);
}
/*
* Returns true if the given relation is a partition. The function
* doesn't acquire any locks on the input relation, thus the caller is
* reponsible for holding the appropriate locks.
*/
bool
PartitionTableNoLock(Oid relationId)
{
Relation rel = try_relation_open(relationId, NoLock);
bool partitionTable = false;
/* don't error out for tables that are dropped */
if (rel == NULL)
{
return false;
}
#if (PG_VERSION_NUM >= 100000)
partitionTable = rel->rd_rel->relispartition;
#endif
/* keep the lock */
heap_close(rel, NoLock);
return partitionTable;
}
/*
* Returns true if the given relation is a partitioned table. The function
* doesn't acquire any locks on the input relation, thus the caller is
* reponsible for holding the appropriate locks.
*/
bool
PartitionedTableNoLock(Oid relationId)
{
Relation rel = try_relation_open(relationId, NoLock);
bool partitionedTable = false;
/* don't error out for tables that are dropped */
if (rel == NULL)
{
return false;
}
#if (PG_VERSION_NUM >= 100000)
if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
{
partitionedTable = true;
}
#endif
/* keep the lock */
heap_close(rel, NoLock);
return partitionedTable;
}
Datum
pg_relation_size_name(PG_FUNCTION_ARGS)
{
text *relname = PG_GETARG_TEXT_P(0);
RangeVar *relrv;
Relation rel;
int64 size;
/**
* This function is peculiar in that it does its own dispatching.
* It does not work on entry db since we do not support dispatching
* from entry-db currently.
*/
if (Gp_role == GP_ROLE_EXECUTE && Gp_segment == -1)
{
elog(ERROR, "This query is not currently supported by GPDB.");
}
relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
if (Gp_role == GP_ROLE_EXECUTE && relrv->schemaname != NULL)
{
Oid namespaceId;
Oid relOid;
/*
* Do this the hard way, because the optimizer wants to be
* able to use this function on relations the user might not
* have direct access to.
*/
AcceptInvalidationMessages();
namespaceId = caql_getoid(
NULL,
cql("SELECT oid FROM pg_namespace "
" WHERE nspname = :1 ",
CStringGetDatum(relrv->schemaname)));
relOid = get_relname_relid(relrv->relname, namespaceId);
if (!OidIsValid(relOid))
{
size = 0;
PG_RETURN_INT64(size);
}
/* Let relation_open do the rest */
rel = try_relation_open(relOid, AccessShareLock, false);
}
else
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);
if (Gp_role == GP_ROLE_DISPATCH)
{
char * rawname;
StringInfoData buffer;
initStringInfo(&buffer);
rawname = DatumGetCString(DirectFunctionCall1(textout,
PointerGetDatum(relname)));
initStringInfo(&buffer);
appendStringInfo(&buffer, "select sum(pg_relation_size('%s'))::int8 from gp_dist_random('gp_id');", rawname);
size += get_size_from_segDBs(buffer.data);
}
relation_close(rel, AccessShareLock);
PG_RETURN_INT64(size);
}