KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > torque > task > TorqueDataDumpTask


1 package org.apache.torque.task;
2
3 /*
4  * Copyright 2001-2004 The Apache Software Foundation.
5  *
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18
19 import java.sql.Connection JavaDoc;
20 import java.sql.DriverManager JavaDoc;
21 import java.sql.ResultSet JavaDoc;
22 import java.sql.SQLException JavaDoc;
23 import java.sql.Statement JavaDoc;
24 import java.util.Iterator JavaDoc;
25 import java.util.NoSuchElementException JavaDoc;
26
27 import org.apache.tools.ant.Project;
28
29 import org.apache.velocity.context.Context;
30
31
32 /**
33  * An extended Texen task used for dumping data from db into XML
34  *
35  * @author <a HREF="mailto:fedor.karpelevitch@home.com">Fedor Karpelevitch</a>
36  * @author <a HREF="mailto:jvanzyl@zenplex.com">Jason van Zyl</a>
37  * @author <a HREF="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
38  * @author <a HREF="mailto:mpoeschl@marmot.at">Martin Poeschl</a>
39  * @version $Id: TorqueDataDumpTask.java,v 1.7 2004/02/22 06:27:41 jmcnally Exp $
40  */
41 public class TorqueDataDumpTask extends TorqueDataModelTask
42 {
43     /** Database name. */
44     private String JavaDoc databaseName;
45
46     /** Database URL used for JDBC connection. */
47     private String JavaDoc databaseUrl;
48
49     /** Database driver used for JDBC connection. */
50     private String JavaDoc databaseDriver;
51
52     /** Database user used for JDBC connection. */
53     private String JavaDoc databaseUser;
54
55     /** Database password used for JDBC connection. */
56     private String JavaDoc databasePassword;
57
58     /** The database connection used to retrieve the data to dump. */
59     private Connection JavaDoc conn;
60
61     /** The statement used to acquire the data to dump. */
62     private Statement JavaDoc stmt;
63
64     /**
65      * Get the database name to dump
66      *
67      * @return The DatabaseName value
68      */
69     public String JavaDoc getDatabaseName()
70     {
71         return databaseName;
72     }
73
74     /**
75      * Set the database name
76      *
77      * @param v The new DatabaseName value
78      */
79     public void setDatabaseName(String JavaDoc v)
80     {
81         databaseName = v;
82     }
83
84     /**
85      * Get the database url
86      *
87      * @return The DatabaseUrl value
88      */
89     public String JavaDoc getDatabaseUrl()
90     {
91         return databaseUrl;
92     }
93
94     /**
95      * Set the database url
96      *
97      * @param v The new DatabaseUrl value
98      */
99     public void setDatabaseUrl(String JavaDoc v)
100     {
101         databaseUrl = v;
102     }
103
104     /**
105      * Get the database driver name
106      *
107      * @return String database driver name
108      */
109     public String JavaDoc getDatabaseDriver()
110     {
111         return databaseDriver;
112     }
113
114     /**
115      * Set the database driver name
116      *
117      * @param v The new DatabaseDriver value
118      */
119     public void setDatabaseDriver(String JavaDoc v)
120     {
121         databaseDriver = v;
122     }
123
124     /**
125      * Get the database user
126      *
127      * @return String database user
128      */
129     public String JavaDoc getDatabaseUser()
130     {
131         return databaseUser;
132     }
133
134     /**
135      * Set the database user
136      *
137      * @param v The new DatabaseUser value
138      */
139     public void setDatabaseUser(String JavaDoc v)
140     {
141         databaseUser = v;
142     }
143
144     /**
145      * Get the database password
146      *
147      * @return String database password
148      */
149     public String JavaDoc getDatabasePassword()
150     {
151         return databasePassword;
152     }
153
154     /**
155      * Set the database password
156      *
157      * @param v The new DatabasePassword value
158      */
159     public void setDatabasePassword(String JavaDoc v)
160     {
161         databasePassword = v;
162     }
163
164     /**
165      * Initializes initial context
166      *
167      * @return the context
168      * @throws Exception generic exception
169      */
170     public Context initControlContext() throws Exception JavaDoc
171     {
172         super.initControlContext();
173
174         context.put("dataset", "all");
175
176         log("Torque - TorqueDataDump starting");
177         log("Your DB settings are:");
178         log("driver: " + databaseDriver);
179         log("URL: " + databaseUrl);
180         log("user: " + databaseUser);
181         // log("password: " + databasePassword);
182
183         try
184         {
185             Class.forName(databaseDriver);
186             log("DB driver instantiated sucessfully", Project.MSG_DEBUG);
187
188             conn = DriverManager.getConnection(
189                     databaseUrl, databaseUser, databasePassword);
190             stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
191                     ResultSet.CONCUR_UPDATABLE);
192
193             log("DB connection established", Project.MSG_DEBUG);
194             context.put("tableTool", new TableTool());
195         }
196         catch (SQLException JavaDoc se)
197         {
198             System.err.println("SQLException while connecting to DB:");
199             se.printStackTrace();
200         }
201         catch (ClassNotFoundException JavaDoc cnfe)
202         {
203             System.err.println("cannot load driver:");
204             cnfe.printStackTrace();
205         }
206         context.put("escape", new org.apache.velocity.anakia.Escape());
207         return context;
208     }
209
210     /**
211      * Closes the db-connection, overriding the <code>cleanup()</code> hook
212      * method in <code>TexenTask</code>.
213      *
214      * @throws Exception Database problem while closing resource.
215      */
216     protected void cleanup() throws Exception JavaDoc
217     {
218         if (stmt != null)
219         {
220             stmt.close();
221         }
222
223         if (conn != null)
224         {
225             conn.close();
226         }
227     }
228
229     /**
230      * A nasty do-it-all tool class. It serves as:
231      * <ul>
232      * <li>context tool to fetch a table iterator</li>
233      * <li>the abovenamed iterator which iterates over the table</li>
234      * <li>getter for the table fields</li>
235      * </ul>
236      */
237     public class TableTool implements Iterator JavaDoc
238     {
239         /** querydataset */
240         private ResultSet JavaDoc rs;
241
242         /**
243          * Constructor for the TableTool object
244          */
245         public TableTool()
246         {
247         }
248
249         /**
250          * Constructor for the TableTool object
251          *
252          * @param qds Description of Parameter
253          * @throws Exception Problem using database record set cursor.
254          */
255         protected TableTool(ResultSet JavaDoc rs) throws Exception JavaDoc
256         {
257             this.rs = rs;
258         }
259
260         /**
261          * Fetches an <code>Iterator</code> for the data in the named table.
262          *
263          * @param tableName Description of Parameter
264          * @return <code>Iterator</code> for the fetched data.
265          * @throws Exception Problem creating connection or executing query.
266          */
267         public TableTool fetch(String JavaDoc tableName) throws Exception JavaDoc
268         {
269             log("Fetching data for table " + tableName, Project.MSG_INFO);
270             return new TableTool(
271                     stmt.executeQuery("SELECT * FROM " + tableName));
272         }
273
274         /**
275          * check if there are more records in the QueryDataSet
276          *
277          * @return true if there are more records
278          */
279         public boolean hasNext()
280         {
281             try
282             {
283                 // TODO optimize this
284 // i tried to use rs.isLast() but this returns wrong results
285 // for empty tables :-(
286 boolean validRow = rs.next();
287                 rs.previous();
288                 return validRow;
289             }
290             catch (Exception JavaDoc se)
291             {
292                 System.err.println("Exception :");
293                 se.printStackTrace();
294             }
295             return false;
296         }
297
298         /**
299          * load the next record from the QueryDataSet
300          *
301          * @return Description of the Returned Value
302          * @throws NoSuchElementException Description of Exception
303          */
304         public Object JavaDoc next() throws NoSuchElementException JavaDoc
305         {
306             try
307             {
308                 System.out.print(".");
309                 rs.next();
310             }
311             catch (Exception JavaDoc se)
312             {
313                 System.err.println("Exception while iterating:");
314                 se.printStackTrace();
315                 throw new NoSuchElementException JavaDoc(se.getMessage());
316             }
317             return this;
318         }
319
320         /**
321          * Returns the value for the column
322          *
323          * @param columnName name of the column
324          * @return value of the column or null if it doesn't exist
325          */
326         public String JavaDoc get(String JavaDoc columnName)
327         {
328             try
329             {
330                 return (rs.getString(columnName));
331             }
332             catch (Exception JavaDoc se)
333             {
334                 log("Exception fetching value " + columnName + ": "
335                         + se.getMessage(), Project.MSG_ERR);
336             }
337             return null;
338         }
339
340         /**
341          * unsupported! always throws Exception
342          *
343          * @throws UnsupportedOperationException unsupported
344          */
345         public void remove() throws UnsupportedOperationException JavaDoc
346         {
347             throw new UnsupportedOperationException JavaDoc();
348         }
349     }
350 }
351
Popular Tags