mondrianmodel.java

OLAP 的客户端代码

    // clear slicer, members in slicer are supposed to be not intensional
    mQuery.slicer = null;
    // regenerate query from quaxes
    queryAdapter.onExecute();
    // remove formulas, which are not for measures only
    Formula[] formulas = mQuery.getFormulas();
    for (int i = 0; i < formulas.length; i++) {
      mondrian.olap.Member m = formulas[i].getMdxMember();
      boolean remove = false;
      if (!m.getDimension().isMeasures()) {
        // not measures - remove
        remove = true;
      } else {
        mondrian.olap.Exp exp = formulas[i].getExpression();
        if (notMeasures(exp))
          remove = true;
      }
      if (remove) {
        String name = formulas[i].getMdxMember().getUniqueName();
        if (mQuery.canRemoveFormula(name)) {
          mQuery.removeFormula(name, true);
        } else {
          logger.fatal("cannot remove formula " + formulas[i].getName());
        }
      }
    }

    queryAdapter.onExecute(); // rewrites currentMdx
    String newMdx = this.currentMdx;
    // restore state
    queryAdapter.setQuaxes(saveQuaxes);
    queryAdapter.setMonQuery(cloneQuery);
    this.currentMdx = saveMdx;
    return newMdx;
  }

  /**
   * @return true, 
   *    if exp refers to members of a dimension other than Measures
   */
  private boolean notMeasures(mondrian.olap.Exp exp) {
    if (exp instanceof mondrian.olap.Member) {
      mondrian.olap.Member m = (mondrian.olap.Member) exp;
      if (m.getDimension().isMeasures())
        return false;
      else
        return true;
    } else if (exp instanceof mondrian.olap.FunCall) {
      mondrian.olap.FunCall f = (FunCall) exp;
      Exp[] args = f.getArgs();
      for (int i = 0; i < args.length; i++) {
        if (notMeasures(args[i]))
          return true;
      }
    }
    return false;
  }

  /**
   * creates a memento which is initialized except the quaxes and mdxQuery
   * @see Memento#setQuaxes
   */
  private MondrianMemento createMemento() {
    MondrianMemento memento = new MondrianMemento();
    memento.setJdbcDriver(jdbcDriver);
    memento.setConnectString(connectString);
    memento.setVersion(MondrianMemento.CURRENT_VERSION);
    // axes swapped
    memento.setAxesSwapped(queryAdapter.isSwapAxes());
    // sorting
    MondrianSortRank sortExt = (MondrianSortRank) getExtension(SortRank.ID);
    if (sortExt != null)
      storeSort(sortExt, memento);
    return memento;
  }

  private MondrianQuaxBean intensionalQuaxBeanFromAxis(MondrianAxis axis) throws OlapException {
    MondrianQuaxBean quaxBean = new MondrianQuaxBean();
    MondrianHierarchy[] hiers = (MondrianHierarchy[]) axis.getHierarchies();

    quaxBean.setNDimension(hiers.length);
    quaxBean.setHierarchizeNeeded(false);
    quaxBean.setOrdinal(axis.getOrdinal());

    PositionNodeBean rootBean = new PositionNodeBean();
    rootBean.setReference(null);
    quaxBean.setPosTreeRoot(rootBean);

    PositionNodeBean parentBean = rootBean;
    for (int i = 0; i < hiers.length; i++) {
      ExpBean expBean;
      if (hiers[i].getDimension().isMeasure()) {
        Exp exp = createMeasuresExp(axis, i);
        expBean = createBeanFromExp(exp);
      } else {
        // the toplevel members may have changed when the bookmark is restored,
        // so we can not compute them here
        ExpBean hierBean = createBeanFromExp(hiers[i].getMonHierarchy());
        expBean = new ExpBean();
        expBean.setType(ExpBean.TYPE_TOPLEVEL_MEMBERS);
        expBean.setArgs(new ExpBean[] { hierBean});
      }
      PositionNodeBean nodeBean = new PositionNodeBean();
      nodeBean.setReference(expBean);
      parentBean.setChildren(new PositionNodeBean[] { nodeBean});
      parentBean = nodeBean;
    }
    return quaxBean;
  }

  /**
   * creates an Exp for the visible Measures
   * @param axis the axis containing the measures dimension
   * @param i the i-th hiararchy on that axis is the measures hierarchy
   */
  private Exp createMeasuresExp(MondrianAxis axis, int i) {
    List measuresList = new ArrayList();
    Set measuresSet = new HashSet();
    for (Iterator it = axis.getPositions().iterator(); it.hasNext();) {
      MondrianPosition mp = (MondrianPosition) it.next();
      MondrianMember member = (MondrianMember) mp.getMembers()[i];
      if (measuresSet.add(member))
        measuresList.add(member.getMonMember());
    }
    if (measuresList.size() == 1)
      return (Exp) measuresList.get(0);
    Exp[] args = (Exp[]) measuresList.toArray(new Exp[measuresList.size()]);
    return new FunCall("{}", Syntax.Braces, args);
  }

  /**
   * restore state from Memento.
   *
   * @param Object
   *          state bean to be restored
   */
  public void setBookmarkState(Object state) {

    MondrianMemento memento = (MondrianMemento) state;
    int version = memento.getVersion();
    if (version <= 1) {
      logger.warn("Bookmark is of old state (not supported any more in the future)!\nPlease save again!");
    }
    mdxQuery = memento.getMdxQuery();

    if (isInitialized) {
      // already initialized, only new query adapter needed

      mondrian.olap.Query monQuery = null;
      try {
        monQuery = parseMDX();
      } catch (OlapException e) {
        // should really not occur
        String err = e.getMessage();
        logger.fatal(err);
        throw new RuntimeException(err);
      }

      // bookmark may change the cube of the same schema (aml does so)
      resetMetaData(monQuery);

      queryAdapter = new MondrianQueryAdapter(this, monQuery);

      MondrianSortRank sortExt = (MondrianSortRank) getExtension(SortRank.ID);
      if (sortExt != null)
        sortExt.reset();

    } else {

      connectString = memento.getConnectString();
      jdbcDriver = memento.getJdbcDriver();

      // Regardless of any state, we will have to process the start MDX.
      //  It might contain WITH MEMBER declarations, which must not be lost.
      //  The start MDX is processed in the QueryAdapter c'tor.
      try {
        initialize();
      } catch (OlapException e) {
        // should really not occur
        String err = e.getMessage();
        logger.fatal(err);
        throw new RuntimeException(err);
      }
      // do we have to get a result ???
    }

    boolean useQuax = true;
    if (version >= 3) {
      useQuax = memento.isUseQuax();
      queryAdapter.setUseQuax(useQuax);
    }

    if (useQuax) {
      // reset the Quaxes to current state
      MondrianQuaxBean[] quaxBeans = (MondrianQuaxBean[]) memento.getQuaxes();
      MondrianQuax quaxes[] = (MondrianQuax[]) queryAdapter.getQuaxes();
      // update the quaxes

      if (version <= 1) {
        for (int i = 0; i < quaxes.length; i++) {
          boolean qubonMode = quaxBeans[i].isQubonMode();

          quaxes[i].setQubonMode(qubonMode);

          // handle old stuff as of MDX version 2
          if (qubonMode)
            MondrianOldStuff.handleQubonMode(quaxes[i], quaxBeans[i], this);
          else
            MondrianOldStuff.handleDrillExMode(quaxes[i], quaxBeans[i], this);
        }
      } else {
        try {
          quaxesFromBeans(quaxes, quaxBeans);
        } catch (OlapException e) {
          logger.error(null, e);
          throw new IllegalArgumentException(e.toString());
        }
      }
    }

    // sorting
    MondrianSortRank sortExt = (MondrianSortRank) getExtension(SortRank.ID);
    restoreSort(sortExt, memento);

    // swap axes if neccessary
    queryAdapter.setSwapAxes(memento.isAxesSwapped());

    // we can not fire a structureChanged event here because the bookmark state
    // of other (GUI) components may already be restored. If they receive a
    // structureChanged they would throw away their bookmark state.
    fireModelChanged();
  }

  private Exp[] createExpsFromBeans(ExpBean[] beans) throws OlapException {
    Exp[] exps = new Exp[beans.length];
    for (int i = 0; i < beans.length; i++) {
      exps[i] = (Exp) createExpFromBean(beans[i]);
    }
    return exps;
  }

  /**
   * create Mondrian exp from expBean
   * @param expBean
   * @return @throws
   *         OlapException
   */
  protected Object createExpFromBean(ExpBean expBean) throws OlapException {
    if (expBean.getType() == ExpBean.TYPE_TOPLEVEL_MEMBERS) {
      SchemaReader scr = getMonConnection().getSchemaReader();
      Exp[] args = createExpsFromBeans(expBean.getArgs());
      mondrian.olap.Hierarchy h = (mondrian.olap.Hierarchy) args[0];
      return MondrianUtil.topLevelMembers(h, false, scr);
    }

    if (expBean.getType() == ExpBean.TYPE_MEMBER) {
      MondrianMember member = (MondrianMember) lookupMemberByUName(expBean.getName());
      if (member == null) {
        // probably schema changed, cannot restore state
        throw new OlapException("could not find member " + expBean.getName());
      }
      return member.getMonMember();
    }

    if (expBean.getType() == ExpBean.TYPE_FUNCALL) {
      // FunCall
      String name = expBean.getName();
      ExpBean[] argBeans = expBean.getArgs();
      Exp[] args = createExpsFromBeans(argBeans);
      Syntax syntax = MondrianUtil.funCallSyntax(name, argBeans.length);
      return new FunCall(name, syntax, args);
    }

    if (expBean.getType() == ExpBean.TYPE_LEVEL) {
      // Level
      MondrianLevel lev = this.lookupLevel(expBean.getName());
      if (lev == null) {
        // probably schema changed, cannot restore state
        throw new OlapException("could not find Level " + expBean.getName());
      }
      return lev.getMonLevel();
    } else if (expBean.getType() == ExpBean.TYPE_HIER) {
      // Hierarchy
      MondrianHierarchy hier = this.lookupHierarchy(expBean.getName());
      if (hier == null) {
        // probably schema changed, cannot restore state
        throw new OlapException("could not find Hierarchy " + expBean.getName());
      }
      return hier.getMonHierarchy();
    } else if (expBean.getType() == ExpBean.TYPE_DIM) {
      // Dimension
      MondrianDimension dim = this.lookupDimension(expBean.getName());
      if (dim == null) {
        // probably schema changed, cannot restore state
        throw new OlapException("could not find Dimension " + expBean.getName());
      }
      return dim.getMonDimension();
    } else if (expBean.getType() == ExpBean.TYPE_STRING_LITERAL) {
      // String literal
      String str = (String) expBean.getLiteralValue();
      return Literal.createString(str);
    } else if (expBean.getType() == ExpBean.TYPE_INTEGER_LITERAL) {
      // Integer literal
      Integer iii = (Integer) expBean.getLiteralValue();
      return Literal.create(iii);
    } else if (expBean.getType() == ExpBean.TYPE_DOUBLE_LITERAL) {
      // Double literal
      Double ddd = (Double) expBean.getLiteralValue();
      return Literal.create(ddd);
    } else
      throw new OlapException("Invalid ExpBean Type " + expBean.getType());

  }

  protected ExpBean createBeanFromExp(Object exp) throws OlapException {
    ExpBean bean = new ExpBean();
    
    // we unwrap the new MemberListScalarExp etc, they will be wrapped again
    // when we restore the bookmark and call resolve(). So here we do the
    // opposite of {@link mondrian.olap.fun.FunTableImpl#createValueFunCall()}
    
    if (exp instanceof MemberListScalarExp) {
      MemberListScalarExp mse = (MemberListScalarExp)exp;
      bean.setType(ExpBean.TYPE_FUNCALL);
      bean.setName("()");
      bean.setArgs(createBeansFromExps(mse.getChildren()));
    } else if (exp instanceof MemberScalarExp) {
      MemberScalarExp mse = (MemberScalarExp)exp;
      bean = createBeanFromExp(mse.getChildren()[0]);
    } else if (exp instanceof TupleScalarExp) {
      TupleScalarExp mse = (TupleScalarExp)exp;
      bean = createBeanFromExp(mse.getChildren()[0]);
    } else if (exp instanceof mondrian.olap.FunCall) {
      FunCall f = (FunCall) exp;
      bean.setType(ExpBean.TYPE_FUNCALL);
      bean.setName(f.getFunName());
      bean.setArgs(createBeansFromExps(f.getArgs()));
    } else if (exp instanceof mondrian.olap.Member) {
      mondrian.olap.Member m = (mondrian.olap.Member) exp;
      bean.setType(ExpBean.TYPE_MEMBER);
      bean.setName(m.getUniqueName());
      bean.setArgs(new ExpBean[0]);
    } else if (exp instanceof mondrian.olap.Level) {
      mondrian.olap.Level lev = (mondrian.olap.Level) exp;
      bean.setType(ExpBean.TYPE_LEVEL);
      bean.setName(lev.getUniqueName());
      bean.setArgs(new ExpBean[0]);
    } else if (exp instanceof mondrian.olap.Hierarchy) {
      mondrian.olap.Hierarchy hier = (mondrian.olap.Hierarchy) exp;
      bean.setType(ExpBean.TYPE_HIER);
      bean.setName(hier.getUniqueName());
      bean.setArgs(new ExpBean[0]);
    } else if (exp instanceof mondrian.olap.Dimension) {
      mondrian.olap.Dimension dim = (mondrian.olap.Dimension) exp;
      bean.setType(ExpBean.TYPE_DIM);
      bean.setName(dim.getUniqueName());
      bean.setArgs(new ExpBean[0]);
    } else if (exp instanceof mondrian.olap.Literal) {
      mondrian.olap.Literal lit = (mondrian.olap.Literal) exp;
      Object val = lit.getValue();
      if (lit.type == Category.Numeric) {
        if (val instanceof Integer)
          bean.setType(ExpBean.TYPE_INTEGER_LITERAL);
        else
          bean.setType(ExpBean.TYPE_DOUBLE_LITERAL);
      } else {
        bean.setType(ExpBean.TYPE_STRING_LITERAL);
      }
      bean.setLiteralValue(val);
      bean.setArgs(new ExpBean[0]);
    } else {
      logger.fatal("cannot create ExpBean type =" + exp.getClass().toString());
      throw new IllegalArgumentException(exp.getClass().toString());
    }

    return bean;
  }

  private ExpBean[] createBeansFromExps(Object[] exps) throws OlapException {
    ExpBean[] beans = new ExpBean[exps.length];
    for (int i = 0; i < exps.length; i++) {
      beans[i] = createBeanFromExp(exps[i]);
    }
    return beans;
  }

  public DataSource getSqlDataSource() {
    return ((RolapConnection) monConnection).getDataSource();
  }

  public String getDynresolver() {
    return dynresolver;
  }

  public void setDynresolver(String dynresolver) {
    this.dynresolver = dynresolver;
  }

  public void setServletContext(ServletContext servletContext) {
    this.servletContext = servletContext;
  }

  /**
   * get Mondrian Connection Pooling property
   */
  public boolean isConnectionPooling() {
    return connectionPooling;
  }

  /**
   * set Mondrian Connection Pooling property
   */
  public void setConnectionPooling(boolean connectionPooling) {
    this.connectionPooling = connectionPooling;
  }

  /**
   * get the external DataSource to be used by Mondrian
   */
  public DataSource getExternalDataSource() {
    return externalDataSource;
  }

  /**
   * set the external DataSource to be used by Mondrian
   */
  public void setExternalDataSource(DataSource externalDataSource) {
    this.externalDataSource = externalDataSource;
  }
  /**
   * Getter for property dynLocale.
   * @return Value of property dynLocale.
   */
  public String getDynLocale() {
      return this.dynLocale;
  }
  
  /**
   * Setter for property dynLocale.
   * @param dynLocale New value of property dynLocale.
   */
  public void setDynLocale(String dynLocale) {
      this.dynLocale = dynLocale;
  }

} // End MondrianModel