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++);
}
}
}
}
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;
}
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();
}
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];
}
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) {
}
}
}
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);
}
}
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("}");
}
}
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;
}
/**
* 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();
}