Пример #1
0
  public static void main1(String[] args) throws ClassNotFoundException, SQLException {
    OlapConnection conn = getConnection(url);
    CellSet cs = getResultSet(mdx, conn);
    // CellSetAxis c;

    int count = 0;
    if (cs.getAxes().size() > 1) {
      for (Position row : cs.getAxes().get(1)) {
        for (Position column : cs.getAxes().get(0)) {
          for (Member member : row.getMembers()) {
            System.out.println("rows:" + member.getUniqueName());
          }
          for (Member member : column.getMembers()) {
            System.out.println("columns:" + member.getUniqueName());
          }
          final Cell cell = cs.getCell(column, row);

          System.out.println("values:" + cell.getValue());

          Position[] positions = new Position[2];
          positions[0] = column;
          positions[1] = row;

          OlapCell oalpCell = new OlapCell(positions, cell.getValue());

          System.out.println("****" + oalpCell.toString());
          System.out.println(count++);
        }
      }
    }
  }
Пример #2
0
 private int getMemberIndex(int depth, int index) {
   if (depth - 1 < measuresAt) {
     Member m =
         dataAxisInfo.fullPositions.get(index).getMembers().get(dataAxisInfo.measuresMember);
     if (uniqueToSelected.containsKey(m.getUniqueName())) {
       return uniqueToSelected.get(m.getUniqueName());
     }
   }
   return 0;
 }
Пример #3
0
 private static String getParameterValue(
     TargetParameter parameter, WhatIfEngineInstance ei, SpagoBICellWrapper cell) {
   if (parameter.isAbsolute()) {
     return parameter.getValue();
   }
   String value = null;
   String dimensionName = parameter.getDimension();
   String hierarchyName = parameter.getHierarchy();
   String levelName = parameter.getLevel();
   String propertyName = parameter.getProperty();
   logger.debug(
       "Looking for dimension "
           + dimensionName
           + ", hierarchy "
           + hierarchyName
           + ", level "
           + levelName
           + ", property "
           + propertyName
           + " ...");
   Hierarchy hierarchy =
       getHierarchy(ei.getSpagoBIPivotModel().getCube(), ei.getModelConfig(), dimensionName);
   Member member = cell.getContextMember(hierarchy);
   logger.debug("Considering context member " + member.getUniqueName());
   logger.debug("Member hierarchy is " + hierarchy.getUniqueName());
   if (hierarchy.getUniqueName().equals(hierarchyName)) {
     if (propertyName == null || propertyName.trim().equals("")) {
       value = getLevelValue(member, levelName);
     } else {
       value = getMemberPropertyValue(member, propertyName);
     }
   }
   return value;
 }
 public String toString() {
   final StringBuilder sb = new StringBuilder();
   sb.append("LocalizedString");
   sb.append("{description=").append(description);
   sb.append(", member=").append(member.getUniqueName());
   sb.append('}');
   return sb.toString();
 }
Пример #5
0
 public Format getValueFormat(int position, int member) {
   int formatIndex = 0;
   if (dataAxisInfo.measuresMember >= 0) {
     formatIndex = member;
   } else if (totalsAxisInfo.measuresMember >= 0) {
     Member m =
         totalsAxisInfo
             .fullPositions
             .get(position)
             .getMembers()
             .get(totalsAxisInfo.measuresMember);
     if (uniqueToSelected.containsKey(m.getUniqueName())) {
       formatIndex = uniqueToSelected.get(m.getUniqueName());
     }
   }
   return valueFormats[formatIndex];
 }
Пример #6
0
  public ResultSet drillthrough(
      String queryName, List<Integer> cellPosition, Integer maxrows, String returns) {
    OlapStatement stmt = null;
    try {
      IQuery query = getIQuery(queryName);
      CellSet cs = query.getCellset();
      SaikuCube cube = getQuery(queryName).getCube();
      final OlapConnection con = olapDiscoverService.getNativeConnection(cube.getConnectionName());
      stmt = con.createStatement();

      String select = null;
      StringBuffer buf = new StringBuffer();
      buf.append("SELECT (");
      for (int i = 0; i < cellPosition.size(); i++) {
        List<Member> members =
            cs.getAxes().get(i).getPositions().get(cellPosition.get(i)).getMembers();
        for (int k = 0; k < members.size(); k++) {
          Member m = members.get(k);
          if (k > 0 || i > 0) {
            buf.append(", ");
          }
          buf.append(m.getUniqueName());
        }
      }
      buf.append(") ON COLUMNS \r\n");
      buf.append("FROM " + cube.getCubeName() + "\r\n");

      SelectNode sn = (new DefaultMdxParserImpl().parseSelect(getMDXQuery(queryName)));
      final Writer writer = new StringWriter();
      sn.getFilterAxis().unparse(new ParseTreeWriter(new PrintWriter(writer)));
      if (StringUtils.isNotBlank(writer.toString())) {
        buf.append("WHERE " + writer.toString());
      }
      select = buf.toString();
      if (maxrows > 0) {
        select = "DRILLTHROUGH MAXROWS " + maxrows + " " + select + "\r\n";
      } else {
        select = "DRILLTHROUGH " + select + "\r\n";
      }
      if (StringUtils.isNotBlank(returns)) {
        select += "\r\n RETURN " + returns;
      }

      log.debug("Drill Through for query (" + queryName + ") : \r\n" + select);
      ResultSet rs = stmt.executeQuery(select);
      return rs;
    } catch (Exception e) {
      throw new SaikuServiceException("Error DRILLTHROUGH: " + queryName, e);
    } finally {
      try {
        if (stmt != null) stmt.close();
      } catch (Exception e) {
      }
    }
  }
Пример #7
0
  public OlapCell(Position[] positions, Object value) {
    v = value;
    for (int i = 0; i < positions.length; i++) {
      Set<String> set = new HashSet<String>();

      for (Member member : positions[i].getMembers()) {
        set.add(member.getUniqueName());
      }

      coordinate.put(String.valueOf(i), set);
    }
  }
Пример #8
0
 private static String getLevelValue(Member member, String levelName) {
   logger.debug("IN: Member is " + member.getUniqueName() + ", levelName is " + levelName);
   String toReturn = null;
   Level level = member.getLevel();
   logger.debug("Member level is " + level.getUniqueName());
   if (level.getUniqueName().equals(levelName)) {
     logger.debug("Member level matches input level name " + levelName + "!!");
     String uniqueName = member.getUniqueName();
     toReturn =
         uniqueName.substring(uniqueName.lastIndexOf("].[") + 3, uniqueName.lastIndexOf("]"));
   } else {
     logger.debug("Member level does NOT match input level name " + levelName + "!!");
     // look for parent member at parent level
     Member parent = member.getParentMember();
     if (parent == null) {
       return null;
     } else {
       return getLevelValue(parent, levelName);
     }
   }
   logger.debug("OUT: returning " + toReturn);
   return toReturn;
 }
 /**
  * Prints an axis and its members.
  *
  * @param pw Print writer
  * @param axis Axis
  */
 private static void printAxis(PrintWriter pw, CellSetAxis axis) {
   List<Position> positions = axis.getPositions();
   for (Position position : positions) {
     boolean firstTime = true;
     pw.print("{");
     for (Member member : position.getMembers()) {
       if (!firstTime) {
         pw.print(", ");
       }
       pw.print(member.getUniqueName());
       firstTime = false;
     }
     pw.println("}");
   }
 }
Пример #10
0
 private static String getMemberPropertyValue(Member member, String propertyName) {
   logger.debug("IN: Member is " + member.getUniqueName() + ", propertyName is " + propertyName);
   String toReturn = null;
   Property property = member.getProperties().get(propertyName);
   if (property != null) {
     try {
       toReturn = member.getPropertyValue(property).toString();
     } catch (OlapException e) {
       logger.error("Error getting the property " + propertyName + " from the cube ", e);
       throw new SpagoBIEngineRuntimeException(
           "Error getting the property " + propertyName + " ", e);
     }
   }
   logger.debug("OUT: returning " + toReturn);
   return toReturn;
 }
Пример #11
0
  /**
   * Populates cells in the matrix corresponding to a particular axis.
   *
   * @param matrix Matrix to populate
   * @param axis Axis
   * @param axisInfo Description of axis
   * @param isColumns True if columns, false if rows
   * @param offset Ordinal of first cell to populate in matrix
   */
  private void populateAxis(
      final Matrix matrix,
      final CellSetAxis axis,
      final AxisInfo axisInfo,
      final boolean isColumns,
      final int offset) {

    if (axis == null) return;
    final Member[] prevMembers = new Member[axisInfo.getWidth()];
    final MemberCell[] prevMemberInfo = new MemberCell[axisInfo.getWidth()];
    final Member[] members = new Member[axisInfo.getWidth()];

    for (int i = 0; i < axis.getPositions().size(); i++) {
      final int x = offset + i;
      final Position position = axis.getPositions().get(i);
      int yOffset = 0;
      final List<Member> memberList = position.getMembers();
      final Map<Hierarchy, List<Integer>> lvls = new HashMap<>();
      for (int j = 0; j < memberList.size(); j++) {
        Member member = memberList.get(j);
        final AxisOrdinalInfo ordinalInfo = axisInfo.ordinalInfos.get(j);
        List<Integer> depths = ordinalInfo.depths;
        Collections.sort(depths);
        lvls.put(member.getHierarchy(), depths);
        if (ordinalInfo.getDepths().size() > 0
            && member.getDepth() < ordinalInfo.getDepths().get(0)) break;
        final int y = yOffset + ordinalInfo.depths.indexOf(member.getDepth());
        members[y] = member;
        yOffset += ordinalInfo.getWidth();
      }

      boolean expanded = false;
      boolean same = true;
      for (int y = 0; y < members.length; y++) {
        final MemberCell memberInfo = new MemberCell();
        final Member member = members[y];
        expanded = false;
        int index = memberList.indexOf(member);
        if (index >= 0) {
          final AxisOrdinalInfo ordinalInfo = axisInfo.ordinalInfos.get(index);
          int depth_i = ordinalInfo.getDepths().indexOf(member.getDepth());
          if (depth_i > 0) {
            expanded = true;
          }
        }
        memberInfo.setExpanded(expanded);
        same = same && i > 0 && Olap4jUtil.equal(prevMembers[y], member);

        if (member != null) {
          if (lvls != null && lvls.get(member.getHierarchy()) != null) {
            memberInfo.setProperty(
                "levelindex",
                "" + lvls.get(member.getHierarchy()).indexOf(member.getLevel().getDepth()));
          }
          if (x - 1 == offset) memberInfo.setLastRow(true);

          matrix.setOffset(offset);
          memberInfo.setRawValue(member.getUniqueName());
          memberInfo.setFormattedValue(member.getCaption()); // First try to get a formatted value
          memberInfo.setParentDimension(member.getDimension().getName());
          memberInfo.setHierarchy(member.getHierarchy().getUniqueName());
          memberInfo.setLevel(member.getLevel().getUniqueName());
          memberInfo.setUniquename(member.getUniqueName());
          //					try {
          //						memberInfo.setChildMemberCount(member.getChildMemberCount());
          //					} catch (OlapException e) {
          //						e.printStackTrace();
          //						throw new RuntimeException(e);
          //					}
          //					NamedList<Property> values = member.getLevel().getProperties();
          //					for(int j=0; j<values.size();j++){
          //						String val;
          //						try {
          //							val = member.getPropertyFormattedValue(values.get(j));
          //						} catch (OlapException e) {
          //							e.printStackTrace();
          //							throw new RuntimeException(e);
          //						}
          //						memberInfo.setProperty(values.get(j).getCaption(), val);
          //					}

          //					if (y > 0) {
          //						for (int previ = y-1; previ >= 0;previ--) {
          //							if(prevMembers[previ] != null) {
          //								memberInfo.setRightOf(prevMemberInfo[previ]);
          //								memberInfo.setRightOfDimension(prevMembers[previ].getDimension().getName());
          //								previ = -1;
          //							}
          //						}
          //					}
          //
          //
          //					if (member.getParentMember() != null)
          //						memberInfo.setParentMember(member.getParentMember().getUniqueName());

        } else {
          memberInfo.setRawValue(null);
          memberInfo.setFormattedValue(null);
          memberInfo.setParentDimension(null);
        }

        if (isColumns) {
          memberInfo.setRight(false);
          memberInfo.setSameAsPrev(same);
          if (member != null) memberInfo.setParentDimension(member.getDimension().getName());
          matrix.set(x, y, memberInfo);
        } else {
          memberInfo.setRight(false);
          memberInfo.setSameAsPrev(false);
          matrix.set(y, x, memberInfo);
        }
        int x_parent = isColumns ? x : y - 1;
        int y_parent = isColumns ? y - 1 : x;
        if (index >= 0) {
          final AxisOrdinalInfo ordinalInfo = axisInfo.ordinalInfos.get(index);
          int depth_i = ordinalInfo.getDepths().indexOf(member.getDepth());
          while (depth_i > 0) {
            depth_i--;
            int parentDepth = (ordinalInfo.getDepths().get(depth_i));
            Member parent = member.getParentMember();
            while (parent != null && parent.getDepth() > parentDepth) {
              parent = parent.getParentMember();
            }
            final MemberCell pInfo = new MemberCell();
            if (parent != null) {
              pInfo.setRawValue(parent.getUniqueName());
              pInfo.setFormattedValue(parent.getCaption()); // First try to get a formatted value
              pInfo.setParentDimension(parent.getDimension().getName());
              pInfo.setHierarchy(parent.getHierarchy().getUniqueName());
              pInfo.setUniquename(parent.getUniqueName());
              pInfo.setLevel(parent.getLevel().getUniqueName());
            } else {
              pInfo.setRawValue("");
              pInfo.setFormattedValue(""); // First try to get a formatted value
              pInfo.setParentDimension(member.getDimension().getName());
              pInfo.setHierarchy(member.getHierarchy().getUniqueName());
              pInfo.setLevel(member.getLevel().getUniqueName());
              pInfo.setUniquename("");
            }
            matrix.set(x_parent, y_parent, pInfo);
            if (isColumns) {
              y_parent--;
            } else {
              x_parent--;
            }
          }
        }
        prevMembers[y] = member;
        prevMemberInfo[y] = memberInfo;
        members[y] = null;
      }
    }
  }
 public String getUniqueName() {
   return member.getUniqueName();
 }