mondrianquaxuti.java

OLAP 的客户端代码

        if (mExp.isCalculatedInQuery())
          continue;
        if (mExp.equals(m) || !mExp.isChildOrEqualTo(m))
          remainder.add(mExp);
      }
      return createMemberSet(remainder);
    } else if (f.isCallTo("Union")) {
      // TODO XMLA
      Exp[] uargs = new Exp[2];
      uargs[0] = (Exp) removeDescendantsFromFunCall(f.getArg(0), member);
      uargs[1] = (Exp) removeDescendantsFromFunCall(f.getArg(1), member);
      if (uargs[0] == null && uargs[1] == null)
        return null;
      if (uargs[1] == null)
        return uargs[0];
      if (uargs[0] == null)
        return uargs[1];
      if (uargs[0] instanceof mondrian.olap.Member) {
        Exp e = uargs[0];
        uargs[0] = new FunCall("{}", Syntax.Braces, new Exp[] { e});
      }
      if (uargs[1] instanceof mondrian.olap.Member) {
        Exp e = uargs[1];
        uargs[1] = new FunCall("{}", Syntax.Braces, new Exp[] { e});
      }
      return new FunCall("Union", uargs);
    }
    throw new Quax.CannotHandleException(f.getFunName());
  }

  /**
   * generate an object for a list of members
   *
   * @param mList
   *          list of members
   * @return null for empty list, single member or set function otherwise
   * @see com.tonbeller.jpivot.olap.query.QuaxUti#createMemberSet(java.util.List)
   */
  public Object createMemberSet(List mList) {
    if (mList.size() == 0)
      return null;
    else if (mList.size() == 1)
      return (Exp) mList.get(0);
    else {
      Exp[] remExps = (Exp[]) mList.toArray(new Exp[0]);
      return new FunCall("{}", Syntax.Braces, remExps);
    }

  }

  /**
   * remove children FunCall from Union should never be called
   *
   * @param f
   * @param mPath
   */
  static FunCall removeChildrenFromUnion(FunCall f, mondrian.olap.Member monMember) {

    FunCall f1 = (FunCall) f.getArg(0);
    FunCall f2 = (FunCall) f.getArg(1);
    if (f1.isCallTo("Children") && ((mondrian.olap.Member) f1.getArg(0)).equals(monMember)) { return f2; }
    if (f2.isCallTo("Children") && ((mondrian.olap.Member) f1.getArg(0)).equals(monMember)) { return f1; }
    FunCall f1New = f1;
    if (f1.isCallTo("Union"))
      f1New = removeChildrenFromUnion(f1, monMember);
    FunCall f2New = f2;
    if (f2.isCallTo("Union"))
      f2New = removeChildrenFromUnion(f2, monMember);

    if (f1 == f1New && f2 == f2New)
      return f;

    return new FunCall("Union", new Exp[] { f1New, f2New});
  }

  /**
   * return member for exp object
   *
   * @see QuaxUti#memberForObj(java.lang.Object)
   */
  public Member memberForObj(Object oExp) {
    mondrian.olap.Member monMember = (mondrian.olap.Member) oExp;
    Member member = model.lookupMemberByUName(monMember.getUniqueName());
    return member;
  }

  /**
   * @return exp object for member
   * @see QuaxUti#objForMember(com.tonbeller.jpivot.olap.model.Member)
   */
  public Object objForMember(Member member) {
    return ((MondrianMember) member).getMonMember();
  }

  /**
   * @return exp object for dimension
   * @see com.tonbeller.jpivot.olap.query.QuaxUti#objForDim
   */
  public Object objForDim(Dimension dim) {
    return ((MondrianDimension) dim).getMonDimension();
  }

  /**
   * return a members dimension
   *
   * @see QuaxUti#dimForMember(com.tonbeller.jpivot.olap.model.Member)
   */
  public Dimension dimForMember(Member member) {
    mondrian.olap.Member m = ((MondrianMember) member).getMonMember();
    mondrian.olap.Dimension monDim = m.getDimension();
    return model.lookupDimension(monDim.getUniqueName());
  }

  /**
   * @return a members hierarchy
   * @see QuaxUti#hierForMember(com.tonbeller.jpivot.olap.model.Member)
   */
  public Hierarchy hierForMember(Member member) {
    mondrian.olap.Member m = ((MondrianMember) member).getMonMember();
    mondrian.olap.Hierarchy monHier = m.getHierarchy();
    return model.lookupHierarchy(monHier.getUniqueName());
  }

  /**
   * @param oLevel
   *          expression object representing level
   * @return Level for given Expression Object
   * @see QuaxUti#LevelForObj(java.lang.Object)
   */
  public Level LevelForObj(Object oLevel) {
    mondrian.olap.Level monLevel = (mondrian.olap.Level) oLevel;
    return model.lookupLevel(monLevel.getUniqueName());
  }

  /**
   * @return count of a FunCall's arguments
   * @see QuaxUti#funCallArgCount(java.lang.Object)
   */
  public int funCallArgCount(Object oFun) {
    FunCall f = (FunCall) oFun;
    return f.getArgs().length;
  }

  /**
   * return a FunCalls argument of given index
   *
   * @see QuaxUti#funCallArg(java.lang.Object, int)
   */
  public Object funCallArg(Object oExp, int index) {
    return ((FunCall) oExp).getArg(index);
  }

  /**
   * @return function name
   * @see com.tonbeller.jpivot.olap.query.QuaxUti#funCallName
   */
  public String funCallName(Object oFun) {
    return ((FunCall) oFun).getFunName();
  }

  /**
   * check level and add a members descendatns to list
   *
   * @param m
   */
  public void addMemberDescendants(List list, Member member, Level level, int[] maxLevel) {
    mondrian.olap.Member m = ((MondrianMember) member).getMonMember();
    mondrian.olap.Level lev = ((MondrianLevel) level).getMonLevel();
    int parentLevel = lev.getDepth() + 1;
    if (parentLevel < maxLevel[0])
      return;
    if (parentLevel > maxLevel[0]) {
      maxLevel[0] = parentLevel;
      list.clear();
    }
    AddDescendants: if (parentLevel > 0) {
      // do nothing if already on List
      for (Iterator iter = list.iterator(); iter.hasNext();) {
        Exp exp = (Exp) iter.next();
        if (exp instanceof FunCall) {
          FunCall f = (FunCall) exp;
          if (f.isCallTo("Descendants") && ((mondrian.olap.Member) f.getArg(0)).equals(m)) {
            break AddDescendants;
          }
        }
      }
      FunCall fChildren = new FunCall("Descendants", Syntax.Function, new Exp[] { m, lev});
      /*
       * // remove all existing Descendants of m from worklist for (Iterator iter =
       * workList.iterator(); iter.hasNext();) { Exp exp = (Exp) iter.next(); if (exp instanceof
       * mondrian.olap.Member && ((mondrian.olap.Member) exp).isChildOrEqualTo(m)) iter.remove(); }
       */
      list.add(fChildren);
    } // AddDescendants
  }

  /**
   * @see QuaxUti#getParentMember(java.lang.Object)
   */
  public Member getParentMember(Object oExp) {
    mondrian.olap.Member m = (mondrian.olap.Member) oExp;
    mondrian.olap.Member monParent = m.getParentMember();
    if (monParent == null)
      return null;
    Member parent = model.lookupMemberByUName(monParent.getUniqueName());
    return parent;
  }

  /**
   * create FunCall
   *
   * @see QuaxUti#createFunCall(java.lang.String, java.lang.Object[], int)
   */
  public Object createFunCall(String function, Object[] args, int funType) {
    Exp[] expArgs = new Exp[args.length];
    for (int i = 0; i < expArgs.length; i++) {
      expArgs[i] = (Exp) args[i];
    }
    Syntax syntax;
    switch (funType) {
    case QuaxUti.FUNTYPE_BRACES:
      syntax = Syntax.Braces;
      break;
    case QuaxUti.FUNTYPE_PROPERTY:
      syntax = Syntax.Property;
      break;
    case QuaxUti.FUNTYPE_TUPLE:
      syntax = Syntax.Parentheses;
      break;
    case QuaxUti.FUNTYPE_INFIX:
      syntax = Syntax.Infix;
      break;
    default:
      syntax = Syntax.Function;
    }
    return new FunCall(function, syntax, expArgs);
  }

  /**
   * @return true, if an expression is a FunCall to e specific function
   * @see QuaxUti#funCallTo(java.lang.Object, java.lang.String)
   */
  public boolean isFunCallTo(Object oExp, String function) {
    return ((FunCall) oExp).isCallTo(function);
  }

  /**
   * @return true if member (2.arg) is child of Member (1.arg)
   * @see com.tonbeller.jpivot.olap.query.QuaxUti#checkParent
   */
  public boolean checkParent(Member pMember, Object cMemObj) {
    mondrian.olap.Member mc = (mondrian.olap.Member) cMemObj;
    if (mc.isCalculatedInQuery())
      return false;
    mondrian.olap.Member mp = mc.getParentMember();
    if (mp == null)
      return false;
    else
      return mp.equals(((MondrianMember) pMember).getMonMember());
  }

  /**
   * @return true if member (1.arg) is child of Member (2.arg)
   * @see com.tonbeller.jpivot.olap.query.QuaxUti#checkParent
   */
  public boolean checkChild(Member cMember, Object pMemObj) {
    mondrian.olap.Member mc = ((MondrianMember) cMember).getMonMember();
    if (mc.isCalculatedInQuery())
      return false;
    mondrian.olap.Member mp = mc.getParentMember();
    if (mp == null)
      return false;
    else
      return mp.equals(pMemObj);
  }

  /**
   * return true if Member (2.arg) is descendant of Member (1.arg)
   *
   * @see QuaxUti#isDescendant(java.lang.Object, com.tonbeller.jpivot.olap.model.Member)
   */
  public boolean checkDescendantM(Member aMember, Member dMember) {
    mondrian.olap.Member monMember = ((MondrianMember) aMember).getMonMember();
    mondrian.olap.Member monDesc = ((MondrianMember) dMember).getMonMember();
    if (monDesc.isCalculatedInQuery() || monDesc.equals(monMember))
      return false;
    return monDesc.isChildOrEqualTo(monMember);
  }

  /**
   * return true if Expression (2.arg) is descendant of Member (1.arg)
   *
   * @see QuaxUti#isDescendant(java.lang.Object, com.tonbeller.jpivot.olap.model.Member)
   */
  public boolean checkDescendantO(Member aMember, Object oMember) {
    mondrian.olap.Member monMember = ((MondrianMember) aMember).getMonMember();
    mondrian.olap.Member monDesc = (mondrian.olap.Member) oMember;
    if (monDesc.isCalculatedInQuery() || monDesc.equals(monMember))
      return false;
    return monDesc.isChildOrEqualTo(monMember);
  }

  /**
   * check level and add a levels members to list
   *
   * @param m
   */
  public void addLevelMembers(List list, Level level, int[] maxLevel) {
    mondrian.olap.Level lev = ((MondrianLevel) level).getMonLevel();
    int iLevel = lev.getDepth();
    if (iLevel < maxLevel[0])
      return;
    if (iLevel > maxLevel[0]) {
      maxLevel[0] = iLevel;
      list.clear();
    }
    AddMembers: if (iLevel > 0) {
      // do nothing if already on List
      for (Iterator iter = list.iterator(); iter.hasNext();) {
        Exp exp = (Exp) iter.next();
        if (exp instanceof FunCall) {
          FunCall f = (FunCall) exp;
          if (f.isCallTo("Members")) {
            break AddMembers;
          }
        }
      }
      FunCall fMembers = new FunCall("Members", Syntax.Property, new Exp[] { lev});
      /*
       * // remove all existing level members from worklist for (Iterator iter =
       * workList.iterator(); iter.hasNext();) { Exp exp = (Exp) iter.next(); if (exp instanceof
       * mondrian.olap.Member && ((mondrian.olap.Member) exp).getLevel().equals(lev)) iter.remove(); }
       */
      list.add(fMembers);
    } // AddDescendants
  }

  /**
   * determine hierarchy for Exp