builtinfuntable.java

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

                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        Object arg0 = getArg(evaluator, args, 0);
                        Object arg1 = getArg(evaluator, args, 1);
                        return Boolean.valueOf(arg0 == arg1);
                    }
                };
            }
        });

        //
        // MEMBER FUNCTIONS
        define(new MultiResolver(
                "Ancestor",
                "Ancestor(<Member>, {<Level>|<Numeric Expression>})",
                "Returns the ancestor of a member at a specified level.",
                new String[] {"fmml", "fmmn"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new FunDefBase(dummyFunDef) {

                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        Member member = getMemberArg(evaluator, args, 0, false);
                        Object arg2 = getArg(evaluator, args, 1);

                        Level level = null;
                        int distance;
                        if (arg2 instanceof Level) {
                            level = (Level) arg2;
                            distance = member.getLevel().getDepth() - level.getDepth();
                        } else {
                            distance = ((Number)arg2).intValue();
                        }

                        return ancestor(evaluator, member, distance, level);
                    }
                };
            }
        });

        define(new FunDefBase(
                "Cousin",
                "Cousin(<member>, <ancestor member>)",
                "Returns the member with the same relative position under <ancestor member> as the member specified.",
                "fmmm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                Member ancestorMember = getMemberArg(evaluator, args, 1, true);
                Member cousin = cousin(
                        evaluator.getSchemaReader(),
                        member,
                        ancestorMember);
                return cousin;
            }
        });

        define(new FunDefBase(
                "CurrentMember",
                "<Dimension>.CurrentMember",
                "Returns the current member along a dimension during an iteration.",
                "pmd") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Dimension dimension = getDimensionArg(evaluator, args, 0, true);
                return evaluator.getContext(dimension);
            }

            public boolean callDependsOn(FunCall call, Dimension dimension) {
                // Depends on only one dimension. For example
                // [Gender].CurrentMember depends upon the [Gender] dimension
                // only.
                return call.getArg(0).getTypeX().usesDimension(dimension);
            }
        });

        define(new FunDefBase(
                "DataMember",
                "<Member>.DataMember",
                "Returns the system-generated data member that is associated with a nonleaf member of a dimension.",
                "pmm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                return member.getDataMember();
            }
        });

        define(new FunDefBase(
                "DefaultMember",
                "<Dimension>.DefaultMember",
                "Returns the default member of a dimension.",
                "pmd") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Dimension dimension = getDimensionArg(evaluator, args, 0, true);
                return evaluator.getSchemaReader().getHierarchyDefaultMember(
                        dimension.getHierarchy());
            }
        });

        define(new FunDefBase(
                "FirstChild",
                "<Member>.FirstChild",
                "Returns the first child of a member.",
                "pmm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                Member[] children = evaluator.getSchemaReader().getMemberChildren(member);
                return (children.length == 0)
                        ? member.getHierarchy().getNullMember()
                        : children[0];
            }
        });

        define(new FunDefBase(
                "FirstSibling",
                "<Member>.FirstSibling",
                "Returns the first child of the parent of a member.",
                "pmm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                Member parent = member.getParentMember();
                Member[] children;
                if (parent == null) {
                    if (member.isNull()) {
                        return member;
                    }
                    children = evaluator.getSchemaReader().getHierarchyRootMembers(member.getHierarchy());
                } else {
                    children = evaluator.getSchemaReader().getMemberChildren(parent);
                }
                return children[0];
            }
        });

        if (false) define(new FunDefBase(
                "Item",
                "<Tuple>.Item(<Numeric Expression>)",
                "Returns a member from a tuple.",
                "mm*"));

        define(new MultiResolver(
                "Lag",
                "<Member>.Lag(<Numeric Expression>)",
                "Returns a member further along the specified member's dimension.",
                new String[]{"mmmn"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new FunDefBase(dummyFunDef) {
                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        Member member = getMemberArg(evaluator, args, 0, true);
                        int n = getIntArg(evaluator, args, 1);
                        return evaluator.getSchemaReader().getLeadMember(member, -n);
                    }
                };
            }
        });

        define(new FunDefBase(
                "LastChild",
                "<Member>.LastChild",
                "Returns the last child of a member.",
                "pmm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                Member[] children =
                        evaluator.getSchemaReader().getMemberChildren(member);
                return (children.length == 0)
                        ? member.getHierarchy().getNullMember()
                        : children[children.length - 1];
            }

        });

        define(new FunDefBase(
                "LastSibling",
                "<Member>.LastSibling",
                "Returns the last child of the parent of a member.",
                "pmm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                Member parent = member.getParentMember();
                Member[] children;
                final SchemaReader schemaReader = evaluator.getSchemaReader();
                if (parent == null) {
                    if (member.isNull()) {
                        return member;
                    }
                    children = schemaReader.getHierarchyRootMembers(
                            member.getHierarchy());
                } else {
                    children = schemaReader.getMemberChildren(parent);
                }
                return children[children.length - 1];
            }
        });

        define(new MultiResolver(
                "Lead",
                "<Member>.Lead(<Numeric Expression>)",
                "Returns a member further along the specified member's dimension.",
                new String[]{"mmmn"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new FunDefBase(dummyFunDef) {
                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        Member member = getMemberArg(evaluator, args, 0, true);
                        int n = getIntArg(evaluator, args, 1);
                        return evaluator.getSchemaReader().getLeadMember(member, n);
                    }
                };
            }});

        define(new FunDefBase(
                "Members",
                "Members(<String Expression>)",
                "Returns the member whose name is specified by a string expression.",
                "fmS"));

        define(new FunDefBase(
                "NextMember",
                "<Member>.NextMember",
                "Returns the next 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(OpeningClosingPeriodFunDef.createResolver(true));
        define(OpeningClosingPeriodFunDef.createResolver(false));

        define(new MultiResolver(
                "ParallelPeriod",
                "ParallelPeriod([<Level>[, <Numeric Expression>[, <Member>]]])",
                "Returns a member from a prior period in the same relative position as a specified member.",
                new String[] {"fm", "fml", "fmln", "fmlnm"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new FunDefBase(dummyFunDef) {
                    public Type getResultType(Validator validator, Exp[] args) {
                        if (args.length == 0) {
                            // With no args, the default implementation cannot
                            // guess the hierarchy, so we supply the Time
                            // dimension.
                            Hierarchy hierarchy = validator.getQuery()
                                    .getCube().getTimeDimension()
                                    .getHierarchy();
                            return new MemberType(hierarchy, null, null);
                        }
                        return super.getResultType(validator, args);
                    }

                    public boolean callDependsOn(FunCall call, Dimension dimension) {
                        if (super.callDependsOn(call, dimension)) {
                            return true;
                        }
                        final Exp[] args = call.getArgs();
                        switch (args.length) {
                        case 0:
                            // ParallelPeriod() depends upon [Time] dimension.
                            return dimension.getDimensionType() == DimensionType.TimeDimension;
                        case 1:
                        case 2:
                            // ParallelPeriod(<Level>, <Numeric Expression>)
                            // and ParallelPeriod(<Level>)
                            // depend on <Level>'s dimension.
                            return args[0].getTypeX().usesDimension(dimension);
                        case 3:
                            return false;
                        default:
                            throw Util.newInternal("bad arg count " + args.length);
                        }
                    }

                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        // Member defaults to [Time].currentmember
                        Member member = (args.length == 3)
                            ? getMemberArg(evaluator, args, 2, true)
                            : evaluator.getContext(
                                evaluator.getCube().getTimeDimension());

                        // Numeric Expression defaults to 1.
                        int lagValue = (args.length >= 2)
                            ? getIntArg(evaluator, args, 1)
                            : 1;

                        Level ancestorLevel;
                        if (args.length >= 1) {
                            ancestorLevel = getLevelArg(evaluator, args, 0, true);
                        } else {
                            Member parent = member.getParentMember();

                            if (parent == null ||
                                    parent.getCategory() != Category.Member) {
                                //
                                // The parent isn't a member (it's probably a hierarchy),