public Member evaluateMember(Evaluator evaluator) { validateSlicerMembers(hierarchy, evaluator); return evaluator.getContext(hierarchy); }
public Member evaluateMember(Evaluator evaluator) { Hierarchy hierarchy = hierarchyCalc.evaluateHierarchy(evaluator); validateSlicerMembers(hierarchy, evaluator); return evaluator.getContext(hierarchy); }
/** * Returns the corresponding member from tuple, or the default member * for the hierarchy if member is not explicitly contained in the tuple. * * * @param member source member * @param tuple tuple containing the target member * @param tupleHierarchies list of the hierarchies explicitly contained * in the tuple, in the same order. * @return target member */ private static Member getCorrespondingMember( final Member member, final List<Member> tuple, final List<Hierarchy> tupleHierarchies, final Evaluator eval) { assert tuple.size() == tupleHierarchies.size(); int dimPos = tupleHierarchies.indexOf(member.getHierarchy()); if (dimPos >= 0) { return tuple.get(dimPos); } else if (eval != null) { return eval.getContext(member.getHierarchy()); } else { return member.getHierarchy().getDefaultMember(); } }
public TupleList evaluateList(Evaluator evaluator) { final Member member; final Level level; if (levelCalc == null) { member = evaluator.getContext(timeHierarchy); level = member.getLevel().getParentLevel(); } else { level = levelCalc.evaluateLevel(evaluator); if (memberCalc == null) { member = evaluator.getContext(level.getHierarchy()); } else { member = memberCalc.evaluateMember(evaluator); } } return new UnaryTupleList( periodsToDate(evaluator, level, member)); }
public Object evaluate(Evaluator evaluator) { TupleList list = AbstractAggregateFunDef .processUnrelatedDimensions( ((RolapEvaluator) evaluator) .getOptimizedSlicerTuples(null), evaluator); for (Member member : prevSlicerMembers) { if (evaluator.getContext( member.getHierarchy()) instanceof CompoundSlicerRolapMember) { evaluator.setContext(member); } } return AggregateFunDef.AggregateCalc.aggregate( valueCalc, evaluator, list); } // depend on the full evaluation context
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; }
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); } };
((RolapEvaluator) evaluator).getCube().getHierarchies(); for (RolapHierarchy hierarchy : hierarchies) { final Member member = ev.getContext(hierarchy); if (member.isAll()) { continue;