KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > teamkonzept > db > TKUnprepQuery


1 /*
2  * $Header: /cvsroot/webman-cms/source/webman/com/teamkonzept/db/TKUnprepQuery.java,v 1.9 2002/02/16 16:03:15 alex Exp $
3  *
4  */

5 package com.teamkonzept.db;
6
7 import java.sql.*;
8 import java.util.*;
9
10 import com.teamkonzept.lib.*;
11 import com.teamkonzept.lib.templates.*;
12
13 /** Abstrakte Klasse, zur Erstellung nicht-präparierter Queries.
14  * Der einer solchen Query zugrundeliegende SQL-String wird aus einem
15  * TKTemplate bei Ausführung der Query erzeugt.
16  *
17  * @see java.sql.Statement
18  * @see com.teamkonzept.lib.TKTemplate
19  * @author
20  * @version
21  */

22 public abstract class TKUnprepQuery extends TKQuery
23 {
24     /** Eine Listiteratorklasse, um auch Felder in das SQL-Template
25      * einfügen zu können. Wird einem Query-Parameter mittels
26      * der Methode setQueryParams() nicht ein einzelner Wert, sondern ein
27      * Feld zugewiesen, so wird in dem SQL-Template das Tag VALUE,
28      * innerhalb derjeniegen Liste mit dem Namen des Query-Parameters,
29      * durch die Werte des zugewiesenen Feldes ersetzt. Zusätzlich
30      * wird das Tag KOMMA durch ',', für alle Elemente ausgenommen dem
31      * letzten, ersetzt.
32      *
33      * Bsp.:
34      * final Integer[] field = { new Integer(1), new Integer(2) };
35      * q.setQueryParams( "MY_LIST", field );
36      *
37      * erzeugt für das Template
38      * <TK_LIST:MY_LIST> ( <TK:VALUE> <TK:KOMMA> ) </TK_LIST:MY_LIST>
39      *
40      * ( 1, 2 )
41      * @author
42      * @version
43      */

44     private class QueryListIterator implements TKListIterator {
45
46             /** Name der Liste
47              */

48          String JavaDoc name;
49             /** Elemente, welche in die Liste einzuf&uuml;gen sind
50              */

51          Object JavaDoc[] items;
52
53             /** Index des zu bearbeitenden Listenelementes
54              */

55         int idx = -1;
56
57         /** Konstruktor.
58          *
59          * @param name - Name der Liste
60          * @param items - Feld der in die Liste einzuf&uuml;genden Elemente
61          */

62         QueryListIterator( final String JavaDoc name, final Object JavaDoc[] items )
63         {
64             this.name = name;
65             this.items = items;
66         }
67
68         /** Methode, welche f&uuml;r die entsprechende Liste die
69          * Methode doSubstitutions() aufruft.
70          *
71          * @param template - SQL-Template in dem die Liste
72          * bearbeitet werden soll.
73          * @param idx - wird nicht verwendet
74          * @param type - Name der Liste
75          *
76          * @return false, wenn der Iterator bereits das letzte Element
77          * bearbeitet hat; true, sonst.
78          *
79          * @exception com.teamkonzept.db.TKSQLError
80          */

81         final public boolean apply( final TKTemplate template, final int idx, final String JavaDoc type )
82         {
83             final QueryListIterator list = (QueryListIterator) listIterators.get( type );
84
85             if ( list == null && foreignIterator != null ) {
86                 return foreignIterator.apply( template, idx, type );
87             } else {
88                 list.idx++;
89                 return list.doSubstitutions( template );
90             }
91         }
92
93         /** Methode, welche die Tags VALUE u. KOMMA innerhalb der Liste
94          * ersetzt.
95          *
96          * @param templ - SQL-Template in dem die Liste
97          * bearbeitet werden soll.
98          *
99          * @return false, wenn der Iterator bereits das letzte Element
100          * bearbeitet hat; true, sonst.
101          *
102          * @exception com.teamkonzept.db.TKSQLError
103          */

104         public boolean doSubstitutions( final TKTemplate tmpl )
105         {
106             if ( idx < items.length ) {
107                 try {
108                     tmpl.add( "VALUE", convert( name, items[idx] ) );
109                 } catch ( final SQLException sqle ) {
110                     printSqlException( sqle, "parameter conversion in QueryListIterator " + name );
111                 }
112
113                 tmpl.add( "KOMMA", idx < ( items.length - 1 ) ? "," : "" );
114
115                 return true;
116             } else {
117                 idx = -1;
118                 return false;
119             }
120         }
121
122         /** Liefert einer Hash-Code f&uuml;r den Listiterator
123          *
124          * @return Hash-Code des Listiterators.
125          */

126         final public int hashCode()
127         {
128             return name.hashCode();
129         }
130     }
131
132         /** Hashtable aller QueryListiteratoren
133          */

134     TKHashtable listIterators = new TKHashtable();
135         /** "fremder" Listiterator
136          */

137     TKListIterator foreignIterator = null;
138         /** SQL-TemplateSyntaxobjekt
139          */

140     TKTemplateSyntax sqlTmplSyntax;
141         /** Typkonverter f&uuml;r die DB-Verbindung
142          */

143     TKSQLTypeConverter typeConverter;
144
145     /** Methode zur Initialisierung der Query.
146      * Diese Methode wird &uuml;blicherweise vom DB-Manager aufgerufen,
147      * um die Query zu initialisieren.
148      *
149      * @param tkConn - Verbindung zu der DB
150      * @param conv - der der DB zugeordnete Typ-Konverter
151      * @param queryID Name der Query Klasse ( wird nicht verwendet )
152      *
153      * @see com.teamkonzept.db.TKDBManager
154      * @see com.teamkonzept.db.TKDBManager#newQuery
155      */

156     public void initQuery( final TKSQLTypeConverter conv, final TKDBConnection tkConn , Object JavaDoc queryID )
157     {
158         this.aTKDBConnection = tkConn;
159         this.typeConverter = conv;
160         initQuery( tkConn.getConnection() );
161     }
162
163     /** Methode zur Initialisierung des Queryobjektes
164      *
165      * @param conn - Verbindung zur DB
166      * @param paramTypes - Liste von Parametername, Parametertyp Paaren
167      * @param setRelevants - geordnete Liste, welche angibt, welche
168      * SQl(Teil)Queries relevante ResultSets liefern.
169      * @param sqlTmplSyntax - Dem der Query zugrundeliegende
170      * SQL-TemplateSyntaxobjekt.
171      *
172      * @exception com.teamkonzept.db.TKSQLError
173      */

174     public void initQuery( final Connection conn,
175                            final Object JavaDoc[][] paramTypes,
176                            final boolean[] setRelevants,
177                            final TKTemplateSyntax sqlTmplSyntax )
178     {
179         super.initQuery( conn, paramTypes, setRelevants );
180
181         try {
182             this.stmt = conn.createStatement();
183         } catch ( SQLException sqle ) {
184             printSqlException(sqle, "Create Statement");
185         }
186         this.sqlTmplSyntax = sqlTmplSyntax;
187         this.sqlString = sqlTmplSyntax.getSource();
188     }
189
190     /** Methode, um die Query auszuf&uuml;hren
191      *
192      * @return true, falls die Query ein java.sql.ResultSet geliefert hat,
193      * false, falls das Resultat der Query ein "Update Count" ist
194      * oder leer ist.
195      *
196      * @exception java.sql.SQLException
197      * @exception com.teamkonzept.db.TKIllegalConversionException
198      */

199     public boolean execute() throws SQLException, TKIllegalConversionException
200     {
201
202         deregisterIndex = registerQuery();
203         final TKTemplate sqlTmpl = sqlTmplSyntax.getNewTemplate();
204         final Enumeration param_keys = queryParams.keys();
205
206         while ( param_keys.hasMoreElements() ) {
207             final String JavaDoc key = (String JavaDoc) param_keys.nextElement();
208             final Object JavaDoc val = queryParams.get( key );
209
210             sqlTmpl.add( key, convert( key, val ) );
211         }
212
213         if ( ! listIterators.isEmpty() ) {
214             sqlTmpl.setListIterator( (TKListIterator) listIterators.elements().nextElement() );
215         } else if ( foreignIterator != null ) {
216             sqlTmpl.setListIterator( foreignIterator );
217         }
218
219         try {
220             sqlTmpl.doTagSubstitution();
221         } catch ( TKTemplateSyntaxException tse ) {
222             throw new TKTemplateSyntaxError( tse.what, tse.type, tse.info );
223         }
224
225         sqlString = sqlTmpl.getText();
226
227         try {
228             currIsResultSet = stmt.execute( sqlString );
229         } catch (SQLException sqle) {
230             printSqlException(sqle, "Execute Unprepared Statement");
231         }
232
233         queryParams.clear();
234         listIterators.clear();
235         sqlString = sqlTmplSyntax.getSource();
236         foreignIterator = null;
237         currPos = 0;
238
239         return currIsResultSet;
240     }
241
242
243     /** Schlie&szlig;t das zu der Query geh&ouml;rige SQL-Statement und
244      * gibt die zugeh&ouml;rigen DB u. JDBC-Resourcen wieder frei.
245      *
246      *
247      * @exception java.sql.SQLException
248      */

249     public void specClose()
250                         throws SQLException
251     {
252         deregisterQuery();
253         if ( stmt != null ) {
254             throwawayResults();
255             stmt.close();
256             //stmt = null;
257
}
258     }
259
260
261     /** Liefert das gegebene Object val, als SQL-String, Der JDBC-Typ in dem
262      * das Objekt dargestellt werden soll, ist durch den Type des Queryparameters
263      * key gegeben.
264      *
265      * @param key - Name des Queryparameters, welcher den JDBC-Typ definiert.
266      * @param val - Das Objekt, f&uuml;r das der SQL-String erzeugt werden soll.
267      *
268      * @throws SQLException
269      * @throws TKIllegalConversionException
270      */

271     final public String JavaDoc convert( final String JavaDoc key, final Object JavaDoc val )
272                                                         throws SQLException, TKIllegalConversionException
273     {
274         if ( paramTypes == null ) {
275             return typeConverter.convert( Types.INTEGER, val );
276         } else {
277             final Integer JavaDoc type = (Integer JavaDoc) paramTypes.get( key );
278
279             if ( type == null ) {
280                 return typeConverter.convert( Types.INTEGER, val );
281             } else {
282                 return typeConverter.convert( type.intValue(), val );
283             }
284         }
285     }
286
287     /** Methode, welche einem Query-Parameter einen Wert oder
288      * ein Feld zuweist.
289      *
290      * @param param - Name des Parameters
291      * @param val - Wert/Feld des Parameters
292      */

293     public void setQueryParams( final String JavaDoc param, final Object JavaDoc val)
294     {
295         if ( val instanceof Object JavaDoc[] ) {
296             listIterators.put( param, new QueryListIterator( param, (Object JavaDoc[]) val ) );
297         } else {
298             super.setQueryParams( param, val );
299         }
300     }
301
302     /** Erm&ouml;glich das setzen eines eignen Listiterators f&uuml;r
303      * das SQL-Template
304      *
305      * @param iter - Der Listiterator, der verwendet werden
306      * soll, wenn f&uuml;r eine Liste kein
307      * QueryListIterator vorhanden ist.
308      */

309     public void setListIterator( final TKListIterator iter )
310     {
311         foreignIterator = iter;
312     }
313
314 }
315
316
Popular Tags