示例#1
0
 public boolean removeMember(
     String queryName, String dimensionName, String uniqueMemberName, String selectionType)
     throws SaikuServiceException {
   IQuery query = getIQuery(queryName);
   removeAllChildren(queryName, dimensionName);
   List<IdentifierSegment> memberList =
       IdentifierNode.parseIdentifier(uniqueMemberName).getSegmentList();
   QueryDimension dimension = query.getDimension(dimensionName);
   final Selection.Operator selectionMode = Selection.Operator.valueOf(selectionType);
   try {
     if (log.isDebugEnabled()) {
       log.debug(
           "query: "
               + queryName
               + " remove:"
               + selectionMode.toString()
               + " "
               + memberList.size());
     }
     Selection selection = dimension.createSelection(selectionMode, memberList);
     dimension.getInclusions().remove(selection);
     return true;
   } catch (OlapException e) {
     throw new SaikuServiceException(
         "Error removing member (" + uniqueMemberName + ") of dimension (" + dimensionName + ")",
         e);
   }
 }
示例#2
0
 public void resetAxisSelections(QueryAxis axis) {
   for (QueryDimension dim : axis.getDimensions()) {
     dim.clearInclusions();
     dim.clearExclusions();
     dim.clearSort();
   }
 }
示例#3
0
  public SaikuFilter getFilter(
      String queryName,
      String filtername,
      String dimensionName,
      String hierarchyName,
      String levelName) {
    IQuery query = getIQuery(queryName);
    CellSet cs = query.getCellset();
    List<SimpleCubeElement> members = new ArrayList<SimpleCubeElement>();
    SimpleCubeElement dimension = null;
    SimpleCubeElement hierarchy = null;
    Set<MetadataElement> mset = new HashSet<MetadataElement>();

    if (cs != null) {
      List<CellSetAxis> axes = new ArrayList<CellSetAxis>();
      axes.addAll(cs.getAxes());
      axes.add(cs.getFilterAxis());
      for (CellSetAxis axis : axes) {
        int posIndex = 0;
        for (Hierarchy h : axis.getAxisMetaData().getHierarchies()) {
          if (h.getName().equals(hierarchyName)) {
            if (hierarchy == null) {
              hierarchy = new SimpleCubeElement(h.getName(), h.getUniqueName(), h.getCaption());
              Dimension d = h.getDimension();
              dimension = new SimpleCubeElement(d.getName(), d.getUniqueName(), d.getCaption());
            }
            if (h.getLevels().size() == 1) {
              break;
            }

            for (Position pos : axis.getPositions()) {
              Member m = pos.getMembers().get(posIndex);
              if (m.getLevel().getName().equals(levelName)) {
                mset.add(m);
              }
            }
            break;
          }
          posIndex++;
        }
      }
      if (mset.size() == 0) {
        QueryDimension qd = query.getDimension(dimensionName);
        if (qd != null && qd.getAxis().getLocation() != null) {
          for (Selection sel : qd.getInclusions()) {
            if ((sel.getRootElement() instanceof Member)) {
              Member m = ((Member) sel.getRootElement());
              if (m.getLevel().getName().equals(levelName)) {
                mset.add(m);
              }
            }
          }
        }
      }
      members = ObjectUtil.convert2Simple(mset);
      Collections.sort(members, new SaikuUniqueNameComparator());
      log.debug("Create Filters: Found members in the result or query: " + members.size());
    }
    return new SaikuFilter(filtername, null, dimension, hierarchy, members);
  }
示例#4
0
 public void moveDimension(QueryDimension dimension, Axis axis, int position) {
   dimension.setHierarchizeMode(HierarchizeMode.PRE);
   if (dimension.getName() != "Measures") {
     dimension.setHierarchyConsistent(true);
   }
   QueryAxis oldQueryAxis = findAxis(dimension);
   QueryAxis newQueryAxis = query.getAxis(axis);
   if (oldQueryAxis != null && newQueryAxis != null) {
     oldQueryAxis.removeDimension(dimension);
     newQueryAxis.addDimension(position, dimension);
   }
 }
示例#5
0
 public SaikuQuery removeFilter(String queryname) {
   IQuery query = getIQuery(queryname);
   if (query != null && query.getFilter() != null) {
     SaikuFilter filter = query.getFilter();
     QueryDimension qDim = query.getDimension(filter.getDimension().getName());
     if (qDim != null) {
       qDim.clearInclusions();
       query.moveDimension(qDim, null);
     }
     query.removeFilter();
   }
   return ObjectUtil.convert(query);
 }
示例#6
0
 public boolean removeLevel(
     String queryName, String dimensionName, String uniqueHierarchyName, String uniqueLevelName) {
   IQuery query = getIQuery(queryName);
   removeAllChildren(queryName, dimensionName);
   QueryDimension dimension = query.getDimension(dimensionName);
   try {
     for (Hierarchy hierarchy : dimension.getDimension().getHierarchies()) {
       if (hierarchy.getUniqueName().equals(uniqueHierarchyName)) {
         for (Level level : hierarchy.getLevels()) {
           if (level.getUniqueName().equals(uniqueLevelName)) {
             Selection inclusion = dimension.createSelection(level);
             dimension.getInclusions().remove(inclusion);
             ArrayList<Selection> removals = new ArrayList<Selection>();
             for (Selection sel : dimension.getInclusions()) {
               if ((sel.getRootElement() instanceof Member)) {
                 if (((Member) sel.getRootElement()).getLevel().equals(level)) {
                   if (dimension.getInclusions().contains(sel)) {
                     removals.add(sel);
                   }
                 }
               }
             }
             dimension.getInclusions().removeAll(removals);
           }
         }
       }
     }
   } catch (Exception e) {
     throw new SaikuServiceException(
         "Cannot remove level" + uniqueLevelName + "from dimension " + dimensionName, e);
   }
   return true;
 }
示例#7
0
 public boolean includeLevel(
     String queryName, String dimensionName, String uniqueHierarchyName, String uniqueLevelName) {
   IQuery query = getIQuery(queryName);
   removeAllChildren(queryName, dimensionName);
   QueryDimension dimension = query.getDimension(dimensionName);
   for (Hierarchy hierarchy : dimension.getDimension().getHierarchies()) {
     if (hierarchy.getUniqueName().equals(uniqueHierarchyName)) {
       for (Level level : hierarchy.getLevels()) {
         if (level.getUniqueName().equals(uniqueLevelName)) {
           Selection sel = dimension.createSelection(level);
           if (!dimension.getInclusions().contains(sel)) {
             dimension.include(level);
           }
           return true;
         }
       }
     }
   }
   return false;
 }
示例#8
0
 public boolean includeChildren(String queryName, String dimensionName, String uniqueMemberName) {
   IQuery query = getIQuery(queryName);
   List<IdentifierSegment> memberList =
       IdentifierNode.parseIdentifier(uniqueMemberName).getSegmentList();
   QueryDimension dimension = query.getDimension(dimensionName);
   try {
     Selection sel = dimension.createSelection(Operator.CHILDREN, memberList);
     dimension.getInclusions().add(sel);
     return true;
   } catch (OlapException e) {
     throw new SaikuServiceException(
         "Cannot include children query ("
             + queryName
             + ") dimension ("
             + dimensionName
             + ") member ("
             + uniqueMemberName
             + ")",
         e);
   }
 }
示例#9
0
  public SaikuQuery applyFilter(String queryname, SaikuFilter filter) throws Exception {
    IQuery query = getIQuery(queryname);
    if (filter != null
        && filter.getName() != null
        && filter.getDimension() != null
        && filter.getMembers() != null) {
      query.setFilter(filter);
      QueryDimension qDim = query.getDimension(filter.getDimension().getName());

      if (qDim != null) {
        qDim.clearInclusions();
        query.moveDimension(qDim, Axis.FILTER);
        for (SimpleCubeElement member : filter.getMembers()) {
          List<IdentifierSegment> memberList =
              IdentifierNode.parseIdentifier(member.getUniqueName()).getSegmentList();
          qDim.include(memberList);
        }
      }
    }
    return ObjectUtil.convert(query);
  }
示例#10
0
  public CellSet execute() throws Exception {

    if (scenario != null && query.getDimension("Scenario") != null) {
      QueryDimension dimension = query.getDimension("Scenario");
      moveDimension(dimension, Axis.FILTER);
      Selection sel =
          dimension.createSelection(
              IdentifierParser.parseIdentifier("[Scenario].[" + getScenario().getId() + "]"));
      if (!dimension.getInclusions().contains(sel)) {
        dimension.getInclusions().add(sel);
      }
    }

    Query mdx = this.query;
    mdx.validate();
    StringWriter writer = new StringWriter();
    mdx.getSelect().unparse(new ParseTreeWriter(new PrintWriter(writer)));
    log.debug("Executing query (" + this.getName() + ") :\n" + writer.toString());
    CellSet cellSet = mdx.execute();
    if (scenario != null && query.getDimension("Scenario") != null) {
      QueryDimension dimension = query.getDimension("Scenario");
      dimension.getInclusions().clear();
      moveDimension(dimension, null);
    }

    return cellSet;
  }
示例#11
0
 public boolean removeAllChildren(String queryName, String dimensionName) {
   IQuery query = getIQuery(queryName);
   QueryDimension dimension = query.getDimension(dimensionName);
   List<Selection> children = new ArrayList<Selection>();
   try {
     for (Selection sel : dimension.getInclusions()) {
       if (sel.getOperator().equals(Operator.CHILDREN)) {
         children.add(sel);
       }
     }
     dimension.getInclusions().removeAll(children);
     return true;
   } catch (Exception e) {
     throw new SaikuServiceException(
         "Cannot remove all children  for query ("
             + queryName
             + ") dimension ("
             + dimensionName
             + ")",
         e);
   }
 }
示例#12
0
  public boolean includeMember(
      String queryName,
      String dimensionName,
      String uniqueMemberName,
      String selectionType,
      int memberposition) {
    IQuery query = getIQuery(queryName);

    List<IdentifierSegment> memberList =
        IdentifierNode.parseIdentifier(uniqueMemberName).getSegmentList();
    QueryDimension dimension = query.getDimension(dimensionName);
    final Selection.Operator selectionMode = Selection.Operator.valueOf(selectionType);
    try {
      removeAllChildren(queryName, dimensionName);
      Selection sel = dimension.createSelection(selectionMode, memberList);
      if (dimension.getInclusions().contains(sel)) {
        dimension.getInclusions().remove(sel);
      }
      if (memberposition < 0) {
        memberposition = dimension.getInclusions().size();
      }
      dimension.getInclusions().add(memberposition, sel);
      return true;
    } catch (OlapException e) {
      throw new SaikuServiceException(
          "Cannot include member query ("
              + queryName
              + ") dimension ("
              + dimensionName
              + ") member ("
              + uniqueMemberName
              + ") operator ("
              + selectionType
              + ") position "
              + memberposition,
          e);
    }
  }
示例#13
0
  public static void main(String[] args) throws Exception {

    // Load the driver
    Class.forName("mondrian.olap4j.MondrianOlap4jDriver");

    // Connect
    final Connection connection =
        DriverManager.getConnection(
            "jdbc:mondrian:" // Driver ident
                + "Jdbc=jdbc:hsqldb:file:foodmart/foodmart;" // Relational DB
                + "Catalog=file:foodmart/FoodMart.xml;"); // Catalog

    // We are dealing with an olap connection. we must unwrap it.
    final OlapConnection olapConnection = connection.unwrap(OlapConnection.class);

    // Get a cube object.
    Cube salesCube = olapConnection.getOlapSchema().getCubes().get("Sales");

    // Build a query object.
    Query myQuery = new Query("myQuery", salesCube);

    // Lookup some dimensions
    QueryDimension productDim = myQuery.getDimension("Product");
    QueryDimension storeDim = myQuery.getDimension("Store");
    QueryDimension timeDim = myQuery.getDimension("Time");

    // Place dimensions on some axis
    myQuery.getAxis(Axis.COLUMNS).addDimension(productDim);
    myQuery.getAxis(Axis.ROWS).addDimension(storeDim);
    myQuery.getAxis(Axis.FILTER).addDimension(timeDim);

    // Including a member by metadata
    Member year1997 =
        salesCube.lookupMember(IdentifierNode.ofNames("Time", "1997").getSegmentList());
    timeDim.include(year1997);

    // Including a member by name parts
    productDim.include(
        Selection.Operator.CHILDREN,
        IdentifierNode.ofNames("Product", "Drink", "Beverages").getSegmentList());

    // We can also exclude members
    productDim.exclude(
        IdentifierNode.ofNames("Product", "Drink", "Beverages", "Carbonated Beverages")
            .getSegmentList());

    // Validate this query
    myQuery.validate();

    // Print!
    System.out.println("/********************* QUERY ***********************/");

    System.out.println(myQuery.getSelect().toString());

    System.out.println("/********************* QUERY ***********************/");
    System.out.println(" ");
    System.out.println(" ");
    System.out.println(" ");
    System.out.println(" ");

    System.out.println("/********************* RESULTS ***********************/");

    RectangularCellSetFormatter formatter = new RectangularCellSetFormatter(false);

    PrintWriter writer = new PrintWriter(System.out);

    formatter.format(myQuery.execute(), writer);

    writer.flush();
    System.out.println("/********************* RESULTS ***********************/");
  }
示例#14
0
  private IQuery applyTag(IQuery query, OlapConnection con, SaikuTag t) throws Exception {
    String xml = query.toXml();
    QueryDeserializer qd = new QueryDeserializer();
    query = qd.unparse(xml, con);

    List<SimpleCubeElement> doneDimension = new ArrayList<SimpleCubeElement>();
    Map<String, QueryDimension> dimensionMap = new HashMap<String, QueryDimension>();
    if (t.getSaikuTupleDimensions() != null) {
      for (SimpleCubeElement st : t.getSaikuTupleDimensions()) {
        if (!doneDimension.contains(st)) {
          QueryDimension dim = query.getDimension(st.getName());
          dimensionMap.put(st.getUniqueName(), dim);
          dim.clearExclusions();
          dim.clearInclusions();
          query.moveDimension(dim, null);
          doneDimension.add(st);
        }
      }
      if (t.getSaikuTupleDimensions().size() > 0) {
        SimpleCubeElement rootDim = t.getSaikuTupleDimensions().get(0);
        QueryDimension dim = query.getDimension(rootDim.getName());
        query.moveDimension(dim, Axis.COLUMNS);

        for (SaikuTuple tuple : t.getSaikuTuples()) {
          SaikuMember m = tuple.getSaikuMember(rootDim.getUniqueName());
          List<SaikuMember> others = tuple.getOtherSaikuMembers(rootDim.getUniqueName());
          Selection sel = dim.createSelection(IdentifierParser.parseIdentifier(m.getUniqueName()));
          for (SaikuMember context : others) {
            QueryDimension otherDim = dimensionMap.get(context.getDimensionUniqueName());
            query.moveDimension(otherDim, Axis.COLUMNS);
            Selection ctxSel =
                otherDim.createSelection(IdentifierParser.parseIdentifier(context.getUniqueName()));
            sel.addContext(ctxSel);
          }
          dim.getInclusions().add(sel);
        }
      }
    }
    if (t.getSaikuDimensionSelections() != null) {
      for (SaikuDimensionSelection dimsel : t.getSaikuDimensionSelections()) {
        if (!dimsel.getName().equals("Measures")) {
          QueryDimension filterDim = query.getDimension(dimsel.getName());
          query.moveDimension(filterDim, Axis.FILTER);
          filterDim.clearInclusions();
          for (SaikuSelection ss : dimsel.getSelections()) {
            if (ss.getType() == SaikuSelection.Type.MEMBER) {
              Selection sel =
                  filterDim.createSelection(IdentifierParser.parseIdentifier(ss.getUniqueName()));
              if (!filterDim.getInclusions().contains(sel)) {
                filterDim.getInclusions().add(sel);
              }
            }
          }
          // TODO: Move it to columns since drilling through with 2 filter items of the same
          // dimension doesn't work
          //					if (filterDim.getInclusions().size() > 1) {
          //						query.moveDimension(filterDim, Axis.COLUMNS);
          //					}
        }
      }
    }

    return query;
  }