|
1
21 package com.jaspersoft.jasperserver.api.engine.jasperreports.util;
22
23 import java.sql.Connection  ;
24 import java.util.ArrayList ;
25 import java.util.Collections ;
26 import java.util.HashMap ;
27 import java.util.HashSet ;
28 import java.util.List ;
29 import java.util.Map ;
30 import java.util.Set ;
31
32 import net.sf.jasperreports.engine.JRDataSource;
33 import net.sf.jasperreports.engine.JRDataset;
34 import net.sf.jasperreports.engine.JRException;
35 import net.sf.jasperreports.engine.JRExpression;
36 import net.sf.jasperreports.engine.JRField;
37 import net.sf.jasperreports.engine.JRGroup;
38 import net.sf.jasperreports.engine.JRParameter;
39 import net.sf.jasperreports.engine.JRPropertiesMap;
40 import net.sf.jasperreports.engine.JRQuery;
41 import net.sf.jasperreports.engine.JRQueryChunk;
42 import net.sf.jasperreports.engine.JRValueParameter;
43 import net.sf.jasperreports.engine.JRVariable;
44 import net.sf.jasperreports.engine.JasperReport;
45 import net.sf.jasperreports.engine.design.JRDesignQuery;
46 import net.sf.jasperreports.engine.query.JRQueryExecuter;
47 import net.sf.jasperreports.engine.query.JRQueryExecuterFactory;
48 import net.sf.jasperreports.engine.util.JRQueryExecuterUtils;
49
50 import org.apache.commons.collections.OrderedMap;
51 import org.apache.commons.collections.map.LinkedMap;
52 import org.apache.commons.logging.Log;
53 import org.apache.commons.logging.LogFactory;
54
55 import com.jaspersoft.jasperserver.api.JSExceptionWrapper;
56 import com.jaspersoft.jasperserver.api.metadata.common.domain.Query;
57
58
62 public class JRQueryExecuterAdapter {
63
64 private static final Log log = LogFactory.getLog(JRQueryExecuterAdapter.class);
65
66 public static OrderedMap executeQuery(final Query query, final String keyColumn, final String [] resultColumns, Map parameterValues) {
67 try {
68 JRQueryExecuterFactory queryExecuterFactory = JRQueryExecuterUtils.getQueryExecuterFactory(query.getLanguage());
69
70 JRParameter[] dsParameters = getDatasetParameters(queryExecuterFactory, parameterValues);
71 JRField[] fields = getDatasetFields(keyColumn, resultColumns);
72 JRQuery dsQuery = new JSQuery(query);
73 JSDataset dataset = new JSDataset(query.getName(), dsParameters, fields, dsQuery);
74
75 Map parametersMap = new HashMap ();
76 for (int i = 0; i < dsParameters.length; i++) {
77 JRParameter parameter = dsParameters[i];
78 parametersMap.put(parameter.getName(), parameter);
79 }
80
81 JRQueryExecuter executer = queryExecuterFactory.createQueryExecuter(dataset, parametersMap);
82 try {
83 JRDataSource ds = executer.createDatasource();
84 OrderedMap values = new LinkedMap();
85 while (ds.next()) {
86 Object valueColumn = ds.getFieldValue(dataset.getField(keyColumn));
87
88 String [] visibleColumnValues = new String [resultColumns.length];
89 for (int idx = 0; idx < resultColumns.length; ++idx) {
90 visibleColumnValues[idx] = (String ) ds.getFieldValue(dataset.getField(resultColumns[idx]));
91 }
92
93 values.put(valueColumn, visibleColumnValues);
94 }
95
96 return values;
97 } finally {
98 executer.close();
99 }
100 } catch (JRException e) {
101 log.error("Error while executing query", e);
102 throw new JSExceptionWrapper(e);
103 }
104
105 }
106
107
108 protected static JRField[] getDatasetFields(final String keyColumn, final String [] resultColumns) {
109 JRField[] fields = new JRField[resultColumns.length + 1];
110 fields[0] = new ColumnField(keyColumn, Object .class);
111 for (int idx = 0; idx < resultColumns.length; ++idx) {
112 fields[idx + 1] = new ColumnField(resultColumns[idx], String .class);
113 }
114 return fields;
115 }
116
117
118 protected static JRParameter[] getDatasetParameters(JRQueryExecuterFactory queryExecuterFactory, Map parameterValues) {
119 boolean jdbcConnectionParam = parameterValues.containsKey(JRParameter.REPORT_CONNECTION);
120
121 List dsParameters = new ArrayList ();
122
123 dsParameters.add(new ValueParameter(JRParameter.REPORT_PARAMETERS_MAP, Map .class, parameterValues));
124 dsParameters.add(new ValueParameter(JRParameter.REPORT_MAX_COUNT, Connection .class, null));
125
126 if (jdbcConnectionParam) {
127 Object value = parameterValues.get(JRParameter.REPORT_CONNECTION);
128 dsParameters.add(new ValueParameter(JRParameter.REPORT_CONNECTION, Connection .class, value));
129 }
130
131 Object [] builtinParameters = queryExecuterFactory.getBuiltinParameters();
132 if (builtinParameters != null) {
133 for (int i = 0; i < builtinParameters.length - 1; i += 2) {
134 String name = (String ) builtinParameters[i];
135 Class type = (Class ) builtinParameters[i + 1];
136 Object value = parameterValues.get(name);
137 dsParameters.add(new ValueParameter(name, type, value));
138 }
139 }
140
141 JRParameter[] params = new JRParameter[dsParameters.size()];
142 return (JRParameter[]) dsParameters.toArray(params);
143 }
144
145
146 public static JRQueryExecuter createQueryExecuter(JasperReport report, Map parameterValues, Query query) {
147 try {
148 JRQueryExecuterFactory queryExecuterFactory = JRQueryExecuterUtils.getQueryExecuterFactory(query.getLanguage());
149
150 ReportQueryDataset dataset = new ReportQueryDataset(report, query, queryExecuterFactory);
151
152 Map parametersMap = new HashMap ();
153 JRParameter[] parameters = dataset.getParameters();
154 for (int i = 0; i < parameters.length; i++) {
155 JRParameter parameter = parameters[i];
156 Object value = parameterValues.get(parameter.getName());
157 ParameterValueDecorator parameterValue = new ParameterValueDecorator(parameter, value);
158 parametersMap.put(parameter.getName(), parameterValue);
159 }
160
161 JRQueryExecuter executer = queryExecuterFactory.createQueryExecuter(dataset, parametersMap);
162 return executer;
163 } catch (JRException e) {
164 throw new JSExceptionWrapper(e);
165 }
166 }
167
168
169 protected static class ColumnField implements JRField {
170 private final String column;
171 private final Class type;
172
173 public ColumnField(final String column, final Class type) {
174 this.column = column;
175 this.type = type;
176 }
177
178 public String getDescription() {
179 return null;
180 }
181
182 public String getName() {
183 return column;
184 }
185
186 public Class getValueClass() {
187 return type;
188 }
189
190 public String getValueClassName() {
191 return type.getName();
192 }
193
194 public void setDescription(String arg0) {
195 }
196 }
197
198
199 protected static class JSQuery implements JRQuery {
200 private final String queryLanguage;
201 private final String queryString;
202 private final JRQueryChunk[] chunks;
203
204 public JSQuery(final String queryLanguage, final String queryString) {
205 this.queryString = queryString;
206 this.queryLanguage = queryLanguage;
207
208 this.chunks = new JRQueryChunk[]{new JRQueryChunk() {
209 public String getText() {
210 return queryString;
211 }
212
213 public byte getType() {
214 return JRQueryChunk.TYPE_TEXT;
215 }
216 }};
217 }
218
219 public JSQuery(Query query) {
220 this(query.getLanguage(), query.getSql());
221 }
222
223 public JRQueryChunk[] getChunks() {
224 return chunks;
225 }
226
227 public String getLanguage() {
228 return queryLanguage;
229 }
230
231 public String getText() {
232 return queryString;
233 }
234 }
235
236
237 protected static class JSDataset implements JRDataset {
238 private final String name;
239 private final JRParameter[] parameters;
240 private final JRField[] fields;
241 private final JRQuery query;
242 private final Map fieldsMap;
243
244 public JSDataset(final String name, final JRParameter[] parameters, final JRField[] fields, final JRQuery query) {
245 this.name = name;
246 this.parameters = parameters;
247 this.fields = fields;
248 this.query = query;
249
250 fieldsMap = new HashMap ();
251 for (int i = 0; i < fields.length; i++) {
252 JRField field = fields[i];
253 fieldsMap.put(field.getName(), field);
254 }
255 }
256
257 public JRField[] getFields() {
258 return fields;
259 }
260
261 public JRExpression getFilterExpression() {
262 return null;
263 }
264
265 public JRGroup[] getGroups() {
266 return null;
267 }
268
269 public String getName() {
270 return name;
271 }
272
273 public JRParameter[] getParameters() {
274 return parameters;
275 }
276
277 public JRPropertiesMap getPropertiesMap() {
278 return null;
279 }
280
281 public JRQuery getQuery() {
282 return query;
283 }
284
285 public String getResourceBundle() {
286 return null;
287 }
288
289 public String getScriptletClass() {
290 return null;
291 }
292
293 public JRVariable[] getVariables() {
294 return null;
295 }
296
297 public byte getWhenResourceMissingType() {
298 return JRDataset.WHEN_RESOURCE_MISSING_TYPE_ERROR;
299 }
300
301 public boolean isMainDataset() {
302 return false;
303 }
304
305 public void setWhenResourceMissingType(byte type) {
306 }
307
308 public JRField getField(String column) {
309 return (JRField) fieldsMap.get(column);
310 }
311 }
312
313 protected static class ValueParameter implements JRValueParameter {
314
315 private final String name;
316 private final Class type;
317 private final Object value;
318
319 public ValueParameter(String name, Class type, Object value) {
320 this.name = name;
321 this.type = type;
322 this.value = value;
323 }
324
325 public String getName() {
326 return name;
327 }
328
329 public String getDescription() {
330 return null;
331 }
332
333 public void setDescription(String description) {
334 }
335
336 public Class getValueClass() {
337 return type;
338 }
339
340 public String getValueClassName() {
341 return type.getName();
342 }
343
344 public boolean isSystemDefined() {
345 return true;
346 }
347
348 public boolean isForPrompting() {
349 return false;
350 }
351
352 public JRExpression getDefaultValueExpression() {
353 return null;
354 }
355
356 public Object getValue() {
357 return value;
358 }
359
360 }
361
362
363 protected static class ReportQueryDataset implements JRDataset {
364 private final JRDataset reportDataset;
365 private final JRParameter[] parameters;
366 private final JRQuery query;
367
368 public ReportQueryDataset(JasperReport report, Query query, JRQueryExecuterFactory queryExecuterFactory) {
369 this.reportDataset = report.getMainDataset();
370 this.query = getQuery(query);
371 this.parameters = getParams(queryExecuterFactory);
372 }
373
374 private JRQuery getQuery(Query query) {
375 JRDesignQuery designQuery = new JRDesignQuery();
376 designQuery.setLanguage(query.getLanguage());
377 designQuery.setText(query.getSql());
378 return designQuery;
379 }
380
381 private JRParameter[] getParams(JRQueryExecuterFactory queryExecuterFactory) {
382 JRParameter[] paramArray;
383 Object [] builtinParameters = queryExecuterFactory.getBuiltinParameters();
384 if (builtinParameters == null || builtinParameters.length == 0) {
385 paramArray = this.reportDataset.getParameters();
386 } else {
387 JRParameter[] reportParams = this.reportDataset.getParameters();
388 List params = new ArrayList (reportParams.length + builtinParameters.length / 2);
389
390 Set paramNames = new HashSet ();
391 for (int i = 0; i < reportParams.length; i++) {
392 JRParameter parameter = reportParams[i];
393 params.add(parameter);
394 paramNames.add(parameter.getName());
395 }
396
397 for (int i = 0; i < builtinParameters.length - 1; i += 2) {
398 String name = (String ) builtinParameters[i];
399 if (!paramNames.contains(name)) {
400 Class type = (Class ) builtinParameters[i + 1];
401 params.add(new ValueParameter(name, type, null));
402 }
403 }
404
405 paramArray = new JRParameter[params.size()];
406 paramArray = (JRParameter[]) params.toArray(paramArray);
407 }
408 return paramArray;
409 }
410
411
414 public String getName() {
415 return reportDataset.getName();
416 }
417
418
421 public String getScriptletClass() {
422 return reportDataset.getScriptletClass();
423 }
424
425
428 public JRParameter[] getParameters() {
429 return parameters;
430 }
431
432
435 public JRQuery getQuery() {
436 return query;
437 }
438
439
442 public JRField[] getFields() {
443 return reportDataset.getFields();
444 }
445
446
449 public JRVariable[] getVariables() {
450 return reportDataset.getVariables();
451 }
452
453
456 public JRGroup[] getGroups() {
457 return reportDataset.getGroups();
458 }
459
460
463 public boolean isMainDataset() {
464 return true;
465 }
466
467
470 public String getResourceBundle() {
471 return reportDataset.getResourceBundle();
472 }
473
474
477 public byte getWhenResourceMissingType() {
478 return reportDataset.getWhenResourceMissingType();
479 }
480
481
484 public void setWhenResourceMissingType(byte type) {
485 }
487
488
491 public JRPropertiesMap getPropertiesMap() {
492 return reportDataset.getPropertiesMap();
493 }
494
495
498 public JRExpression getFilterExpression() {
499 return reportDataset.getFilterExpression();
500 }
501 }
502
503
504 protected static class ParameterValueDecorator implements JRValueParameter {
505 private final JRParameter parameter;
506 private final Object value;
507
508 public ParameterValueDecorator(final JRParameter parameter, final Object value) {
509 this.parameter = parameter;
510 this.value = value;
511 }
512
513
516 public Object getValue() {
517 return value;
518 }
519
520
523 public String getName() {
524 return parameter.getName();
525 }
526
527
530 public String getDescription() {
531 return parameter.getDescription();
532 }
533
534
537 public void setDescription(String arg0) {
538 }
540
541
544 public Class getValueClass() {
545 return parameter.getValueClass();
546 }
547
548
551 public String getValueClassName() {
552 return parameter.getValueClassName();
553 }
554
555
558 public boolean isSystemDefined() {
559 return parameter.isSystemDefined();
560 }
561
562
565 public boolean isForPrompting() {
566 return parameter.isForPrompting();
567 }
568
569
572 public JRExpression getDefaultValueExpression() {
573 return parameter.getDefaultValueExpression();
574 }
575
576
577 }
578
579 }
580 |
Popular Tags |
Java API By Example, From Geeks To Geeks.