xmla_quaxuti.java

OLAP 的客户端代码

/*
 * ====================================================================
 * 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) 2003-2004 TONBELLER AG.
 * All Rights Reserved.
 * You must accept the terms of that agreement to use this software.
 * ====================================================================
 *
 * 
 */

package com.tonbeller.jpivot.xmla;

import java.util.Iterator;
import java.util.List;

import org.apache.log4j.Logger;

import com.tonbeller.jpivot.olap.mdxparse.Exp;
import com.tonbeller.jpivot.olap.mdxparse.FunCall;
import com.tonbeller.jpivot.olap.model.Dimension;
import com.tonbeller.jpivot.olap.model.Hierarchy;
import com.tonbeller.jpivot.olap.model.Level;
import com.tonbeller.jpivot.olap.model.Member;
import com.tonbeller.jpivot.olap.model.OlapException;
import com.tonbeller.jpivot.olap.query.Quax;
import com.tonbeller.jpivot.olap.query.QuaxUti;
import com.tonbeller.jpivot.olap.query.SetExp;
import com.tonbeller.jpivot.olap.query.Quax.CannotHandleException;

/**
 * Utility Functions for Quax
 */
public class XMLA_QuaxUti implements QuaxUti {

  static Logger logger = Logger.getLogger(XMLA_QuaxUti.class);

  /**
   * 
   * @param f
   * @param m
   * @return true if FunCall matches member
   */
  public boolean isMemberInFunCall(Object oExp, Member m) throws Quax.CannotHandleException {
    FunCall f = (FunCall) oExp;
    XMLA_Member xm = (XMLA_Member) m;
    try {
      if (f.isCallTo("Children")) {
        return isMemberInChildren(f, xm);
      } else if (f.isCallTo("Descendants")) {
        return isMemberInDescendants(f, xm);
      } else if (f.isCallTo("Members")) {
        return isMemberInLevel(f, xm);
      } else if (f.isCallTo("Union")) {
        return isMemberInUnion(f, xm);
      } else if (f.isCallTo("{}")) { return isMemberInSet(f, xm); }
    } catch (OlapException e) {
      logger.error("?", e);
      return false;
    }
    throw new Quax.CannotHandleException(f.getFunction());
  }

  /**
   * @param f Children FunCall
   * @param mSearch member to search for
   * @return true if member mSearch is in set of children function
   */
  private boolean isMemberInChildren(FunCall f, XMLA_Member mSearch) {
    // calculated members are not really child
    if (mSearch.isCalculated())
      return false;

    XMLA_Member parent = (XMLA_Member) f.getArgs()[0];
    if (checkParent(parent, mSearch))
      return true;
    return false;
  }

  /**
   * @param f Descendants FunCall
   * @param mSearch member to search for
   * @return true if member mSearch is in set of Descendants function
   */
  private boolean isMemberInDescendants(FunCall f, XMLA_Member mSearch) throws OlapException {
    // calculated members are not really child
    if (mSearch.isCalculated())
      return false;

    XMLA_Member ancestor = (XMLA_Member) f.getArgs()[0];
    XMLA_Level level = (XMLA_Level) f.getArgs()[1];
    XMLA_Level mLevel = (XMLA_Level) mSearch.getLevel();
    if (!mLevel.equals(level))
      return false;
    if (mSearch.equals(ancestor))
      return false;

    int ancestorLevelNumber = ((XMLA_Level) ancestor.getLevel()).getDepth();
    XMLA_Member mm = mSearch;
    while (ancestorLevelNumber < ((XMLA_Level) mm.getLevel()).getDepth()) {
      mm = (XMLA_Member) mm.getParent();
    }

    if (mm.equals(ancestor))
      return true;
    else
      return false;

  }

  /**
   * @param f Members FunCall
   * @param mSearch member to search for
   * @return true if member mSearch is in set of Members function
   */
  private boolean isMemberInLevel(FunCall f, XMLA_Member mSearch) {
    XMLA_Level level = (XMLA_Level) f.getArgs()[0];
    if (level.equals(mSearch.getLevel()))
      return true;
    return false;
  }

  /**
   * @param f Set FunCall
   * @param mSearch member to search for
   * @return true if member mSearch is in set function
   */
  private boolean isMemberInSet(FunCall f, XMLA_Member mSearch) {
    // set of members expected
    for (int i = 0; i < f.getArgs().length; i++) {
      XMLA_Member m = (XMLA_Member) f.getArgs()[i];
      if (m.equals(mSearch))
        return true;
    }
    return false;
  }

  /**
   * @param f Union FunCall
   * @param mSearch member to search for
   * @return true if member mSearch is in set function
   */
  private boolean isMemberInUnion(FunCall f, XMLA_Member mSearch) throws CannotHandleException {
    // Unions may be nested
    for (int i = 0; i < 2; i++) {
      FunCall fChild = (FunCall) f.getArgs()[i];
      if (isMemberInFunCall(fChild, mSearch))
        return true;
    }
    return false;
  }

  /**
   * @param f TopBottom FunCall
   * @param mSearch member to search for
   * @return true if member mSearch is in set of Top/Bottom function
   */
  /*
   private boolean isMemberInTopBottom(FunCall f, XMLA_Member mSearch) throws OlapException {
   if (!(f.getArgs()[0] instanceof FunCall)) {
   logger.error("unexpected Exp in TopBottom function: " + f.getArgs()[0].getClass());
   return false; // should not occur
   }
   FunCall set = (FunCall) f.getArgs()[0];
   if (set.isCallTo("Children")) {
   return isMemberInChildren(set, mSearch);
   
   } else if (set.isCallTo("Descendants")) {
   return isMemberInDescendants(set, mSearch);
   } else if (set.isCallTo("Members")) {
   return isMemberInLevel(set, mSearch);
   }
   return false;
   }
   */

  /**
   * 
   * @param f
   * @param m
   * @return true if FunCall contains child of member
   */
  public boolean isChildOfMemberInFunCall(Object oFun, Member m) throws CannotHandleException {
    // calculated members do not have children
    if (((XMLA_Member) m).isCalculated())
      return false;
    FunCall f = (FunCall) oFun;
    try {

      if (f.isCallTo("Children")) {
        return (((XMLA_Member) f.getArgs()[0]).equals(m));
      } else if (f.isCallTo("Descendants")) {
        // true, if f = descendants(m2, level) contains any child of m
        // so level must be parent-level of m
        XMLA_Member ancestor = (XMLA_Member) f.getArgs()[0];
        XMLA_Level lev = (XMLA_Level) f.getArgs()[1];
        XMLA_Level parentLevel = lev.getParentLevel();
        if (parentLevel != null && m.getLevel().equals(parentLevel)) {
          XMLA_Member mm = (XMLA_Member) m;
          int ancestorLevelNumber = ((XMLA_Level) ancestor.getLevel()).getDepth();
          while (ancestorLevelNumber < ((XMLA_Level) mm.getLevel()).getDepth()) {
            mm = (XMLA_Member) mm.getParent();
          }

          if (mm.equals(ancestor))
            return true;
          else
            return false;
        } else
          return false;
      } else if (f.isCallTo("Members")) {
        XMLA_Level lev = (XMLA_Level) f.getArgs()[0];
        XMLA_Level parentLevel = lev.getParentLevel();
        if (parentLevel != null && m.getLevel().equals(parentLevel))
          return true;
        else
          return false;
      } else if (f.isCallTo("Union")) {
        if (isChildOfMemberInFunCall(f.getArgs()[0], m))
          return true;
        else
          return isChildOfMemberInFunCall(f.getArgs()[1], m);
      } else if (f.isCallTo("{}")) {
        for (int i = 0; i < f.getArgs().length; i++) {
          XMLA_Member mm = (XMLA_Member) f.getArgs()[i];
          XMLA_Member mmp = (XMLA_Member) mm.getParent();
          if (mmp != null && mmp.equals(m))
            return true;
        }
        return false;
      }
    } catch (OlapException e) {
      // should not occur
      logger.error("?", e);
      return false;
    }
    throw new Quax.CannotHandleException(f.getFunction());
  }

  /**
   * 
   * @param f
   * @param m
   * @return true if FunCall contains descendants of member
   */

  public boolean isDescendantOfMemberInFunCall(Object oExp, Member member)
      throws CannotHandleException {
    XMLA_Member m = (XMLA_Member) member;
    // calculated members do not have children
    if (m.isCalculated())
      return false;

    FunCall f = (FunCall) oExp;
    if (f.isCallTo("Children")) {
      // true, if m2.children contains descendants of m
      //  <==> m is equal or ancestor of m2
      XMLA_Member mExp = (XMLA_Member) f.getArgs()[0];
      return (m.equals(mExp) || XMLA_Util.isDescendant(m, mExp));
    } else if (f.isCallTo("Descendants")) {
      // true, if descendants(m2) contain descendants of m
      //  <==> m is equal or ancestor of m2
      XMLA_Member mExp = (XMLA_Member) f.getArgs()[0];
      return (m.equals(mExp) || XMLA_Util.isDescendant(m, mExp));
    } else if (f.isCallTo("Members")) {
      XMLA_Level levExp = (XMLA_Level) f.getArgs()[0];
      return (levExp.getDepth() > ((XMLA_Level) m.getLevel()).getDepth());
    } else if (f.isCallTo("Union")) {
      if (isDescendantOfMemberInFunCall(f.getArgs()[0], m))
        return true;
      else
        return isDescendantOfMemberInFunCall(f.getArgs()[1], m);
    } else if (f.isCallTo("{}")) {
      for (int i = 0; i < f.getArgs().length; i++) {
        XMLA_Member mExp = (XMLA_Member) f.getArgs()[i];
        return (!m.equals(mExp) && XMLA_Util.isDescendant(m, mExp));
      }
      return false;
    }
    throw new Quax.CannotHandleException(f.getFunction());
  }

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

    FunCall f1 = (FunCall) f.getArgs()[0];
    FunCall f2 = (FunCall) f.getArgs()[1];
    if (f1.isCallTo("Children") && ((XMLA_Member) f1.getArgs()[0]).equals(monMember)) { return f2; }
    if (f2.isCallTo("Children") && ((XMLA_Member) f1.getArgs()[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});
  }

  /**
   * check level and add a member's uncles to list 
   * @param m
   */
  public void addMemberUncles(List list, Member m, int[] maxLevel) {
    XMLA_Member xm = (XMLA_Member) m;

    int parentLevel = ((XMLA_Level) xm.getLevel()).getDepth() - 1;
    if (parentLevel < maxLevel[0])
      return;
    if (parentLevel > maxLevel[0]) {
      maxLevel[0] = parentLevel;
      list.clear();
    }
    AddUncels: if (parentLevel > 0) {
      XMLA_Member parent;
      XMLA_Member grandPa;
      try {
        parent = (XMLA_Member) xm.getParent();
        grandPa = (XMLA_Member) parent.getParent();
      } catch (OlapException e) {