headings.add( hierarchy.getUniqueName() );
headings.add( rowMember.getHierarchy().getUniqueName() );
public String getUniqueName() { return hierarchy.getUniqueName(); }
public String toString() { return hierarchy.getUniqueName(); }
public boolean isHierarchyAllowed(Hierarchy mdxHierarchy) { String hierName = mdxHierarchy.getUniqueName(); if (noAccessHierarchies == null || hierName == null) { return true; } for (Hierarchy noAccessHierarchy : noAccessHierarchies) { if (hierName.equalsIgnoreCase(noAccessHierarchy.getUniqueName())) { return false; } } return true; }
/** * Returns whether two hierarchies are equal. * * @param hierarchy1 First hierarchy * @param hierarchy2 Second hierarchy * @return Whether hierarchies are equal */ private static boolean equal( final Hierarchy hierarchy1, final Hierarchy hierarchy2) { return hierarchy1 == null || hierarchy2 == null || hierarchy2.getUniqueName().equals( hierarchy1.getUniqueName()); }
public Member getLimitedMemberForHierarchy(Hierarchy mdxHierarchy) { String hierName = mdxHierarchy.getUniqueName(); if (limitedMembers == null || hierName == null) { return null; } for (Member limitedMember : limitedMembers) { Hierarchy limitedHierarchy = limitedMember.getHierarchy(); if (hierName.equalsIgnoreCase(limitedHierarchy.getUniqueName())) { return limitedMember; } } return null; }
/** * Creates a type representing a hierarchy. * * @param dimension Dimension that values of this type must belong to, or * null if the dimension is unknown * @param hierarchy Hierarchy that values of this type must belong to, * null if the hierarchy is unknown */ public HierarchyType(Dimension dimension, Hierarchy hierarchy) { this.dimension = dimension; this.hierarchy = hierarchy; StringBuilder buf = new StringBuilder("HierarchyType<"); if (hierarchy != null) { buf.append("hierarchy=").append(hierarchy.getUniqueName()); } else if (dimension != null) { buf.append("dimension=").append(dimension.getUniqueName()); } buf.append(">"); this.digest = buf.toString(); }
public Access getAccess(Hierarchy hierarchy) { Access access = Access.NONE; for (Role role : roleList) { access = max(access, role.getAccess(hierarchy)); if (access == Access.ALL) { break; } } LOGGER.debug( "Access level " + access + " granted to hierarchy " + hierarchy.getUniqueName() + " because of a union of roles."); return access; }
public Access getAccess(Hierarchy hierarchy) { assert hierarchy != null; HierarchyAccessImpl hierarchyAccess = hierarchyGrants.get(hierarchy); if (hierarchyAccess != null) { LOGGER.trace( "Access level " + hierarchyAccess.access + " granted to dimension " + hierarchy.getUniqueName()); return hierarchyAccess.access; } // There was no explicit rule for this particular hierarchy. // Let's check the parent dimension. Access access = getAccess(hierarchy.getDimension()); if (access == Access.ALL) { // Access levels of 'none' and 'custom' are not enough. LOGGER.trace( "Access level ALL " + " granted to hierarchy " + hierarchy.getUniqueName() + " because of the grant to dimension " + hierarchy.getDimension().getUniqueName()); return Access.ALL; } // Access denied, since we know that the dimension check has // checked for its parents as well. LOGGER.trace( "Access denided to hierarchy " + hierarchy.getUniqueName()); return Access.NONE; }
public Hierarchy lookupHierarchy(Id.NameSegment s, boolean unique) { for (Dimension dimension : dimensions) { Hierarchy[] hierarchies = dimension.getHierarchies(); for (Hierarchy hierarchy : hierarchies) { String name = unique ? hierarchy.getUniqueName() : hierarchy.getName(); if (name.equals(s.getName())) { return hierarchy; } } } return null; }
private static void validateSlicerMembers( Hierarchy hierarchy, Evaluator evaluator) { if (evaluator instanceof RolapEvaluator) { RolapEvaluator rev = (RolapEvaluator) evaluator; Map<Hierarchy, Set<Member>> map = Util.getMembersToHierarchyMap(rev.getSlicerMembers()); Set<Member> members = map.get(hierarchy); if (members != null && members.size() > 1) { throw MondrianResource.instance() .CurrentMemberWithCompoundSlicer.ex( hierarchy.getUniqueName()); } } } }
buf.append("level=").append(level.getUniqueName()); } else if (hierarchy != null) { buf.append("hierarchy=").append(hierarchy.getUniqueName()); } else if (dimension != null) { buf.append("dimension=").append(dimension.getUniqueName());
public static boolean matches( Member member, List<Id.Segment> nameParts) { if (Util.equalName(Util.implode(nameParts), member.getUniqueName())) { // exact match return true; } Id.Segment segment = nameParts.get(nameParts.size() - 1); while (member.getParentMember() != null) { if (!segment.matches(member.getName())) { return false; } member = member.getParentMember(); nameParts = nameParts.subList(0, nameParts.size() - 1); segment = nameParts.get(nameParts.size() - 1); } if (segment.matches(member.getName())) { return Util.equalName( member.getHierarchy().getUniqueName(), Util.implode(nameParts.subList(0, nameParts.size() - 1))); } else if (member.isAll()) { return Util.equalName( member.getHierarchy().getUniqueName(), Util.implode(nameParts)); } else { return false; } }
/** * Checks that there are no duplicate dimensions in a list of member types. * If so, the member types will form a valid tuple type. * If not, throws {@link mondrian.olap.MondrianException}. * * @param memberTypes Array of member types */ public static void checkHierarchies(MemberType[] memberTypes) { for (int i = 0; i < memberTypes.length; i++) { MemberType memberType = memberTypes[i]; for (int j = 0; j < i; j++) { MemberType member1 = memberTypes[j]; final Hierarchy hierarchy = memberType.getHierarchy(); final Hierarchy hierarchy1 = member1.getHierarchy(); if (hierarchy != null && hierarchy == hierarchy1) { throw MondrianResource.instance().DupHierarchiesInTuple.ex( hierarchy.getUniqueName()); } } } } }
/** * Returns the default hierarchy of a dimension, or null if there is no * default. * * @see MondrianResource#CannotImplicitlyConvertDimensionToHierarchy * * @param dimension Dimension * @return Default hierarchy, or null */ public static Hierarchy getDimensionDefaultHierarchy(Dimension dimension) { final Hierarchy[] hierarchies = dimension.getHierarchies(); if (hierarchies.length == 1) { return hierarchies[0]; } if (MondrianProperties.instance().SsasCompatibleNaming.get()) { // In SSAS 2005, dimensions with more than one hierarchy do not have // a default hierarchy. return null; } for (Hierarchy hierarchy : hierarchies) { if (hierarchy.getName() == null || hierarchy.getUniqueName().equals(dimension.getUniqueName())) { return hierarchy; } } return null; }
+ " granted to level " + level.getUniqueName() + " because of the grant to hierarchy " + level.getHierarchy().getUniqueName()); return hierarchyAccess.access;
/** * Returns the unique name of the level, hierarchy, or dimension of this * type, whichever is most specific. * * @param type Type * @return Most specific description of type */ private String uniqueName(Type type) { if (type.getLevel() != null) { return type.getLevel().getUniqueName(); } else if (type.getHierarchy() != null) { return type.getHierarchy().getUniqueName(); } else { return type.getDimension().getUniqueName(); } }
MondrianResource.instance().FunctionMbrAndLevelHierarchyMismatch.ex( "ParallelPeriod", ancestorLevel.getHierarchy().getUniqueName(), member.getHierarchy().getUniqueName());
public Type getResultType(Validator validator, Exp[] args) { if (args.length == 0) { // With no args, the default implementation cannot // guess the hierarchy. RolapHierarchy defaultTimeHierarchy = ((RolapCube) validator.getQuery().getCube()).getTimeHierarchy( getName()); return new SetType(MemberType.forHierarchy(defaultTimeHierarchy)); } if (args.length >= 2) { Type hierarchyType = args[0].getType(); MemberType memberType = (MemberType) args[1].getType(); if (memberType.getHierarchy() != null && hierarchyType.getHierarchy() != null && memberType.getHierarchy() != hierarchyType.getHierarchy()) { throw Util.newError( "Type mismatch: member must belong to hierarchy " + hierarchyType.getHierarchy().getUniqueName()); } } // If we have at least one arg, it's a level which will // tell us the type. return super.getResultType(validator, args); }