xmla_model.java

OLAP 的客户端代码

        uri = memento.getUri();
        dataSource = memento.getDataSource();
        catalog = memento.getCatalog();
        mdxQuery = memento.getMdxQuery();

        // 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.

        initialize();
      }

      // need to get the result first, so that members are gotten
      result = (XMLA_Result) getResult();
    } catch (OlapException e) {
      // should really not occur
      String err = e.getMessage();
      logger.fatal(err);
      throw new RuntimeException(err);
    }
    boolean useQuax = memento.isUseQuax();
    queryAdapter.setUseQuax(useQuax);

    if (useQuax) {
      // reset the Quaxes to current state
      QuaxBean[] quaxBeans = memento.getQuaxes();
      Quax quaxes[] = queryAdapter.getQuaxes();
      // update the quaxes
      try {
        quaxesFromBeans(quaxes, quaxBeans);
      } catch (OlapException e) {
        throw new IllegalArgumentException(e.toString());
      }
    }
    // sorting
    XMLA_SortRank sortExt = (XMLA_SortRank) getExtension(SortRank.ID);
    restoreSort(sortExt, memento);

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

    // calc measure property assignment
    calcMeasurePropMap = memento.getCalcMeasurePropMap();
    if (calcMeasurePropMap == null)
      calcMeasurePropMap = new HashMap();
    result = null;
  }

  /**
   *
   * @param rootBean
   * @return
   */
  private TreeNode createPosTreeFromBean(PositionNodeBean rootBean) throws OlapException {
    ExpBean expBean = rootBean.getReference(); // null for root
    Exp exp;
    if (expBean == null)
      exp = null;
    else
      exp = (Exp) createExpFromBean(expBean);
    TreeNode node = new TreeNode(exp);
    PositionNodeBean[] beanChildren = rootBean.getChildren();
    for (int i = 0; i < beanChildren.length; i++) {
      TreeNode childNode = createPosTreeFromBean(beanChildren[i]);
      node.addChildNode(childNode);
    }
    return node;
  }

  /**
   *
   * @param expBean
   * @return
   * @throws OlapException
   */
  protected Object createExpFromBean(ExpBean expBean) throws OlapException {
    if (expBean.getType() == ExpBean.TYPE_MEMBER) {
      XMLA_Member member = (XMLA_Member) lookupMemberByUName(expBean.getName());
      if (member == null) {
        retrieveMember(expBean.getName());
      }
      member = (XMLA_Member) lookupMemberByUName(expBean.getName());
      if (member == null) {
        // probably schema changed, cannot restore state
        throw new OlapException("could not find member " + expBean.getName());
      }
      return member;
    } else if (expBean.getType() == ExpBean.TYPE_FUNCALL) {
      // FunCall
      String name = expBean.getName();
      ExpBean[] argBeans = expBean.getArgs();
      Exp[] args = new Exp[argBeans.length];
      for (int i = 0; i < argBeans.length; i++) {
        args[i] = (Exp) createExpFromBean(argBeans[i]);
      }

      int synType = XMLA_Util.funCallSyntax(name);
      FunCall f = new FunCall(name, args, synType);
      return f;
    } else if (expBean.getType() == ExpBean.TYPE_LEVEL) {
      // Level
      XMLA_Level lev = lookupLevelByUName(expBean.getName());
      if (lev == null) {
        // probably schema changed, cannot restore state
        throw new OlapException("could not find Level " + expBean.getName());
      }
      return lev;
    } else if (expBean.getType() == ExpBean.TYPE_HIER) {
      // Hierarchy
      XMLA_Hierarchy hier = lookupHierByUName(expBean.getName());
      if (hier == null) {
        // probably schema changed, cannot restore state
        throw new OlapException("could not find Hierarchy " + expBean.getName());
      }
      return hier;
    } else if (expBean.getType() == ExpBean.TYPE_DIM) {
      // Dimension
      XMLA_Dimension dim = lookupDimByUName(expBean.getName());
      if (dim == null) {
        // probably schema changed, cannot restore state
        throw new OlapException("could not find Dimension " + expBean.getName());
      }
      return dim;
    } 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();
    if (exp instanceof Member) {
      XMLA_Member m = (XMLA_Member) exp;
      bean.setType(ExpBean.TYPE_MEMBER);
      bean.setName(m.getUniqueName());
      bean.setArgs(new ExpBean[0]);
    } else if (exp instanceof FunCall) {
      FunCall f = (FunCall) exp;
      bean.setType(ExpBean.TYPE_FUNCALL);
      bean.setName(f.getFunction());
      ExpBean[] args = new ExpBean[f.getArgs().length];
      for (int i = 0; i < args.length; i++) {
        args[i] = createBeanFromExp(f.getArgs()[i]);
      }
      bean.setArgs(args);
    } else if (exp instanceof Level) {
      XMLA_Level lev = (XMLA_Level) exp;
      bean.setType(ExpBean.TYPE_LEVEL);
      bean.setName(lev.getUniqueName());
      bean.setArgs(new ExpBean[0]);
    } else if (exp instanceof Hierarchy) {
      XMLA_Hierarchy hier = (XMLA_Hierarchy) exp;
      bean.setType(ExpBean.TYPE_HIER);
      bean.setName(hier.getUniqueName());
      bean.setArgs(new ExpBean[0]);
    } else if (exp instanceof Dimension) {
      XMLA_Dimension dim = (XMLA_Dimension) exp;
      bean.setType(ExpBean.TYPE_DIM);
      bean.setName(dim.getUniqueName());
      bean.setArgs(new ExpBean[0]);
    } else if (exp instanceof Literal) {
      Literal lit = (Literal) exp;
      Object val = lit.getValueObject();
      if (lit.type == Literal.TYPE_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());
    }
    return bean;
  }

  /**
   * 
   * @param mdxQuery
   */
  private void parse(String mdxQuery) throws OlapException {

    // parse the query string 
    parser parser_obj;
    Reader reader = new StringReader(mdxQuery);
    parser_obj = new parser(new Lexer(reader));

    Symbol parse_tree = null;
    pQuery = null;
    try {
      parse_tree = parser_obj.parse();
    } catch (Exception e) {
      throw new OlapException(e);
    }
    pQuery = (ParsedQuery) parse_tree.value;
    pQuery.afterParse();

    String newCube = pQuery.getCube();
    if (cube == null || !cube.equals(newCube)) {
      isNewCube = true;
      cube = newCube;
    }
  }

  /**
   * get meta data from mdx data source
   */
  private void initCubeMetaData() throws OlapException {

    /*
     // find out, whether this cube contains mandatory SAP variables
     //  SAP bug
     //  SAP variables are not returned fully,
     //  only data type and description.
     if (this.isSAP()){
     List sapvars = discoverer.discoverSapVar(catalog, pQuery.getCube());
     }
     */

    // read dimensions
    List dims = soap.discoverDim(catalog, pQuery.getCube());
    evaluateDimensions(dims);

    // read hierarchies
    List hiers = soap.discoverHier(catalog, pQuery.getCube(), null);
    evaluateHiers(hiers);

    // now, as we got all hierarchies, assign them to the dimensions
    // first, create HashMap of dimensions
    HashMap hDim = new HashMap();
    for (Iterator iter = aDimensions.iterator(); iter.hasNext();) {
      XMLA_Dimension dim = (XMLA_Dimension) iter.next();
      hDim.put(dim.getUniqueName(), dim);
    }
    for (Iterator iter = aHierarchies.iterator(); iter.hasNext();) {
      XMLA_Hierarchy hier = (XMLA_Hierarchy) iter.next();
      XMLA_Dimension dim = (XMLA_Dimension) hDim.get(hier.getDimUniqueName());
      if (dim != null) {
        dim.addHier(hier);
        hier.setDimension(dim);
      }
    }

    // read levels
    List levels = soap.discoverLev(catalog, pQuery.getCube(), null, null);
    evaluateLevels(levels);

    // now, as we got all Levels, assign them to the hierarchies
    // first, create HashMap of dimensions
    HashMap hHier = new HashMap();
    for (Iterator iter = aHierarchies.iterator(); iter.hasNext();) {
      XMLA_Hierarchy hier = (XMLA_Hierarchy) iter.next();
      hHier.put(hier.getUniqueName(), hier);
    }
    for (Iterator iter = aLevels.iterator(); iter.hasNext();) {
      XMLA_Level lev = (XMLA_Level) iter.next();
      XMLA_Hierarchy hier = (XMLA_Hierarchy) hHier.get(lev.getHierUniqueName());
      if (hier != null) {
        hier.addLevel(lev);
        lev.setHierarchy(hier);
      }
    }

    // now go through levels of hierarchy and set the child/parent pointers
    for (Iterator iter = aHierarchies.iterator(); iter.hasNext();) {
      XMLA_Hierarchy hier = (XMLA_Hierarchy) iter.next();
      adjustLevels(hier);
    }

    // get all properties for the cube
    //  assign properties to levels (not SAP)
    //  assign properties to dimensions (SAP)
    List propList = null;
    try {
      propList = soap.discoverProp(getCatalog(), getCube(), null, null, null);
    } catch (OlapException e) {
      // not handled
      logger.error("?", e);
    }

    if (propList != null && propList.size() > 0) {
      PropLoop: for (Iterator iterator = propList.iterator(); iterator.hasNext();) {
        OlapItem poi = (OlapItem) iterator.next();
        String name = poi.getName();
        // what is the level for this property
        //  SAP: level information is garbage
        String propType = poi.getProperty("PROPERTY_TYPE");
        // 1 == MDPROP_MEMBER
        // 2 = MDPROP_CELL
        if (!"1".equals(propType))
          continue PropLoop; // only member properties
        String levUName = poi.getProperty("LEVEL_UNIQUE_NAME");
        String dimUName = poi.getProperty("DIMENSION_UNIQUE_NAME");
        String caption = poi.getCaption();
        if (caption == null)
          caption = name;
        XMLA_Dimension dim = this.lookupDimByUName(dimUName);
        if (this.isSAP() || this.isMondrian()) {
          // dimension contain the properties
          XMLA_MemberProp prop = new XMLA_MemberProp(name, caption, dim);
          dim.addProp(prop);

        } else {
          // Microsoft, use Level
          if (levUName != null && levUName.length() > 0) {
            XMLA_Level level = lookupLevelByUName(levUName);
            XMLA_MemberProp prop = new XMLA_MemberProp(name, caption, level);
            level.addProp(prop);
          }
        }

      }
    }

  }

  /**
   * set paren and child level
   * @param hier
   */
  private void adjustLevels(XMLA_Hierarchy hier) {
    XMLA_Level[] levels = (XMLA_Level[]) hier.getLevels();
    XMLA_Level[] orderedLevels = new XMLA_Level[levels.length];
    for (int i = 0; i < levels.length; i++) {
      int num = levels[i].getDepth();
      orderedLevels[num] = levels[i];
    }
    for (int i = 0; i < levels.length; i++) {
      int num = levels[i].getDepth();
      if (num > 0) {
        levels[i].setParentLevel(orderedLevels[num - 1]);
      } else {
        levels[i].setParentLevel(null);
      }

      if (num < levels.length - 1) {
        levels[i].setChildLevel(orderedLevels[num + 1]);
      } else {
        levels[i].setChildLevel(null);
      }
    }

  }

  /**
   * Evaluate the result of Discovery MDSCHEMA_DIMENSIONS request
   * @param dims list of dimension items
   */
  private void evaluateDimensions(List dims) {

    for (Iterator iter = dims.iterator(); iter.hasNext();) {
      OlapItem dimit = (OlapItem) iter.next();

      XMLA_Dimension dim = new XMLA_Dimension();
      dim.setName(dimit.getName());
      dim.setCaption(dimit.getCaption());
      dim.setUniqueName(dimit.getUniqueName());

      String str = dimit.getProperty("DIMENSION_ORDINAL");
      if (str != null)
        dim.setOrdinal(Integer.parseInt(str));

      str = dimit.getProperty("DIMENSION_TYPE");
      if (str != null)
        dim.setType(Integer.parseInt(str));

      str = dimit.getProperty("DIMENSION_CARDINALITY");
      if (str != null)
        dim.setCardinality(Integer.parseInt(str));

      str = dimit.getProperty("DEFAULT_HIERARCHY");
      if (str != null)
        dim.setDefaultHier(str);

      str = dimit.getProperty("IS_VIRTUAL");
      if (str != null)
        dim.setVirtual(str.equals("true"));

      str = dimit.getProperty("IS_READWRITE");
      if (str != null)
        dim.setReadWrite(str.equals("true"));

      str = dimit.getProperty("DIMENSION_UNIQUE_SETTINGS");
      if (str != null)
        dim.setUniqueSettings(Integer.parseInt(str));

      str = dimit.getProperty("DIMENSION_IS_VISIBLE");
      if (str != null)
        dim.setVisible(str.equals("true"));

      aDimensions.add(dim);
    }

  }

  /**
   * Evaluate the result of Discovery MDSCHEMA_HIERARCHIES request
   * @param hiers list of olap items
   */
  private void evaluateHiers(List hiers) {

    for (Iterator iter = hiers.iterator(); iter.hasNext();) {
      OlapItem hierit = (OlapItem) iter.next();

      XMLA_Hierarchy hier = new XMLA_Hierarchy(this);
      // hier.setName(hierit.getName());
      hier.setCaption(hierit.getCaption());
      hier.setUniqueName(hierit.getUniqueName());

      String str = hierit.getProperty("HIERARCHY_CAPTION");
      if (str != null)
        hier.setCaption(str);

      str = hierit.getProperty("DIMENSION_UNIQUE_NAME");
      if (str != null)
        hier.setDimUniqueName(str);

      str = hierit.getProperty("DIMENSION_TYPE");
      if (str != null)
        hier.setDimType(Integer.parseInt(str));

      str = hierit.getProperty("HIERARCHY_CARDINALITY");
      if (str != null)
        hier.setCardinality(Integer.parseInt(str));

      str = hierit.getProperty("DEFAULT_MEMBER");
      if (str != null)
        hier.setDefaultMember(str);

      str = hierit.getProperty("ALL_MEMBER");
      if (str != null)
        hier.setAllMember(str);

      str = hierit.getProperty("STRUCTURE");
      if (str != null)
        hier.setStructure(Integer.parseInt(str));

      str = hierit.getProperty("IS_VIRTUAL");
      if (str != null)
        hier.setVirtual(str.equals("true"));

      str = hierit.getProperty("IS_READWRITE");
      if (str != null)
        hier.setReadWrite(str.equals("true"));

      str = hierit.getProperty("DIMENSION_UNIQUE_SETTINGS");
      if (str != null)
        hier.setDimUniqueSettings(Integer.parseInt(str));

      str = hierit.getProperty("DIMENSION_IS_VISIBLE");
      if (str != null)
        hier.setDimVisible(str.equals("true"));

      str = hierit.getProperty("HIERARCHY_ORDINAL");
      if (str != null)
        hier.setOrdinal(Integer.parseInt(str));

      str = hierit.getProperty("DIMENSION_IS_SHARED");
      if (str != null)
        hier.setDimShared(str.equals("true"));

      aHierarchies.add(hier);
    }
  }

  /**
   * Evaluate the result of Discovery MDSCHEMA_LEVELS request
   * @param levels List of OlapItems
   */
  private void evaluateLevels(List levels) {

    for (Iterator iter = levels.iterator(); iter.hasNext();) {
      OlapItem levit = (OlapItem) iter.next();
      XMLA_Level lev = new XMLA_Level(this);
      lev.setName(levit.getName());
      lev.setCaption(levit.getCaption());
      lev.setUniqueName(levit.getUniqueName());

      String str = levit.getProperty("DIMENSION_UNIQUE_NAME");
      if (str != null)
        lev.setDimUniqueName(str);