mondrianquaxuti.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.mondrian;

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

import mondrian.olap.Exp;
import mondrian.olap.FunCall;
import mondrian.olap.SchemaReader;
import mondrian.olap.Syntax;

import org.apache.log4j.Logger;

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.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 MondrianQuaxUti implements QuaxUti {

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

  private MondrianModel model = null;

  private SchemaReader scr;

  /**
   * c'tor
   *
   * @param model
   */
  MondrianQuaxUti(MondrianModel model) {
    this.model = model;
    scr = model.getConnection().getSchemaReader();
  }

  /**
   * check whether a Funcall does NOT resolve to top level of hierarchy
   *
   * @param f
   * @return
   */
  public boolean isFunCallNotTopLevel(Object oFun) throws CannotHandleException {
    FunCall f = (FunCall) oFun;
    if (f.isCallTo("Children")) {
      return true; // children *not* top level
    } else if (f.isCallTo("Descendants")) {
      return true; // descendants*not* top level
    } else if (f.isCallTo("Members")) {
      mondrian.olap.Level lev = (mondrian.olap.Level) f.getArg(0);
      return (lev.getDepth() > 0);
    } else if (f.isCallTo("Union")) {
      if (isFunCallNotTopLevel(f.getArg(0)))
        return true;
      return isFunCallNotTopLevel(f.getArg(1));
    } else if (f.isCallTo("{}")) {
      for (int i = 0; i < f.getArgs().length; i++) {
        if (!isMemberOnToplevel((mondrian.olap.Member) f.getArg(i)))
          return true;
      }
      return false;
    }
    throw new Quax.CannotHandleException(f.getFunName());
  }

  /**
   * @return true if member is on top level (has no parent)
   * @see com.tonbeller.jpivot.olap.query.QuaxUti#isMemberOnToplevel
   */
  public boolean isMemberOnToplevel(Object oMem) {
    mondrian.olap.Member m = ((MondrianMember) oMem).getMonMember();
    return isMemberOnToplevel(m);
  }

  /**
   */
  private boolean isMemberOnToplevel(mondrian.olap.Member m) {
    if (m.getLevel().getDepth() > 0)
      return false;
    else
      return true;
  }

  /**
   *
   * @param f
   * @param m
   * @return true if FunCall matches member
   */
  public boolean isMemberInFunCall(Object oFun, Member member) throws CannotHandleException {
    FunCall f = (FunCall) oFun;
    mondrian.olap.Member m = ((MondrianMember) member).getMonMember();
    return isMemberInFunCall(f, m);
  }

  /**
   *
   * @param f
   * @param m
   * @return true if FunCall matches member
   */
  private boolean isMemberInFunCall(FunCall f, mondrian.olap.Member m) throws CannotHandleException {
    if (f.isCallTo("Children")) {
      return isMemberInChildren(f, m);
    } else if (f.isCallTo("Descendants")) {
      return isMemberInDescendants(f, m);
    } else if (f.isCallTo("Members")) {
      return isMemberInLevel(f, m);
    } else if (f.isCallTo("Union")) {
      return isMemberInUnion(f, m);
    } else if (f.isCallTo("{}")) { return isMemberInSet(f, m); }
    throw new Quax.CannotHandleException(f.getFunName());
  }

  /**
   * @param f
   *          Children FunCall
   * @param mSearch
   *          member to search for
   * @return true if member mSearch is in set of children function
   */
  private boolean isMemberInChildren(mondrian.olap.FunCall f, mondrian.olap.Member mSearch) {
    if (mSearch.isCalculatedInQuery())
      return false;
    mondrian.olap.Member parent = (mondrian.olap.Member) f.getArg(0);
    if (parent.equals(mSearch.getParentMember()))
      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, mondrian.olap.Member mSearch) {
    if (mSearch.isCalculatedInQuery())
      return false;
    mondrian.olap.Member ancestor = (mondrian.olap.Member) f.getArg(0);
    mondrian.olap.Level level = (mondrian.olap.Level) f.getArg(1);
    if (mSearch.equals(ancestor))
      return false;
    if (!mSearch.isChildOrEqualTo(ancestor))
      return false;
    if (level.equals(mSearch.getLevel()))
      return true;
    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(mondrian.olap.FunCall f, mondrian.olap.Member mSearch) {
    if (mSearch.isCalculatedInQuery())
      return false;
    mondrian.olap.Level level = (mondrian.olap.Level) f.getArg(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(mondrian.olap.FunCall f, mondrian.olap.Member mSearch) {
    // set of members expected
    for (int i = 0; i < f.getArgs().length; i++) {
      mondrian.olap.Member m = (mondrian.olap.Member) f.getArg(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(mondrian.olap.FunCall f, mondrian.olap.Member mSearch)
      throws CannotHandleException {
    // Unions may be nested
    for (int i = 0; i < 2; i++) {
      FunCall fChild = (FunCall) f.getArg(i);
      if (isMemberInFunCall(fChild, mSearch))
        return true;
    }
    return false;
  }

  /**
   *
   * @param f
   * @param m
   * @return true if FunCall contains child of member
   */
  public boolean isChildOfMemberInFunCall(Object oFun, Member member) throws CannotHandleException {
    FunCall f = (FunCall) oFun;
    mondrian.olap.Member m = ((MondrianMember) member).getMonMember();
    if (f.isCallTo("Children")) {
      return (((mondrian.olap.Member) f.getArg(0)).equals(m));
    } else if (f.isCallTo("Descendants")) {
      mondrian.olap.Member ancestor = (mondrian.olap.Member) f.getArg(0);
      mondrian.olap.Level lev = (mondrian.olap.Level) f.getArg(1);
      mondrian.olap.Level parentLevel = lev.getParentLevel();
      if (parentLevel != null && m.getLevel().equals(parentLevel)) {
        if (m.isChildOrEqualTo(ancestor))
          return true;
        else
          return false;
      } else
        return false;
    } else if (f.isCallTo("Members")) {
      mondrian.olap.Level lev = (mondrian.olap.Level) f.getArg(0);
      mondrian.olap.Level parentLevel = lev.getParentLevel();
      if (parentLevel != null && m.getLevel().equals(parentLevel))
        return true;
      else
        return false;
    } else if (f.isCallTo("Union")) {
      if (isChildOfMemberInFunCall(f.getArg(0), member))
        return true;
      else
        return isChildOfMemberInFunCall(f.getArg(1), member);
    } else if (f.isCallTo("{}")) {
      for (int i = 0; i < f.getArgs().length; i++) {
        mondrian.olap.Member mm = (mondrian.olap.Member) f.getArg(i);
        if (mm.isCalculatedInQuery())
          continue;
        mondrian.olap.Member mmp = mm.getParentMember();
        if (mmp != null && mmp.equals(m))
          return true;
      }
      return false;
    }
    throw new Quax.CannotHandleException(f.getFunName());
  }

  /**
   * @param f
   * @param m
   * @return true if FunCall contains descendants of member
   */
  public boolean isDescendantOfMemberInFunCall(Object oFun, Member member)
      throws CannotHandleException {
    FunCall f = (FunCall) oFun;
    mondrian.olap.Member m = ((MondrianMember) member).getMonMember();
    if (f.isCallTo("Children")) {
      mondrian.olap.Member mExp = (mondrian.olap.Member) f.getArg(0);
      return (mExp.isChildOrEqualTo(m));
    } else if (f.isCallTo("Descendants")) {
      mondrian.olap.Member mExp = (mondrian.olap.Member) f.getArg(0);
      return (mExp.isChildOrEqualTo(m));
    } else if (f.isCallTo("Members")) {
      mondrian.olap.Level levExp = (mondrian.olap.Level) f.getArg(0);
      return (levExp.getDepth() > m.getLevel().getDepth());
    } else if (f.isCallTo("Union")) {
      if (isDescendantOfMemberInFunCall(f.getArg(0), member))
        return true;
      else
        return isDescendantOfMemberInFunCall(f.getArg(1), member);
    } else if (f.isCallTo("{}")) {
      for (int i = 0; i < f.getArgs().length; i++) {
        mondrian.olap.Member mExp = (mondrian.olap.Member) f.getArg(i);
        if (mExp.isCalculatedInQuery())
          continue;
        if (!m.equals(mExp) && mExp.isChildOrEqualTo(m))
          return true;
      }
      return false;
    }
    throw new Quax.CannotHandleException(f.getFunName());
  }

  /**
   * remove descendants of member from set Funcall this function is only called if there *are*
   * descendants of member in funcall
   *
   * @param f
   * @param m
   * @return the remainder after descendants were removed
   */
  public Object removeDescendantsFromFunCall(Object oFun, Member member)
      throws CannotHandleException {
    FunCall f = (FunCall) oFun;
    mondrian.olap.Member m = ((MondrianMember) member).getMonMember();
    if (f.isCallTo("Children")) {
      // as we know, that there is a descendent of m in x.children,
      //  we know that *all* x.children are descendants of m
      return null;
    } else if (f.isCallTo("Descendants")) {
      // as we know, that there is a descendent of m in x.descendants
      //  we know that *all* x.descendants are descendants of m
      return null;
    } else if (f.isCallTo("Members")) {
      mondrian.olap.Level levExp = (mondrian.olap.Level) f.getArg(0);
      mondrian.olap.Member[] members = scr.getLevelMembers(levExp);
      List remainder = new ArrayList();
      for (int i = 0; i < members.length; i++) {
        if (!members[i].isChildOrEqualTo(m))
          remainder.add(members[i]);
      }
      return createMemberSet(remainder);
    } else if (f.isCallTo("{}")) {
      List remainder = new ArrayList();
      for (int i = 0; i < f.getArgs().length; i++) {
        mondrian.olap.Member mExp = (mondrian.olap.Member) f.getArg(i);