public String getUniqueName() { return dimension.getUniqueName(); }
public String toString() { return dimension.getUniqueName(); }
/** * Creates a type representing a dimension. * * @param dimension Dimension that values of this type must belong to, or * null if the dimension is unknown */ public DimensionType(Dimension dimension) { this.dimension = dimension; StringBuilder buf = new StringBuilder("DimensionType<"); if (dimension != null) { buf.append("dimension=").append(dimension.getUniqueName()); } buf.append(">"); this.digest = buf.toString(); }
/** * Finds out non joining dimensions for this cube. Equality test for * dimensions is done based on the unique name. Object equality can't be * used. * * @param otherDims Set of dimensions to be tested for existence in this * cube * @return Set of dimensions that do not exist (non joining) in this cube */ public Set<Dimension> nonJoiningDimensions(Set<Dimension> otherDims) { Dimension[] baseCubeDimensions = getDimensions(); Set<String> baseCubeDimNames = new HashSet<String>(); for (Dimension baseCubeDimension : baseCubeDimensions) { baseCubeDimNames.add(baseCubeDimension.getUniqueName()); } Set<Dimension> nonJoiningDimensions = new HashSet<Dimension>(); for (Dimension otherDim : otherDims) { if (!baseCubeDimNames.contains(otherDim.getUniqueName())) { nonJoiningDimensions.add(otherDim); } } return nonJoiningDimensions; }
/** * 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(Dimension dimension) { Access access = Access.NONE; for (Role role : roleList) { access = max(access, role.getAccess(dimension)); if (access == Access.ALL) { break; } } LOGGER.debug( "Access level " + access + " granted to dimension " + dimension.getUniqueName() + " because of a union of roles."); return access; }
Util.assertPrecondition(isMutable(), "isMutable()"); LOGGER.trace( "Grant " + access + " on dimension " + dimension.getUniqueName()); dimensionGrants.put(dimension, access);
buf.append("hierarchy=").append(hierarchy.getUniqueName()); } else if (dimension != null) { buf.append("dimension=").append(dimension.getUniqueName());
/** * Sorts a list of members into hierarchical order. The members must belong * to the same dimension. * * @param memberList List of members * @param post Whether to sort in post order; if false, sorts in pre order * * @see #hierarchizeTupleList(mondrian.calc.TupleList, boolean) */ public static void hierarchizeMemberList( List<Member> memberList, boolean post) { if (memberList.size() <= 1) { return; } Dimension dimension = memberList.get(0).getDimension(); if (dimension.isHighCardinality()) { LOGGER.warn( MondrianResource.instance() .HighCardinalityInDimension.str( dimension.getUniqueName())); return; } Comparator<Member> comparator = new HierarchizeComparator(post); Collections.sort(memberList, comparator); }
? dimension.getUniqueName() : Util.makeFqName(dimension, this.name); } else { this.uniqueName = dimension.getUniqueName(); } else { this.uniqueName = dimension.getUniqueName();
private boolean isAxisHighCardinality( int axisOrdinal, TupleList tupleList) { Boolean highCardinality = positionsHighCardinality.get(axisOrdinal); if (highCardinality != null) { return highCardinality; } highCardinality = false; //noinspection LoopStatementThatDoesntLoop List<Member> tuple = !tupleList.isEmpty() ? tupleList.get(0) : null; if (tuple != null && !tuple.isEmpty()) { Dimension dimension = tuple.get(0).getDimension(); highCardinality = dimension.isHighCardinality(); if (highCardinality) { LOGGER.warn( MondrianResource.instance() .HighCardinalityInDimension.str( dimension.getUniqueName())); } } positionsHighCardinality.put(axisOrdinal, highCardinality); return highCardinality; }
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; }
buf.append("hierarchy=").append(hierarchy.getUniqueName()); } else if (dimension != null) { buf.append("dimension=").append(dimension.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 dimension " + level.getDimension().getUniqueName()); return access;
LOGGER.trace( "Cascading grant CUSTOM on dimension " + hierarchy.getDimension().getUniqueName() + " because of the grant to hierarchy" + hierarchy.getUniqueName());
/** * 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(); } }
public List<RolapMember> getMembersInLevel( RolapLevel level, TupleConstraint constraint) { if (level.isAll()) { return Collections.singletonList(hierarchy.getAllMember()); } Dimension dimension = level.getDimension(); boolean isHighCardinality = dimension.isHighCardinality(); final TupleReader tupleReader = isHighCardinality ? new HighCardSqlTupleReader(constraint) : new SqlTupleReader(constraint); if (isHighCardinality) { LOGGER.warn( MondrianResource.instance() .HighCardinalityInDimension.str( dimension.getUniqueName())); } tupleReader.addLevelMembers(level, this, null); final TupleList tupleList = tupleReader.readMembers(dataSource, null, null); assert tupleList.getArity() == 1; return Util.cast(tupleList.slice(0)); }
.HighCardinalityInDimension.str( tupleList.get(0).get(0).getDimension() .getUniqueName())); filteredTupleList = new DelegatingTupleList(
MondrianResource.instance() .HighCardinalityInDimension.str( dimension.getUniqueName())); return list;