KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > continuent > sequoia > controller > backend > DriverCompliance


1 /**
2  * Sequoia: Database clustering technology.
3  * Copyright (C) 2002-2004 French National Institute For Research In Computer
4  * Science And Control (INRIA).
5  * Contact: sequoia@continuent.org
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  * Initial developer(s): Emmanuel Cecchet.
20  * Contributor(s): ______________________.
21  */
22
23 package org.continuent.sequoia.controller.backend;
24
25 import java.net.ConnectException JavaDoc;
26 import java.sql.Connection JavaDoc;
27 import java.sql.DatabaseMetaData JavaDoc;
28 import java.sql.ResultSet JavaDoc;
29 import java.sql.Statement JavaDoc;
30
31 import org.continuent.sequoia.common.i18n.Translate;
32 import org.continuent.sequoia.common.log.Trace;
33 import org.continuent.sequoia.controller.connection.DriverManager;
34
35 /**
36  * This class checks if a given driver provides the mandatory features necessary
37  * for Sequoia.
38  *
39  * @author <a HREF="mailto:Emmanuel.Cecchet@inria.fr">Emmanuel Cecchet </a>
40  * @version 1.0
41  */
42 public class DriverCompliance
43 {
44   private boolean isCompliant = false;
45   private boolean hasBeenTested = false;
46   private boolean supportSetQueryTimeout = false;
47   private boolean supportGetGeneratedKeys = false;
48   private boolean supportGetColumnCount = false;
49   private boolean supportGetColumnClassName = false;
50   private boolean supportGetColumnTypeName = false;
51   private boolean supportGetColumnType = false;
52   private boolean supportGetColumnDisplaySize = false;
53   private boolean supportGetTableName = false;
54   private boolean supportSetCursorName = false;
55   private boolean supportSetFetchSize = false;
56   private boolean supportSerializableIsolation = false;
57   private boolean supportSetMaxRows = false;
58
59   private Trace logger;
60
61   private static final int TIMEOUT_VALUE = 1000;
62   private static final String JavaDoc DEFAULT_TEST_STATEMENT = "select 1";
63   private String JavaDoc databaseProductName = "Sequoia";
64
65   /**
66    * Builds a new DriverCompliance object.
67    *
68    * @param logger the logger to use
69    */
70   public DriverCompliance(Trace logger)
71   {
72     this.logger = logger;
73   }
74
75   /**
76    * Check the driver compliance.
77    *
78    * @param backendUrl the JDBC URL to connect to
79    * @param login the user login
80    * @param password the user password
81    * @param driverPath path for driver
82    * @param driverClassName class name for driver
83    * @param connectionTestStatement SQL statement used to check if a connection
84    * is still valid
85    * @return true if the driver is Sequoia compliant
86    * @throws ConnectException if it is not possible to connect to the backend
87    */
88   public boolean complianceTest(String JavaDoc backendUrl, String JavaDoc login,
89       String JavaDoc password, String JavaDoc driverPath, String JavaDoc driverClassName,
90       String JavaDoc connectionTestStatement) throws ConnectException JavaDoc
91   {
92     if (hasBeenTested)
93       return isCompliant;
94
95     isCompliant = false;
96
97     //
98 // Connection test
99 //
100 Connection JavaDoc c = null;
101     try
102     {
103       c = DriverManager.getConnection(backendUrl, login, password, driverPath,
104           driverClassName);
105     }
106     catch (Exception JavaDoc e)
107     {
108       if (logger.isDebugEnabled())
109         logger.error(Translate.get("backend.driver.test.connection.failed", e),
110             e);
111       else
112         logger.error(Translate.get("backend.driver.test.connection.failed", e));
113       throw (ConnectException JavaDoc) new ConnectException JavaDoc(e.getMessage())
114           .initCause(e);
115     }
116
117     if (c == null)
118     { // SEQUOIA-735 fix
119 String JavaDoc msg = Translate.get("backend.driver.test.connection.failed",
120           "DriverManager returned an unexpected null connection for "
121               + backendUrl + " using driver " + driverClassName);
122       logger.error(msg);
123       throw new ConnectException JavaDoc(msg);
124     }
125
126     if (logger.isDebugEnabled())
127       logger.debug(Translate.get("backend.driver.test.connection.ok"));
128
129     //
130 // Transaction isolation (serializable)
131 //
132 try
133     {
134       c.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
135       supportSerializableIsolation = true;
136     }
137     catch (Exception JavaDoc e)
138     {
139       if (logger.isDebugEnabled())
140         logger.error(Translate.get(
141             "backend.driver.test.serializable.isolation.failed", e), e);
142       else
143         logger.error(Translate.get(
144             "backend.driver.test.serializable.isolation.failed", e));
145     }
146     if (logger.isDebugEnabled())
147       logger.debug(Translate
148           .get("backend.driver.test.serializable.isolation.ok"));
149
150     //
151 // Connection meta data
152 //
153 DatabaseMetaData JavaDoc connectionMetaData;
154     try
155     {
156       connectionMetaData = c.getMetaData();
157     }
158     catch (Exception JavaDoc e)
159     {
160       if (logger.isDebugEnabled())
161         logger
162             .error(Translate.get("backend.driver.test.metadata.failed", e), e);
163       else
164         logger.error(Translate.get("backend.driver.test.metadata.failed", e));
165       return isCompliant;
166     }
167     if (logger.isDebugEnabled())
168       logger.debug(Translate.get("backend.driver.test.metadata.ok"));
169
170     try
171     {
172       this.databaseProductName = connectionMetaData.getDatabaseProductName();
173       logger.info(Translate
174           .get("backend.detected.as", this.databaseProductName));
175     }
176     catch (Exception JavaDoc e)
177     {
178       logger.warn(Translate
179           .get("backend.driver.test.database.productname.failed"));
180     }
181
182     //
183 // Statement
184 //
185 Statement JavaDoc s;
186     try
187     {
188       s = c.createStatement();
189     }
190     catch (Exception JavaDoc e)
191     {
192       if (logger.isDebugEnabled())
193         logger.error(Translate.get("backend.driver.test.statement.failed", e),
194             e);
195       else
196         logger.error(Translate.get("backend.driver.test.statement.failed", e));
197       return isCompliant;
198     }
199
200     try
201     {
202       if (connectionTestStatement == null)
203       {
204         if (logger.isDebugEnabled())
205           logger.debug(Translate.get("backend.driver.using.default.statement",
206               DEFAULT_TEST_STATEMENT));
207         connectionTestStatement = DEFAULT_TEST_STATEMENT;
208       }
209       s.execute(connectionTestStatement);
210     }
211     catch (Exception JavaDoc e)
212     {
213       if (logger.isDebugEnabled())
214         logger.error(Translate.get("backend.driver.test.statement.invalid",
215             new String JavaDoc[]{connectionTestStatement, e.getMessage()}), e);
216       else
217         logger.error(Translate.get("backend.driver.test.statement.invalid",
218             new String JavaDoc[]{connectionTestStatement, e.getMessage()}));
219       return isCompliant;
220     }
221     if (logger.isDebugEnabled())
222       logger.debug(Translate.get("backend.driver.test.statement.ok"));
223
224     //
225 // Set cursor name
226 //
227 try
228     {
229       s.setCursorName("testcursor");
230       supportSetCursorName = true;
231       if (logger.isDebugEnabled())
232         logger
233             .debug(Translate.get("backend.driver.statement.setCursorName.ok"));
234     }
235     catch (Exception JavaDoc e1)
236     {
237       logger.warn(Translate
238           .get("backend.driver.statement.setCursorName.failed"));
239       supportSetMaxRows = false;
240     }
241
242     //
243 // Set fetch size
244 //
245 try
246     {
247       s.setFetchSize(25);
248       supportSetFetchSize = true;
249       if (logger.isDebugEnabled())
250         logger.debug(Translate.get("backend.driver.statement.setFetchSize.ok"));
251     }
252     catch (Exception JavaDoc e1)
253     {
254       logger
255           .warn(Translate.get("backend.driver.statement.setFetchSize.failed"));
256       supportSetMaxRows = false;
257     }
258
259     //
260 // Set max rows
261 //
262 try
263     {
264       s.setMaxRows(5);
265       supportSetMaxRows = true;
266       if (logger.isDebugEnabled())
267         logger.debug(Translate.get("backend.driver.statement.setMaxRows.ok"));
268     }
269     catch (Exception JavaDoc e1)
270     {
271       logger.warn(Translate.get("backend.driver.statement.setMaxRows.failed"));
272       supportSetMaxRows = false;
273     }
274
275     //
276 // Get generated keys
277 //
278 try
279     {
280       s.getGeneratedKeys();
281       supportGetGeneratedKeys = true;
282       if (logger.isDebugEnabled())
283         logger.debug(Translate
284             .get("backend.driver.statement.getGeneratedKeys.ok"));
285     }
286     catch (Exception JavaDoc e1)
287     {
288       logger.warn(Translate
289           .get("backend.driver.statement.getGeneratedKeys.failed"));
290       supportGetGeneratedKeys = false;
291     }
292     catch (AbstractMethodError JavaDoc e1)
293     {
294       logger.warn(Translate
295           .get("backend.driver.statement.getGeneratedKeys.failed"));
296       supportGetGeneratedKeys = false;
297     }
298     catch (java.lang.NoSuchMethodError JavaDoc e1)
299     {
300       logger.warn(Translate
301           .get("backend.driver.statement.getGeneratedKeys.failed"));
302       supportGetGeneratedKeys = false;
303     }
304
305     // Commented out:
306 // A prepared statement can be sent to the DBMS right away to be compiled
307 // Should fine a work around for this test.
308
309     // PreparedStatement ps;
310 // try
311 // {
312 // ps = c.prepareStatement("INSERT INTO versions VALUES (?,?)");
313 // ps.setInt(1, 10);
314 // ps.setString(2, "just a test");
315 // }
316 // catch (Exception e)
317 // {
318 // logger.warn(Translate.get("backend.driver.prepared.statement.failed"),
319 // e);
320 // }
321 // if (logger.isDebugEnabled())
322 // logger.debug(Translate.get("backend.driver.prepared.statement.ok"));
323
324     //
325 // Set Query Timeout
326 //
327 try
328     {
329       s.setQueryTimeout(TIMEOUT_VALUE);
330       supportSetQueryTimeout = true;
331     }
332     catch (Exception JavaDoc e)
333     {
334       logger.warn(Translate.get("backend.driver.setQueryTimeout.failed", e));
335     }
336     if (supportSetQueryTimeout && logger.isDebugEnabled())
337       logger.debug(Translate.get("backend.driver.setQueryTimeout.ok"));
338
339     //
340 // Get tables
341 //
342 ResultSet JavaDoc rs;
343     try
344     {
345       String JavaDoc[] types = {"TABLE", "VIEW"};
346       rs = connectionMetaData.getTables(null, null, "%", types);
347     }
348     catch (Exception JavaDoc e)
349     {
350       if (logger.isDebugEnabled())
351         logger.error(Translate.get("backend.driver.metadata.getTables.failed",
352             e), e);
353       else
354         logger.error(Translate.get("backend.driver.metadata.getTables.failed",
355             e));
356       return isCompliant;
357     }
358     if (logger.isDebugEnabled())
359       logger.debug(Translate.get("backend.driver.metadata.getTables.ok"));
360
361     //
362 // Get MetaData
363 //
364 java.sql.ResultSetMetaData JavaDoc rsMetaData;
365     try
366     {
367       rsMetaData = rs.getMetaData();
368     }
369     catch (Exception JavaDoc e)
370     {
371       if (logger.isDebugEnabled())
372         logger.error(Translate.get(
373             "backend.driver.resultset.getMetaData.failed", e), e);
374       else
375         logger.error(Translate.get(
376             "backend.driver.resultset.getMetaData.failed", e));
377       return isCompliant;
378     }
379     if (logger.isDebugEnabled())
380       logger.debug(Translate.get("backend.driver.resultset.getMetaData.ok"));
381
382     //
383 // ResultSet.getObject()
384 //
385 try
386     {
387       if (rs.next() && (rsMetaData.getColumnCount() > 0))
388       {
389         rs.getObject(1);
390       }
391       else
392         logger.warn(Translate.get("backend.driver.resultset.getObject.unable"));
393     }
394     catch (Exception JavaDoc e)
395     {
396       if (logger.isDebugEnabled())
397         logger.error(Translate.get("backend.driver.resultset.getObject.failed",
398             e), e);
399       else
400         logger.error(Translate.get("backend.driver.resultset.getObject.failed",
401             e));
402       return isCompliant;
403     }
404     if (logger.isDebugEnabled())
405       logger.debug(Translate.get("backend.driver.resultset.getObject.ok"));
406
407     try
408     {
409       rsMetaData.getColumnCount();
410       supportGetColumnCount = true;
411     }
412     catch (Exception JavaDoc e)
413     {
414       if (logger.isDebugEnabled())
415         logger.error(Translate.get(
416             "backend.driver.metadata.getColumnCount.failed", e), e);
417       else
418         logger.error(Translate.get(
419             "backend.driver.metadata.getColumnCount.failed", e));
420       return isCompliant;
421     }
422     if (supportGetColumnCount && logger.isDebugEnabled())
423       logger.debug(Translate.get("backend.driver.metadata.getColumnCount.ok"));
424
425     try
426     {
427       rsMetaData.getColumnName(1);
428     }
429     catch (Exception JavaDoc e)
430     {
431       if (logger.isDebugEnabled())
432         logger.error(Translate.get(
433             "backend.driver.metadata.getColumnName.failed", e), e);
434       else
435         logger.error(Translate.get(
436             "backend.driver.metadata.getColumnName.failed", e));
437       return isCompliant;
438     }
439     if (logger.isDebugEnabled())
440       logger.debug(Translate.get("backend.driver.metadata.getColumnName.ok"));
441
442     try
443     {
444       rsMetaData.getTableName(1);
445       supportGetTableName = true;
446     }
447     catch (Exception JavaDoc e)
448     {
449       logger.warn(Translate.get("backend.driver.metadata.getTableName.failed",
450           e));
451     }
452
453     if (supportGetTableName && logger.isDebugEnabled())
454       logger.debug(Translate.get("backend.driver.metadata.getTableName.ok"));
455
456     try
457     {
458       rsMetaData.getColumnDisplaySize(1);
459       supportGetColumnDisplaySize = true;
460     }
461     catch (Exception JavaDoc e)
462     {
463       logger.warn(Translate.get(
464           "backend.driver.metadata.getColumnDisplaySize.failed", e));
465     }
466     if (supportGetColumnDisplaySize && logger.isDebugEnabled())
467       logger.debug(Translate
468           .get("backend.driver.metadata.getColumnDisplaySize.ok"));
469
470     try
471     {
472       rsMetaData.getColumnType(1);
473       supportGetColumnType = true;
474     }
475     catch (Exception JavaDoc e)
476     {
477       logger.warn(Translate.get("backend.driver.metadata.getColumnType.failed",
478           e));
479     }
480     if (supportGetColumnType && logger.isDebugEnabled())
481       logger.debug(Translate.get("backend.driver.metadata.getColumnType.ok"));
482
483     try
484     {
485       rsMetaData.getColumnTypeName(1);
486       supportGetColumnTypeName = true;
487     }
488     catch (Exception JavaDoc e)
489     {
490       logger.warn(Translate.get(
491           "backend.driver.metadata.getColumnTypeName.failed", e));
492     }
493     if (supportGetColumnTypeName && logger.isDebugEnabled())
494       logger.debug(Translate
495           .get("backend.driver.metadata.getColumnTypeName.ok"));
496
497     try
498     {
499       rsMetaData.getColumnClassName(1);
500       supportGetColumnClassName = true;
501     }
502     catch (Exception JavaDoc e)
503     {
504       logger.warn(Translate.get(
505           "backend.driver.metadata.getColumnClassName.failed", e));
506     }
507     if (supportGetColumnClassName && logger.isDebugEnabled())
508       logger.debug(Translate
509           .get("backend.driver.metadata.getColumnClassName.ok"));
510
511     isCompliant = true;
512     hasBeenTested = true;
513     return isCompliant;
514   }
515
516   /**
517    * Returns the databaseProductName value.
518    *
519    * @return Returns the databaseProductName.
520    */
521   public String JavaDoc getDatabaseProductName()
522   {
523     return this.databaseProductName;
524   }
525
526   /**
527    * @return true if the driver is compliant to the Sequoia requirements
528    */
529   public boolean isCompliant()
530   {
531     return isCompliant;
532   }
533
534   /**
535    * @return true if the driver supports getGeneratedKeys
536    */
537   public boolean supportGetGeneratedKeys()
538   {
539     return supportGetGeneratedKeys;
540   }
541
542   /**
543    * @return true if the driver supports getColumnClassName
544    */
545   public boolean supportGetColumnClassName()
546   {
547     return supportGetColumnClassName;
548   }
549
550   /**
551    * @return true if the driver supports getColumnCount
552    */
553   public boolean supportGetColumnCount()
554   {
555     return supportGetColumnCount;
556   }
557
558   /**
559    * @return true if the driver supports getColumnDisplaySize
560    */
561   public boolean supportGetColumnDisplaySize()
562   {
563     return supportGetColumnDisplaySize;
564   }
565
566   /**
567    * @return true if the driver supports getColumnType
568    */
569   public boolean supportGetColumnType()
570   {
571     return supportGetColumnType;
572   }
573
574   /**
575    * @return true if the driver supports getColumnTypeName
576    */
577   public boolean supportGetColumnTypeName()
578   {
579     return supportGetColumnTypeName;
580   }
581
582   /**
583    * @return true if the driver supports getTableName
584    */
585   public boolean supportGetTableName()
586   {
587     return supportGetTableName;
588   }
589
590   /**
591    * Returns the supportSetCursorName value.
592    *
593    * @return Returns the supportSetCursorName.
594    */
595   public boolean supportSetCursorName()
596   {
597     return supportSetCursorName;
598   }
599
600   /**
601    * Returns the supportSetFetchSize value.
602    *
603    * @return Returns the supportSetFetchSize.
604    */
605   public boolean supportSetFetchSize()
606   {
607     return supportSetFetchSize;
608   }
609
610   /**
611    * Returns the supportSerializableIsolation value.
612    *
613    * @return Returns the supportSerializableIsolation.
614    */
615   public final boolean supportSerializableIsolation()
616   {
617     return supportSerializableIsolation;
618   }
619
620   /**
621    * @return true if the driver supports Statement.setMaxRows
622    */
623   public boolean supportSetMaxRows()
624   {
625     return supportSetMaxRows;
626   }
627
628   /**
629    * @return true if the driver supports setQueryTimeout
630    */
631   public boolean supportSetQueryTimeout()
632   {
633     return supportSetQueryTimeout;
634   }
635 }
Popular Tags