private void traverse(List<Integer>[] levels, List<TotalNode>[] totalLists) {
int fullPosition = 0;
final Member[] prevMemberBranch = new Member[memberBranch.length];
nextpos:
for (final Position p : dataAxisInfo.axis.getPositions()) {
int depth = 1;
int mI = 0;
for (final Member m : p.getMembers()) {
final int maxDepth = levels[mI].get(levels[mI].size() - 1);
if (m.getDepth() < maxDepth) {
continue nextpos;
}
positionMember(depth, m, levels[mI], memberBranch);
depth += levels[mI].size();
mI++;
}
int changedFrom = 1;
while (changedFrom < memberBranch.length - 1
&& memberBranch[changedFrom].equals(prevMemberBranch[changedFrom])) {
changedFrom++;
}
for (int i = totalBranch.length - 1; i >= changedFrom; i--) {
if (totalBranch[i] != null) {
totalBranch[i - 1].appendChild(totalBranch[i]);
}
}
for (int i = changedFrom; i < totalBranch.length; i++) {
String[] captions = measuresAt > i - 1 ? measuresCaptions : null;
totalBranch[i] =
new TotalNode(
captions, measures, aggrTempl[i], this, totalsAxisInfo.fullPositions.size());
totalLists[i].add(totalBranch[i]);
}
System.arraycopy(memberBranch, 0, prevMemberBranch, 0, prevMemberBranch.length);
totalBranch[totalBranch.length - 1].setSpan(1);
totalBranch[totalBranch.length - 1].setWidth(1);
for (int t = 0; t < totalsAxisInfo.fullPositions.size(); t++) {
Cell cell = getCellAt(fullPosition, t);
for (int branchNode = 0; branchNode < totalBranch.length; branchNode++) {
if (aggrTempl[branchNode] != null) {
totalBranch[branchNode].addData(getMemberIndex(branchNode, fullPosition), t, cell);
}
}
}
fullPosition++;
}
for (int i = totalBranch.length - 1; i > 0; i--) {
totalBranch[i - 1].appendChild(totalBranch[i]);
}
for (TotalNode n : totalLists[totalLists.length - 1]) {
n.setWidth(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++);
}
}
}
}
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);
}
public List<SaikuMember> getResultMetadataMembers(
String queryName,
boolean preferResult,
String dimensionName,
String hierarchyName,
String levelName) {
IQuery query = getIQuery(queryName);
CellSet cs = query.getCellset();
List<SaikuMember> members = new ArrayList<SaikuMember>();
Set<Level> levels = new HashSet<Level>();
if (cs != null && preferResult) {
for (CellSetAxis axis : cs.getAxes()) {
int posIndex = 0;
for (Hierarchy h : axis.getAxisMetaData().getHierarchies()) {
if (h.getUniqueName().equals(hierarchyName)) {
log.debug("Found hierarchy in the result: " + hierarchyName);
if (h.getLevels().size() == 1) {
break;
}
Set<Member> mset = new HashSet<Member>();
for (Position pos : axis.getPositions()) {
Member m = pos.getMembers().get(posIndex);
if (!m.getLevel().getLevelType().equals(Type.ALL)) {
levels.add(m.getLevel());
}
if (m.getLevel().getUniqueName().equals(levelName)) {
mset.add(m);
}
}
members = ObjectUtil.convertMembers(mset);
Collections.sort(members, new SaikuUniqueNameComparator());
break;
}
posIndex++;
}
}
log.debug("Found members in the result: " + members.size());
}
if (cs == null || !preferResult || members.size() == 0 || levels.size() == 1) {
members =
olapDiscoverService.getLevelMembers(
query.getSaikuCube(), dimensionName, hierarchyName, levelName);
}
return members;
}
/**
* 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("}");
}
}
/**
* Computes a description of an axis.
*
* @param axis Axis
* @return Description of axis
*/
private AxisInfo computeAxisInfo(final CellSetAxis axis) {
if (axis == null) {
return new AxisInfo(0);
}
final AxisInfo axisInfo = new AxisInfo(axis.getAxisMetaData().getHierarchies().size());
int p = -1;
for (final Position position : axis.getPositions()) {
++p;
int k = -1;
for (final Member member : position.getMembers()) {
++k;
final AxisOrdinalInfo axisOrdinalInfo = axisInfo.ordinalInfos.get(k);
if (!axisOrdinalInfo.getDepths().contains(member.getDepth())) {
axisOrdinalInfo.getDepths().add(member.getDepth());
axisOrdinalInfo.addLevel(member.getDepth(), member.getLevel());
Collections.sort(axisOrdinalInfo.depths);
}
}
}
return axisInfo;
}
/**
* 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;
}
}
}
/**
* Formats a two-dimensional page.
*
* @param cellSet Cell set
* @param pageCoords Coordinates of page [page, chapter, section, ...]
* @param columnsAxis Columns axis
* @param columnsAxisInfo Description of columns axis
* @param rowsAxis Rows axis
* @param rowsAxisInfo Description of rows axis
*/
private Matrix formatPage(
final CellSet cellSet,
final int[] pageCoords,
final CellSetAxis columnsAxis,
final AxisInfo columnsAxisInfo,
final CellSetAxis rowsAxis,
final AxisInfo rowsAxisInfo) {
// Figure out the dimensions of the blank rectangle in the top left
// corner.
final int yOffset = columnsAxisInfo.getWidth();
final int xOffsset = rowsAxisInfo.getWidth();
// Populate a string matrix
final Matrix matrix =
new Matrix(
xOffsset + (columnsAxis == null ? 1 : columnsAxis.getPositions().size()),
yOffset + (rowsAxis == null ? 1 : rowsAxis.getPositions().size()));
// Populate corner
List<Level> levels = new ArrayList<>();
if (rowsAxis != null && rowsAxis.getPositions().size() > 0) {
Position p = rowsAxis.getPositions().get(0);
for (int m = 0; m < p.getMembers().size(); m++) {
AxisOrdinalInfo a = rowsAxisInfo.ordinalInfos.get(m);
for (Integer depth : a.getDepths()) {
levels.add(a.getLevel(depth));
}
}
for (int x = 0; x < xOffsset; x++) {
Level xLevel = levels.get(x);
String s = xLevel.getCaption();
for (int y = 0; y < yOffset; y++) {
final MemberCell memberInfo = new MemberCell(false, x > 0);
if (y == yOffset - 1) {
memberInfo.setRawValue(s);
memberInfo.setFormattedValue(s);
memberInfo.setProperty("__headertype", "row_header_header");
memberInfo.setProperty("levelindex", "" + levels.indexOf(xLevel));
memberInfo.setHierarchy(xLevel.getHierarchy().getUniqueName());
memberInfo.setParentDimension(xLevel.getDimension().getName());
memberInfo.setLevel(xLevel.getUniqueName());
}
matrix.set(x, y, memberInfo);
}
}
}
// Populate matrix with cells representing axes
// noinspection SuspiciousNameCombination
populateAxis(matrix, columnsAxis, columnsAxisInfo, true, xOffsset);
populateAxis(matrix, rowsAxis, rowsAxisInfo, false, yOffset);
// Populate cell values
for (final Cell cell : cellIter(pageCoords, cellSet)) {
final List<Integer> coordList = cell.getCoordinateList();
int x = xOffsset;
if (coordList.size() > 0) x += coordList.get(0);
int y = yOffset;
if (coordList.size() > 1) y += coordList.get(1);
final DataCell cellInfo = new DataCell(true, false, coordList);
cellInfo.setCoordinates(cell.getCoordinateList());
if (cell.getValue() != null) {
try {
cellInfo.setRawNumber(cell.getDoubleValue());
} catch (Exception e1) {
}
}
String cellValue = cell.getFormattedValue(); // First try to get a
// formatted value
if (cellValue == null || cellValue.equals("null")) { // $NON-NLS-1$
cellValue = ""; // $NON-NLS-1$
}
if (cellValue.length() < 1) {
final Object value = cell.getValue();
if (value == null || value.equals("null")) // $NON-NLS-1$
cellValue = ""; // $NON-NLS-1$
else {
try {
// TODO this needs to become query / execution specific
DecimalFormat myFormatter =
new DecimalFormat(SaikuProperties.formatDefautNumberFormat); // $NON-NLS-1$
DecimalFormatSymbols dfs = new DecimalFormatSymbols(SaikuProperties.locale);
myFormatter.setDecimalFormatSymbols(dfs);
cellValue = myFormatter.format(cell.getValue());
} catch (Exception e) {
// TODO: handle exception
}
}
// the raw value
}
// Format string is relevant for Excel export
// xmla cells can throw an error on this
try {
String formatString =
(String) cell.getPropertyValue(Property.StandardCellProperty.FORMAT_STRING);
if (formatString != null && !formatString.startsWith("|")) {
cellInfo.setFormatString(formatString);
} else {
formatString = formatString.substring(1, formatString.length());
cellInfo.setFormatString(formatString.substring(0, formatString.indexOf("|")));
}
} catch (Exception e) {
// we tried
}
Map<String, String> cellProperties = new HashMap<>();
String val = Olap4jUtil.parseFormattedCellValue(cellValue, cellProperties);
if (!cellProperties.isEmpty()) {
cellInfo.setProperties(cellProperties);
}
cellInfo.setFormattedValue(val);
matrix.set(x, y, cellInfo);
}
return matrix;
}