protected static String getUnitName(JRReport report, JRDataset dataset, String nameSuffix) {
String className;
if (dataset.isMainDataset()) {
className = report.getName();
} else {
className = report.getName() + "_" + dataset.getName();
}
className = JRStringUtil.getJavaIdentifier(className) + nameSuffix;
return className;
}
public JRField[] getFields(IReportConnection con, JRDataset reportDataset, Map parameters)
throws JRException, UnsupportedOperationException {
/** Copyright (C) 2006 CINCOM SYSTEMS, INC. All Rights Reserved www.cincom.com */
if (con instanceof it.businesslogic.ireport.connection.JRXMLADataSourceConnection) {
try {
String query = reportDataset.getQuery().getText();
java.util.ArrayList v_fields = getFields(query, (JRXMLADataSourceConnection) con);
// Translate
JRField[] final_fields = new JRField[v_fields.size()];
for (int i = 0; i < v_fields.size(); ++i) {
XmlaFieldNode f = (XmlaFieldNode) v_fields.get(i);
JRDesignField field = new JRDesignField();
field.setName(f.getName());
field.setValueClassName(f.getClassType());
field.setDescription(f.getDescription());
final_fields[i] = field;
}
return final_fields;
} catch (Exception ex) {
throw new JRException(ex);
}
} else {
throw new JRException(
"The active connection is not of type XMLA. Activate an XMLA connection first.");
}
}
private void setGroups(JRDataset dataset, JRFillObjectFactory factory) {
JRGroup[] jrGroups = dataset.getGroups();
if (jrGroups != null && jrGroups.length > 0) {
groups = new JRFillGroup[jrGroups.length];
for (int i = 0; i < groups.length; i++) {
groups[i] = factory.getGroup(jrGroups[i]);
}
}
}
private void setFields(JRDataset dataset, JRFillObjectFactory factory) {
JRField[] jrFields = dataset.getFields();
if (jrFields != null && jrFields.length > 0) {
fields = new JRFillField[jrFields.length];
fieldsMap = new HashMap();
for (int i = 0; i < fields.length; i++) {
fields[i] = factory.getField(jrFields[i]);
fieldsMap.put(fields[i].getName(), fields[i]);
}
}
}
private void setParameters(JRDataset dataset, JRFillObjectFactory factory) {
JRParameter[] jrParameters = dataset.getParameters();
if (jrParameters != null && jrParameters.length > 0) {
parameters = new JRFillParameter[jrParameters.length];
parametersMap = new HashMap();
for (int i = 0; i < parameters.length; i++) {
parameters[i] = factory.getParameter(jrParameters[i]);
parametersMap.put(parameters[i].getName(), parameters[i]);
}
}
}
/**
* Creates a fill dataset object.
*
* @param filler the filelr
* @param dataset the template dataset
* @param factory the fill object factory
*/
protected JRFillDataset(JRBaseFiller filler, JRDataset dataset, JRFillObjectFactory factory) {
factory.put(dataset, this);
this.filler = filler;
this.parent = dataset;
this.isMain = dataset.isMainDataset();
scriptletClassName = dataset.getScriptletClass();
resourceBundleBaseName = dataset.getResourceBundle();
whenResourceMissingType = dataset.getWhenResourceMissingType();
query = dataset.getQuery();
setParameters(dataset, factory);
setFields(dataset, factory);
setVariables(dataset, factory);
setGroups(dataset, factory);
}
private void setVariables(JRDataset dataset, JRFillObjectFactory factory) {
JRVariable[] jrVariables = dataset.getVariables();
if (jrVariables != null && jrVariables.length > 0) {
List variableList = new ArrayList(jrVariables.length * 3);
variablesMap = new HashMap();
for (int i = 0; i < jrVariables.length; i++) {
addVariable(jrVariables[i], variableList, factory);
}
setVariables(variableList);
}
}
public JRQueryExecuter createQueryExecuter(JRDataset jRDataset, Map map) throws JRException {
JRQuery query = jRDataset.getQuery();
String queryString = query.getText();
return new CSVQueryExecuter(queryString);
}
public JRExpression getFilterExpression() {
return parent.getFilterExpression();
}
public JRPropertiesMap getPropertiesMap() {
return parent.getPropertiesMap();
}
public boolean hasProperties() {
return parent.hasProperties();
}
public String getResourceBundle() {
return parent.getResourceBundle();
}
public JRSortField[] getSortFields() {
return parent.getSortFields();
}
public String getScriptletClass() {
return parent.getScriptletClass();
}
public String getName() {
return parent.getName();
}
public JRField[] getFields(IReportConnection irConn, JRDataset reportDataset, Map parameters)
throws JRException, UnsupportedOperationException {
if (irConn == null || !irConn.isJDBCConnection()) {
throw new JRException(
"The active connection is not of type JDBC. Activate a JDBC connection first.");
}
String query = reportDataset.getQuery().getText();
String error_msg = "";
Connection con = null;
PreparedStatement ps = null;
try {
// look for parameters in the query and replace them with default values.
// parameters look something like
// $P{QuoteGroupID}
// or
// $P!{OrderByClause}
java.util.List queryParams = new ArrayList();
JRParameter[] jrParams = reportDataset.getParameters();
for (int k = 0; k < jrParams.length; ++k) {
JRParameter parameter = jrParams[k];
String p1 = "$P{" + parameter.getName() + "}";
String p2 = "$P!{" + parameter.getName() + "}";
Object defValue = parameters.get(parameter.getName());
int ip1 = query.indexOf(p1);
while (ip1 != -1) {
// add a query parameter
if (defValue == null) {
throw new IllegalArgumentException(
"Please set a " + "default value for the parameter '" + parameter.getName() + "'");
}
String before = query.substring(0, ip1);
String after = query.substring(ip1 + p1.length());
query = before + " ? " + after;
queryParams.add(defValue);
ip1 = query.indexOf(p1);
}
int ip2 = query.indexOf(p2);
while (ip2 != -1) {
// String replacement, Altering the SQL statement.
if (defValue == null) {
throw new IllegalArgumentException(
"Please set a " + "default value for the parameter '" + parameter.getName() + "'");
}
String before = query.substring(0, ip2);
String after = query.substring(ip2 + p2.length());
query = before + "" + defValue.toString() + "" + after;
ip2 = query.indexOf(p2);
}
}
con = irConn.getConnection();
ps = con.prepareStatement(query);
// for(int pc=0; pc<queryParams.size(); pc++ ) {
// ps.setObject(pc+1, queryParams.get(pc) );
// }
for (int pc = 0; pc < queryParams.size(); pc++) {
Class parameterType = queryParams.get(pc).getClass();
if (java.lang.Boolean.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.BIT);
} else {
ps.setBoolean(pc + 1, ((Boolean) queryParams.get(pc)).booleanValue());
}
} else if (java.lang.Byte.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.TINYINT);
} else {
ps.setByte(pc + 1, ((Byte) queryParams.get(pc)).byteValue());
}
} else if (java.lang.Double.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.DOUBLE);
} else {
ps.setDouble(pc + 1, ((Double) queryParams.get(pc)).doubleValue());
}
} else if (java.lang.Float.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.FLOAT);
} else {
ps.setFloat(pc + 1, ((Float) queryParams.get(pc)).floatValue());
}
} else if (java.lang.Integer.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.INTEGER);
} else {
ps.setInt(pc + 1, ((Integer) queryParams.get(pc)).intValue());
}
} else if (java.lang.Long.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.BIGINT);
} else {
ps.setLong(pc + 1, ((Long) queryParams.get(pc)).longValue());
}
} else if (java.lang.Short.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.SMALLINT);
} else {
ps.setShort(pc + 1, ((Short) queryParams.get(pc)).shortValue());
}
} else if (java.math.BigDecimal.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.DECIMAL);
} else {
ps.setBigDecimal(pc + 1, (BigDecimal) queryParams.get(pc));
}
} else if (java.lang.String.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.VARCHAR);
} else {
ps.setString(pc + 1, queryParams.get(pc).toString());
}
} else if (java.sql.Timestamp.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.TIMESTAMP);
} else {
ps.setTimestamp(pc + 1, (java.sql.Timestamp) queryParams.get(pc));
}
} else if (java.sql.Time.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.TIME);
} else {
ps.setTime(pc + 1, (java.sql.Time) queryParams.get(pc));
}
} else if (java.util.Date.class.isAssignableFrom(parameterType)) {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.DATE);
} else {
ps.setDate(pc + 1, new java.sql.Date(((java.util.Date) queryParams.get(pc)).getTime()));
}
} else {
if (queryParams.get(pc) == null) {
ps.setNull(pc + 1, Types.JAVA_OBJECT);
} else {
ps.setObject(pc + 1, queryParams.get(pc));
}
}
}
// Some JDBC drivers don't supports this method...
try {
ps.setFetchSize(0);
} catch (Exception e) {
}
ResultSet rs = ps.executeQuery();
// if (in < num) return;
ResultSetMetaData rsmd = rs.getMetaData();
// if (in < num) return;
List columns = new ArrayList();
for (int i = 1; i <= rsmd.getColumnCount(); ++i) {
JRDesignField field = new JRDesignField();
field.setName(rsmd.getColumnLabel(i));
field.setValueClassName(Misc.getJdbcTypeClass(rsmd, i));
field.setDescription("");
columns.add(field);
}
JRField[] final_fields = new JRField[columns.size()];
for (int i = 0; i < final_fields.length; ++i) {
final_fields[i] = (JRField) columns.get(i);
}
return final_fields;
} catch (IllegalArgumentException ie) {
throw new JRException(ie.getMessage());
} catch (NoClassDefFoundError ex) {
ex.printStackTrace();
error_msg = "NoClassDefFoundError!!\nCheck your classpath!";
throw new JRException(error_msg);
} catch (java.sql.SQLException ex) {
error_msg = "SQL problems:\n" + ex.getMessage();
throw new JRException(error_msg);
} catch (Exception ex) {
ex.printStackTrace();
error_msg =
"General problem:\n"
+ ex.getMessage()
+ "\n\nCheck username and password; is the DBMS active ?!";
throw new JRException(error_msg);
} catch (Throwable t) {
throw new JRException(t.getMessage());
} finally {
if (ps != null)
try {
ps.close();
} catch (Exception e) {
}
if (con != null)
try {
con.close();
} catch (Exception e) {
}
}
}