builtinfuntable.java

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

                        return var(evaluator.push(), members, exp, true);
                    }
                };
            }
        });

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

        //
        // SET FUNCTIONS
        
        /*
         * AddCalculatedMembers adds calculated members that are siblings
         * of the members in the set. The set is limited to one dimension.
         */
        define(new FunDefBase(
                "AddCalculatedMembers",
                "AddCalculatedMembers(<Set>)",
                "Adds calculated members to a set.",
                "fxx") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                List memberList = (List) getArg(evaluator, args, 0);
                if (memberList != null) {
                    /*
                     * Determine unique levels in the set
                     */
                	Map levelMap = new HashMap();
                	
                	Dimension dim = null;
                	
                	Iterator it = memberList.iterator();
                	while (it.hasNext()) {
                		Object obj = it.next();
                		if (!(obj instanceof Member)) {
                			throw newEvalException(this, "Only single dimension members allowed in set for AddCalculatedMembers");
                		}
                		Member member = (Member) obj;
                		if (dim == null) {
                			dim = member.getDimension();
                		} else if (dim != member.getDimension()) {
                			throw newEvalException(this, "Only members from the same dimension are allowed in the AddCalculatedMembers set: "  
                					+ dim.toString() + " vs " + member.getDimension().toString());
                		}
                		if (!levelMap.containsKey(member.getLevel())) {
                			levelMap.put(member.getLevel(), null); 
                		}
                	}
                	/*
                	 * For each level, add the calculated members from both
                	 * the schema and the query
                	 */
                	List workingList = new ArrayList();
                	workingList.addAll(memberList);
                	it = levelMap.keySet().iterator();
                	while (it.hasNext()) {
                		Level level = (Level) it.next();
                		List tmp = evaluator.getSchemaReader().getCalculatedMembers(level);
                		if (tmp != null) {
                			workingList.addAll(tmp);
                		}
                        tmp = evaluator.getQuery().getSchemaReader(true).getCalculatedMembers(level);
                		if (tmp != null) {
                			workingList.addAll(tmp);
                		}
                	}
                	memberList = workingList;
                	
                }
                return memberList;
            }
        });

        define(new FunDefBase(
                "Ascendants",
                "Ascendants(<Member>)",
                "Returns the set of the ascendants of a specified member.",
                "fxm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, false);
                if (member.isNull()) {
                    return new ArrayList();
                }
                Member[] members = member.getAncestorMembers();
                final List result = new ArrayList(members.length + 1);
                result.add(member);
                addAll(result, members);
                return result;
            }
        });

        define(new MultiResolver(
                "BottomCount",
                "BottomCount(<Set>, <Count>[, <Numeric Expression>])",
                "Returns a specified number of items from the bottom of a set, optionally ordering the set first.",
                new String[]{"fxxnn", "fxxn"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new FunDefBase(dummyFunDef) {
                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        List list = (List) getArg(evaluator, args, 0);
                        int n = getIntArg(evaluator, args, 1);
                        ExpBase exp = (ExpBase) getArgNoEval(args, 2, null);
                        if (exp != null) {
                            boolean desc = false, brk = true;
                            sort(evaluator.push(), list, exp, desc, brk);
                        }
                        if (n < list.size()) {
                            list = list.subList(0, n);
                        }
                        return list;
                    }
                };
            }
        });

        define(new MultiResolver(
                "BottomPercent",
                "BottomPercent(<Set>, <Percentage>, <Numeric Expression>)",
                "Sorts a set and returns the bottom N elements whose cumulative total is at least a specified percentage.",
                new String[]{"fxxnn"}) {
            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 exp = (ExpBase) getArgNoEval(args, 2);
                        Double n = getDoubleArg(evaluator, args, 1);
                        return topOrBottom(evaluator.push(), members, exp, false, true, n.doubleValue());
                    }
                };
            }
        });

        define(new MultiResolver(
                "BottomSum",
                "BottomSum(<Set>, <Value>, <Numeric Expression>)",
                "Sorts a set and returns the bottom N elements whose cumulative total is at least a specified value.",
                new String[]{"fxxnn"}) {
            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 exp = (ExpBase) getArgNoEval(args, 2);
                        Double n = getDoubleArg(evaluator, args, 1);
                        return topOrBottom(evaluator.push(), members, exp, false, false, n.doubleValue());
                    }
                };
            }
        });

        define(new FunDefBase(
                "Children",
                "<Member>.Children",
                "Returns the children of a member.",
                "pxm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                Member[] children = evaluator.getSchemaReader().getMemberChildren(member);
                return Arrays.asList(children);
            }
        });

        define(new MultiResolver(
                "Crossjoin",
                "Crossjoin(<Set1>, <Set2>)",
                "Returns the cross product of two sets.",
                new String[]{"fxxx"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new CrossJoinFunDef(dummyFunDef);
            }
        });

        define(new MultiResolver(
                "NonEmptyCrossJoin",
                "NonEmptyCrossJoin(<Set1>, <Set2>)",
                "Returns the cross product of two sets, excluding empty tuples and tuples without associated fact table data.",
                new String[]{"fxxx"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new NonEmptyCrossJoinFunDef(dummyFunDef);
            }
        });

        define(new MultiResolver(
                "*",
                "<Set1> * <Set2>",
                "Returns the cross product of two sets.",
                new String[]{"ixxx", "ixmx", "ixxm", "ixmm"}) {
            public FunDef resolve(
                    Exp[] args, Validator validator, int[] conversionCount) {
                // This function only applies in contexts which require a set.
                // Elsewhere, "*" is the multiplication operator.
                // This means that [Measures].[Unit Sales] * [Gender].[M] is
                // well-defined.
                if (validator.requiresExpression()) {
                    return null;
                }
                return super.resolve(args, validator, conversionCount);
            }

            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new CrossJoinFunDef(dummyFunDef);
            }
        });

        define(new DescendantsFunDef.Resolver());

        define(new FunDefBase(
                "Distinct",
                "Distinct(<Set>)",
                "Eliminates duplicate tuples from a set.",
                "fxx") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                List list = (List) getArg(evaluator, args, 0);
                HashSet hashSet = new HashSet(list.size());
                Iterator iter = list.iterator();
                List result = new ArrayList();

                while (iter.hasNext()) {
                    Object element = iter.next();
                    MemberHelper lookupObj = new MemberHelper(element);

                    if (hashSet.add(lookupObj)) {
                        result.add(element);
                    }
                }
                return result;
            }
        });

        define(new MultiResolver(
                "DrilldownLevel",
                "DrilldownLevel(<Set>[, <Level>]) or DrilldownLevel(<Set>, , <Index>)",
                "Drills down the members of a set, at a specified level, to one level below. Alternatively, drills down on a specified dimension in the set.",
                new String[]{"fxx", "fxxl"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new FunDefBase(dummyFunDef) {
                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        //todo add fssl functionality
                        List set0 = (List) getArg(evaluator, args, 0);

                        if (set0.size() == 0) {
                            return set0;
                        }

                        int searchDepth = -1;

                        Level level = getLevelArg(evaluator, args, 1, false);
                        if (level != null) {
                            searchDepth = level.getDepth();
                        }

                        if (searchDepth == -1) {
                            searchDepth = ((Member)set0.get(0)).getLevel().getDepth();

                            for (int i = 1, m = set0.size(); i < m; i++) {
                                Member member = (Member) set0.get(i);
                                int memberDepth = member.getLevel().getDepth();

                                if (memberDepth > searchDepth) {
                                    searchDepth = memberDepth;
                                }
                            }
                        }

                        List drilledSet = new ArrayList();

                        for (int i = 0, m = set0.size(); i < m; i++) {
                            Member member = (Member) set0.get(i);
                            drilledSet.add(member);

                            Member nextMember = i == m - 1 ? null : (Member) set0.get(i + 1);

                            //
                            // This member is drilled if it's at the correct depth
                            // and if it isn't drilled yet. A member is considered
                            // to be "drilled" if it is immediately follo