mondrian.olap.Axis Java Examples

/**
 * 
 * @param axes
 * @param axis
 * @param pos
 * @param result
 * @param dataList
 * @param rowno
 */
private void getRowData(Axis[] axes, int axis, int[] pos, Result result, List<List<ValueData>> dataList, int rowno , Position position , CubeReportData cubeData , List<ColumnProperties> cols) {
	if (axis < 0) {
		if (dataList.size() <= rowno || dataList.get(rowno) == null) {
			dataList.add(new ArrayList<ValueData>());
		}
		Cell cell = result.getCell(pos) ;
		ValueData valueData  = new ValueData(cell.getValue(), cell.getFormattedValue(), null  , cell.canDrillThrough(), cell.getDrillThroughSQL(true) , position!=null && position.size()>0 ? position.get(position.size()-1).getName():"" , cell.getCachedFormatString() , cols) ;
		int rows = 0 ;
		valueData.setRow(getParentLevel(cubeData.getRow() , rowno, rows)) ;
		dataList.get(rowno).add(valueData);
	} else {
		Axis _axis = axes[axis];
		List<Position> positions = _axis.getPositions();
		for (int i = 0; i < positions.size(); i++) {
			Position posit = positions.get(i) ;
			pos[axis] = i;
			if (axis == 0) {
				int row = axis + 1 < pos.length ? pos[axis + 1] : 0;
				rowno = row;
			}
			getRowData(axes, axis - 1, pos, result, dataList, rowno , posit , cubeData , cols);
		}
	}
}
 

public static int computeMemberCountForAxis( final Axis axis,
                                             final boolean membersOnAxisSorted ) {
  final List<Position> positions = axis.getPositions();
  final MemberAddingStrategy strategy = membersOnAxisSorted ?
    new SortedMemberAddingStrategy( positions ) :
    new ResultSetOrderMemberAddingStrategy();

  for ( int positionsIndex = 0; positionsIndex < positions.size(); positionsIndex++ ) {
    final Position position = positions.get( positionsIndex );
    for ( int positionIndex = 0; positionIndex < position.size(); positionIndex++ ) {
      Member m = position.get( positionIndex );
      computeDeepColumnNames( m, strategy );
    }
  }

  return strategy.values().size();
}
 

private Member getCandidateMembers( final int columnIndex,
                                    final int[] cellKey ) {

  final int axisIndex = columnToAxisPosition.get( columnIndex );
  final Axis[] axes = resultSet.getAxes();
  final Axis axis = axes[ axisIndex ];

  final List<Position> positionList = axis.getPositions();
  if ( positionList.isEmpty() ) {
    return null;
  }

  final int posIndex = cellKey[ axisIndex ];
  final Position position = positionList.get( posIndex );

  final Member memberByName = findMemberByName( position, columnIndex );
  if ( memberByName != null ) {
    return memberByName;
  }
  return findRootMember( position, columnIndex );
}
 

public DenormalizedMDXTableModel( final Result resultSet,
                                  final int rowLimit,
                                  final boolean membersOnAxisSorted ) {
  ArgumentNullException.validate( "resultSet", resultSet );

  this.resultSet = resultSet;

  final Axis[] axes = this.resultSet.getAxes();

  this.axesSize = ResultSetProcessingLib.computeItemsPerAxis( axes );
  this.rowCount = computeRowCount( axesSize );
  final int[] axesMembers = ResultSetProcessingLib.computeTotalColumnsPerAxis( axes, 0, membersOnAxisSorted );

  this.columnCount = computeColumnCount( axesMembers );
  this.columnToAxisPosition = ResultSetProcessingLib.computeColumnToAxisMapping( axes, axesMembers, columnCount, 0 );
  this.columnToMemberMapping = Collections.unmodifiableList
    ( ResultSetProcessingLib.computeColumnToMemberMapping( axes, axesMembers, 0, membersOnAxisSorted ) );
  this.columnNames = computeColumnNames( columnToMemberMapping );

  if ( rowLimit > 0 ) {
    rowCount = Math.min( rowLimit, rowCount );
  }
}
 

/**
 * @return
 */
private GenericObjectTable createRowHeaders() {
  final Axis[] axes = this.resultSet.getAxes();
  if ( axes.length < 2 ) {
    return new GenericObjectTable();
  }
  final Axis axis = axes[ AXIS_ROW ];
  final List<Position> positions = axis.getPositions();
  final int rowCount = positions.size();
  final GenericObjectTable result = new GenericObjectTable( Math.max( 1, rowCount ), 5 );

  for ( int r = 0; r < rowCount; r++ ) {
    final Position position = positions.get( r );
    Member member = null;
    final int colCount = position.size();
    for ( int c = 0; c < colCount; c++ ) {
      member = position.get( c );
      result.setObject( r, c, member.getName() );
    }
    if ( member != null ) {
      result.setObject( r, colCount, member.getHierarchy().getName() );
    }
  }
  return result;
}
 

private GenericObjectTable createColumnHeaders() {
  final Axis[] axes = this.resultSet.getAxes();
  if ( axes.length < 1 ) {
    return new GenericObjectTable();
  }
  final Axis axis = axes[ AXIS_COLUMN ];
  final List<Position> positions = axis.getPositions();
  final int colCount = positions.size();
  final GenericObjectTable result = new GenericObjectTable( 20, Math.max( 1, colCount ) );
  for ( int c = 0; c < colCount; c++ ) {
    final Position position = positions.get( c );
    Member member = null;
    final int rowCount = position.size();
    for ( int r = 0; r < rowCount; r++ ) {
      member = position.get( r );
      if ( member != null ) {
        result.setObject( r, c, member.getName() );
      }
    }

    if ( member != null ) {
      result.setObject( rowCount, c, member.getHierarchy().getName() );
    }
  }
  return result;
}
 

private Member getCandidateMembers( final int columnIndex,
                                    final int[] cellKey ) {

  final int axisIndex = columnToAxisPosition.get( columnIndex );
  final Axis[] axes = resultSet.getAxes();
  final Axis axis = axes[ axisIndex ];

  final List<Position> positionList = axis.getPositions();
  if ( positionList.isEmpty() ) {
    return null;
  }

  final int posIndex = cellKey[ axisIndex ];
  final Position position = positionList.get( posIndex );

  final Member memberByName = findMemberByName( position, columnIndex );
  if ( memberByName != null ) {
    return memberByName;
  }
  return findRootMember( position, columnIndex );
}
 

protected List<String> computeColumnNames( final Axis[] axes,
                                           final List<Member> columnToMemberMapper ) {
  ArrayList<String> columnNames = new ArrayList<String>();
  for ( final Member member : columnToMemberMapper ) {
    columnNames.add( member.getLevel().getUniqueName() );
  }
  if ( axes.length > 0 ) {
    // now create the column names for the column-axis
    final Axis axis = axes[ 0 ];
    final List<Position> positions = axis.getPositions();
    for ( int i = 0; i < positions.size(); i++ ) {
      final Position position = positions.get( i );
      columnNames.add( ResultSetProcessingLib.computeUniqueColumnName( position ) );
    }
  } else {
    columnNames.add( "Measure" );
  }
  return Collections.unmodifiableList( columnNames );
}
 

public JRMondrianAxis(Axis axis, Hierarchy[] axisHierarchies, JRMondrianFactory factory)
{
	List<Position> positions = axis.getPositions();
	tuples = new JRMondrianTuple[positions.size()];
	
	int idx = 0;
	for (Iterator<Position> it = positions.iterator(); it.hasNext(); ++idx)
	{
		Position position = it.next();
		tuples[idx] = new JRMondrianTuple(position, factory);
	}
	
	hierarchies = new JRMondrianHierarchy[axisHierarchies.length];
	for (int i = 0; i < axisHierarchies.length; i++)
	{
		hierarchies[i] = new JRMondrianHierarchy(axisHierarchies[i]);
	}
}
 

public LegacyBandedMDXTableModel( final Result resultSet, final int queryLimitValue )
  throws ReportDataFactoryException {
  this.resultSet = resultSet;
  final Axis[] axes = resultSet.getAxes();
  final int axisCount = axes.length;
  if ( axisCount > 2 ) {
    throw new ReportDataFactoryException( "Cannot handle results with more than two axes." );
  }
  this.rowHeaders = createRowHeaders();
  this.columnHeaders = createColumnHeaders();

  if ( rowHeaders.getRowCount() > 0 ) {
    columnCount = rowHeaders.getColumnCount() + columnHeaders.getColumnCount();
  } else {
    columnCount = columnHeaders.getColumnCount();
  }
  if ( columnCount == 0 ) {
    columnCount = 1;
    emptyAxisCase = true;
    columnNames = new String[] { "Measure" };
    rowCount = 1;
  } else {
    columnNames = new String[ columnCount ];
    for ( int i = 0; i < columnNames.length; i++ ) {
      columnNames[ i ] = calcColumnName( i );
    }

    if ( axisCount == 2 ) {
      rowCount = rowHeaders.getRowCount();
    } else {
      rowCount = Math.max( 1, rowHeaders.getRowCount() );
    }
  }

  if ( queryLimitValue > 0 ) {
    rowCount = Math.min( queryLimitValue, rowCount );
  }
}
 

public BandedMDXTableModel( final Result resultSet, final int rowLimit,
                            final boolean membersOnAxisSorted ) {
  ArgumentNullException.validate( "resultSet", resultSet );

  this.resultSet = resultSet;

  // rowcount is the product of all axis-sizes. If an axis contains more than one member, then
  // Mondrian already performs the crossjoin for us.

  // column count is the sum of the maximum of all hierachy levels of all axis.

  final Axis[] axes = this.resultSet.getAxes();


  this.axesSize = ResultSetProcessingLib.computeItemsPerAxis( axes );
  this.rowCount = computeRowCount( axesSize );

  final int[] axesMembers = ResultSetProcessingLib.computeTotalColumnsPerAxis( axes, 1, membersOnAxisSorted );

  this.columnCount = computeColumnCount( axesMembers, this.axesSize );
  this.columnToAxisPosition = ResultSetProcessingLib.computeColumnToAxisMapping( axes, axesMembers, columnCount, 1 );
  this.columnToMemberMapping = Collections.unmodifiableList
    ( ResultSetProcessingLib.computeColumnToMemberMapping( axes, axesMembers, 1, membersOnAxisSorted ) );
  this.columnNames = computeColumnNames( axes, columnToMemberMapping );

  if ( rowLimit > 0 ) {
    rowCount = Math.min( rowLimit, rowCount );
  }
}
 

public JRMondrianResult(Result result)
{
	this.result = result;

	JRMondrianFactory factory = new JRMondrianFactory();

	Query query = result.getQuery();
	Axis[] resultAxes = result.getAxes();
	axes = new JRMondrianAxis[resultAxes.length];
	for (int i = 0; i < resultAxes.length; i++)
	{
		AxisOrdinal ordinal = AxisOrdinal.StandardAxisOrdinal.forLogicalOrdinal(i);
		axes[i] = new JRMondrianAxis(resultAxes[i], query.getMdxHierarchiesOnAxis(ordinal), factory);
	}
}
 

public static int[] computeItemsPerAxis( final Axis[] axes ) {
  int[] axesSize = new int[ axes.length ];
  for ( int axesIndex = 0; axesIndex < axes.length; axesIndex += 1 ) {
    final Axis axis = axes[ axesIndex ];
    axesSize[ axesIndex ] = axis.getPositions().size();
  }
  return axesSize;
}
 

public static IntList computeColumnToAxisMapping( final Axis[] axes, final int[] axesMembers,
                                                  final int columnCount, final int startAxis ) {
  IntList columnToAxisPosition = new IntList( columnCount );
  for ( int axesIndex = axes.length - 1; axesIndex >= startAxis; axesIndex -= 1 ) {
    int memberCntAxis = axesMembers[ axesIndex ];
    for ( int x = 0; x < memberCntAxis; x += 1 ) {
      columnToAxisPosition.add( axesIndex );
    }
  }
  return columnToAxisPosition;
}
 

public static int[] computeTotalColumnsPerAxis( final Axis[] axes, final int startAxis,
                                                final boolean membersOnAxisSorted ) {
  final int[] membersPerAxis = new int[ axes.length ];
  // Axis contains (zero or more) positions, which contains (zero or more) members
  for ( int axesIndex = startAxis; axesIndex < axes.length; axesIndex++ ) {
    Axis axis = axes[ axesIndex ];
    membersPerAxis[ axesIndex ] = ResultSetProcessingLib.computeMemberCountForAxis( axis, membersOnAxisSorted );
  }

  return membersPerAxis;
}
 

public static ArrayList<Member> computeColumnToMemberMapping( final Axis[] axes,
                                                              final int[] axesMembers,
                                                              final int startAxis,
                                                              final boolean membersOnAxisSorted ) {
  final ArrayList<Member> columnToMemberMapper = new ArrayList<Member>();
  for ( int axesIndex = axes.length - 1; axesIndex >= startAxis; axesIndex -= 1 ) {
    final Axis axis = axes[ axesIndex ];
    final List<Position> positions = axis.getPositions();

    final MemberAddingStrategy strategy = membersOnAxisSorted ?
      new SortedMemberAddingStrategy( positions ) :
      new ResultSetOrderMemberAddingStrategy();

    for ( int positionsIndex = 0; positionsIndex < positions.size(); positionsIndex++ ) {
      final Position position = positions.get( positionsIndex );
      for ( int positionIndex = 0; positionIndex < position.size(); positionIndex++ ) {
        Member m = position.get( positionIndex );
        computeDeepColumnNames( m, strategy );
      }
    }

    Collection<Member> columnNamesSet = strategy.values();
    if ( columnNamesSet.size() != axesMembers[ axesIndex ] ) {
      logger.error( "ERROR: Number of names is not equal the pre-counted number." );
    }

    columnToMemberMapper.addAll( columnNamesSet );
  }
  return columnToMemberMapper;
}
 

private static void outputFlattenedRecurse( Result result, List<List<Object>> rows, List<Object> rowValues,
  int[] coords, int axisOrdinal ) {
  final Axis[] axes = result.getAxes();
  if ( axisOrdinal == axes.length ) {
    final Cell cell = result.getCell( coords );
    // Output the raw (unformatted) value of the cell.
    // NOTE: We could output other properties of the cell here, such as its
    // formatted value, too.
    rowValues.add( cell.getValue() );

    // Add a copy of the completed row to the list of rows.
    rows.add( new ArrayList<>( rowValues ) );
  } else {
    final Axis axis = axes[axisOrdinal];
    int k = -1;
    int saveLength = rowValues.size();
    for ( Position position : axis.getPositions() ) {
      coords[axisOrdinal] = ++k;
      for ( Member member : position ) {
        rowValues.add( member.getUniqueName() );
      }
      outputFlattenedRecurse( result, rows, rowValues, coords, axisOrdinal + 1 );
      while ( rowValues.size() > saveLength ) {
        rowValues.remove( rowValues.size() - 1 );
      }
    }
  }
}
 

@SuppressWarnings("deprecation")
	public CubeReportData execute(String mdx,List<ColumnProperties> cols) throws Exception{
		Connection connection = null ;
		CubeReportData cubeReportData = new CubeReportData();
		try{
			connection = dataSource.service(schemaFile.getAbsolutePath()) ;
			Query query = connection.parseQuery(mdx);
			Result result = connection.execute(query) ;
			Axis[] axises = result.getAxes();
			cubeReportData.setData(new ArrayList<List<ValueData>>());
			for (int i = 0; i < axises.length; i++) {
				if (i == 0) {
					cubeReportData.setCol(createTitle(axises[i], i , cols));
				} else {
					cubeReportData.setRow(createTitle(axises[i], i , cols));
//					cubeReportData.setTotal(axises[i].getDataSize());
				}
			}
			if(cubeReportData.getRow()==null){
				cubeReportData.setRow(new Level("root","row", null , 0)) ;
				cubeReportData.getRow().setTitle(new ArrayList<List<Level>>());
				if(cubeReportData.getRow().getTitle().size()==0){
					List<Level> rowList = new ArrayList<Level>() ;
					rowList.add(new Level("合计","row", null , 0)) ;
					cubeReportData.getRow().getTitle().add(rowList) ;
				}
			}
			getRowData(result.getAxes(), result.getAxes().length - 1, new int[result.getAxes().length], result, cubeReportData.getData(), 0 , null , cubeReportData , cols);
			processSum(cubeReportData.getRow(), cubeReportData.getData() , cubeReportData.getRow()) ;
			processSum(cubeReportData.getCol(), cubeReportData.getData() , cubeReportData.getCol()) ;
			cubeReportData.getRow().setTitle(new ArrayList<List<Level>>()) ;
			processTitle(cubeReportData.getRow() , cubeReportData.getRow());
			
		}catch(Exception ex){ 
			ex.printStackTrace();
			throw ex;
		}finally{
			if(connection!=null){
				connection.close();
			}
			if(schemaFile.exists()){
				schemaFile.delete();
			}
		}
		return cubeReportData ;
	}
 

/**
 * Retrieve the rows from the opened query. Also create a description of the flattened output of the query. This call
 * populated rowMetaInterface and rows The query needs to be opened beforehand.
 *
 * @throws KettleDatabaseException
 *           in case something goes wrong
 *
 *           TODO: this is not quite working for our purposes.
 */
public void createFlattenedOutput() throws KettleDatabaseException {

  final Axis[] axes = result.getAxes();
  rows = new ArrayList<>();
  headings = new ArrayList<>();

  // Compute headings. Each heading is a hierarchy name. If there are say
  // 2 members on the columns, and 3 members on the rows axis, then there
  // will be 5 headings.
  //
  for ( Axis axis : axes ) {
    final List<Position> positions = axis.getPositions();
    if ( positions.isEmpty() ) {
      // Result set is empty. There is no data to print, and we cannot
      // even deduce column headings.
      return;
    }
    for ( Member member : positions.get( 0 ) ) {
      Hierarchy hierarchy = member.getHierarchy();
      headings.add( hierarchy.getUniqueName() );
    }
  }

  int[] coords = new int[axes.length];
  outputFlattenedRecurse( result, rows, new ArrayList<>(), coords, 0 );

  outputRowMeta = new RowMeta();

  // Just scan the first row to see what data types we received...
  //
  for ( int i = 0; i < rows.size() && i < 1; i++ ) {

    List<Object> rowValues = rows.get( i );

    for ( int c = 0; c < rowValues.size(); c++ ) {
      Object valueData = rowValues.get( c );

      int valueType;

      if ( valueData instanceof String ) {
        valueType = ValueMetaInterface.TYPE_STRING;
      } else if ( valueData instanceof Date ) {
        valueType = ValueMetaInterface.TYPE_DATE;
      } else if ( valueData instanceof Boolean ) {
        valueType = ValueMetaInterface.TYPE_BOOLEAN;
      } else if ( valueData instanceof Integer ) {
        valueType = ValueMetaInterface.TYPE_INTEGER;
        valueData = Long.valueOf( ( (Integer) valueData ).longValue() );
      } else if ( valueData instanceof Short ) {
        valueType = ValueMetaInterface.TYPE_INTEGER;
        valueData = Long.valueOf( ( (Short) valueData ).longValue() );
      } else if ( valueData instanceof Byte ) {
        valueType = ValueMetaInterface.TYPE_INTEGER;
        valueData = Long.valueOf( ( (Byte) valueData ).longValue() );
      } else if ( valueData instanceof Long ) {
        valueType = ValueMetaInterface.TYPE_INTEGER;
      } else if ( valueData instanceof Double ) {
        valueType = ValueMetaInterface.TYPE_NUMBER;
      } else if ( valueData instanceof Float ) {
        valueType = ValueMetaInterface.TYPE_NUMBER;
        valueData = Double.valueOf( ( (Float) valueData ).doubleValue() );
      } else if ( valueData instanceof BigDecimal ) {
        valueType = ValueMetaInterface.TYPE_BIGNUMBER;
      } else {
        throw new KettleDatabaseException( BaseMessages.getString( PKG, "MondrianInputErrorUnhandledType", valueData.getClass().toString() ) );
      }

      try {
        ValueMetaInterface valueMeta = ValueMetaFactory.createValueMeta( headings.get( c ), valueType );
        outputRowMeta.addValueMeta( valueMeta );
        rowValues.set( i, valueData );
      } catch ( Exception e ) {
        throw new KettleDatabaseException( e );
      }
    }
  }

  // Now that we painstakingly found the metadata that comes out of the Mondrian database, cache it please...
  //
  DBCacheEntry cacheEntry = new DBCacheEntry( databaseMeta.getName(), queryString );
  DBCache.getInstance().put( cacheEntry, outputRowMeta );
}