src/org/objectweb/cjdbc/controller/backend/DriverCompliance.java

説明を見る。

package org.objectweb.cjdbc.controller.backend;

import java.net.ConnectException;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.Statement;

import org.objectweb.cjdbc.common.i18n.Translate;
import org.objectweb.cjdbc.common.log.Trace;
import org.objectweb.cjdbc.controller.connection.DriverManager;

public class DriverCompliance
{
  private boolean             isCompliant                 = false;
  private boolean             hasBeenTested               = false;
  private boolean             supportSetQueryTimeout      = false;
  private boolean             supportGetGeneratedKeys     = false;
  private boolean             supportGetColumnCount       = false;
  private boolean             supportGetColumnClassName   = false;
  private boolean             supportGetColumnTypeName    = false;
  private boolean             supportGetColumnType        = false;
  private boolean             supportGetColumnDisplaySize = false;
  private boolean             supportGetTableName         = false;
  private boolean             supportSetCursorName        = false;
  private boolean             supportSetFetchSize         = false;
  private boolean             supportSetMaxRows           = false;

  private Trace               logger;

  private static final int    TIMEOUT_VALUE               = 1000;
  private static final String DEFAULT_TEST_STATEMENT      = "select 1";
  private String              databaseProductName         = "C-JDBC";

  public DriverCompliance(Trace logger)
  {
    this.logger = logger;
  }

  public boolean complianceTest(String backendUrl, String login,
      String password, String driverPath, String driverClassName,
      String connectionTestStatement) throws ConnectException
  {
    if (hasBeenTested)
      return isCompliant;

    isCompliant = false;

    Connection c = null;
    try
    {
      c = DriverManager.getConnection(backendUrl, login, password, driverPath,
          driverClassName);
    }
    catch (Exception e)
    {
      logger.error(Translate.get("backend.driver.test.connection.failed", e));
      throw new ConnectException(e.getMessage());
    }
    if (logger.isDebugEnabled())
      logger.debug(Translate.get("backend.driver.test.connection.ok"));

    DatabaseMetaData connectionMetaData;
    try
    {
      connectionMetaData = c.getMetaData();
    }
    catch (Exception e)
    {
      logger.error(Translate.get("backend.driver.test.metadata.failed", e));
      return isCompliant;
    }
    if (logger.isDebugEnabled())
      logger.debug(Translate.get("backend.driver.test.metadata.ok"));

    try
    {
      this.databaseProductName = connectionMetaData.getDatabaseProductName();
      logger.info(Translate
          .get("backend.detected.as", this.databaseProductName));
    }
    catch (Exception e)
    {
      logger.warn(Translate.get(
          "backend.driver.test.database.productname.failed", e));
    }

    Statement s;
    try
    {
      s = c.createStatement();
    }
    catch (Exception e)
    {
      logger.error(Translate.get("backend.driver.test.statement.failed", e));
      return isCompliant;
    }

    try
    {
      if (connectionTestStatement == null)
      {
        if (logger.isDebugEnabled())
          logger.debug(Translate.get("backend.driver.using.default.statement",
              DEFAULT_TEST_STATEMENT));
        connectionTestStatement = DEFAULT_TEST_STATEMENT;
      }
      s.execute(connectionTestStatement);
    }
    catch (Exception e)
    {
      logger.error(Translate.get("backend.driver.test.statement.invalid",
          connectionTestStatement));
      return isCompliant;
    }
    if (logger.isDebugEnabled())
      logger.debug(Translate.get("backend.driver.test.statement.ok"));

    try
    {
      s.setCursorName("testcursor");
      supportSetCursorName = true;
      if (logger.isDebugEnabled())
        logger
            .debug(Translate.get("backend.driver.statement.setCursorName.ok"));
    }
    catch (Exception e1)
    {
      logger.warn(Translate
          .get("backend.driver.statement.setCursorName.failed"));
      supportSetMaxRows = false;
    }

    try
    {
      s.setFetchSize(25);
      supportSetFetchSize = true;
      if (logger.isDebugEnabled())
        logger.debug(Translate.get("backend.driver.statement.setFetchSize.ok"));
    }
    catch (Exception e1)
    {
      logger
          .warn(Translate.get("backend.driver.statement.setFetchSize.failed"));
      supportSetMaxRows = false;
    }

    try
    {
      s.setMaxRows(5);
      supportSetMaxRows = true;
      if (logger.isDebugEnabled())
        logger.debug(Translate.get("backend.driver.statement.setMaxRows.ok"));
    }
    catch (Exception e1)
    {
      logger.warn(Translate.get("backend.driver.statement.setMaxRows.failed"));
      supportSetMaxRows = false;
    }

    try
    {
      s.getGeneratedKeys();
      supportGetGeneratedKeys = true;
      if (logger.isDebugEnabled())
        logger.debug(Translate
            .get("backend.driver.statement.getGeneratedKeys.ok"));
    }
    catch (Exception e1)
    {
      logger.warn(Translate
          .get("backend.driver.statement.getGeneratedKeys.failed"));
      supportGetGeneratedKeys = false;
    }
    catch (AbstractMethodError e1)
    {
      logger.warn(Translate
          .get("backend.driver.statement.getGeneratedKeys.failed"));
      supportGetGeneratedKeys = false;
    }
    catch (java.lang.NoSuchMethodError e1)
    {
      logger.warn(Translate
          .get("backend.driver.statement.getGeneratedKeys.failed"));
      supportGetGeneratedKeys = false;
    }

    // Commented out:
    // A prepared statement can be sent to the DBMS right away to be compiled
    // Should fine a work around for this test.

    //    PreparedStatement ps;
    //    try
    //    {
    //      ps = c.prepareStatement("INSERT INTO versions VALUES (?,?)");
    //      ps.setInt(1, 10);
    //      ps.setString(2, "just a test");
    //    }
    //    catch (Exception e)
    //    {
    //      logger.warn(Translate.get("backend.driver.prepared.statement.failed"),
    // e);
    //    }
    //    if (logger.isDebugEnabled())
    //      logger.debug(Translate.get("backend.driver.prepared.statement.ok"));

    try
    {
      s.setQueryTimeout(TIMEOUT_VALUE);
      supportSetQueryTimeout = true;
    }
    catch (Exception e)
    {
      logger.warn(Translate.get("backend.driver.setQueryTimeout.failed", e));
    }
    if (supportSetQueryTimeout && logger.isDebugEnabled())
      logger.warn(Translate.get("backend.driver.setQueryTimeout.ok"));

    ResultSet rs;
    try
    {
      String[] types = {"TABLE", "VIEW"};
      rs = connectionMetaData.getTables(null, null, "%", types);
    }
    catch (Exception e)
    {
      logger
          .error(Translate.get("backend.driver.metadata.getTables.failed", e));
      return isCompliant;
    }
    if (logger.isDebugEnabled())
      logger.debug(Translate.get("backend.driver.metadata.getTables.ok"));

    java.sql.ResultSetMetaData rsMetaData;
    try
    {
      rsMetaData = rs.getMetaData();
    }
    catch (Exception e)
    {
      logger.error(Translate.get("backend.driver.resultset.getMetaData.failed",
          e));
      return isCompliant;
    }
    if (logger.isDebugEnabled())
      logger.debug(Translate.get("backend.driver.resultset.getMetaData.ok"));

    try
    {
      if (rs.next())
      {
        rs.getObject(1);
      }
      else
        logger.warn(Translate.get("backend.driver.resultset.getObject.unable"));
    }
    catch (Exception e)
    {
      logger.error(Translate
          .get("backend.driver.resultset.getObject.failed", e));
      return isCompliant;
    }
    if (logger.isDebugEnabled())
      logger.debug(Translate.get("backend.driver.resultset.getObject.ok"));

    try
    {
      rsMetaData.getColumnCount();
      supportGetColumnCount = true;
    }
    catch (Exception e)
    {
      logger.error(Translate
          .get("backend.driver.metadata.getColumnCount.failed"));
      return isCompliant;
    }
    if (supportGetColumnCount && logger.isDebugEnabled())
      logger.debug(Translate.get("backend.driver.metadata.getColumnCount.ok"));

    try
    {
      rsMetaData.getColumnName(1);
    }
    catch (Exception e)
    {
      logger.error(Translate
          .get("backend.driver.metadata.getColumnName.failed"));
      return isCompliant;
    }
    if (logger.isDebugEnabled())
      logger.debug(Translate.get("backend.driver.metadata.getColumnName.ok"));

    try
    {
      rsMetaData.getTableName(1);
      supportGetTableName = true;
    }
    catch (Exception e)
    {
      logger.warn(Translate.get("backend.driver.metadata.getTableName.failed",
          e));
    }

    if (supportGetTableName && logger.isDebugEnabled())
      logger.debug(Translate.get("backend.driver.metadata.getTableName.ok"));

    try
    {
      rsMetaData.getColumnDisplaySize(1);
      supportGetColumnDisplaySize = true;
    }
    catch (Exception e)
    {
      logger.warn(Translate.get(
          "backend.driver.metadata.getColumnDisplaySize.failed", e));
    }
    if (supportGetColumnDisplaySize && logger.isDebugEnabled())
      logger.debug(Translate
          .get("backend.driver.metadata.getColumnDisplaySize.ok"));

    try
    {
      rsMetaData.getColumnType(1);
      supportGetColumnType = true;
    }
    catch (Exception e)
    {
      logger.warn(Translate.get("backend.driver.metadata.getColumnType.failed",
          e));
    }
    if (supportGetColumnType && logger.isDebugEnabled())
      logger.debug(Translate.get("backend.driver.metadata.getColumnType.ok"));

    try
    {
      rsMetaData.getColumnTypeName(1);
      supportGetColumnTypeName = true;
    }
    catch (Exception e)
    {
      logger.warn(Translate.get(
          "backend.driver.metadata.getColumnTypeName.failed", e));
    }
    if (supportGetColumnTypeName && logger.isDebugEnabled())
      logger.debug(Translate
          .get("backend.driver.metadata.getColumnTypeName.ok"));

    try
    {
      rsMetaData.getColumnClassName(1);
      supportGetColumnClassName = true;
    }
    catch (Exception e)
    {
      logger.warn(Translate.get(
          "backend.driver.metadata.getColumnClassName.failed", e));
    }
    if (supportGetColumnClassName && logger.isDebugEnabled())
      logger.debug(Translate
          .get("backend.driver.metadata.getColumnClassName.ok"));

    isCompliant = true;
    hasBeenTested = true;
    return isCompliant;
  }

  public boolean isCompliant()
  {
    return isCompliant;
  }

  public boolean supportGetGeneratedKeys()
  {
    return supportGetGeneratedKeys;
  }

  public boolean supportGetColumnClassName()
  {
    return supportGetColumnClassName;
  }

  public boolean supportGetColumnCount()
  {
    return supportGetColumnCount;
  }

  public boolean supportGetColumnDisplaySize()
  {
    return supportGetColumnDisplaySize;
  }

  public boolean supportGetColumnType()
  {
    return supportGetColumnType;
  }

  public boolean supportGetColumnTypeName()
  {
    return supportGetColumnTypeName;
  }

  public boolean supportGetTableName()
  {
    return supportGetTableName;
  }

  public boolean supportSetQueryTimeout()
  {
    return supportSetQueryTimeout;
  }

  public boolean supportSetMaxRows()
  {
    return supportSetMaxRows;
  }

  public boolean supportSetCursorName()
  {
    return supportSetCursorName;
  }

  public boolean supportSetFetchSize()
  {
    return supportSetFetchSize;
  }

  public String getDatabaseProductName()
  {
    return this.databaseProductName;
  }
}

---