public RolapMember getMemberParent(RolapMember member) {
RolapMember parentMember = member.getParentMember();
// Skip over hidden parents.
while (parentMember != null && parentMember.isHidden()) {
parentMember = parentMember.getParentMember();
}
// Skip over non-accessible parents.
if (parentMember != null) {
if (hierarchyAccess.getAccess(parentMember) == Access.NONE) {
return null;
}
}
return parentMember;
}
private void processMemberChildren(
List<RolapMember> fullChildren,
List<RolapMember> children,
MemberChildrenConstraint constraint) {
// todo: optimize if parentMember is beyond last level
List<RolapMember> grandChildren = null;
for (int i = 0; i < fullChildren.size(); i++) {
RolapMember member = fullChildren.get(i);
// If a child is hidden (due to raggedness) include its children.
// This must be done before applying access-control.
if (ragged) {
if (member.isHidden()) {
// Replace this member with all of its children.
// They might be hidden too, but we'll get to them in due
// course. They also might be access-controlled; that's why
// we deal with raggedness before we apply access-control.
fullChildren.remove(i);
if (grandChildren == null) {
grandChildren = new ArrayList<RolapMember>();
} else {
grandChildren.clear();
}
memberReader.getMemberChildren(member, grandChildren, constraint);
fullChildren.addAll(i, grandChildren);
// Step back to before the first child we just inserted,
// and go through the loop again.
--i;
continue;
}
}
// Filter out children which are invisible because of
// access-control.
final Access access;
if (hierarchyAccess != null) {
access = hierarchyAccess.getAccess(member);
} else {
access = Access.ALL;
}
switch (access) {
case NONE:
break;
default:
children.add(member);
break;
}
}
}
public MemberChildrenConstraint getChildByNameConstraint(
RolapMember parent, Id.Segment childName) {
// Ragged hierarchies span multiple levels, so SQL WHERE does not work
// there
if (!enabled || parent.getHierarchy().isRagged()) {
return DefaultMemberChildrenConstraint.instance();
}
return new ChildByNameConstraint(childName);
}
private boolean canSee(final RolapMember member) {
if (ragged && member.isHidden()) {
return false;
}
if (hierarchyAccess != null) {
final Access access = hierarchyAccess.getAccess(member);
return access != Access.NONE;
}
return true;
}
/**
* Returns the scenario inside a calculated member in the scenario dimension. For example, applied
* to [Scenario].[1], returns the Scenario object representing scenario #1.
*
* @param member Wrapper member
* @return Wrapped scenario
*/
static Scenario forMember(final RolapMember member) {
if (isScenario(member.getHierarchy())) {
final Formula formula = ((RolapCalculatedMember) member).getFormula();
final ResolvedFunCall resolvedFunCall = (ResolvedFunCall) formula.getExpression();
final Calc calc = resolvedFunCall.getFunDef().compileCall(null, null);
return ((ScenarioCalc) calc).getScenario();
} else {
return null;
}
}
/**
* Creates a WritebackCell.
*
* @param cube Cube
* @param members Members that form context
* @param constrainedColumnsBitKey Bitmap of columns which have values
* @param keyValues List of values, by bit position
* @param newValue New value
* @param currentValue Current value
* @param allocationPolicy Allocation policy
*/
WritebackCell(
RolapCube cube,
List<RolapMember> members,
BitKey constrainedColumnsBitKey,
Object[] keyValues,
double newValue,
double currentValue,
AllocationPolicy allocationPolicy) {
assert keyValues.length == constrainedColumnsBitKey.cardinality();
Util.discard(cube); // not used currently
Util.discard(constrainedColumnsBitKey); // not used currently
Util.discard(keyValues); // not used currently
this.newValue = newValue;
this.currentValue = currentValue;
this.allocationPolicy = allocationPolicy;
this.atomicCellCount = computeAtomicCellCount(cube, members);
// Build the array of members by ordinal. If a member is not
// specified for a particular dimension, use the 'all' member (not
// necessarily the same as the default member).
final List<RolapHierarchy> hierarchyList = cube.getHierarchies();
this.membersByOrdinal = new Member[hierarchyList.size()];
for (int i = 0; i < membersByOrdinal.length; i++) {
membersByOrdinal[i] = hierarchyList.get(i).getDefaultMember();
}
for (RolapMember member : members) {
final RolapHierarchy hierarchy = member.getHierarchy();
if (isScenario(hierarchy)) {
assert member.isAll();
}
// REVIEW The following works because Measures is the only
// dimension whose members do not belong to RolapCubeDimension,
// just a regular RolapDimension, but has ordinal 0.
final int ordinal = hierarchy.getOrdinalInCube();
membersByOrdinal[ordinal] = member;
}
}
public RolapMember getLeadMember(RolapMember member, int n) {
int i = 0;
int increment = 1;
if (n < 0) {
increment = -1;
n = -n;
}
while (i < n) {
member = memberReader.getLeadMember(member, increment);
if (member.isNull()) {
return member;
}
if (canSee(member)) {
++i;
}
}
return member;
}
