Add dbutil project.

This was referenced by Openfire as dbutil.jar, but because this cannot be referenced via Maven Central, we add it as module for Openfire.

dbutil/src/main/java/org/jivesoftware/database/AbstractConnection.java

+/**
+ * $RCSfile$
+ * $Revision: 37 $
+ * $Date: 2004-10-20 23:08:43 -0700 (Wed, 20 Oct 2004) $
+ *
+ * Copyright (C) 2004 Jive Software. All rights reserved.
+ *
+ * This software is published under the terms of the GNU Public License (GPL),
+ * a copy of which is included in this distribution.
+ */
+
+package org.jivesoftware.database;
+
+import java.sql.*;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.Executor;
+
+/**
+ * An implementation of the Connection interface that wraps an underlying
+ * Connection object.
+ *
+ * @author Gaston Dombiak
+ */
+public abstract class AbstractConnection implements Connection {
+
+    protected Connection connection;
+
+    public AbstractConnection(Connection connection) {
+        this.connection = connection;
+    }
+
+    public <T> T unwrap(Class<T> iface) throws SQLException {
+        return connection.unwrap(iface);
+    }
+
+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
+        return connection.isWrapperFor(iface);
+    }
+
+    public Statement createStatement() throws SQLException {
+        return connection.createStatement();
+    }
+
+    public PreparedStatement prepareStatement(String sql) throws SQLException {
+        return connection.prepareStatement(sql);
+    }
+
+    public CallableStatement prepareCall(String sql) throws SQLException {
+        return connection.prepareCall(sql);
+    }
+
+    public String nativeSQL(String sql) throws SQLException {
+        return connection.nativeSQL(sql);
+    }
+
+    public void setAutoCommit(boolean autoCommit) throws SQLException {
+        connection.setAutoCommit(autoCommit);
+    }
+
+    public boolean getAutoCommit() throws SQLException {
+        return connection.getAutoCommit();
+    }
+
+    public void commit() throws SQLException {
+        connection.commit();
+    }
+
+    public void rollback() throws SQLException {
+        connection.rollback();
+    }
+
+    public void close() throws SQLException {
+        connection.close();
+    }
+
+    public boolean isClosed() throws SQLException {
+        return connection.isClosed();
+    }
+
+    public DatabaseMetaData getMetaData() throws SQLException {
+        return connection.getMetaData();
+    }
+
+    public void setReadOnly(boolean readOnly) throws SQLException {
+        connection.setReadOnly(readOnly);
+    }
+
+    public boolean isReadOnly() throws SQLException {
+        return connection.isReadOnly();
+    }
+
+    public void setCatalog(String catalog) throws SQLException {
+        connection.setCatalog(catalog);
+    }
+
+    public String getCatalog() throws SQLException {
+        return connection.getCatalog();
+    }
+
+    public void setTransactionIsolation(int level) throws SQLException {
+        connection.setTransactionIsolation(level);
+    }
+
+    public int getTransactionIsolation() throws SQLException {
+        return connection.getTransactionIsolation();
+    }
+
+    public SQLWarning getWarnings() throws SQLException {
+        return connection.getWarnings();
+    }
+
+    public void clearWarnings() throws SQLException {
+        connection.clearWarnings();
+    }
+
+    public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {
+        return connection.createStatement(resultSetType, resultSetConcurrency);
+    }
+
+    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
+            throws SQLException {
+        return connection.prepareStatement(sql, resultSetType, resultSetConcurrency);
+    }
+
+    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+        return connection.prepareCall(sql, resultSetType, resultSetConcurrency);
+    }
+
+    public Map<String, Class<?>> getTypeMap() throws SQLException {
+        return connection.getTypeMap();
+    }
+
+    public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+        connection.setTypeMap(map);
+    }
+
+    public void setHoldability(int holdability) throws SQLException {
+        connection.setHoldability(holdability);
+    }
+
+    public int getHoldability() throws SQLException {
+        return connection.getHoldability();
+    }
+
+    public Savepoint setSavepoint() throws SQLException {
+        return connection.setSavepoint();
+    }
+
+    public Savepoint setSavepoint(String name) throws SQLException {
+        return connection.setSavepoint(name);
+    }
+
+    public void rollback(Savepoint savepoint) throws SQLException {
+        connection.rollback(savepoint);
+    }
+
+    public void releaseSavepoint(Savepoint savepoint) throws SQLException {
+        connection.releaseSavepoint(savepoint);
+    }
+
+    public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
+            throws SQLException {
+        return connection.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
+    }
+
+    public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
+                                              int resultSetHoldability) throws SQLException {
+        return connection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
+    }
+
+    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
+                                         int resultSetHoldability) throws SQLException {
+        return connection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
+    }
+
+    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
+        return connection.prepareStatement(sql, autoGeneratedKeys);
+    }
+
+    public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
+        return connection.prepareStatement(sql, columnIndexes);
+    }
+
+    public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
+        return connection.prepareStatement(sql, columnNames);
+    }
+
+    public Clob createClob() throws SQLException {
+        return connection.createClob();
+    }
+
+    public Blob createBlob() throws SQLException {
+        return connection.createBlob();
+    }
+
+    public NClob createNClob() throws SQLException {
+        return connection.createNClob();
+    }
+
+    public SQLXML createSQLXML() throws SQLException {
+        return connection.createSQLXML();
+    }
+
+    public boolean isValid(int timeout) throws SQLException {
+        return connection.isValid(timeout);
+    }
+
+    public void setClientInfo(String name, String value) throws SQLClientInfoException {
+        connection.setClientInfo(name, value);
+    }
+
+    public void setClientInfo(Properties properties) throws SQLClientInfoException {
+        connection.setClientInfo(properties);
+    }
+
+    public String getClientInfo(String name) throws SQLException {
+        return connection.getClientInfo(name);
+    }
+
+    public Properties getClientInfo() throws SQLException {
+        return connection.getClientInfo();
+    }
+
+    public Array createArrayOf(String typeName, Object[] elements) throws SQLException {
+        return connection.createArrayOf(typeName, elements);
+    }
+
+    public Struct createStruct(String typeName, Object[] attributes) throws SQLException {
+        return connection.createStruct(typeName, attributes);
+    }
+
+    public void setSchema(String schema) throws SQLException {
+        connection.setSchema(schema);
+    }
+
+    public String getSchema() throws SQLException {
+        return connection.getSchema();
+    }
+
+    public void abort(Executor executor) throws SQLException {
+        connection.abort(executor);
+    }
+
+    public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException {
+        connection.setNetworkTimeout(executor, milliseconds);
+    }
+
+    public int getNetworkTimeout() throws SQLException {
+        return connection.getNetworkTimeout();
+    }
+}

dbutil/src/main/java/org/jivesoftware/database/PreparedStatementWrapper.java

+/**
+ * $RCSfile$
+ * $Revision: 37 $
+ * $Date: 2004-10-20 23:08:43 -0700 (Wed, 20 Oct 2004) $
+ *
+ * Copyright (C) 2004 Jive Software. All rights reserved.
+ *
+ * This software is published under the terms of the GNU Public License (GPL),
+ * a copy of which is included in this distribution.
+ */
+
+package org.jivesoftware.database;
+
+import java.sql.*;
+import java.math.BigDecimal;
+import java.io.InputStream;
+import java.io.Reader;
+import java.util.Calendar;
+import java.net.URL;
+
+/**
+ * An implementation of the PreparedStatement interface that wraps an underlying
+ * PreparedStatement object.
+ *
+ * @author Gaston Dombiak
+ */
+public abstract class PreparedStatementWrapper extends StatementWrapper
+        implements PreparedStatement {
+
+    protected PreparedStatement pstmt;
+
+    public PreparedStatementWrapper(PreparedStatement pstmt) {
+        super(pstmt);
+        this.pstmt = pstmt;
+    }
+
+    public ResultSet executeQuery() throws SQLException {
+        return pstmt.executeQuery();
+    }
+
+    public int executeUpdate() throws SQLException {
+        return pstmt.executeUpdate();
+    }
+
+    public void setNull(int parameterIndex, int sqlType) throws SQLException {
+        pstmt.setNull(parameterIndex, sqlType);
+    }
+
+    public void setBoolean(int parameterIndex, boolean x) throws SQLException {
+        pstmt.setBoolean(parameterIndex, x);
+    }
+
+    public void setByte(int parameterIndex, byte x) throws SQLException {
+        pstmt.setByte(parameterIndex, x);
+    }
+
+    public void setShort(int parameterIndex, short x) throws SQLException {
+        pstmt.setShort(parameterIndex, x);
+    }
+
+    public void setInt(int parameterIndex, int x) throws SQLException {
+        pstmt.setInt(parameterIndex, x);
+    }
+
+    public void setLong(int parameterIndex, long x) throws SQLException {
+        pstmt.setLong(parameterIndex, x);
+    }
+
+    public void setFloat(int parameterIndex, float x) throws SQLException {
+        pstmt.setFloat(parameterIndex, x);
+    }
+
+    public void setDouble(int parameterIndex, double x) throws SQLException {
+        pstmt.setDouble(parameterIndex, x);
+    }
+
+    public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
+        pstmt.setBigDecimal(parameterIndex, x);
+    }
+
+    public void setString(int parameterIndex, String x) throws SQLException {
+        pstmt.setString(parameterIndex, x);
+    }
+
+    public void setBytes(int parameterIndex, byte x[]) throws SQLException {
+        pstmt.setBytes(parameterIndex, x);
+    }
+
+    public void setDate(int parameterIndex, Date x) throws SQLException {
+        pstmt.setDate(parameterIndex, x);
+    }
+
+    public void setTime(int parameterIndex, Time x) throws SQLException {
+        pstmt.setTime(parameterIndex, x);
+    }
+
+    public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
+        pstmt.setTimestamp(parameterIndex, x);
+    }
+
+    public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
+        pstmt.setAsciiStream(parameterIndex, x, length);
+    }
+
+    @Deprecated public void setUnicodeStream(int parameterIndex, InputStream x, int length)
+            throws SQLException {
+        pstmt.setUnicodeStream(parameterIndex, x, length);
+    }
+
+    public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
+        pstmt.setBinaryStream(parameterIndex, x, length);
+    }
+
+    public void clearParameters() throws SQLException {
+        pstmt.clearParameters();
+    }
+
+    public void setObject(int parameterIndex, Object x, int targetSqlType, int scale)
+            throws SQLException {
+        pstmt.setObject(parameterIndex, x, targetSqlType, scale);
+    }
+
+    public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
+        pstmt.setObject(parameterIndex, x, targetSqlType);
+    }
+
+    public void setObject(int parameterIndex, Object x) throws SQLException {
+        pstmt.setObject(parameterIndex, x);
+    }
+
+    public boolean execute() throws SQLException {
+        return pstmt.execute();
+    }
+
+    public void addBatch() throws SQLException {
+        pstmt.addBatch();
+    }
+
+    public void setCharacterStream(int parameterIndex, Reader reader, int length)
+            throws SQLException {
+        pstmt.setCharacterStream(parameterIndex, reader, length);
+    }
+
+    public void setRef(int i, Ref x) throws SQLException {
+        pstmt.setRef(i, x);
+    }
+
+    public void setBlob(int i, Blob x) throws SQLException {
+        pstmt.setBlob(i, x);
+    }
+
+    public void setClob(int i, Clob x) throws SQLException {
+        pstmt.setClob(i, x);
+    }
+
+    public void setArray(int i, Array x) throws SQLException {
+        pstmt.setArray(i, x);
+    }
+
+    public ResultSetMetaData getMetaData() throws SQLException {
+        return pstmt.getMetaData();
+    }
+
+    public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
+        pstmt.setDate(parameterIndex, x, cal);
+    }
+
+    public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
+        pstmt.setTime(parameterIndex, x, cal);
+    }
+
+    public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
+        pstmt.setTimestamp(parameterIndex, x, cal);
+    }
+
+    public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
+        pstmt.setNull(paramIndex, sqlType, typeName);
+    }
+
+    public void setURL(int parameterIndex, URL x) throws SQLException {
+        pstmt.setURL(parameterIndex, x);
+    }
+
+    public ParameterMetaData getParameterMetaData() throws SQLException {
+        return pstmt.getParameterMetaData();
+    }
+
+    public void setRowId(int parameterIndex, RowId x) throws SQLException {
+        pstmt.setRowId(parameterIndex, x);
+    }
+
+    public void setNString(int parameterIndex, String value) throws SQLException {
+        pstmt.setNString(parameterIndex, value);
+    }
+
+    public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
+        pstmt.setNCharacterStream(parameterIndex, value, length);
+    }
+
+    public void setNClob(int parameterIndex, NClob value) throws SQLException {
+        pstmt.setNClob(parameterIndex, value);
+    }
+
+    public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
+        pstmt.setClob(parameterIndex, reader, length);
+    }
+
+    public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
+        pstmt.setBlob(parameterIndex, inputStream, length);
+    }
+
+    public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
+        pstmt.setNClob(parameterIndex, reader, length);
+    }
+
+    public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
+        pstmt.setSQLXML(parameterIndex, xmlObject);
+    }
+
+    public void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException {
+        pstmt.setAsciiStream(parameterIndex, x, length);
+    }
+
+    public void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException {
+        pstmt.setBinaryStream(parameterIndex, x, length);
+    }
+
+    public void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException {
+        pstmt.setCharacterStream(parameterIndex, reader, length);
+    }
+
+    public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
+        pstmt.setAsciiStream(parameterIndex, x);
+    }
+
+    public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
+        pstmt.setBinaryStream(parameterIndex, x);
+    }
+
+    public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
+        pstmt.setCharacterStream(parameterIndex, reader);
+    }
+
+    public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
+        pstmt.setNCharacterStream(parameterIndex, value);
+    }
+
+    public void setClob(int parameterIndex, Reader reader) throws SQLException {
+        pstmt.setClob(parameterIndex, reader);
+    }
+
+    public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
+        pstmt.setBlob(parameterIndex, inputStream);
+    }
+
+    public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+        pstmt.setNClob(parameterIndex, reader);
+    }
+}

dbutil/src/main/java/org/jivesoftware/database/ProfiledConnectionEntry.java

+/**
+ * $RCSfile$
+ * $Revision: 37 $
+ * $Date: 2004-10-20 23:08:43 -0700 (Wed, 20 Oct 2004) $
+ *
+ * Copyright (C) 2004 Jive Software. All rights reserved.
+ *
+ * This software is published under the terms of the GNU Public License (GPL),
+ * a copy of which is included in this distribution.
+ */
+
+package org.jivesoftware.database;
+
+/**
+ * Simple class for tracking profiling stats for individual SQL queries.
+ *
+ * @author Jive Software
+ */
+public class ProfiledConnectionEntry {
+    /**
+     * The SQL query.
+     */
+    public String sql;
+
+    /**
+     * Number of times the query has been executed.
+     */
+    public int count;
+
+    /**
+     * The total time spent executing the query (in milliseconds).
+     */
+    public int totalTime;
+
+    public ProfiledConnectionEntry(String sql) {
+        this.sql = sql;
+        count = 0;
+        totalTime = 0;
+    }
+}

dbutil/src/main/java/org/jivesoftware/database/StatementWrapper.java

+/**
+ * $RCSfile$
+ * $Revision: 37 $
+ * $Date: 2004-10-20 23:08:43 -0700 (Wed, 20 Oct 2004) $
+ *
+ * Copyright (C) 2004 Jive Software. All rights reserved.
+ *
+ * This software is published under the terms of the GNU Public License (GPL),
+ * a copy of which is included in this distribution.
+ */
+
+package org.jivesoftware.database;
+
+import java.sql.*;
+
+/**
+ * An implementation of the Statement interface that wraps an underlying
+ * Statement object.
+ *
+ * @author Gaston Dombiak
+ */
+public abstract class StatementWrapper implements Statement {
+
+    protected Statement stmt;
+
+    /**
+     * Creates a new StatementWrapper that wraps <tt>stmt</tt>.
+     *
+     * @param stmt The to-be-wrapped statement.
+     */
+    public StatementWrapper(Statement stmt) {
+        this.stmt = stmt;
+    }
+
+    public ResultSet executeQuery(String sql) throws SQLException {
+        return stmt.executeQuery(sql);
+    }
+
+    public int executeUpdate(String sql) throws SQLException {
+        return stmt.executeUpdate(sql);
+    }
+
+    public void close() throws SQLException {
+        stmt.close();
+    }
+
+    public int getMaxFieldSize() throws SQLException {
+        return stmt.getMaxFieldSize();
+    }
+
+    public void setMaxFieldSize(int max) throws SQLException {
+        stmt.setMaxFieldSize(max);
+    }
+
+    public int getMaxRows() throws SQLException {
+        return stmt.getMaxRows();
+    }
+
+    public void setMaxRows(int max) throws SQLException {
+        stmt.setMaxRows(max);
+    }
+
+    public void setEscapeProcessing(boolean enable) throws SQLException {
+        stmt.setEscapeProcessing(enable);
+    }
+
+    public int getQueryTimeout() throws SQLException {
+        return stmt.getQueryTimeout();
+    }
+
+    public void setQueryTimeout(int seconds) throws SQLException {
+        stmt.setQueryTimeout(seconds);
+    }
+
+    public void cancel() throws SQLException {
+        stmt.cancel();
+    }
+
+    public SQLWarning getWarnings() throws SQLException {
+        return stmt.getWarnings();
+    }
+
+    public void clearWarnings() throws SQLException {
+        stmt.clearWarnings();
+    }
+
+    public void setCursorName(String name) throws SQLException {
+        stmt.setCursorName(name);
+    }
+
+    public boolean execute(String sql) throws SQLException {
+        return stmt.execute(sql);
+    }
+
+    public ResultSet getResultSet() throws SQLException {
+        return stmt.getResultSet();
+    }
+
+    public int getUpdateCount() throws SQLException {
+        return stmt.getUpdateCount();
+    }
+
+    public boolean getMoreResults() throws SQLException {
+        return stmt.getMoreResults();
+    }
+
+    public void setFetchDirection(int direction) throws SQLException {
+        stmt.setFetchDirection(direction);
+    }
+
+    public int getFetchDirection() throws SQLException {
+        return stmt.getFetchDirection();
+    }
+
+    public void setFetchSize(int rows) throws SQLException {
+        stmt.setFetchSize(rows);
+    }
+
+    public int getFetchSize() throws SQLException {
+        return stmt.getFetchSize();
+    }
+
+    public int getResultSetConcurrency() throws SQLException {
+        return stmt.getResultSetConcurrency();
+    }
+
+    public int getResultSetType() throws SQLException {
+        return stmt.getResultSetType();
+    }
+
+    public void addBatch(String sql) throws SQLException {
+        stmt.addBatch(sql);
+    }
+
+    public void clearBatch() throws SQLException {
+        stmt.clearBatch();
+    }
+
+    public int[] executeBatch() throws SQLException {
+        return stmt.executeBatch();
+    }
+
+    public Connection getConnection() throws SQLException {
+        return stmt.getConnection();
+    }
+
+    public boolean getMoreResults(int current) throws SQLException {
+        return stmt.getMoreResults(current);
+    }
+
+    public ResultSet getGeneratedKeys() throws SQLException {
+        return stmt.getGeneratedKeys();
+    }
+
+    public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
+        return stmt.executeUpdate(sql, autoGeneratedKeys);
+    }
+
+    public int executeUpdate(String sql, int columnIndexes[]) throws SQLException {
+        return stmt.executeUpdate(sql, columnIndexes);
+    }
+
+    public int executeUpdate(String sql, String columnNames[]) throws SQLException {
+        return stmt.executeUpdate(sql, columnNames);
+    }
+
+    public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
+        return stmt.execute(sql, autoGeneratedKeys);
+    }
+
+    public boolean execute(String sql, int columnIndexes[]) throws SQLException {
+        return stmt.execute(sql, columnIndexes);
+    }
+
+    public boolean execute(String sql, String columnNames[]) throws SQLException {
+        return stmt.execute(sql, columnNames);
+    }
+
+    public int getResultSetHoldability() throws SQLException {
+        return stmt.getResultSetHoldability();
+    }
+
+    public <T> T unwrap(Class<T> iface) throws SQLException {
+        return stmt.unwrap(iface);
+    }
+
+    public boolean isWrapperFor(Class<?> iface) throws SQLException {
+        return stmt.isWrapperFor(iface);
+    }
+
+    public boolean isClosed() throws SQLException {
+        return stmt.isClosed();
+    }
+
+    public void setPoolable(boolean poolable) throws SQLException {
+        stmt.setPoolable(poolable);
+    }
+
+    public boolean isPoolable() throws SQLException {
+        return stmt.isPoolable();
+    }
+
+    public void closeOnCompletion() throws SQLException {
+        stmt.closeOnCompletion();
+    }
+
+    @Override
+    public boolean isCloseOnCompletion() throws SQLException {
+        return stmt.isCloseOnCompletion();
+    }
+}