private Member getTopParent(Member m) { while (true) { Member parent = m.getParentMember(); if (parent == null) { return m; } m = parent; } }
public void getMemberChildren( RolapMember parentMember, List<RolapMember> children) { for (Member member : members) { if (member.getParentMember() == parentMember) { ((List)children).add(member); } } }
/** * Returns whether {@code m0} is an ancestor of {@code m1}. * * @param strict if true, a member is not an ancestor of itself */ static boolean isAncestorOf(Member m0, Member m1, boolean strict) { if (strict) { if (m1 == null) { return false; } m1 = m1.getParentMember(); } while (m1 != null) { if (m1.equals(m0)) { return true; } m1 = m1.getParentMember(); } return false; }
public void getMemberChildren( List<RolapMember> parentMembers, List<RolapMember> children) { for (Member member : members) { if (parentMembers.contains(member.getParentMember())) { ((List)children).add(member); } } }
VisualTotalMember( Member member, String name, String caption, final Exp exp) { super( (RolapMember) member.getParentMember(), (RolapLevel) member.getLevel(), RolapUtil.sqlNullValue, name, MemberType.FORMULA); this.member = member; this.caption = caption; this.exp = exp; }
private static boolean isChildOrEqualTo(Member member, String uniqueName) { while (true) { String thisUniqueName = member.getUniqueName(); if (thisUniqueName.equals(uniqueName)) { // found a match return true; } // try candidate's parentMember member = member.getParentMember(); if (member == null) { // have reached root return false; } } }
/** * Finds the zero based ordinal of a Member among its siblings. */ public static int getMemberOrdinalInParent( SchemaReader reader, Member member) { Member parent = member.getParentMember(); List<Member> siblings = (parent == null) ? reader.getHierarchyRootMembers(member.getHierarchy()) : reader.getMemberChildren(parent); for (int i = 0; i < siblings.size(); i++) { if (siblings.get(i).equals(member)) { return i; } } throw Util.newInternal( "could not find member " + member + " amongst its siblings"); }
/** * Adds the slicer member and all parent members to mapOfSlicerMembers * capturing the sliced members associated with an Expression. * */ private static void addSlicedMemberToMap( Map<MondrianDef.Expression, Set<RolapMember>> mapOfSlicerMembers, Member slicerMember) { if (slicerMember == null || slicerMember.isAll() || slicerMember.isNull()) { return; } assert slicerMember instanceof RolapMember; MondrianDef.Expression expression = ((RolapLevel) slicerMember.getLevel()).getKeyExp(); if (!mapOfSlicerMembers.containsKey(expression)) { mapOfSlicerMembers.put( expression, new LinkedHashSet<RolapMember>()); } mapOfSlicerMembers.get(expression).add((RolapMember) slicerMember); addSlicedMemberToMap( mapOfSlicerMembers, slicerMember.getParentMember()); }
Member firstSibling(Member member, Evaluator evaluator) { Member parent = member.getParentMember(); List<Member> children; final SchemaReader schemaReader = evaluator.getSchemaReader(); if (parent == null) { if (member.isNull()) { return member; } children = schemaReader.getHierarchyRootMembers( member.getHierarchy()); } else { children = schemaReader.getMemberChildren(parent); } return children.get(children.size() - 1); } });
/** * Walks up the hierarchy, setting the ordinals of ancestors until it * reaches the root or hits an ancestor whose ordinal has already been * assigned. * * <p>Assigns the given ordinal to the ancestor nearest the root which has * not been assigned an ordinal, and increments by one for each descendant. * * @param ordinal Ordinal to assign to deepest ancestor * @param child Member whose ancestors ordinals to set * @return Ordinal, incremented for each time it was used */ private static int bottomUpSetParentOrdinals(int ordinal, Member child) { Member parent = child.getParentMember(); if ((parent != null) && parent.getOrdinal() == -1) { ordinal = bottomUpSetParentOrdinals(ordinal, parent); ordinal = setOrdinal(parent, ordinal); } return ordinal; }
/** * Tells whether the member concerned by this grant object * is a children of a given member. The result of the computation * is cached for faster results, since this might get called * very often. */ private boolean isSubGrant(Member parentMember) { if (parentsCache.containsKey(parentMember.getUniqueName())) { return parentsCache.get(parentMember.getUniqueName()); } for (Member m = member; m != null; m = m.getParentMember()) { if (m.equals(parentMember)) { // We have proved that this granted member is a // descendant of 'member'. Cache it and return. parentsCache.put( parentMember.getUniqueName(), Boolean.TRUE); return true; } } // Not a parent. Cache it and return. if (MondrianProperties.instance() .EnableRolapCubeMemberCache.get()) { parentsCache.put( parentMember.getUniqueName(), Boolean.FALSE); } return false; }
private static Member cousin2( SchemaReader schemaReader, Member member1, Member member2) { if (member1.getLevel() == member2.getLevel()) { return member2; } Member uncle = cousin2(schemaReader, member1.getParentMember(), member2); if (uncle == null) { return null; } int ordinal = Util.getMemberOrdinalInParent(schemaReader, member1); List<Member> cousins = schemaReader.getMemberChildren(uncle); if (cousins.size() <= ordinal) { return null; } return cousins.get(ordinal); }
Member firstSibling(Member member, Evaluator evaluator) { Member parent = member.getParentMember(); List<Member> children; final SchemaReader schemaReader = evaluator.getSchemaReader(); if (parent == null) { if (member.isNull()) { return member; } children = schemaReader.getHierarchyRootMembers( member.getHierarchy()); } else { children = schemaReader.getMemberChildren(parent); } return children.get(0); } });
List<Member> memberSiblings(Member member, Evaluator evaluator) { if (member.isNull()) { // the null member has no siblings -- not even itself return Collections.emptyList(); } Member parent = member.getParentMember(); final SchemaReader schemaReader = evaluator.getSchemaReader(); if (parent == null) { return schemaReader.getHierarchyRootMembers( member.getHierarchy()); } else { return schemaReader.getMemberChildren(parent); } } });
public MondrianOlap4jMember getParentMember() { final mondrian.olap.Member parentMember = member.getParentMember(); if (parentMember == null) { return null; } final RolapConnection conn = olap4jSchema.olap4jCatalog.olap4jDatabaseMetaData .olap4jConnection.getMondrianConnection2(); final boolean isVisible = Locus.execute( conn, "MondrianOlap4jMember.getParentMember", new Locus.Action<Boolean>() { public Boolean execute() { return conn.getSchemaReader() .isVisible(parentMember); } }); if (!isVisible) { return null; } return new MondrianOlap4jMember(olap4jSchema, parentMember); }
public int getMemberDepth(Member member) { final Role.HierarchyAccess hierarchyAccess = role.getAccessDetails(member.getHierarchy()); if (hierarchyAccess != null) { final int memberDepth = member.getLevel().getDepth(); final int topLevelDepth = hierarchyAccess.getTopLevelDepth(); return memberDepth - topLevelDepth; } else if (((RolapLevel) member.getLevel()).isParentChild()) { // For members of parent-child hierarchy, members in the same level // may have different depths. int depth = 0; for (Member m = member.getParentMember(); m != null; m = m.getParentMember()) { depth++; } return depth; } else { return member.getLevel().getDepth(); } }
private String getUniqueNameWithoutAll(Member member) { // build unique string Member parentMember = member.getParentMember(); if ((parentMember != null) && !parentMember.isAll()) { return Util.makeFqName( getUniqueNameWithoutAll(parentMember), member.getName()); } else { return Util.makeFqName(member.getHierarchy(), member.getName()); } }
static List<Member> periodsToDate( Evaluator evaluator, Level level, Member member) { if (member == null) { member = evaluator.getContext(level.getHierarchy()); } Member m = member; while (m != null) { if (m.getLevel() == level) { break; } m = m.getParentMember(); } // If m == null, then "level" was lower than member's level. // periodsToDate([Time].[Quarter], [Time].[1997] is valid, // but will return an empty List List<Member> members = new ArrayList<Member>(); if (m != null) { // e.g. m is [Time].[1997] and member is [Time].[1997].[Q1].[3] // we now have to make m to be the first member of the range, // so m becomes [Time].[1997].[Q1].[1] SchemaReader reader = evaluator.getSchemaReader(); m = Util.getFirstDescendantOnLevel(reader, m, member.getLevel()); reader.getMemberRange(level, m, member, members); } return members; }
private Member getCalculatedChild( Member parent, String childName, Evaluator evaluator) { final SchemaReader schemaReader = evaluator.getQuery().getSchemaReader(true); Level childLevel = parent.getLevel().getChildLevel(); if (childLevel == null) { return parent.getHierarchy().getNullMember(); } List<Member> calcMemberList = schemaReader.getCalculatedMembers(childLevel); for (Member child : calcMemberList) { // the parent check is required in case there are parallel children // with the same names if (child.getParentMember().equals(parent) && child.getName().equals(childName)) { return child; } } return parent.getHierarchy().getNullMember(); } }
public Member evaluateMember(Evaluator evaluator) { Member member; int lagValue = lagValueCalc.evaluateInteger(evaluator); Level ancestorLevel; if (ancestorLevelCalc != null) { ancestorLevel = ancestorLevelCalc.evaluateLevel(evaluator); if (memberCalc == null) { member = evaluator.getContext(ancestorLevel.getHierarchy()); } else { member = memberCalc.evaluateMember(evaluator); } } else { member = memberCalc.evaluateMember(evaluator); Member parent = member.getParentMember(); if (parent == null) { // This is a root member, // so there is no parallelperiod. return member.getHierarchy().getNullMember(); } ancestorLevel = parent.getLevel(); } return parallelPeriod( member, ancestorLevel, evaluator, lagValue); } };