private boolean containsCalcMembers(Member[] currentMembers) { // Any calculated members which are not measures, we can't drill // through. Trivial calculated members should have been converted // already. We allow simple calculated measures such as // [Measures].[Unit Sales] / [Measures].[Store Sales] provided that both // are from the same cube. for (int i = 1; i < currentMembers.length; i++) { final Member currentMember = currentMembers[i]; if (currentMember.isCalculated()) { return true; } } return false; }
private List<Member> getCalculatedMembersFromContext( Evaluator evaluator) { Member[] currentMembers = evaluator.getMembers(); List<Member> calculatedMembers = new ArrayList<Member>(); for (Member currentMember : currentMembers) { if (currentMember.isCalculated()) { calculatedMembers.add(currentMember); } } return calculatedMembers; }
private static boolean isMemberCalculated(Member member) { // Skip calculated members (except if leaf of parent-child hier) return member.isCalculated() && !member.isParentChildLeaf(); }
/** * Removes every member from a list which is calculated. * The list must not be null, and must consist only of members. * * @param memberList Member list * @return List of non-calculated members */ static List<Member> removeCalculatedMembers(List<Member> memberList) { List<Member> clone = new ArrayList<Member>(); for (Member member : memberList) { if (member.isCalculated() && !member.isParentChildPhysicalMember()) { continue; } clone.add(member); } return clone; }
private Member getMember(Exp exp) { if (exp instanceof MemberExpr) { Member m = ((MemberExpr)exp).getMember(); if (m.isMeasure() && !m.isCalculated()) { return m; } } // Since the expression is not a base measure, we won't // attempt to determine the aggregator and will simply sum. LOGGER.warn( "Unable to determine aggregator for non-base measures " + "in 2nd parameter of Aggregate(), summing: " + exp.toString()); return null; }
/** * Finds out non joining dimensions for this cube. * Useful for finding out non joining dimensions for a stored measure from * a base cube. * * @param tuple array of members * @return Set of dimensions that do not exist (non joining) in this cube */ public Set<Dimension> nonJoiningDimensions(Member[] tuple) { Set<Dimension> otherDims = new HashSet<Dimension>(); for (Member member : tuple) { if (!member.isCalculated()) { otherDims.add(member.getDimension()); } } return nonJoiningDimensions(otherDims); }
public Object visit(MemberExpr memberExpr) { Member member = memberExpr.getMember(); if (member.isCalculated()) { if (activeMembers.add(member)) { Exp memberExp = member.getExpression(); memberExp.accept(this); activeMembers.remove(member); } } return null; } }
public static Set<Member> getMembersNestedInMeasures(Set<Member> measures) { Set<Member> membersNestedInMeasures = new HashSet<>(); for (Member m : measures) { if (m.isCalculated()) { Exp exp = m.getExpression(); exp.accept( new MemberExtractingVisitor( membersNestedInMeasures, null, false)); } } return membersNestedInMeasures; }
public static boolean containsCalculatedMember( List<Member> members, boolean allowExpandableMembers) { for (Member member : members) { if (member.isCalculated()) { if (allowExpandableMembers) { if (!isSupportedCalculatedMember(member)) { return true; } } else { return true; } } } return false; }
private void process(final Member member) { if (member.isMeasure()) { if (member.isCalculated()) { if (activeMeasures.add(member)) { Exp exp = member.getExpression(); finder.found = false; exp.accept(finder); if (! finder.found) { exp.accept(this); } activeMeasures.remove(member); } } else { queryMeasureSet.add(member); } } } }
public Object visit(MemberExpr memberExpr) { Member member = memberExpr.getMember(); if (!member.isMeasure() && !member.isCalculated()) { addMember(member); } else if (member.isCalculated()) { if (activeMembers.add(member)) { Exp exp = member.getExpression(); finder.found = false; exp.accept(finder); if (! finder.found) { exp.accept(this); } activeMembers.remove(member); } } return null; }
private boolean isNativeCompatible(Member member) { return member.isParentChildLeaf() || (!member.isMeasure() && !member.isCalculated() && !member.isAll()); }
private void mergeMember(final Member member) { this.axisCount++; if (! countOnly) { if (isSlicer) { if (! members.contains(member)) { members.add(member); } } else { if (member.isNull()) { return; } else if (member.isMeasure()) { return; } else if (member.isCalculated()) { return; } else if (member.isAll()) { return; } Member topParent = getTopParent(member); if (! this.members.contains(topParent)) { this.members.add(topParent); } } } } }
private boolean targetHasShiftedContext(TargetBase target) { Set<Member> measures = new HashSet<>(); measures.addAll( constraint.getEvaluator().getQuery().getMeasuresMembers()); for (Member measure : measures) { if (measure.isCalculated() && SqlConstraintUtils.containsValidMeasure( measure.getExpression())) { return true; } } Set<Member> membersInMeasures = SqlConstraintUtils.getMembersNestedInMeasures(measures); return membersInMeasures.contains( target.getLevel().getHierarchy().getAllMember()); }
for (Member checkMember : expandedMemberList) { if (checkMember == null || checkMember.isCalculated() || !(checkMember instanceof RolapCubeMember))
public static void expandSupportedCalculatedMember( Member member, Evaluator evaluator, boolean disjointSlicerTuples, TupleConstraintStruct expandedSet) { if (member.isCalculated() && isSupportedCalculatedMember(member)) { expandExpressions(member, null, evaluator, expandedSet); } else if (member instanceof RolapResult.CompoundSlicerRolapMember) { if (!disjointSlicerTuples) { expandedSet.addMember(replaceCompoundSlicerPlaceholder( member, (RolapEvaluator) evaluator)); } } else { // just the member expandedSet.addMember(member); } }
public Object visit(MemberExpr memberExpr) { Member member = memberExpr.getMember(); returnFormula(member); if (member.isCalculated() && member instanceof RolapCalculatedMember && !hasCyclicReference(memberExpr)) { Formula formula = ((RolapCalculatedMember) member).getFormula(); formula.accept(validator); returnFormula(member); } return super.visit(memberExpr); }
private void replaceTrivialCalcMember(int i, List<Member> members) { Member member = members.get(i); if (!member.isCalculated()) { return;
public Object visit(ParameterExpr parameterExpr) { final Parameter parameter = parameterExpr.getParameter(); final Type type = parameter.getType(); if (type instanceof mondrian.olap.type.MemberType) { final Object value = parameter.getValue(); if (value instanceof Member) { final Member member = (Member) value; if (!member.isMeasure() && !member.isCalculated()) { addMember(member); } } else { parameter.getDefaultExp().accept(this); } } return null; }
/** * Removes every tuple from a list which is calculated. * The list must not be null, and must consist only of members. * * @param memberList Member list * @return List of non-calculated members */ static TupleList removeCalculatedMembers(TupleList memberList) { if (memberList.getArity() == 1) { return new UnaryTupleList( removeCalculatedMembers( memberList.slice(0))); } else { final TupleList clone = memberList.cloneList(memberList.size()); outer: for (List<Member> members : memberList) { for (Member member : members) { if (member.isCalculated() && !member.isParentChildPhysicalMember()) { continue outer; } } clone.add(members); } return clone; } }