builtinfuntable.java

来自「数据仓库展示程序」· Java 代码 · 共 1,452 行 · 第 1/5 页

                                // so there is no parallelperiod.
                                //
                                return member.getHierarchy().getNullMember();
                            }

                            ancestorLevel = parent.getLevel();
                        }

                        //
                        // Now do some error checking.
                        // The ancestorLevel and the member must be from the
                        // same hierarchy.
                        //
                        if (member.getHierarchy() != ancestorLevel.getHierarchy()) {
                            MondrianResource.instance().FunctionMbrAndLevelHierarchyMismatch.ex(
                                    "ParallelPeriod", ancestorLevel.getHierarchy().getUniqueName(),
                                    member.getHierarchy().getUniqueName()
                            );
                        }

                        int distance = member.getLevel().getDepth() - ancestorLevel.getDepth();

                        Member ancestor = ancestor(evaluator, member, distance, ancestorLevel);

                        Member inLaw = evaluator.getSchemaReader().getLeadMember(ancestor, -lagValue);

                        return cousin(evaluator.getSchemaReader(), member, inLaw);
                    }
                };
            }
        });

        define(new FunDefBase(
                "Parent",
                "<Member>.Parent",
                "Returns the parent of a member.",
                "pmm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                Member parent = evaluator.getSchemaReader().getMemberParent(member);
                if (parent == null) {
                    parent = member.getHierarchy().getNullMember();
                }
                return parent;
            }
        });

        define(new FunDefBase(
                "PrevMember",
                "<Member>.PrevMember",
                "Returns the previous member in the level that contains a specified member.",
                "pmm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                return evaluator.getSchemaReader().getLeadMember(member, -1);
            }
        });

        define(new FunDefBase(
                "StrToMember",
                "StrToMember(<String Expression>)",
                "Returns a member from a unique name String in MDX format.",
                "fmS") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                String mname = getStringArg(evaluator, args, 0, null);
                Cube cube = evaluator.getCube();
                SchemaReader schemaReader = evaluator.getSchemaReader();
                String[] uniqueNameParts = Util.explode(mname);
                Member member = (Member) schemaReader.lookupCompound(cube,
                        uniqueNameParts, true, Category.Member);
                // Member member = schemaReader.getMemberByUniqueName(uniqueNameParts, false);
                return member;
            }
        });

        if (false) define(new FunDefBase(
                "ValidMeasure",
                "ValidMeasure(<Tuple>)",
                "Returns a valid measure in a virtual cube by forcing inapplicable dimensions to their top level.",
                "fm*"));
        //
        // NUMERIC FUNCTIONS
        define(new AggregateFunDef.Resolver());

        define(new MultiResolver(
                "$AggregateChildren",
                "$AggregateChildren(<Hierarchy>)",
                "Equivalent to 'Aggregate(<Hierarchy>.CurrentMember.Children); for internal use.",
                new String[] {"Inh"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new FunDefBase(dummyFunDef) {
                    final Exp valueFunCall = createValueFunCall();

                    public void unparse(Exp[] args, PrintWriter pw) {
                        pw.print(getName());
                        pw.print("(");
                        args[0].unparse(pw);
                        pw.print(")");
                    }

                    public boolean callDependsOn(FunCall call, Dimension dimension) {
                        return true;
                    }

                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        Hierarchy hierarchy = getHierarchyArg(evaluator, args, 0, true);
                        Member member = evaluator.getParent().getContext(hierarchy.getDimension());
                        List members =
                                (List) member.getPropertyValue(
                                        Property.CONTRIBUTING_CHILDREN.name);
                        Aggregator aggregator =
                                (Aggregator) evaluator.getProperty(
                                        Property.AGGREGATION_TYPE.name, null);
                        if (aggregator == null) {
                            throw newEvalException(null, "Could not find an aggregator in the current evaluation context");
                        }
                        Aggregator rollup = aggregator.getRollup();
                        if (rollup == null) {
                            throw newEvalException(null, "Don't know how to rollup aggregator '" + aggregator + "'");
                        }
                        return rollup.aggregate(evaluator.push(), members, valueFunCall);
                    }
                };
            }
        });

        define(new MultiResolver(
                "Avg",
                "Avg(<Set>[, <Numeric Expression>])",
                "Returns the average value of a numeric expression evaluated over a set.",
                new String[]{"fnx", "fnxn"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new AbstractAggregateFunDef(dummyFunDef) {
                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        List members = (List) getArg(evaluator, args, 0);
                        ExpBase exp = (ExpBase) getArgNoEval(args, 1, valueFunCall);
                        return avg(evaluator.push(), members, exp);
                    }
                };
            }
        });

        define(new MultiResolver(
                "Correlation",
                "Correlation(<Set>, <Numeric Expression>[, <Numeric Expression>])",
                "Returns the correlation of two series evaluated over a set.",
                new String[]{"fnxn","fnxnn"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new AbstractAggregateFunDef(dummyFunDef) {
                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        List members = (List) getArg(evaluator, args, 0);
                        ExpBase exp1 = (ExpBase) getArgNoEval(args, 1);
                        ExpBase exp2 = (ExpBase) getArgNoEval(args, 2, valueFunCall);
                        return correlation(evaluator.push(), members, exp1, exp2);
                    }
                };
            }
        });

        final String[] resWords = {"INCLUDEEMPTY", "EXCLUDEEMPTY"};
        define(new MultiResolver(
                "Count",
                "Count(<Set>[, EXCLUDEEMPTY | INCLUDEEMPTY])",
                "Returns the number of tuples in a set, empty cells included unless the optional EXCLUDEEMPTY flag is used.",
            new String[]{"fnx", "fnxy"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new AbstractAggregateFunDef(dummyFunDef) {
                    public boolean callDependsOn(FunCall call, Dimension dimension) {
                        // COUNT(<set>, INCLUDEEMPTY) is straightforward -- it
                        // depends only on the dimensions that <Set> depends
                        // on.
                        if (super.callDependsOn(call, dimension)) {
                            return true;
                        }
                        final Exp[] args = call.getArgs();
                        String empties = getLiteralArg(args, 1, "INCLUDEEMPTY", resWords, null);
                        final boolean includeEmpty = empties.equals("INCLUDEEMPTY");
                        if (includeEmpty) {
                            return false;
                        }
                        // COUNT(<set>, EXCLUDEEMPTY) depends only on the
                        // dimensions that <Set> depends on, plus all
                        // dimensions not masked by the set.
                        if (args[0].getTypeX().usesDimension(dimension)) {
                            return false;
                        }
                        return true;
                    }

                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        List members = (List) getArg(evaluator, args, 0);
                        String empties = getLiteralArg(args, 1, "INCLUDEEMPTY", resWords, null);
                        final boolean includeEmpty = empties.equals("INCLUDEEMPTY");
                        return count(evaluator, members, includeEmpty);
                    }
                };
            }
            public String[] getReservedWords() {
                return resWords;
            }
        });

        define(new FunDefBase(
                "Count",
                "<Set>.Count",
                "Returns the number of tuples in a set including empty cells.",
                "pnx") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                List members = (List) getArg(evaluator, args, 0);
                return count(evaluator, members, true);
            }
        });

        define(new MultiResolver(
                "Covariance",
                "Covariance(<Set>, <Numeric Expression>[, <Numeric Expression>])",
                "Returns the covariance of two series evaluated over a set (biased).",
                new String[]{"fnxn","fnxnn"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new FunDefBase(dummyFunDef) {
                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        List members = (List) getArg(evaluator, args, 0);
                        ExpBase exp1 = (ExpBase) getArgNoEval(args, 1);
                        ExpBase exp2 = (ExpBase) getArgNoEval(args, 2);
                        return covariance(evaluator.push(), members, exp1, exp2, true);
                    }
                };
            }
        });

        define(new MultiResolver(
                "CovarianceN",
                "CovarianceN(<Set>, <Numeric Expression>[, <Numeric Expression>])",
                "Returns the covariance of two series evaluated over a set (unbiased).",
                new String[]{"fnxn","fnxnn"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new AbstractAggregateFunDef(dummyFunDef) {
                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        List members = (List) getArg(evaluator, args, 0);
                        ExpBase exp1 = (ExpBase) getArgNoEval(args, 1);
                        ExpBase exp2 = (ExpBase) getArgNoEval(args, 2, valueFunCall);
                        return covariance(evaluator.push(), members, exp1, exp2, false);
                    }
                };
            }
        });

        define(new FunDefBase(
                "IIf",
                "IIf(<Logical Expression>, <Numeric Expression1>, <Numeric Expression2>)",
                "Returns one of two numeric values determined by a logical test.",
                "fnbnn") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Boolean b = getBooleanArg(evaluator, args, 0);
                if (b == null) {
                    // The result of the logical expression is not known,
                    // probably because some necessary value is not in the
                    // cache yet. Evaluate both expressions so that the cache
                    // gets populated as soon as possible.
                    getDoubleArg(evaluator, args, 1, null);
                    getDoubleArg(evaluator, args, 2, null);
                    return new Double(Double.NaN);
                }
                Object o = (b.booleanValue())
                        ? getDoubleArg(evaluator, args, 1, null)
                        : getDoubleArg(evaluator, args, 2, null);
                return o;
            }
        });


        define(new FunkResolver(
                "LinRegIntercept",
                "LinRegIntercept(<Set>, <Numeric Expression>[, <Numeric Expression>])",
                "Calculates the linear regression of a set and returns the value of b in the regression line y = ax + b.",
                new String[]{"fnxn","fnxnn"},
                new LinReg.Intercept()));

        define(new FunkResolver(
                "LinRegPoint",
                "LinRegPoint(<Numeric Expression>, <Set>, <Numeric Expression>[, <Numeric Expression>])",
                "Calculates the linear regression of a set and returns the value of y in the regression line y = ax + b.",
                new String[]{"fnnxn","fnnxnn"},
                new LinReg.Point()));

        define(new FunkResolver(
                "LinRegR2",
                "LinRegR2(<Set>, <Numeric Expression>[, <Numeric Expression>])",
                "Calculates the linear regression of a set and returns R2 (the coefficient of determination).",
                new String[]{"fnxn","fnxnn"},
                new LinReg.R2()));