import org.olap4j.metadata.Cube; //导入依赖的package包/类
public static Level lookupLevel(Cube cube, List<IdentifierSegment> segmentList) {
	
	if(segmentList.size() < 2)
		return null;
	
	Dimension dim = cube.getDimensions().get(segmentList.get(0).getName());
	if(dim instanceof ServerDimension){
		
		Hierarchy h = dim.getHierarchies().get(segmentList.get(1).getName());
		if(h!=null && segmentList.size()==3 && h.getLevels().size()==1){
			return  h.getLevels().get(0);
		}else if(h!=null && segmentList.size()==4){
			return h.getLevels().get(segmentList.get(2).getName());
		}

		
	}

	return null;
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
public Cube convertToComplexType(String convertFrom) throws ConversionException {

		String[] pieces = PersisterUtils.splitByDelimiter(convertFrom, 4);
		
		Olap4jDataSource ds = dsCollection.getDataSource(pieces[0], Olap4jDataSource.class);
		
		Catalog catalog;
		try {
			catalog = mapping.createConnection(ds).getCatalogs().get(pieces[1]);
		} catch (Exception ex) {
			throw new ConversionException("Error connecting to data source " + pieces[0] + 
					" to get cube defined by " + convertFrom, ex);
		}
		Schema schema;
		try {
			schema = catalog.getSchemas().get(pieces[2]);
			Cube cube = schema.getCubes().get(pieces[3]);
			return cube;
		} catch (OlapException e) {
			throw new ConversionException("The cube could not be retrieved from the string " + 
					convertFrom, e);
		}
	}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
/**
 * The additional information that must be provided for this method is the data source
 * that the cube is contained in.
 */
public String convertToSimpleType(Cube convertFrom, Object ... additionalInfo) {
	SPDataSource ds = (SPDataSource) additionalInfo[0];
	String name = convertFrom.getName();
	String schemaName = convertFrom.getSchema().getName();
	Catalog catalog = convertFrom.getSchema().getCatalog();
	String catalogName = catalog.getName();

	StringBuilder result = new StringBuilder();
	result.append(ds.getName());
	result.append(DELIMITER);
	result.append(catalogName);
	result.append(DELIMITER);
	result.append(schemaName);
	result.append(DELIMITER);
	result.append(name);

	return result.toString();
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
public void setCurrentCube(Cube currentCube, boolean resetQuery) throws SQLException {
    Cube oldCube = this.currentCube;
    this.currentCube = currentCube;
    
    if (currentCube != oldCube && currentCube != null && resetQuery) {
    	setMdxQuery(new Query(OLAP4J_QUERY_NAME, currentCube));
    }
    
    if (currentCube != null) {
    	cubeName = currentCube.getName();
    	schemaName = currentCube.getSchema().getName();
    	catalogName = currentCube.getSchema().getCatalog().getName();
    } else {
    	cubeName = null;
    	schemaName = null;
    	catalogName = null;
    }
    
    firePropertyChange("currentCube", oldCube, currentCube);
    fireStructureChanged();
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
protected void populateCube(
    OlapConnection connection,
    Catalog catalog,
    Cube cube,
    List<Row> rows)
    throws XmlaException, SQLException
{
    int ordinal = 0;
    for (Dimension dimension : cube.getDimensions()) {
        // Must increment ordinal for all dimensions but
        // only output some of them.
        boolean genOutput = dimensionUnameCond.apply(dimension);
        if (genOutput) {
            populateDimension(
                connection, catalog, cube, dimension, ordinal, rows);
        }
        ordinal += dimension.getHierarchies().size();
    }
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
protected void populateDimension(
    OlapConnection connection,
    Catalog catalog,
    Cube cube,
    Dimension dimension,
    int ordinal,
    List<Row> rows)
    throws XmlaException, SQLException
{
    final NamedList<Hierarchy> hierarchies = dimension.getHierarchies();
    for (Hierarchy hierarchy
        : filter(hierarchies, hierarchyNameCond, hierarchyUnameCond))
    {
        populateHierarchy(
            connection,
            catalog,
            cube,
            dimension,
            hierarchy,
            ordinal + hierarchies.indexOf(hierarchy),
            rows);
    }
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
protected void populateCatalog(
    OlapConnection connection,
    Catalog catalog,
    List<Row> rows)
    throws XmlaException, SQLException
{
    for (Schema schema : filter(catalog.getSchemas(), schemaNameCond)) {
        for (Cube cube : filteredCubes(schema, cubeNameCond)) {
            if (isRestricted(MemberUniqueName)) {
                // NOTE: it is believed that if MEMBER_UNIQUE_NAME is
                // a restriction, then none of the remaining possible
                // restrictions other than TREE_OP are relevant
                // (or allowed??).
                outputUniqueMemberName(
                    connection, catalog, cube, rows);
            } else {
                populateCube(connection, catalog, cube, rows);
            }
        }
    }
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
private void populateNamedSets(
    Cube cube,
    Catalog catalog,
    List<Row> rows)
{
    for (NamedSet namedSet : filter(cube.getSets(), setUnameCond)) {
        Row row = new Row();
        row.set(CatalogName.name, catalog.getName());
        row.set(SchemaName.name, cube.getSchema().getName());
        row.set(CubeName.name, cube.getName());
        row.set(SetName.name, namedSet.getUniqueName());
        row.set(Scope.name, GLOBAL_SCOPE);
        row.set(Description.name, namedSet.getDescription());
        addRow(row, rows);
    }
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
private void populateLevel(
    Catalog catalog,
    Cube cube,
    Level level,
    List<Row> rows)
    throws SQLException
{
    final XmlaHandler.XmlaExtra extra =
        getExtra(catalog.getMetaData().getConnection());
    for (Property property
        : filter(extra.getLevelProperties(level), propertyNameCond))
    {
        if (extra.isPropertyInternal(property)) {
            continue;
        }
        outputProperty(
            property, catalog, cube, level, rows);
    }
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
public void testAnnotation() throws SQLException {
    final OlapConnection connection =
        getTestContext().getOlap4jConnection();
    final CellSet cellSet =
        connection.createStatement().executeOlapQuery(
            "select from [Sales]");
    final CellSetMetaData metaData = cellSet.getMetaData();
    final Cube salesCube = metaData.getCube();
    Annotated annotated = ((OlapWrapper) salesCube).unwrap(Annotated.class);
    final Annotation annotation =
        annotated.getAnnotationMap().get("caption.fr_FR");
    assertEquals("Ventes", annotation.getValue());

    final Map<String, Object> map =
        XmlaHandler.getExtra(connection).getAnnotationMap(salesCube);
    assertEquals("Ventes", map.get("caption.fr_FR"));
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
protected void populateCube(OlapConnection connection, Catalog catalog, Cube cube, List<Row> rows) throws XmlaException, SQLException {
   if (isRestricted(LevelUniqueName)) {
      // Note: If the LEVEL_UNIQUE_NAME has been specified, then
      // the dimension and hierarchy are specified implicitly.
      String levelUniqueName = getRestrictionValueAsString(LevelUniqueName);
      if (levelUniqueName == null) {
         // The query specified two or more unique names
         // which means that nothing will match.
         return;
      }

      Level level = lookupLevel(cube, levelUniqueName);
      if (level != null) {
         // Get members of this level, without access control, but
         // including calculated members.
         List<Member> members = level.getMembers();
         outputMembers(connection, members, catalog, cube, rows);
      }
   } else {
      for (Dimension dimension : filter(cube.getDimensions(), dimensionUnameCond)) {
         populateDimension(connection, catalog, cube, dimension, rows);
      }
   }
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
private void outputUniqueMemberName(final OlapConnection connection, final Catalog catalog, Cube cube, List<Row> rows) throws SQLException {
   final Object unameRestrictions = restrictions.get(MemberUniqueName.name);
   List<String> list;
   if (unameRestrictions instanceof String) {
      list = Collections.singletonList((String) unameRestrictions);
   } else {
      list = (List<String>) unameRestrictions;
   }
   for (String memberUniqueName : list) {
      final IdentifierNode identifierNode = IdentifierNode.parseIdentifier(memberUniqueName);
      Member member = cube.lookupMember(identifierNode.getSegmentList());
      if (member == null) {
         return;
      }
      if (isRestricted(TreeOp_)) {
         int treeOp = getRestrictionValueAsInt(TreeOp_);
         if (treeOp == -1) {
            return;
         }
         populateMember(connection, catalog, cube, member, treeOp, rows);
      } else {
         outputMember(connection, member, catalog, cube, rows);
      }
   }
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
protected OlapOp getOlapOp(ParseTreeNode op_node, String name, Cube cube)
		throws OlapException {
	
	Class c = functionMap.get(name.toLowerCase());
	if(c==null)
		return null;
	try {
		Constructor cons = c.getConstructor(new Class[]{op_node.getClass(), Cube.class});
		return (OlapOp) cons.newInstance(op_node, cube);
	} catch (Exception e) {
		throw new RuntimeException("Fail to run function "+name, e);
	}
	
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
@Override
public NamedList<Cube> getCubes() throws OlapException {
	
	NamedList<Cube> list = MetadataUtils.metadataNamedList(new ArrayList<Cube>());
	
   for(CubeDefinition def : definition.cubes){
	   list.add(new ServerCube(this, def));  
   }

   return list;
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
public static Member lookupMember(Cube cube, List<IdentifierSegment> segmentList) {
	
	if(segmentList.size() < 3)
		return null;
	
	Dimension dim = cube.getDimensions().get(segmentList.get(0).getName());
	if(dim instanceof ServerDimension){
		
		Hierarchy h = dim.getHierarchies().get(segmentList.get(1).getName());
		if(h!=null){
			
			Level level = null;
			String memberName = null;
			
			if(segmentList.size()==3){		
				level = h.hasAll() ? h.getLevels().get(1) : h.getLevels().get(0);
				memberName = segmentList.get(2).getName();
			}else if(segmentList.size()==4){
				level = h.getLevels().get(segmentList.get(2).getName());
				memberName = segmentList.get(3).getName();
			}
			
			if(level!=null){
				return new LevelMember(level, memberName, memberName,  0);
			}
			
		}
		
	}

	return null;
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
/**
 * Sets the current cube to the given cube. This affects the tree of items
 * that can be dragged into the query builder, and it resets the query
 * builder. It also executes the (empty) query on the new cube.
 * 
 * @param currentCube
 *            The new cube to make current. If this is already the current
 *            cube, the query will not be reset. Can be null to revert to
 *            the "no cube selected" state.
 * @throws SQLException
 */
public void setCurrentCube(Cube currentCube) throws SQLException {
    if (currentCube != query.getCurrentCube()) {
        query.setCurrentCube(currentCube);
    }
    if (currentCube != null) {
        cubeTree.setModel(new Olap4jTreeModel(Collections.singletonList(currentCube)));
        cubeTree.expandRow(0);
    } else {
        cubeTree.setModel(new DefaultTreeModel(new DefaultMutableTreeNode("Hidden")));
    }
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
/**
 * Commits a persisted {@link OlapQuery} object property
 * 
 * @param olapQuery
 *            The {@link OlapQuery} object to commit the persisted property
 *            upon
 * @param propertyName
 *            The property name
 * @param newValue
 *            The persisted property value to be committed
 * @throws SPPersistenceException
 *             Thrown if the property name is not known in this method or if
 *             the new value could not be committed.
 */
private void commitOlapQueryProperty(OlapQuery olapQuery,
		String propertyName, Object newValue)
		throws SPPersistenceException {
	if (propertyName.equals("olapDataSource")) {
		olapQuery.setOlapDataSource((Olap4jDataSource) converter
				.convertToComplexType(newValue, Olap4jDataSource.class));

	} else if (propertyName.equals("currentCube")) {
		try {
			olapQuery.setCurrentCube((Cube) converter.convertToComplexType(
					newValue, Cube.class), false);
		} catch (SQLException e) {
			throw new SPPersistenceException(olapQuery.getUUID(),
					"Cannot commit currentCube property for OlapQuery with name \""
							+ olapQuery.getName() + "\" and UUID \""
							+ olapQuery.getUUID() + "\" to value "
							+ newValue.toString(), e);
		}

	} else if (propertyName.equals("nonEmpty")) {
		olapQuery.setNonEmpty((Boolean) converter.convertToComplexType(
				newValue, Boolean.class));
		
	} else if (propertyName.equals("modifiedOlapQuery")) {
		olapQuery.setModifiedOlapQuery((String) converter.convertToComplexType(
				newValue, String.class));

	} else {
		throw new SPPersistenceException(
				olapQuery.getUUID(),
				getSPPersistenceExceptionMessage(olapQuery, propertyName));
	}
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
public NamedList<Cube> getCubes(final OlapConnection connection) {
	NamedList<Cube> cubes = null;
	try {
		cubes = connection.getOlapSchema().getCubes();

	} catch (final OlapException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return cubes;
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
protected void populateHierarchy(
    OlapConnection connection,
    Catalog catalog,
    Cube cube,
    Hierarchy hierarchy,
    List<Row> rows)
    throws XmlaException, SQLException
{
    for (Level level
        : filter(hierarchy.getLevels(), levelUnameCond, levelNameCond))
    {
        outputLevel(
            connection, catalog, cube, hierarchy, level, rows);
    }
}
 

import org.olap4j.metadata.Cube; //导入依赖的package包/类
private void outputMembers(
    OlapConnection connection,
    List<Member> members,
    final Catalog catalog,
    Cube cube,
    List<Row> rows)
    throws SQLException
{
    for (Member member : members) {
        outputMember(connection, member, catalog, cube, rows);
    }
}