JDBCManager.java

/*
 * Class:        JDBCManager
 * Description:  Interface to access databases
 * Environment:  Java
 * Software:     SSJ 
 * Copyright (C) 2001  Pierre L'Ecuyer and Universite de Montreal
 * Organization: DIRO, Universite de Montreal
 * @author       
 * @since
 *
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
package umontreal.ssj.util;
 
import java.io.*;
import java.net.URL;
import java.sql.*;
import javax.sql.DataSource;
import java.util.Properties;
import javax.naming.*;

public class JDBCManager {

   public static Connection connectToDatabase(Properties prop) throws SQLException {
      Connection connection = null;
      String jndiName;
 
      if ((jndiName = prop.getProperty("jdbc.jndi-name")) != null) {
         try {
            InitialContext context = new InitialContext();
            connection = ((DataSource) context.lookup(jndiName)).getConnection();
         } catch (NamingException e) {
            throw new IllegalArgumentException("The jdbc.jndi-name property refers to the invalid name " + jndiName);
         }
      } else {
         String driver = prop.getProperty("jdbc.driver");
         String uri = prop.getProperty("jdbc.uri");
         if (uri != null) {
            if (driver != null) {
               try {
                  Class driverClass = Class.forName(driver);
                  if (!Driver.class.isAssignableFrom(driverClass))
                     throw new IllegalArgumentException("The driver name " + driver
                           + " does not correspond to a class implementing the java.sql.Driver interface");
                  // Needed by some buggy drivers
                  driverClass.newInstance();
               } catch (ClassNotFoundException cnfe) {
                  throw new IllegalArgumentException("Could not find the driver class " + driver);
               } catch (IllegalAccessException iae) {
                  throw new IllegalArgumentException(
                        "An illegal access prevented the instantiation of driver class " + driver);
               } catch (InstantiationException ie) {
                  throw new IllegalArgumentException(
                        "An instantiation exception prevented the instantiation of driver class " + driver + ": "
                              + ie.getMessage());
               }
            }
            connection = DriverManager.getConnection(uri);
         } else {
            throw new IllegalArgumentException(
                  "The jdbc.driver and jdbc.uri properties must be given if jdbc.jndi-name is not set");
         }
      }
 
      return connection;
   }

   public static Connection connectToDatabase(InputStream is) throws IOException, SQLException {
      Properties prop = new Properties();
 
      prop.load(is);
 
      return connectToDatabase(prop);
   }

   public static Connection connectToDatabase(URL url) throws IOException, SQLException {
 
      InputStream is = url.openStream();
      try {
         return connectToDatabase(is);
      } finally {
         is.close();
      }
   }

   public static Connection connectToDatabase(File file) throws IOException, SQLException {
 
      FileInputStream is = new FileInputStream(file);
      try {
         return connectToDatabase(is);
      } finally {
         is.close();
      }
   }

   public static Connection connectToDatabase(String fileName) throws IOException, SQLException {
 
      FileInputStream is = new FileInputStream(fileName);
      try {
         return connectToDatabase(is);
      } finally {
         is.close();
      }
   }

   public static Connection connectToDatabaseFromResource(String resource) throws IOException, SQLException {
 
      InputStream is = JDBCManager.class.getClassLoader().getResourceAsStream(resource);
      try {
         return connectToDatabase(is);
      } finally {
         is.close();
      }
   }

   public static double[] readDoubleData(Statement stmt, String query) throws SQLException {
      ResultSet rs = stmt.executeQuery(query);
      rs.last();
      double[] res = new double[rs.getRow()];
      rs.first();
 
      for (int i = 0; i < res.length; i++) {
         res[i] = rs.getDouble(1);
         rs.next();
      }
      rs.close();
 
      return res;
   }

   public static double[] readDoubleData(Connection connection, String query) throws SQLException {
      Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
      try {
         return readDoubleData(stmt, query);
      } finally {
         stmt.close();
      }
   }

   public static double[] readDoubleData(Statement stmt, String table, String column) throws SQLException {
      final String query = "SELECT " + column + " FROM " + table;
 
      return readDoubleData(stmt, query);
   }

   public static double[] readDoubleData(Connection connection, String table, String column) throws SQLException {
      final String query = "SELECT " + column + " FROM " + table;
 
      return readDoubleData(connection, query);
   }

   public static int[] readIntData(Statement stmt, String query) throws SQLException {
      ResultSet rs = stmt.executeQuery(query);
      rs.last();
      int[] res = new int[rs.getRow()];
      rs.first();
 
      for (int i = 0; i < res.length; i++) {
         res[i] = rs.getInt(1);
         rs.next();
      }
      rs.close();
 
      return res;
   }

   public static int[] readIntData(Connection connection, String query) throws SQLException {
      Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
      try {
         return readIntData(stmt, query);
      } finally {
         stmt.close();
      }
   }

   public static int[] readIntData(Statement stmt, String table, String column) throws SQLException {
      final String query = "SELECT " + column + " FROM " + table;
 
      return readIntData(stmt, query);
   }

   public static int[] readIntData(Connection connection, String table, String column) throws SQLException {
      final String query = "SELECT " + column + " FROM " + table;
 
      return readIntData(connection, query);
   }

   public static Object[] readObjectData(Statement stmt, String query) throws SQLException {
      ResultSet rs = stmt.executeQuery(query);
      rs.last();
      Object[] res = new Object[rs.getRow()];
      rs.first();
 
      for (int i = 0; i < res.length; i++) {
         res[i] = rs.getObject(1);
         rs.next();
      }
      rs.close();
 
      return res;
   }

   public static Object[] readObjectData(Connection connection, String query) throws SQLException {
      Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
      try {
         return readObjectData(stmt, query);
      } finally {
         stmt.close();
      }
   }

   public static Object[] readObjectData(Statement stmt, String table, String column) throws SQLException {
      final String query = "SELECT " + column + " FROM " + table;
 
      return readObjectData(stmt, query);
   }

   public static Object[] readObjectData(Connection connection, String table, String column) throws SQLException {
      final String query = "SELECT " + column + " FROM " + table;
 
      return readObjectData(connection, query);
   }

   public static double[][] readDoubleData2D(Statement stmt, String query) throws SQLException {
      ResultSet rs = stmt.executeQuery(query);
      rs.last();
      int c = rs.getMetaData().getColumnCount();
      double[][] res = new double[rs.getRow()][c];
      rs.first();
 
      for (int i = 0; i < res.length; i++) {
         for (int j = 0; j < res[i].length; j++)
            res[i][j] = rs.getDouble(1 + j);
         rs.next();
      }
      rs.close();
 
      return res;
   }

   public static double[][] readDoubleData2D(Connection connection, String query) throws SQLException {
      Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
      try {
         return readDoubleData2D(stmt, query);
      } finally {
         stmt.close();
      }
   }

   public static double[][] readDoubleData2DTable(Statement stmt, String table) throws SQLException {
      final String query = "SELECT * FROM " + table;
 
      return readDoubleData2D(stmt, query);
   }

   public static double[][] readDoubleData2DTable(Connection connection, String table) throws SQLException {
      final String query = "SELECT * FROM " + table;
 
      return readDoubleData2D(connection, query);
   }

   public static int[][] readIntData2D(Statement stmt, String query) throws SQLException {
      ResultSet rs = stmt.executeQuery(query);
      rs.last();
      int c = rs.getMetaData().getColumnCount();
      int[][] res = new int[rs.getRow()][c];
      rs.first();
 
      for (int i = 0; i < res.length; i++) {
         for (int j = 0; j < res[i].length; j++)
            res[i][j] = rs.getInt(1 + j);
         rs.next();
      }
      rs.close();
 
      return res;
   }

   public static int[][] readIntData2D(Connection connection, String query) throws SQLException {
      Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
      try {
         return readIntData2D(stmt, query);
      } finally {
         stmt.close();
      }
   }

   public static int[][] readIntData2DTable(Statement stmt, String table) throws SQLException {
      final String query = "SELECT * FROM " + table;
 
      return readIntData2D(stmt, query);
   }

   public static int[][] readIntData2DTable(Connection connection, String table) throws SQLException {
      final String query = "SELECT * FROM " + table;
 
      return readIntData2D(connection, query);
   }

   public static Object[][] readObjectData2D(Statement stmt, String query) throws SQLException {
      ResultSet rs = stmt.executeQuery(query);
      rs.last();
      int c = rs.getMetaData().getColumnCount();
      Object[][] res = new Object[rs.getRow()][c];
      rs.first();
 
      for (int i = 0; i < res.length; i++) {
         for (int j = 0; j < res[i].length; j++)
            res[i][j] = rs.getObject(1 + j);
         rs.next();
      }
      rs.close();
 
      return res;
   }

   public static Object[][] readObjectData2D(Connection connection, String query) throws SQLException {
      Statement stmt = connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
      try {
         return readObjectData2D(stmt, query);
      } finally {
         stmt.close();
      }
   }

   public static Object[][] readObjectData2DTable(Statement stmt, String table) throws SQLException {
      final String query = "SELECT * FROM " + table;
 
      return readObjectData2D(stmt, query);
   }

   public static Object[][] readObjectData2DTable(Connection connection, String table) throws SQLException {
      final String query = "SELECT * FROM " + table;
 
      return readObjectData2D(connection, query);
   }
 
}