Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.j256.ormlite.jdbc;
  
  import java.sql.ResultSet;
  import java.sql.Savepoint;
 import java.sql.Types;
 
Wrapper around a JDBC java.sql.Connection object which we delegate to.

Author(s):
graywatson
 
 public class JdbcDatabaseConnection implements DatabaseConnection {
 
 	private static final String JDBC_META_TABLE_NAME_COLUMN = "TABLE_NAME";
 
 	private static Object[] noArgs = new Object[0];
 	private static FieldType[] noArgTypes = new FieldType[0];
 	private static GenericRowMapper<LonglongWrapper = new OneLongWrapper();
 
 	private Connection connection;
 	private Boolean supportsSavePoints = null;
 
 	public JdbcDatabaseConnection(Connection connection) {
 		this. = connection;
 	}
 
 	public boolean isAutoCommitSupported() throws SQLException {
 		return true;
 	}
 
 	public boolean getAutoCommit() throws SQLException {
 	}
 
 	public void setAutoCommit(boolean autoCommitthrows SQLException {
 		.setAutoCommit(autoCommit);
 	}
 
 	public Savepoint setSavePoint(String namethrows SQLException {
 		if ( == null) {
 		}
 			return .setSavepoint(name);
 		} else {
 			return null;
 		}
 	}
 
 	public void commit(Savepoint savepointthrows SQLException {
 		if (savepoint == null) {
 		} else {
 		}
 	}
 
 	public void rollback(Savepoint savepointthrows SQLException {
 		if (savepoint == null) {
 		} else {
 			.rollback(savepoint);
 		}
 	}
 
 	public CompiledStatement compileStatement(String statementStatementType typeFieldType[] argFieldTypes)
 			throws SQLException {
 	}
 
 	public void close() throws SQLException {
 	}

Returns whether the connection has already been closed. Used by JdbcConnectionSource.
 
 	public boolean isClosed() throws SQLException {
 		return .isClosed();
 	}
 
 	public int insert(String statementObject[] argsFieldType[] argFieldTypesGeneratedKeyHolder keyHolder)
			throws SQLException {
		if (keyHolder == null) {
			stmt = .prepareStatement(statement);
else {
		}
		try {
			statementSetArgs(stmtargsargFieldTypes);
			int rowN = stmt.executeUpdate();
			if (keyHolder != null) {
				ResultSet resultSet = stmt.getGeneratedKeys();
				ResultSetMetaData metaData = resultSet.getMetaData();
				int colN = metaData.getColumnCount();
				while (resultSet.next()) {
					for (int colC = 1; colC <= colNcolC++) {
						// get the id column data so we can pass it back to the caller thru the keyHolder
						Number id = getIdColumnData(resultSetmetaDatacolC);
						keyHolder.addKey(id);
					}
				}
			}
			return rowN;
finally {
			stmt.close();
		}
	}
	public int update(String statementObject[] argsFieldType[] argFieldTypesthrows SQLException {
		try {
			statementSetArgs(stmtargsargFieldTypes);
			return stmt.executeUpdate();
finally {
			stmt.close();
		}
	}
	public int delete(String statementObject[] argsFieldType[] argFieldTypesthrows SQLException {
		// it's a call to executeUpdate
		return update(statementargsargFieldTypes);
	}
	public <T> Object queryForOne(String statementObject[] argsFieldType[] argFieldTypes,
			GenericRowMapper<T> rowMapperObjectCache objectCachethrows SQLException {
		try {
			statementSetArgs(stmtargsargFieldTypes);
			DatabaseResults results = new JdbcDatabaseResults(stmtstmt.executeQuery(), objectCache);
			if (!results.next()) {
				// no results at all
				return null;
			}
first = rowMapper.mapRow(results);
			if (results.next()) {
else {
				return first;
			}
finally {
			stmt.close();
		}
	}
	public long queryForLong(String statementthrows SQLException {
		// don't care about the object cache here
		Object result = queryForOne(statementnull);
		if (result == null) {
			throw new SQLException("No results returned in query-for-long: " + statement);
else if (result == ) {
			throw new SQLException("More than 1 result returned in query-for-long: " + statement);
else {
			return (Longresult;
		}
	}
	public boolean isTableExists(String tableNamethrows SQLException {
		ResultSet results = null;
		try {
			results = metaData.getTables(nullnull"%"new String[] { "TABLE" });
			// we do it this way because some result sets don't like us to findColumn if no results
			if (!results.next()) {
				return false;
			}
			do {
				String dbTableName = results.getString(col);
				if (tableName.equalsIgnoreCase(dbTableName)) {
					return true;
				}
while (results.next());
			return false;
finally {
			if (results != null) {
				results.close();
			}
		}
	}

Return the internal database connection. Most likely for testing purposes.
		return ;
	}

Set the internal database connection. Most likely for testing purposes.
	public void setInternalConnection(Connection connection) {
		this. = connection;
	}

Return the id associated with the column.
	private Number getIdColumnData(ResultSet resultSetResultSetMetaData metaDataint columnIndex)
			throws SQLException {
		int typeVal = metaData.getColumnType(columnIndex);
		switch (typeVal) {
			case . :
			case . :
			case . :
				return (NumberresultSet.getLong(columnIndex);
			case . :
				return (NumberresultSet.getInt(columnIndex);
			default :
				String columnName = metaData.getColumnName(columnIndex);
				throw new SQLException("Unexpected ID column type " + TypeValMapper.getSqlTypeForTypeVal(typeVal)
" (typeVal " + typeVal + ") in column " + columnName + "(#" + columnIndex
") is not a number");
		}
	}
	private void statementSetArgs(PreparedStatement stmtObject[] argsFieldType[] argFieldTypesthrows SQLException {
		if (args == null) {
			return;
		}
		for (int i = 0; i < args.lengthi++) {
			Object arg = args[i];
			int typeVal = TypeValMapper.getTypeValForSqlType(argFieldTypes[i].getSqlType());
			if (arg == null) {
				stmt.setNull(i + 1, typeVal);
else {
				stmt.setObject(i + 1, argtypeVal);
			}
		}
	}

Row mapper that handles a single long result.
	private static class OneLongWrapper implements GenericRowMapper<Long> {
		public Long mapRow(DatabaseResults rsthrows SQLException {
			// maps the first column (sql #1)
			return rs.getLong(0);
		}
	}
New to GrepCode? Check out our FAQ X