CompositeQuery


1   package com.teamkonzept.db;
2   
3   import java.sql.*;
4   import java.util.*;
5   
6   import com.teamkonzept.lib.*;
7   import org.apache.log4j.Category;
8   
9   
10  /**
11   *
12   * @author  $Author: alex $
13   * @version $Revision: 1.13 $
14   */
15  public abstract class CompositeQuery extends TKQuery
16  {
17  
18      /** Logging Category */
19      private static Category cat = Category.getInstance(CompositeQuery.class);
20  
21      /** query objects in the order they are to be executed*/
22      TKVector queries = new TKVector();
23  
24  
25      /** behaviour during execute(): */
26      boolean defaultParameterPropagation = false;
27  
28      /** nested hash, 3 levels:
29          1) destQuery
30          2) sourceQuery
31          3) destParam
32          4) sourceParam
33      */
34      TKHashtable parameterMapping = new TKHashtable();
35  
36      /**
37          hash to store resultsets
38      */
39      TKHashtable queryResults = new TKHashtable();
40  
41  
42      /**
43          hash to store conditons for execution
44          key:    query
45          value:  TKVector of parameters
46      */
47      TKHashtable requiredParams = new TKHashtable();
48  
49      /**
50          if relevantQuery is not null, it is used by fetchResultSet()
51      */
52      TKQuery relevantQuery = null;
53  
54  
55      /**
56          template method.
57          implemented by concrete subclass
58  
59          should contain:
60          1) calls to registerQuery
61          2) callsto setInternalParameter
62      */
63      protected abstract void initConcreteCompositeQuery() throws SQLException;
64  
65      /*
66      boolean initCompositeQuery()throws SQLException{
67          initConcreteCompositeQuery();
68          return true;
69      }
70      */
71      public void initQuery( final TKSQLTypeConverter conv, final TKDBConnection tkdbConn, Object   queryID){
72  
73          queryParams = new TKHashtable();
74  
75          // initialisation
76          /*
77          try{
78              initCompositeQuery();
79          }
80          catch(SQLException e){
81              throw new Error(e.getMessage());
82          }
83          */
84      }
85  
86      /**
87          to ignore:
88      */
89      public void initQuery( final Connection conn ){
90          //NOP
91      }
92  
93  
94      /**
95          template method
96      */
97      protected boolean beforeExecution(int i){
98          return true;
99      }
100 
101     /**
102         registers and creates query object
103     */
104     protected TKQuery registerQuery(Class   queryClass)throws SQLException{
105         TKQuery query = TKDBManager.newQuery(queryClass);
106 
107         // store query:
108         queries.addElement(query);
109 
110         return query;
111     }
112 
113     /**
114         defines that destParam of destQuery will be assigned
115         the value sourceParam of the resultset of sourceQuery
116     */
117     protected boolean setInternalParameter(TKQuery destQuery, TKQuery sourceQuery, String   destParam, String   sourceParam)throws SQLException{
118 
119         // check if input param exists
120         if(!new TKVector(((TKPrepQuery)destQuery).paramOrder).contains(destParam)){
121             throw new SQLException(
122                 " Attempt to reference nonexisting query input parameter: " +
123                 destParam + " in query " +  destQuery   + " by CompositeQuery " +this
124             );
125         }
126 
127         // store information
128         Object  [] keyList = {destQuery, sourceQuery, destParam};
129         parameterMapping.put(keyList, sourceParam);
130 
131         return true;
132     }
133 
134     /**
135         fetches parameters from resultsets and sets them into queries
136     */
137     boolean internalParamsPropagation(int i)throws SQLException{
138         TKQuery destQuery = getQuery(i);
139         TKHashtable sourceQueries = (TKHashtable)parameterMapping.get(destQuery);
140         // no internal parameters for this query
141         if(sourceQueries == null){
142             return true;
143         }
144         Enumeration sourceQueriesEnum = sourceQueries.keys();
145         while(sourceQueriesEnum.hasMoreElements()){
146             TKQuery sourceQuery = (TKQuery) sourceQueriesEnum.nextElement();
147             TKHashtable paramPairs = (TKHashtable)sourceQueries.get(sourceQuery);
148             Enumeration destParams =  paramPairs.keys();
149             while(destParams.hasMoreElements()){
150                 String   destParameter    = (String  ) destParams.nextElement();
151                 String   sourceParameter  = (String  ) paramPairs.get(destParameter);
152                 Object   parameterValue   = getResult(sourceQuery, sourceParameter);
153                 destQuery.setQueryParams(destParameter, parameterValue);
154                     // report
155             }
156         }
157         return true;
158     }
159 
160     Object   getResult(TKQuery query, String   resultName)throws SQLException{
161         ResultSet rs = (ResultSet) getResultSet(query);
162         if(rs != null && hasColumn(query, resultName)){
163             return rs.getObject(resultName);
164         }
165         else return null;
166     }
167 
168     /**
169         Fetches ResultSet of cache or query, sets it on the first row, and stores it for later use.
170     */
171     ResultSet getResultSet(TKQuery query)throws SQLException{
172         ResultSet rs = (ResultSet)queryResults.get(query);
173         if(rs == null){
174             rs = query.fetchResultSet();
175             if(rs != null && rs.next()){
176 
177                 queryResults.put(query, rs);
178             }
179         }
180         return rs;
181     }
182 
183     /*
184     ResultSet getResultSet(TKQuery query)throws SQLException{
185         //ResultSet rs = (ResultSet)queryResults.get(query);
186         ResultSet rs;
187         Object obj = queryResults.get(query);
188         if(obj == null){
189             rs = query.fetchResultSet();
190             if(rs != null){
191                 rs.next();
192                 queryResults.put(query, rs);
193             }
194             else{
195                 queryResults.put(query, new TKNull())
196             }
197         }
198         if(obj instanceof TKNull){
199             return null;
200         }
201         return rs;
202     }
203     */
204     /**
205         OBSOLETE
206         checks if the resultset of this query is required by following queries, eventually stores it.
207         relies on:
208         1. that the query renders the relevant resultset as the first one.
209         2. the ResultSet has only one row of interest.
210     */
211     /*
212     void storeResultSet(TKQuery query, boolean conditional)throws SQLException{
213 
214          if(sourceQueries().contains(query)){
215             storeResultSet(query);
216          }
217     }
218     void storeResultSet(TKQuery query)throws SQLException{
219         ResultSet rs = query.fetchResultSet();
220         if (rs!= null && rs.next()){
221             queryResults.put(query, rs);
222         }
223     }
224     */
225     /**
226         finds all the queries that are used to retrieve internal parameters
227 
228     */
229     TKVector  sourceQueries(){
230         TKVector allSourceQueries = new TKVector();
231         Enumeration sourceHashes = parameterMapping.elements();
232         while(sourceHashes.hasMoreElements()){
233             TKHashtable currSourceHash = (TKHashtable) sourceHashes.nextElement();
234             Enumeration currSourceQueries = currSourceHash.keys();
235             while(currSourceQueries.hasMoreElements()){
236                 allSourceQueries.addElement(currSourceQueries.nextElement());
237             }
238         }
239         return allSourceQueries;
240     }
241 
242 
243 
244     protected void setDefaultParameterPropagation(){
245         defaultParameterPropagation = true;
246     }
247 
248     boolean defaultPropagation(int i)throws SQLException{
249         if(queries.elementAt(i) instanceof TKNull){
250             return false;
251         }
252         TKPrepQuery destQ = (TKPrepQuery)getQuery(i);
253         for(int j = 0 ; j<i ; j++){
254             TKQuery sourceQuery = getQuery(j);
255             if(sourceQuery == null){
256                 continue;
257             }
258             retrieveValues(destQ,sourceQuery);
259 
260         }
261         return true;
262     }
263 
264     boolean retrieveValues(TKPrepQuery destQ, TKQuery sourceQ)throws SQLException{
265         TKVector unsetParams = getUnsetParams(destQ);
266         ListIterator unsetParamsIter = unsetParams.listIterator();
267         while(unsetParamsIter.hasNext()){
268             String   paramName = (String  )unsetParamsIter.next();
269             Object   paramVal  = getResult(sourceQ, paramName);
270             if(paramVal !=null){
271                 destQ.setQueryParams(paramName, paramVal);
272                 cat.debug(" sets " + paramName + " to " + paramVal + " from " + sourceQ);
273 
274 
275             }
276 
277         }
278         return true;
279     }
280 
281 
282     /**
283         propagates parameters to all registered queries
284     */
285     protected void setQueryParams(){
286         Enumeration queryEnum = queriesEnumeration();
287         while( queryEnum.hasMoreElements() ){
288             TKQuery query = (TKQuery) queryEnum.nextElement();
289             Enumeration names = queryParams.keys();
290             while( names.hasMoreElements()){
291                 String   name = (String  ) names.nextElement();
292                 query.setQueryParams(name, queryParams.get(name));
293             }
294         }
295     }
296     /*
297     public void setQueryParams( String param, Object val){
298         Enumeration queryEnum = queriesEnumeration();
299         while( queryEnum.hasMoreElements() ){
300             TKQuery curr = (TKQuery) queryEnum.nextElement();
301             curr.setQueryParams(param, val);
302         }
303     }
304     */
305 
306     /**
307      *  fuehrt die Query aus
308      * @throws SQLException vom Treiber geschmissen
309      * @return ob ein ResultSet vorhanden ist
310      */
311     public boolean execute()throws SQLException{
312 
313         initConcreteCompositeQuery();
314 
315         setQueryParams();
316 
317         boolean hasResultset = false;
318 
319 
320 
321         for(int i=0; i< queries.size(); i++){
322 
323             // will be assigned the return value of
324             // the template method
325             boolean doIt;
326 
327             TKQuery query = getQuery(i);
328             if(query == null){
329                 continue;
330             }
331             // transfer parametervalues from resultsets to queries
332             internalParamsPropagation(i);
333 
334             //call template method
335             doIt = beforeExecution(i);
336 
337             doIt = checkRequiredParameters(query);
338 
339             if(doIt){
340                 if(defaultParameterPropagation){
341                     defaultPropagation(i);
342                 }
343                 cat.debug(" execute " + query );
344                 cat.debug(" with set params: " + query.queryParams);
345                 if(query instanceof TKPrepQuery) cat.debug(" and with unset params: " + getUnsetParams((TKPrepQuery)query));
346                 TKVector req=  (TKVector)requiredParams.get(query);
347                 cat.debug(" requiredParams: "+ (req != null? req.toString(): "NULL"));
348                 hasResultset = query.execute();
349             }
350             else{
351                 queries.set(i, new TKNull());
352             }
353             //storeResultSet(query, true);
354 
355         }
356         return hasResultset;
357     }
358 
359     /** returnes the resultset of the query executed as last */
360     public ResultSet fetchResultSet(){
361         TKQuery query;
362         if(relevantQuery != null){
363             query = relevantQuery;
364         }
365         else{
366             query = getQuery(queries.size()-1);
367         }
368         if (query == null) {  // we should better check whether query is null...
369             return null;
370         }
371         return query.fetchResultSet();
372     }
373 
374 
375     public void close()throws SQLException{
376         Enumeration queryEnum = queriesEnumeration();
377         while(queryEnum.hasMoreElements()){
378             Object   next =  queryEnum.nextElement();
379             if(next instanceof TKQuery){
380                 TKQuery query = (TKQuery) next;
381                 query.close();
382             }
383         }
384     }
385 
386     public TKQuery getQuery(int i){
387         TKQuery query;
388         Object   obj = queries.get(i);
389         if(obj == null || obj instanceof TKNull){
390             return null;
391         }
392         else{
393             query =(TKQuery) queries.get(i);
394             return query;
395         }
396     }
397 
398     public Enumeration queriesEnumeration(){
399         return queries.elements();
400     }
401 
402 
403     public void specClose(){
404         //NOP
405     }
406 
407 // methods for control of execution
408     protected void setRequiredParam(TKQuery query, String  [] params){
409         for(int i = 0; i< params.length; i++){
410             setRequiredParam(query, params[i]);
411         }
412     }
413     protected void setRequiredParam(TKQuery query, String   param){
414 
415         TKVector paramsVector = (TKVector)requiredParams.get(query);
416         if(paramsVector == null){
417             paramsVector = new TKVector();
418             requiredParams.put(query,paramsVector);
419         }
420         paramsVector.add(param);
421     }
422     /**
423         Returns true <=>  all strings in requiredParams for a certain query
424         are set as parameters of this query.
425 
426     */
427 
428 
429     public boolean checkRequiredParameters(TKQuery query){
430         //TKQuery query =  getQuery(i);
431         //Set allreadySetParams = query.queryParams.keySet();
432 
433         TKVector reqParams = (TKVector) requiredParams.get(query);
434         if(reqParams == null){
435             return true;
436         }
437         Enumeration reqParamsEnum = reqParams.elements();
438         while(reqParamsEnum.hasMoreElements()){
439             String   reqParam = (String  )reqParamsEnum.nextElement();
440 
441             //boolean cont = allreadySetParams.contains(reqParam);
442             Object   setParam =  query.queryParams.get(reqParam);
443             if(setParam == null){
444                 return false;
445             }
446             else if(setParam instanceof TKNull){
447                 return false;
448             }
449         }
450         return true;
451     }
452 
453 
454 
455 // methods for default parameter propagation
456     public boolean areAllParamsSet(TKPrepQuery query){
457         return (getUnsetParams(query).size() == 0);
458     }
459 
460 
461 
462     public boolean isParameterSet( String   paramName){
463         if(queryParams == null) return false;
464         Object   parameterValue = queryParams.get(paramName);
465         return parameterValue != null && !( parameterValue instanceof TKNull);
466     }
467 
468     /*
469     public boolean isParameterSet( String paramName){
470         Enumeration queryEnum = queriesEnumeration();
471         while(queryEnum.hasMoreElements()){
472             Object obj = queryEnum.nextElement();
473             if( !(obj instanceof TKNull)){
474                 TKPrepQuery query = (TKPrepQuery)  obj;
475                 if(isParameterSet(query, paramName)){
476                     return true;
477                 }
478             }
479         }
480         return false;
481     }
482     */
483 
484     public boolean isParameterSet(TKPrepQuery query, String   paramName){
485         Object   parameterValue = query.queryParams.get(paramName);
486         return parameterValue != null && !( parameterValue instanceof TKNull);
487     }
488 
489     public TKVector getUnsetParams(TKPrepQuery query){
490         TKVector unsParams = new TKVector();
491         if(query.paramOrder == null) return unsParams;
492         for(int i=0; i < query.paramOrder.length; i++){
493             String   currParam = query.paramOrder[i];
494             Object   currVal = query.queryParams.get(currParam);
495             if(currVal == null ||  (currVal instanceof TKNull) ){
496                 unsParams.addElement(currParam);
497             }
498             /*
499             if(!query.queryParams.containsKey(currParam)){
500                 unsParams.addElement(currParam);
501             }
502             */
503         }
504         return unsParams;
505     }
506 
507     public boolean hasColumn(TKQuery query, String   colName)throws SQLException{
508         ResultSet rs = getResultSet(query);
509         if(rs != null){
510             return hasColumn(rs, colName);
511         }
512         else return false;
513     }
514     public boolean hasColumn(ResultSet rs, String   colName)throws SQLException{
515         ResultSetMetaData meta = rs.getMetaData();
516         int colCount = meta.getColumnCount();
517         for(int i = 1; i <= colCount;i++){
518             if(colName.equals(meta.getColumnName(i).toUpperCase())){
519                 return true;
520             }
521 
522         }
523         return false;
524     }
525 
526     protected Object   searchParamInResults(String   paramName){
527         return null;
528 
529     }
530 
531     public void setRelevantQuery(TKQuery query){
532         relevantQuery = query;
533     }
534 }
535
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags