builtinfuntable.java

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

/*
// $Id: //open/mondrian/src/main/mondrian/olap/fun/BuiltinFunTable.java#88 $
// This software is subject to the terms of the Common Public License
// Agreement, available at the following URL:
// http://www.opensource.org/licenses/cpl.html.
// Copyright (C) 2002-2005 Kana Software, Inc. and others.
// All Rights Reserved.
// You must accept the terms of that agreement to use this software.
//
// jhyde, 26 February, 2002
*/
package mondrian.olap.fun;

import mondrian.olap.*;
import mondrian.olap.DimensionType;
import mondrian.olap.LevelType;
import mondrian.olap.type.*;
import mondrian.util.Format;
import mondrian.resource.MondrianResource;

import java.util.*;
import java.io.PrintWriter;

/**
 * <code>BuiltinFunTable</code> contains a list of all built-in MDX functions.
 *
 * <p>Note: Boolean expressions return {@link Boolean#TRUE},
 * {@link Boolean#FALSE} or null. null is returned if the expression can not be
 * evaluated because some values have not been loaded from database yet.</p>
 *
 * @author jhyde
 * @since 26 February, 2002
 * @version $Id: //open/mondrian/src/main/mondrian/olap/fun/BuiltinFunTable.java#88 $
 **/
public class BuiltinFunTable extends FunTableImpl {

    /** the singleton **/
    private static BuiltinFunTable instance;

    /**
     * Creates a function table containing all of the builtin MDX functions.
     * This method should only be called from {@link BuiltinFunTable#instance}.
     */
    private BuiltinFunTable() {
        super();
    }

    protected void defineFunctions() {
        defineReserved("NULL");

        // first char: p=Property, m=Method, i=Infix, P=Prefix
        // 2nd:

        // ARRAY FUNCTIONS
        if (false) define(new FunDefBase(
                "SetToArray",
                "SetToArray(<Set>[, <Set>]...[, <Numeric Expression>])",
                "Converts one or more sets to an array for use in a user-defined function.",
                "fa*"));
        //
        // DIMENSION FUNCTIONS
        define(new FunDefBase(
                "Dimension",
                "<Hierarchy>.Dimension",
                "Returns the dimension that contains a specified hierarchy.",
                "pdh") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Hierarchy hierarchy = getHierarchyArg(evaluator, args, 0, true);
                return hierarchy.getDimension();
            }
        });

        //??Had to add this to get <Hierarchy>.Dimension to work?
        define(new FunDefBase(
                "Dimension",
                "<Dimension>.Dimension",
                "Returns the dimension that contains a specified hierarchy.",
                "pdd") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Dimension dimension = getDimensionArg(evaluator, args, 0, true);
                return dimension;
            }

        });

        define(new FunDefBase(
                "Dimension",
                "<Level>.Dimension",
                "Returns the dimension that contains a specified level.",
                "pdl") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Level level = getLevelArg(evaluator, args, 0, true);
                return level.getDimension();
            }
        });

        define(new FunDefBase(
                "Dimension",
                "<Member>.Dimension",
                "Returns the dimension that contains a specified member.",
                "pdm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                return member.getDimension();
            }
        });

        define(new FunDefBase(
                "Dimensions",
                "Dimensions(<Numeric Expression>)",
                "Returns the dimension whose zero-based position within the cube is specified by a numeric expression.",
                "fdn") {
            public Type getResultType(Validator validator, Exp[] args) {
                return new mondrian.olap.type.DimensionType(null);
            }

            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Cube cube = evaluator.getCube();
                Dimension[] dimensions = cube.getDimensions();
                int n = getIntArg(evaluator, args, 0);
                if ((n > dimensions.length) || (n < 1)) {
                    throw newEvalException(
                            this, "Index '" + n + "' out of bounds");
                }
                return dimensions[n - 1];
            }
        });
        define(new FunDefBase(
                "Dimensions",
                "Dimensions(<String Expression>)",
                "Returns the dimension whose name is specified by a string.",
                "fdS") {
            public Type getResultType(Validator validator, Exp[] args) {
                return new mondrian.olap.type.DimensionType(null);
            }

            public Object evaluate(Evaluator evaluator, Exp[] args) {
                String defValue = "Default Value";
                String s = getStringArg(evaluator, args, 0, defValue);
                if (s.indexOf("[") == -1) {
                    s = Util.quoteMdxIdentifier(s);
                }
                OlapElement o = evaluator.getSchemaReader().lookupCompound(
                        evaluator.getCube(),
                        explode(s),
                        false,
                        Category.Dimension);
                if (o instanceof Dimension) {
                    return (Dimension) o;
                } else if (o == null) {
                    throw newEvalException(this, "Dimension '" + s + "' not found");
                } else {
                    throw newEvalException(this, "Dimensions(" + s + ") found " + o);
                }
            }
        });

        //
        // HIERARCHY FUNCTIONS
        define(new FunDefBase(
                "Hierarchy",
                "<Level>.Hierarchy",
                "Returns a level's hierarchy.",
                "phl") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Level level = getLevelArg(evaluator, args, 0, true);
                return level.getHierarchy();
            }
        });
        define(new FunDefBase(
                "Hierarchy",
                "<Member>.Hierarchy",
                "Returns a member's hierarchy.",
                "phm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                return member.getHierarchy();
            }
        });

        //
        // LEVEL FUNCTIONS
        define(new FunDefBase(
                "Level",
                "<Member>.Level",
                "Returns a member's level.",
                "plm") {
            public Type getResultType(Validator validator, Exp[] args) {
                final Type argType = args[0].getTypeX();
                return new mondrian.olap.type.LevelType(argType.getHierarchy(),
                        argType.getLevel());
            }

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

        define(new FunDefBase(
                "Levels",
                "<Hierarchy>.Levels(<Numeric Expression>)",
                "Returns the level whose position in a hierarchy is specified by a numeric expression.",
                "mlhn") {
            public Type getResultType(Validator validator, Exp[] args) {
                final Type argType = args[0].getTypeX();
                return new mondrian.olap.type.LevelType(argType.getHierarchy(),
                        argType.getLevel());
            }

            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Hierarchy hierarchy = getHierarchyArg(evaluator, args, 0, true);
                Level[] levels = hierarchy.getLevels();

                int n = getIntArg(evaluator, args, 1);
                if ((n >= levels.length) || (n < 0)) {
                    throw newEvalException(
                            this, "Index '" + n + "' out of bounds");
                }
                return levels[n];
            }
        });

        define(new FunDefBase(
                "Levels",
                "Levels(<String Expression>)",
                "Returns the level whose name is specified by a string expression.",
                "flS") {
            public Type getResultType(Validator validator, Exp[] args) {
                final Type argType = args[0].getTypeX();
                return new mondrian.olap.type.LevelType(argType.getHierarchy(),
                        argType.getLevel());
            }
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                String s = getStringArg(evaluator, args, 0, null);
                Cube cube = evaluator.getCube();
                OlapElement o = (s.startsWith("[")) ?
                        evaluator.getSchemaReader().lookupCompound(
                                cube,
                                explode(s),
                                false,
                                Category.Level) :
                        // lookupCompound barfs if "s" doesn't have matching
                        // brackets, so don't even try
                        null;

                if (o instanceof Level) {
                    return (Level) o;
                } else if (o == null) {
                    throw newEvalException(this, "Level '" + s + "' not found");
                } else {
                    throw newEvalException(this, "Levels('" + s + "') found " + o);
                }
            }
        });

        //
        // LOGICAL FUNCTIONS
        define(new MultiResolver(
                "IsEmpty",
                "IsEmpty(<Value Expression>)",
                "Determines if an expression evaluates to the empty cell value.",
                new String[] {"fbS", "fbn"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new FunDefBase(dummyFunDef) {
                    public Object evaluate(Evaluator evaluator, Exp[] args) {
                        Object o = getScalarArg(evaluator, args, 0);
                        return Boolean.valueOf(o == Util.nullValue);
                    }
                };
            }
        });

        define(new FunDefBase(
                "IS NULL",
                "<Member> IS NULL",
                "Returns whether a member is null.",
                "pbm") {
            public Object evaluate(Evaluator evaluator, Exp[] args) {
                Member member = getMemberArg(evaluator, args, 0, true);
                return Boolean.valueOf(member.isNull());
            }
        });

        define(new MultiResolver(
                "IS",
                "<Expression> IS <Expression>",
                "Returns whether two objects are the same (idempotent)",
                new String[] {"ibmm", "ibll", "ibhh", "ibdd"}) {
            protected FunDef createFunDef(Exp[] args, FunDef dummyFunDef) {
                return new FunDefBase(dummyFunDef) {