PartitionType PartitionTypeIndicator::getFacePartitionType(int i) const
{
if(cell_indicator_.size())
{
// We determine the partition type by the type of the
// connected cells:
// If all of them are interior and border, then the type is
// interior and border, respectively.
// If one of them is of type interior and the other is
// of type overlap, then the type is border.
OrientedEntityTable<1,0>::row_type cells_of_face =
grid_data_->face_to_cell_[Entity<1>(*grid_data_,i,true)];
if(cells_of_face.size()==1)
{
int cell_index = cells_of_face[0].index();
PartitionType cell_part = PartitionType(cell_indicator_[cell_index]);
if(cell_part!=OverlapEntity)
return cell_part;
else
{
// If the cell is in the overlap and the face is on the boundary,
// then the partition type has to Front! Here we check whether
// we are at the boundary.
Entity<0> cell(*grid_data_, cell_index, true);
OrientedEntityTable<0,1>::row_type cell_to_face=grid_data_->cell_to_face_[cell];
Entity<0>::LeafIntersectionIterator intersection=cell.ilevelbegin();
for(int subindex=0; subindex<cell_to_face.size(); ++subindex, ++intersection)
if(cell_to_face[subindex].index()==i)
break;
assert(intersection!=cell.ilevelend());
if(intersection.boundary())
return FrontEntity;
else
return cell_part;
}
}
else
{
if(cells_of_face[0].index()==std::numeric_limits<int>::max())
{
assert(cells_of_face[1].index()!=std::numeric_limits<int>::max());
// At the boder of the processor's but not the global domain
return getProcessorBoundaryPartitionType(PartitionType(cell_indicator_[cells_of_face[1].index()]));
}
if(cells_of_face[1].index()==std::numeric_limits<int>::max())
{
assert(cells_of_face[0].index()!=std::numeric_limits<int>::max());
// At the boder of the processor's but not the global domain
return getProcessorBoundaryPartitionType(PartitionType(cell_indicator_[cells_of_face[0].index()]));
}
if(cell_indicator_[cells_of_face[0].index()]==
cell_indicator_[cells_of_face[1].index()])
return PartitionType(cell_indicator_[cells_of_face[0].index()]);
else
return BorderEntity;
}
}
return InteriorEntity;
}
/*
* PruneShardList prunes shards from given list based on the selection criteria,
* and returns remaining shards in another list.
*/
List *
PruneShardList(Oid relationId, List *whereClauseList, List *shardIntervalList)
{
List *remainingShardList = NIL;
ListCell *shardIntervalCell = NULL;
List *restrictInfoList = NIL;
Node *baseConstraint = NULL;
Var *partitionColumn = PartitionColumn(relationId);
char partitionMethod = PartitionType(relationId);
/* build the filter clause list for the partition method */
if (partitionMethod == DISTRIBUTE_BY_HASH)
{
Node *hashedNode = HashableClauseMutator((Node *) whereClauseList,
partitionColumn);
List *hashedClauseList = (List *) hashedNode;
restrictInfoList = BuildRestrictInfoList(hashedClauseList);
}
else
{
restrictInfoList = BuildRestrictInfoList(whereClauseList);
}
/* override the partition column for hash partitioning */
if (partitionMethod == DISTRIBUTE_BY_HASH)
{
partitionColumn = MakeInt4Column();
}
/* build the base expression for constraint */
baseConstraint = BuildBaseConstraint(partitionColumn);
/* walk over shard list and check if shards can be pruned */
foreach(shardIntervalCell, shardIntervalList)
{
ShardInterval *shardInterval = lfirst(shardIntervalCell);
List *constraintList = NIL;
bool shardPruned = false;
/* set the min/max values in the base constraint */
UpdateConstraint(baseConstraint, shardInterval);
constraintList = list_make1(baseConstraint);
shardPruned = predicate_refuted_by(constraintList, restrictInfoList);
if (shardPruned)
{
ereport(DEBUG2, (errmsg("predicate pruning for shardId "
UINT64_FORMAT, shardInterval->id)));
}
else
{
remainingShardList = lappend(remainingShardList, &(shardInterval->id));
}
}
/*
* CheckHashPartitionedTable looks up the partition information for the given
* tableId and checks if the table is hash partitioned. If not, the function
* throws an error.
*/
static void
CheckHashPartitionedTable(Oid distributedTableId)
{
char partitionType = PartitionType(distributedTableId);
if (partitionType != HASH_PARTITION_TYPE)
{
ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("unsupported table partition type: %c", partitionType)));
}
}
PartitionType PartitionTypeIndicator::getPointPartitionType(int index) const
{
if(point_indicator_.size())
return PartitionType(point_indicator_[index]);
return InteriorEntity;
}
PartitionType PartitionTypeIndicator::getPartitionType(const EntityRep<0>& cell_entity) const
{
if(cell_indicator_.size())
return PartitionType(cell_indicator_[cell_entity.index()]);
return InteriorEntity;
}
/*
* PruneShardList prunes shards from given list based on the selection criteria,
* and returns remaining shards in another list.
*/
List *
PruneShardList(Oid relationId, List *whereClauseList, List *shardIntervalList)
{
List *remainingShardList = NIL;
ListCell *shardIntervalCell = NULL;
List *restrictInfoList = NIL;
Node *baseConstraint = NULL;
Var *partitionColumn = PartitionColumn(relationId);
char partitionMethod = PartitionType(relationId);
/* build the filter clause list for the partition method */
switch (partitionMethod)
{
case APPEND_PARTITION_TYPE:
case RANGE_PARTITION_TYPE:
{
restrictInfoList = BuildRestrictInfoList(whereClauseList);
break;
}
case HASH_PARTITION_TYPE:
{
Node *hashedNode = HashableClauseMutator((Node *) whereClauseList,
partitionColumn);
List *hashedClauseList = (List *) hashedNode;
restrictInfoList = BuildRestrictInfoList(hashedClauseList);
/* override the partition column for hash partitioning */
partitionColumn = MakeInt4Column();
break;
}
default:
{
ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("unsupported table partition type: %c",
partitionMethod)));
}
}
/* build the base expression for constraint */
baseConstraint = BuildBaseConstraint(partitionColumn);
/* walk over shard list and check if shards can be pruned */
foreach(shardIntervalCell, shardIntervalList)
{
ShardInterval *shardInterval = lfirst(shardIntervalCell);
List *constraintList = NIL;
bool shardPruned = false;
/* set the min/max values in the base constraint */
UpdateConstraint(baseConstraint, shardInterval);
constraintList = list_make1(baseConstraint);
shardPruned = predicate_refuted_by(constraintList, restrictInfoList);
if (shardPruned)
{
ereport(DEBUG2, (errmsg("predicate pruning for shard with ID "
INT64_FORMAT, shardInterval->id)));
}
else
{
remainingShardList = lappend(remainingShardList, &(shardInterval->id));
}
}