Java tutorial
/* // This software is subject to the terms of the Eclipse Public License v1.0 // Agreement, available at the following URL: // http://www.eclipse.org/legal/epl-v10.html. // You must accept the terms of that agreement to use this software. // // Copyright (C) 2001-2005 Julian Hyde // Copyright (C) 2005-2013 Pentaho and others // All Rights Reserved. */ package mondrian.rolap; import mondrian.calc.Calc; import mondrian.mdx.ResolvedFunCall; import mondrian.olap.*; import mondrian.olap.fun.AggregateFunDef; import mondrian.olap.fun.VisualTotalsFunDef; import mondrian.server.Locus; import mondrian.spi.PropertyFormatter; import mondrian.util.*; import org.apache.commons.collections.map.Flat3Map; import org.apache.log4j.Logger; import org.eigenbase.util.property.StringProperty; import java.math.BigDecimal; import java.util.*; /** * Basic implementation of a member in a {@link RolapHierarchy}. * * @author jhyde * @since 10 August, 2001 */ public class RolapMemberBase extends MemberBase implements RolapMember { /** * For members of a level with an ordinal expression defined, the * value of that expression for this member as retrieved via JDBC; * otherwise null. */ private Comparable orderKey; private Boolean isParentChildLeaf; private static final Logger LOGGER = Logger.getLogger(RolapMember.class); /** * Sets a member's parent. * * <p>Can screw up the caching structure. Only to be called by * {@link mondrian.olap.CacheControl#createMoveCommand}. * * <p>New parent must be in same level as old parent. * * @param parentMember New parent member * * @see #getParentMember() * @see #getParentUniqueName() */ void setParentMember(RolapMember parentMember) { final RolapMember previousParentMember = getParentMember(); if (previousParentMember.getLevel() != parentMember.getLevel()) { throw new IllegalArgumentException("new parent belongs to different level than old"); } this.parentMember = parentMember; } /** Ordinal of the member within the hierarchy. Some member readers do not * use this property; in which case, they should leave it as its default, * -1. */ private int ordinal; private final Object key; /** * Maps property name to property value. * * <p> We expect there to be a lot of members, but few of them will * have properties. So to reduce memory usage, when empty, this is set to * an immutable empty set. */ private Map<String, Object> mapPropertyNameToValue; private Boolean containsAggregateFunction = null; /** * Creates a RolapMemberBase. * * @param parentMember Parent member * @param level Level this member belongs to * @param key Key to this member in the underlying RDBMS * @param name Name of this member * @param memberType Type of member */ protected RolapMemberBase(RolapMember parentMember, RolapLevel level, Object key, String name, MemberType memberType) { super(parentMember, level, memberType); assert key != null; assert !(parentMember instanceof RolapCubeMember) || this instanceof RolapCalculatedMember || this instanceof VisualTotalsFunDef.VisualTotalMember; if (key instanceof byte[]) { // Some drivers (e.g. Derby) return byte arrays for binary columns // but byte arrays do not implement Comparable this.key = new String((byte[]) key); } else { this.key = key; } this.ordinal = -1; this.mapPropertyNameToValue = Collections.emptyMap(); if (name != null && !(key != null && name.equals(key.toString()))) { // Save memory by only saving the name as a property if it's // different from the key. setProperty(Property.NAME.name, name); } else if (key != null) { setUniqueName(key); } } protected RolapMemberBase() { super(); this.key = RolapUtil.sqlNullValue; } RolapMemberBase(RolapMember parentMember, RolapLevel level, Object value) { this(parentMember, level, value, null, MemberType.REGULAR); assert !(level instanceof RolapCubeLevel); } protected Logger getLogger() { return LOGGER; } public RolapLevel getLevel() { return (RolapLevel) level; } public RolapHierarchy getHierarchy() { return (RolapHierarchy) level.getHierarchy(); } public RolapMember getParentMember() { return (RolapMember) super.getParentMember(); } // Regular members do not have annotations. Measures and calculated members // do, so they override this method. public Map<String, Annotation> getAnnotationMap() { return Collections.emptyMap(); } public int hashCode() { return getUniqueName().hashCode(); } public boolean equals(Object o) { if (o == this) { return true; } if (o instanceof RolapMemberBase && equals((RolapMemberBase) o)) { return true; } if (o instanceof RolapCubeMember && equals(((RolapCubeMember) o).getRolapMember())) { // TODO: remove, RolapCubeMember should never meet RolapMember assert !Bug.BugSegregateRolapCubeMemberFixed; return true; } return false; } public boolean equals(OlapElement o) { return (o instanceof RolapMemberBase) && equals((RolapMemberBase) o); } private boolean equals(RolapMemberBase that) { assert that != null; // public method should have checked // Do not use equalsIgnoreCase; unique names should be identical, and // hashCode assumes this. return this.getUniqueName().equals(that.getUniqueName()); } void makeUniqueName(HierarchyUsage hierarchyUsage) { if (parentMember == null && key != null) { String n = hierarchyUsage.getName(); if (n != null) { String name = keyToString(key); n = Util.quoteMdxIdentifier(n); this.uniqueName = Util.makeFqName(n, name); if (getLogger().isDebugEnabled()) { getLogger().debug("RolapMember.makeUniqueName: uniqueName=" + uniqueName); } } } } protected void setUniqueName(Object key) { String name = keyToString(key); // Drop the '[All Xxxx]' segment in regular members. // Keep the '[All Xxxx]' segment in the 'all' member. // Keep the '[All Xxxx]' segment in calc members. // Drop it in visual-totals and parent-child members (which are flagged // as calculated, but do have a data member). if (parentMember == null || (parentMember.isAll() && (!isCalculated() || this instanceof VisualTotalsFunDef.VisualTotalMember || getDataMember() != null))) { final RolapHierarchy hierarchy = getHierarchy(); final Dimension dimension = hierarchy.getDimension(); final RolapLevel level = getLevel(); if (dimension.getDimensionType() != null && (dimension.getDimensionType().equals(DimensionType.MeasuresDimension) && hierarchy.getName().equals(dimension.getName()))) { // Kludge to ensure that calc members are called // [Measures].[Foo] not [Measures].[Measures].[Foo]. We can // remove this code when we revisit the scheme to generate // member unique names. this.uniqueName = Util.makeFqName(dimension, name); } else { if (name.equals(level.getName())) { this.uniqueName = Util.makeFqName(Util.makeFqName(hierarchy.getUniqueName(), level.getName()), name); } else { this.uniqueName = Util.makeFqName(hierarchy, name); } } } else { this.uniqueName = Util.makeFqName(parentMember, name); } } public boolean isCalculatedInQuery() { return false; } public String getName() { final Object name = getPropertyValue(Property.NAME.name); return (name != null) ? String.valueOf(name) : keyToString(key); } public void setName(String name) { throw new Error("unsupported"); } /** * Sets a property of this member to a given value. * * <p>WARNING: Setting system properties such as "$name" may have nasty * side-effects. */ public synchronized void setProperty(String name, Object value) { if (name.equals(Property.CAPTION.name)) { setCaption((String) value); return; } if (mapPropertyNameToValue.isEmpty()) { // the empty map is shared and immutable; create our own PropertyValueMapFactory factory = PropertyValueMapFactoryFactory.getPropertyValueMapFactory(); mapPropertyNameToValue = factory.create(this); } if (name.equals(Property.NAME.name)) { if (value == null) { value = RolapUtil.mdxNullLiteral(); } setUniqueName(value); } if (name.equals(Property.MEMBER_ORDINAL.name)) { String ordinal = (String) value; if (ordinal.startsWith("\"") && ordinal.endsWith("\"")) { ordinal = ordinal.substring(1, ordinal.length() - 1); } final double d = Double.parseDouble(ordinal); setOrdinal((int) d); } mapPropertyNameToValue.put(name, value); } public Object getPropertyValue(String propertyName) { return getPropertyValue(propertyName, true); } public Object getPropertyValue(String propertyName, boolean matchCase) { Property property = Property.lookup(propertyName, matchCase); if (property != null) { Schema schema; Member parentMember; List<RolapMember> list; switch (property.ordinal) { case Property.NAME_ORDINAL: // Do NOT call getName() here. This property is internal, // and must fall through to look in the property list. break; case Property.CAPTION_ORDINAL: return getCaption(); case Property.CONTRIBUTING_CHILDREN_ORDINAL: list = new ArrayList<RolapMember>(); getHierarchy().getMemberReader().getMemberChildren(this, list); return list; case Property.CATALOG_NAME_ORDINAL: // TODO: can't go from member to connection thence to // Connection.getCatalogName() break; case Property.SCHEMA_NAME_ORDINAL: schema = getHierarchy().getDimension().getSchema(); return schema.getName(); case Property.CUBE_NAME_ORDINAL: // TODO: can't go from member to cube cube yet break; case Property.DIMENSION_UNIQUE_NAME_ORDINAL: return getHierarchy().getDimension().getUniqueName(); case Property.HIERARCHY_UNIQUE_NAME_ORDINAL: return getHierarchy().getUniqueName(); case Property.LEVEL_UNIQUE_NAME_ORDINAL: return getLevel().getUniqueName(); case Property.LEVEL_NUMBER_ORDINAL: return getLevel().getDepth(); case Property.MEMBER_UNIQUE_NAME_ORDINAL: return getUniqueName(); case Property.MEMBER_NAME_ORDINAL: return getName(); case Property.MEMBER_TYPE_ORDINAL: return getMemberType().ordinal(); case Property.MEMBER_GUID_ORDINAL: return null; case Property.MEMBER_CAPTION_ORDINAL: return getCaption(); case Property.MEMBER_ORDINAL_ORDINAL: return getOrdinal(); case Property.CHILDREN_CARDINALITY_ORDINAL: return Locus.execute(((RolapSchema) level.getDimension().getSchema()).getInternalConnection(), "Member.CHILDREN_CARDINALITY", new Locus.Action<Integer>() { public Integer execute() { if (isAll() && childLevelHasApproxRowCount()) { return getLevel().getChildLevel().getApproxRowCount(); } else { ArrayList<RolapMember> list = new ArrayList<RolapMember>(); getHierarchy().getMemberReader().getMemberChildren(RolapMemberBase.this, list); return list.size(); } } }); case Property.PARENT_LEVEL_ORDINAL: parentMember = getParentMember(); return parentMember == null ? 0 : parentMember.getLevel().getDepth(); case Property.PARENT_UNIQUE_NAME_ORDINAL: parentMember = getParentMember(); return parentMember == null ? null : parentMember.getUniqueName(); case Property.PARENT_COUNT_ORDINAL: parentMember = getParentMember(); return parentMember == null ? 0 : 1; case Property.VISIBLE_ORDINAL: break; case Property.MEMBER_KEY_ORDINAL: case Property.KEY_ORDINAL: return this == this.getHierarchy().getAllMember() ? 0 : getKey(); case Property.SCENARIO_ORDINAL: return ScenarioImpl.forMember(this); default: break; // fall through } } return getPropertyFromMap(propertyName, matchCase); } /** * Returns the value of a property by looking it up in the property map. * * @param propertyName Name of property * @param matchCase Whether to match name case-sensitive * @return Property value */ protected Object getPropertyFromMap(String propertyName, boolean matchCase) { synchronized (this) { if (matchCase) { return mapPropertyNameToValue.get(propertyName); } else { for (String key : mapPropertyNameToValue.keySet()) { if (key.equalsIgnoreCase(propertyName)) { return mapPropertyNameToValue.get(key); } } return null; } } } protected boolean childLevelHasApproxRowCount() { return getLevel().getChildLevel().getApproxRowCount() > Integer.MIN_VALUE; } /** * @deprecated Use {@link #isAll}; will be removed in mondrian-4.0 */ public boolean isAllMember() { return getLevel().getHierarchy().hasAll() && getLevel().getDepth() == 0; } public Property[] getProperties() { return getLevel().getInheritedProperties(); } public int getOrdinal() { return ordinal; } public Comparable getOrderKey() { return orderKey; } void setOrdinal(int ordinal) { if (this.ordinal == -1) { this.ordinal = ordinal; } } void setOrderKey(Comparable orderKey) { this.orderKey = orderKey; } private void resetOrdinal() { this.ordinal = -1; } public Object getKey() { return this.key; } /** * Compares this member to another {@link RolapMemberBase}. * * <p>The method first compares on keys; null keys always collate last. * If the keys are equal, it compares using unique name. * * <p>This method does not consider {@link #ordinal} field, because * ordinal is only unique within a parent. If you want to compare * members which may be at any position in the hierarchy, use * {@link mondrian.olap.fun.FunUtil#compareHierarchically}. * * @return -1 if this is less, 0 if this is the same, 1 if this is greater */ public int compareTo(Object o) { RolapMemberBase other = (RolapMemberBase) o; assert this.key != null && other.key != null; if (this.key == RolapUtil.sqlNullValue && other.key == RolapUtil.sqlNullValue) { // if both keys are null, they are equal. // compare by unique name. return this.getName().compareTo(other.getName()); } if (other.key == RolapUtil.sqlNullValue) { // not null is greater than null return 1; } if (this.key == RolapUtil.sqlNullValue) { // null is less than not null return -1; } // as both keys are not null, compare by key // String, Double, Integer should be possible // any key object should be "Comparable" // anyway - keys should be of the same class if (this.key.getClass().equals(other.key.getClass())) { if (this.key instanceof String) { // use a special case sensitive compare name which // first compares w/o case, and if 0 compares with case return Util.caseSensitiveCompareName((String) this.key, (String) other.key); } else { return Util.compareKey(this.key, other.key); } } // Compare by unique name in case of different key classes. // This is possible, if a new calculated member is created // in a dimension with an Integer key. The calculated member // has a key of type String. return this.getUniqueName().compareTo(other.getUniqueName()); } public boolean isHidden() { final RolapLevel rolapLevel = getLevel(); switch (rolapLevel.getHideMemberCondition()) { case Never: return false; case IfBlankName: { // If the key value in the database is null, then we use // a special key value whose toString() is "null". final String name = getName(); return name.equals(RolapUtil.mdxNullLiteral()) || Util.isBlank(name); } case IfParentsName: { final Member parentMember = getParentMember(); if (parentMember == null) { return false; } final String parentName = parentMember.getName(); final String name = getName(); return (parentName == null ? "" : parentName).equals(name == null ? "" : name); } default: throw Util.badValue(rolapLevel.getHideMemberCondition()); } } public int getDepth() { return getLevel().getDepth(); } public String getPropertyFormattedValue(String propertyName) { // do we have a formatter ? if yes, use it Property[] props = getLevel().getProperties(); Property prop = null; for (Property prop1 : props) { if (prop1.getName().equals(propertyName)) { prop = prop1; break; } } PropertyFormatter pf; if (prop != null && (pf = prop.getFormatter()) != null) { return pf.formatProperty(this, propertyName, getPropertyValue(propertyName)); } Object val = getPropertyValue(propertyName); if (val != null && val instanceof Number) { // Numbers are a special case. We don't want any // scientific notations, so we wrap in a BigDecimal // before calling toString. This is cheap to perform here // because this method only gets called by the GUI. val = new BigDecimal(((Number) val).doubleValue()); } return (val == null) ? "" : val.toString(); } public boolean isParentChildLeaf() { if (isParentChildLeaf == null) { isParentChildLeaf = getLevel().isParentChild() && getDimension().getSchema().getSchemaReader().getMemberChildren(this).size() == 0; } return isParentChildLeaf; } /** * Returns a list of member lists where the first member * list is the root members while the last member array is the * leaf members. * * <p>If you know that you will need to get all or most of the members of * a hierarchy, then calling this which gets all of the hierarchy's * members all at once is much faster than getting members one at * a time. * * @param schemaReader Schema reader * @param hierarchy Hierarchy * @return List of arrays of members */ public static List<List<Member>> getAllMembers(SchemaReader schemaReader, Hierarchy hierarchy) { long start = System.currentTimeMillis(); try { // Getting the members by Level is the fastest way that I could // find for getting all of a hierarchy's members. List<List<Member>> list = new ArrayList<List<Member>>(); Level[] levels = hierarchy.getLevels(); for (Level level : levels) { List<Member> members = schemaReader.getLevelMembers(level, true); if (members != null) { list.add(members); } } return list; } finally { if (LOGGER.isDebugEnabled()) { long end = System.currentTimeMillis(); LOGGER.debug("RolapMember.getAllMembers: time=" + (end - start)); } } } public static int getHierarchyCardinality(SchemaReader schemaReader, Hierarchy hierarchy) { int cardinality = 0; Level[] levels = hierarchy.getLevels(); for (Level level1 : levels) { cardinality += schemaReader.getLevelCardinality(level1, true, true); } return cardinality; } /** * Sets member ordinal values using a Bottom-up/Top-down algorithm. * * <p>Gets an array of members for each level and traverses * array for the lowest level, setting each member's * parent's parent's etc. member's ordinal if not set working back * down to the leaf member and then going to the next leaf member * and traversing up again. * * <p>The above algorithm only works for a hierarchy that has all of its * leaf members in the same level (that is, a non-ragged hierarchy), which * is the norm. After all member ordinal values have been set, traverses * the array of members, making sure that all members' ordinals have been * set. If one is found that is not set, then one must to a full Top-down * setting of the ordinals. * * <p>The Bottom-up/Top-down algorithm is MUCH faster than the Top-down * algorithm. * * @param schemaReader Schema reader * @param seedMember Member */ public static void setOrdinals(SchemaReader schemaReader, Member seedMember) { seedMember = RolapUtil.strip((RolapMember) seedMember); // The following are times for executing different set ordinals // algorithms for both the FoodMart Sales cube/Store dimension // and a Large Data set with a dimension with about 250,000 members. // // Times: // Original setOrdinals Top-down // Foodmart: 63ms // Large Data set: 651865ms // Calling getAllMembers before calling original setOrdinals // Top-down // Foodmart: 32ms // Large Data set: 73880ms // Bottom-up/Top-down // Foodmart: 17ms // Large Data set: 4241ms long start = System.currentTimeMillis(); try { Hierarchy hierarchy = seedMember.getHierarchy(); int ordinal = hierarchy.hasAll() ? 1 : 0; List<List<Member>> levelMembers = getAllMembers(schemaReader, hierarchy); List<Member> leafMembers = levelMembers.get(levelMembers.size() - 1); levelMembers = levelMembers.subList(0, levelMembers.size() - 1); // Set all ordinals for (Member child : leafMembers) { ordinal = bottomUpSetParentOrdinals(ordinal, child); ordinal = setOrdinal(child, ordinal); } boolean needsFullTopDown = needsFullTopDown(levelMembers); // If we must to a full Top-down, then first reset all ordinal // values to -1, and then call the Top-down if (needsFullTopDown) { for (List<Member> members : levelMembers) { for (Member member : members) { if (member instanceof RolapMemberBase) { ((RolapMemberBase) member).resetOrdinal(); } } } // call full Top-down setOrdinalsTopDown(schemaReader, seedMember); } } finally { if (LOGGER.isDebugEnabled()) { long end = System.currentTimeMillis(); LOGGER.debug("RolapMember.setOrdinals: time=" + (end - start)); } } } /** * Returns whether the ordinal assignment algorithm needs to perform * the more expensive top-down algorithm. If the hierarchy is 'uneven', not * all leaf members are at the same level, then bottom-up setting of * ordinals will have missed some. * * @param levelMembers Array containing the list of members in each level * except the leaf level * @return whether we need to apply the top-down ordinal assignment */ private static boolean needsFullTopDown(List<List<Member>> levelMembers) { for (List<Member> members : levelMembers) { for (Member member : members) { if (member.getOrdinal() == -1) { return true; } } } return false; } /** * 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; } private static int setOrdinal(Member member, int ordinal) { if (member instanceof RolapMemberBase) { ((RolapMemberBase) member).setOrdinal(ordinal++); } else { // TODO LOGGER.warn("RolapMember.setAllChildren: NOT RolapMember " + "member.name=" + member.getName() + ", member.class=" + member.getClass().getName() + ", ordinal=" + ordinal); ordinal++; } return ordinal; } /** * Sets ordinals of a complete member hierarchy as required by the * MEMBER_ORDINAL XMLA element using a depth-first algorithm. * * <p>For big hierarchies it takes a bunch of time. SQL Server is * relatively fast in comparison so it might be storing such * information in the DB. * * @param schemaReader Schema reader * @param member Member */ private static void setOrdinalsTopDown(SchemaReader schemaReader, Member member) { long start = System.currentTimeMillis(); try { Member parent = schemaReader.getMemberParent(member); if (parent == null) { // top of the world int ordinal = 0; List<Member> siblings = schemaReader.getHierarchyRootMembers(member.getHierarchy()); for (Member sibling : siblings) { ordinal = setAllChildren(ordinal, schemaReader, sibling); } } else { setOrdinalsTopDown(schemaReader, parent); } } finally { if (LOGGER.isDebugEnabled()) { long end = System.currentTimeMillis(); LOGGER.debug("RolapMember.setOrdinalsTopDown: time=" + (end - start)); } } } private static int setAllChildren(int ordinal, SchemaReader schemaReader, Member member) { ordinal = setOrdinal(member, ordinal); List<Member> children = schemaReader.getMemberChildren(member); for (Member child : children) { ordinal = setAllChildren(ordinal, schemaReader, child); } return ordinal; } /** * Converts a key to a string to be used as part of the member's name * and unique name. * * <p>Usually, it just calls {@link Object#toString}. But if the key is an * integer value represented in a floating-point column, we'd prefer the * integer value. For example, one member of the * <code>[Sales].[Store SQFT]</code> dimension comes out "20319.0" but we'd * like it to be "20319". */ protected static String keyToString(Object key) { String name; if (key == null || RolapUtil.sqlNullValue.equals(key)) { name = RolapUtil.mdxNullLiteral(); } else if (key instanceof Id.NameSegment) { name = ((Id.NameSegment) key).name; } else { name = key.toString(); } if ((key instanceof Number) && name.endsWith(".0")) { name = name.substring(0, name.length() - 2); } return name; } /** * <p>Interface definition for the pluggable factory used to decide * which implementation of {@link java.util.Map} to use to store * property string/value pairs for member properties.</p> * * <p>This permits tuning for performance, memory allocation, etcetera. * For example, if a member belongs to a level which has 10 member * properties a HashMap may be preferred, while if the level has * only two member properties a Flat3Map may make more sense.</p> */ public interface PropertyValueMapFactory { /** * Creates a {@link java.util.Map} to be used for storing * property string/value pairs for the specified * {@link mondrian.olap.Member}. * * @param member Member * @return the Map instance to store property/value pairs */ Map<String, Object> create(Member member); } /** * Default {@link RolapMemberBase.PropertyValueMapFactory} * implementation, used if * {@link mondrian.olap.MondrianProperties#PropertyValueMapFactoryClass} * is not set. */ public static final class DefaultPropertyValueMapFactory implements PropertyValueMapFactory { /** * {@inheritDoc} * <p>This factory creates an * {@link org.apache.commons.collections.map.Flat3Map} if * it appears that the provided member has less than 3 properties, * and a {@link java.util.HashMap} if it appears * that it has more than 3.</p> * * <p>Guessing the number of properties * can be tricky since some subclasses of * {@link mondrian.olap.Member}</p> have additional properties * that aren't explicitly declared. The most common offenders * are the (@link mondrian.olap.Measure} implementations, which * often have 4 or more undeclared properties, so if the member * is a measure, the factory will create a {@link java.util.HashMap}. * </p> * * @param member {@inheritDoc} * @return {@inheritDoc} */ @SuppressWarnings({ "unchecked" }) public Map<String, Object> create(Member member) { assert member != null; Property[] props = member.getProperties(); if ((member instanceof RolapMeasure) || (props == null) || (props.length > 3)) { return new HashMap<String, Object>(); } else { return new Flat3Map(); } } } /** * <p>Creates the PropertyValueMapFactory which is in turn used * to create property-value maps for member properties.</p> * * <p>The name of the PropertyValueMapFactory is drawn from * {@link mondrian.olap.MondrianProperties#PropertyValueMapFactoryClass} * in mondrian.properties. If unset, it defaults to * {@link RolapMemberBase.DefaultPropertyValueMapFactory}. </p> */ public static final class PropertyValueMapFactoryFactory extends ObjectFactory.Singleton<PropertyValueMapFactory> { /** * Single instance of the <code>PropertyValueMapFactory</code>. */ private static final PropertyValueMapFactoryFactory factory; static { factory = new PropertyValueMapFactoryFactory(); } /** * Access the <code>PropertyValueMapFactory</code> instance. * * @return the <code>Map</code>. */ public static PropertyValueMapFactory getPropertyValueMapFactory() { return factory.getObject(); } /** * The constructor for the <code>PropertyValueMapFactoryFactory</code>. * This passes the <code>PropertyValueMapFactory</code> class to the * <code>ObjectFactory</code> base class. */ @SuppressWarnings({ "unchecked" }) private PropertyValueMapFactoryFactory() { super((Class) PropertyValueMapFactory.class); } protected StringProperty getStringProperty() { return MondrianProperties.instance().PropertyValueMapFactoryClass; } protected PropertyValueMapFactory getDefault(Class[] parameterTypes, Object[] parameterValues) throws CreationException { return new DefaultPropertyValueMapFactory(); } } public boolean containsAggregateFunction() { // searching for agg functions is expensive, so cache result if (containsAggregateFunction == null) { containsAggregateFunction = foundAggregateFunction(getExpression()); } return containsAggregateFunction; } /** * Returns whether an expression contains a call to an aggregate * function such as "Aggregate" or "Sum". * * @param exp Expression * @return Whether expression contains a call to an aggregate function. */ private static boolean foundAggregateFunction(Exp exp) { if (exp instanceof ResolvedFunCall) { ResolvedFunCall resolvedFunCall = (ResolvedFunCall) exp; if (resolvedFunCall.getFunDef() instanceof AggregateFunDef) { return true; } else { for (Exp argExp : resolvedFunCall.getArgs()) { if (foundAggregateFunction(argExp)) { return true; } } } } return false; } public Calc getCompiledExpression(RolapEvaluatorRoot root) { return root.getCompiled(getExpression(), true, null); } public int getHierarchyOrdinal() { return getHierarchy().getOrdinalInCube(); } public void setContextIn(RolapEvaluator evaluator) { final RolapMember defaultMember = evaluator.root.defaultMembers[getHierarchyOrdinal()]; // This method does not need to call RolapEvaluator.removeCalcMember. // That happens implicitly in setContext. evaluator.setContext(defaultMember); evaluator.setExpanding(this); } } // End RolapMemberBase.java