builtinfuntable.java

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

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

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

        define(new MultiResolver(
                "Max",
                "Max(<Set>[, <Numeric Expression>])",
                "Returns the maximum 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 max(evaluator.push(), members, exp);
                    }
            };
            }
        });

        define(new MultiResolver(
                "Median",
                "Median(<Set>[, <Numeric Expression>])",
                "Returns the median 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);
                        //todo: ignore nulls, do we need to ignore the List?
                        return median(evaluator.push(), members, exp);
                }
            };
            }
        });

        define(new MultiResolver(
                "Min",
                "Min(<Set>[, <Numeric Expression>])",
                "Returns the minimum 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 min(evaluator.push(), members, exp);
                    }
                };
            }
        });

        define(new FunDefBase(
                "Ordinal",
                "<Level>.Ordinal",
                "Returns the zero-based ordinal value associated with a level.",
                "pnl") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Level level = getLevelArg(evaluator, args, 0, false);

                return new Double(level.getDepth());
            }
        });

        define(RankFunDef.createResolver());

        define(new CacheFunDef.CacheFunResolver());

        define(new MultiResolver(
                "Stddev",
                "Stddev(<Set>[, <Numeric Expression>])",
                "Alias for Stdev.",
                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 stdev(evaluator.push(), members, exp, false);
                    }
                };
            }
        });

        define(new MultiResolver(
                "Stdev",
                "Stdev(<Set>[, <Numeric Expression>])",
                "Returns the standard deviation of a numeric expression evaluated over a set (unbiased).",
                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 stdev(evaluator.push(), members, exp, false);
                    }
                };
            }
        });

        define(new MultiResolver(
                "StddevP",
                "StddevP(<Set>[, <Numeric Expression>])",
                "Alias for StdevP.",
                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 stdev(evaluator.push(), members, exp, true);
                    }
                };
            }
        });

        define(new MultiResolver(
                "StdevP",
                "StdevP(<Set>[, <Numeric Expression>])",
                "Returns the standard deviation of a numeric expression evaluated over a set (biased).",
                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 stdev(evaluator.push(), members, exp, true);
                    }
                };
            }
        });

        define(new MultiResolver(
                "Sum", "Sum(<Set>[, <Numeric Expression>])", "Returns the sum 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 sum(evaluator.push(), members, exp);
                    }
                };
            }
        });

        define(new FunDefBase(
                "Value",
                "<Measure>.Value",
                "Returns the value of a measure.",
                "pnm") {
            public boolean callDependsOn(FunCall call, Dimension dimension) {
                if (super.callDependsOn(call, dimension)) {
                    return true;
                }
                if (call.getArg(0).getTypeX().usesDimension(dimension)) {
                    return false;
                }
                return true;
            }

            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                return member.evaluateScalar(evaluator);
            }
        });

        define(new FunDefBase(
                "_Value",
                "_Value(<Tuple>)",
                "Returns the value of the current measure within the context of a tuple.",
                "fnt") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                if (true) {
                    throw new UnsupportedOperationException(); // todo: obsolete
                }
                Member[] members = getTupleArg(evaluator, args, 0);
                Evaluator evaluator2 = evaluator.push(members);
                return evaluator2.evaluateCurrent();
            }

            public boolean callDependsOn(FunCall call, Dimension dimension) {
                // A call to the _Value function depends upon every dimension
                // which is not an explicit argument. For example,
                //  _Value((Gender.M, Measures.[Unit Sales]))
                // depends upon everything EXCEPT Gender and Measures.
                final Exp[] args = call.getArgs();
                for (int i = 0; i < args.length; i++) {
                    Exp arg = args[i];
                    final Type argType = arg.getTypeX();
                    if (argType.usesDimension(dimension)) {
                        return arg.dependsOn(dimension);
                    }
                }
                return true;
            }
        });

        define(new FunDefBase(
                "_Value",
                "_Value()",
                "Returns the value of the current measure.",
                "fn") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                if (true) {
                    throw new UnsupportedOperationException(); // todo: obsolete
                }
                return evaluator.evaluateCurrent();
            }
        });

        // _Value is a pseudo-function which evaluates a tuple to a number.
        // It needs a custom resolver.
        if (false) define(new ResolverBase(
                "_Value",
                null,
                null,
                Syntax.Parentheses) {
            public FunDef resolve(
                    Exp[] args, Validator validator, int[] conversionCount) {
                if (args.length == 1 &&
                        args[0].getCategory() == Category.Tuple) {
                    return new ValueFunDef(new int[] {Category.Tuple});
                }
                for (int i = 0; i < args.length; i++) {
                    Exp arg = args[i];
                    if (!validator.canConvert(arg, Category.Member,  conversionCount)) {
                        return null;
                    }
                }
                int[] argTypes = new int[args.length];
                for (int i = 0; i < argTypes.length; i++) {
                    argTypes[i] = Category.Member;
                }
                return new ValueFunDef(argTypes);
            }
        });

        define(new MultiResolver(
                "Var",
                "Var(<Set>[, <Numeric Expression>])",
                "Returns the variance of a numeric expression evaluated over a set (unbiased).",
                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 var(evaluator.push(), members, exp, false);
                    }
                };
            }
        });

        define(new MultiResolver(
                "Variance", "Variance(<Set>[, <Numeric Expression>])",
                "Alias for Var.",
                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 var(evaluator.push(), members, exp, false);
                    }
                };
            }
        });

        define(new MultiResolver(
                "VarianceP",
                "VarianceP(<Set>[, <Numeric Expression>])",
                "Alias for VarP.",
                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);