/**
* Licensed to JumpMind Inc under one or more contributor
* license agreements. See the NOTICE file distributed
* with this work for additional information regarding
* copyright ownership. JumpMind Inc licenses this file
* to you under the GNU General Public License, version 3.0 (GPLv3)
* (the "License"); you may not use this file except in compliance
* with the License.
*
* You should have received a copy of the GNU General Public License,
* version 3.0 (GPLv3) along with this library; if not, see
* <http://www.gnu.org/licenses/>.
*
* 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 org.jumpmind.db.sql;
import static org.jumpmind.db.model.ColumnTypes.ORACLE_TIMESTAMPLTZ;
import static org.jumpmind.db.model.ColumnTypes.ORACLE_TIMESTAMPTZ;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import javax.sql.DataSource;
import org.apache.commons.io.IOUtils;
import org.jumpmind.db.model.TypeMap;
import org.jumpmind.db.platform.DatabaseInfo;
import org.jumpmind.exception.IoException;
import org.jumpmind.util.LinkedCaseInsensitiveMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.SqlTypeValue;
import org.springframework.jdbc.core.StatementCreatorUtils;
import org.springframework.jdbc.support.lob.DefaultLobHandler;
import org.springframework.jdbc.support.lob.LobHandler;
public class JdbcSqlTemplate extends AbstractSqlTemplate implements ISqlTemplate {
static final Logger log = LoggerFactory.getLogger(JdbcSqlTemplate.class);
protected DataSource dataSource;
protected boolean requiresAutoCommitFalseToSetFetchSize = false;
protected SqlTemplateSettings settings;
protected SymmetricLobHandler lobHandler;
protected Boolean supportsGetGeneratedKeys = null;
protected int[] primaryKeyViolationCodes;
protected String[] primaryKeyViolationSqlStates;
protected String[] primaryKeyViolationMessageParts;
protected int[] foreignKeyViolationCodes;
protected String[] foreignKeyViolationSqlStates;
protected String[] foreignKeyViolationMessageParts;
protected int isolationLevel;
public JdbcSqlTemplate(DataSource dataSource, SqlTemplateSettings settings,
SymmetricLobHandler lobHandler, DatabaseInfo databaseInfo) {
this.dataSource = dataSource;
this.settings = settings == null ? new SqlTemplateSettings() : settings;
this.lobHandler = lobHandler == null ? new SymmetricLobHandler(new DefaultLobHandler())
: lobHandler;
this.isolationLevel = databaseInfo.getMinIsolationLevelToPreventPhantomReads();
}
protected Connection getConnection() throws SQLException {
return this.dataSource.getConnection();
}
public DataSource getDataSource() {
return dataSource;
}
public boolean isRequiresAutoCommitFalseToSetFetchSize() {
return requiresAutoCommitFalseToSetFetchSize;
}
public void setSettings(SqlTemplateSettings settings) {
this.settings = settings;
}
public SqlTemplateSettings getSettings() {
return settings;
}
public SymmetricLobHandler getLobHandler() {
return lobHandler;
}
public <T> ISqlReadCursor<T> queryForCursor(String sql, ISqlRowMapper<T> mapper, Object[] args,
int[] types) {
logSql(sql, args);
return new JdbcSqlReadCursor<T>(this, mapper, sql, args, types);
}
public int getIsolationLevel() {
return isolationLevel;
}
public void setIsolationLevel(int isolationLevel) {
this.isolationLevel = isolationLevel;
}
public <T> T queryForObject(final String sql, final Class<T> clazz, final Object... args) {
logSql(sql, args);
return execute(new IConnectionCallback<T>() {
public T execute(Connection con) throws SQLException {
T result = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = con.prepareStatement(expandSql(sql, args));
ps.setQueryTimeout(settings.getQueryTimeout());
setValues(ps, expandArgs(sql, args));
rs = ps.executeQuery();
if (rs.next()) {
result = getObjectFromResultSet(rs, clazz);
}
} finally {
close(rs);
close(ps);
}
return result;
}
});
}
@Deprecated
public byte[] queryForBlob(final String sql, final Object... args) {
return queryForBlob(sql, -1, null, args);
}
public byte[] queryForBlob(final String sql, final int jdbcTypeCode, final String jdbcTypeName,
final Object... args) {
logSql(sql, args);
return execute(new IConnectionCallback<byte[]>() {
public byte[] execute(Connection con) throws SQLException {
if (lobHandler.needsAutoCommitFalseForBlob(jdbcTypeCode, jdbcTypeName)) {
con.setAutoCommit(false);
}
byte[] result = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = con.prepareStatement(sql);
ps.setQueryTimeout(settings.getQueryTimeout());
setValues(ps, args);
rs = ps.executeQuery();
if (rs.next()) {
result = lobHandler.getBlobAsBytes(rs, 1, jdbcTypeCode, jdbcTypeName);
}
} finally {
if (lobHandler.needsAutoCommitFalseForBlob(jdbcTypeCode, jdbcTypeName)
&& con != null) {
con.setAutoCommit(true);
}
close(rs);
close(ps);
}
return result;
}
});
}
@Deprecated
public String queryForClob(final String sql, final Object... args) {
return queryForClob(sql, -1, null, args);
}
public String queryForClob(final String sql, final int jdbcTypeCode, final String jdbcTypeName, final Object... args) {
logSql(sql, args);
return execute(new IConnectionCallback<String>() {
public String execute(Connection con) throws SQLException {
String result = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = con.prepareStatement(sql);
ps.setQueryTimeout(settings.getQueryTimeout());
setValues(ps, args);
rs = ps.executeQuery();
if (rs.next()) {
result = lobHandler.getClobAsString(rs, 1, jdbcTypeCode, jdbcTypeName);
}
} finally {
close(rs);
close(ps);
}
return result;
}
});
}
public Map<String, Object> queryForMap(final String sql, final Object... args) {
logSql(sql, args);
return execute(new IConnectionCallback<Map<String, Object>>() {
@SuppressWarnings("resource")
public Map<String, Object> execute(Connection con) throws SQLException {
Map<String, Object> result = null;
PreparedStatement ps = null;
ResultSet rs = null;
try {
ps = con.prepareStatement(sql);
ps.setQueryTimeout(settings.getQueryTimeout());
if (args != null && args.length > 0) {
setValues(ps, args);
}
rs = ps.executeQuery();
if (rs.next()) {
ResultSetMetaData meta = rs.getMetaData();
int colCount = meta.getColumnCount();
result = new LinkedCaseInsensitiveMap<Object>(colCount);
for (int i = 1; i <= colCount; i++) {
String key = meta.getColumnName(i);
Object value = rs.getObject(i);
if (value instanceof Blob) {
Blob blob = (Blob) value;
try {
value = IOUtils.toByteArray(blob.getBinaryStream());
} catch (IOException e) {
throw new IoException(e);
}
} else if (value instanceof Clob) {
Clob clob = (Clob) value;
try {
value = IOUtils.toByteArray(clob.getCharacterStream());
} catch (IOException e) {
throw new IoException(e);
}
} else if (value != null) {
Class<?> clazz = value.getClass();
Class<?> superClazz = clazz.getSuperclass();
if (superClazz != null
&& superClazz.getName().equals("oracle.sql.Datum")) {
try {
Method method = superClazz.getMethod("toJdbc");
value = method.invoke(value);
} catch (Exception e) {
throw new IllegalStateException(e);
}
}
}
result.put(key, value);
}
}
} finally {
close(rs);
close(ps);
}
return result;
}
});
}
public ISqlTransaction startSqlTransaction(boolean autoCommit) {
return new JdbcSqlTransaction(this, autoCommit);
}
public ISqlTransaction startSqlTransaction() {
return new JdbcSqlTransaction(this);
}
public int update(final String sql, final Object[] args, final int[] types) {
logSql(sql, args);
return execute(new IConnectionCallback<Integer>() {
public Integer execute(Connection con) throws SQLException {
if (args == null) {
Statement stmt = null;
try {
stmt = con.createStatement();
stmt.setQueryTimeout(settings.getQueryTimeout());
stmt.execute(sql);
return stmt.getUpdateCount();
} finally {
close(stmt);
}
} else {
PreparedStatement ps = null;
try {
ps = con.prepareStatement(sql);
ps.setQueryTimeout(settings.getQueryTimeout());
if (types != null) {
setValues(ps, args, types, getLobHandler()
.getDefaultHandler());
} else {
setValues(ps, args);
}
ps.execute();
return ps.getUpdateCount();
} finally {
close(ps);
}
}
}
});
}
public int update(boolean autoCommit, boolean failOnError, int commitRate, String... sql) {
return update(autoCommit, failOnError, commitRate, null, sql);
}
public int update(boolean autoCommit, boolean failOnError, int commitRate,
ISqlResultsListener resultsListener, String... sql) {
return this.update(autoCommit, failOnError, true, true,
commitRate, resultsListener, new ListSqlStatementSource(sql));
}
public int update(final boolean autoCommit, final boolean failOnError, final boolean failOnDrops,
final boolean failOnSequenceCreate, final int commitRate, final ISqlResultsListener resultsListener, final ISqlStatementSource source) {
return execute(new IConnectionCallback<Integer>() {
@SuppressWarnings("resource")
public Integer execute(Connection con) throws SQLException {
int totalUpdateCount = 0;
boolean oldAutoCommitSetting = con.getAutoCommit();
Statement stmt = null;
try {
con.setAutoCommit(autoCommit);
stmt = con.createStatement();
int statementCount = 0;
for (String statement = source.readSqlStatement(); statement != null; statement = source
.readSqlStatement()) {
logSql(statement, null);
try {
boolean hasResults = stmt.execute(statement);
int updateCount = stmt.getUpdateCount();
totalUpdateCount += updateCount;
int rowsRetrieved = 0;
if (hasResults) {
ResultSet rs = null;
try {
rs = stmt.getResultSet();
while (rs.next()) {
rowsRetrieved++;
}
} finally {
close(rs);
}
}
if (resultsListener != null) {
resultsListener.sqlApplied(statement, updateCount, rowsRetrieved,
statementCount);
}
statementCount++;
if (statementCount % commitRate == 0 && !autoCommit) {
con.commit();
}
} catch (SQLException ex) {
boolean isDrop = statement.toLowerCase().trim().startsWith("drop");
boolean isSequenceCreate = statement.toLowerCase().trim().startsWith("create sequence");
if (resultsListener != null) {
resultsListener.sqlErrored(statement, translate(statement, ex),
statementCount, isDrop, isSequenceCreate);
}
if ((isDrop && !failOnDrops) || (isSequenceCreate && !failOnSequenceCreate)) {
log.debug("{}. Failed to execute: {}", ex.getMessage(), statement);
} else {
log.warn("{}. Failed to execute: {}", ex.getMessage(), statement);
if (failOnError) {
throw ex;
}
}
}
}
if (!autoCommit) {
con.commit();
}
return totalUpdateCount;
} catch (SQLException ex) {
if (!autoCommit) {
con.rollback();
}
throw ex;
} finally {
close(stmt);
if (!con.isClosed()) {
con.setAutoCommit(oldAutoCommitSetting);
}
}
}
});
}
public void testConnection() {
execute(new IConnectionCallback<Boolean>() {
public Boolean execute(Connection con) throws SQLException {
return true;
}
});
}
public <T> T execute(IConnectionCallback<T> callback) {
Connection c = null;
try {
c = getConnection();
return callback.execute(c);
} catch (SQLException ex) {
throw translate(ex);
} finally {
close(c);
}
}
/**
* Determine the column name to use. The column name is determined based on
* a lookup using ResultSetMetaData.
* <p>
* This method implementation takes into account recent clarifications
* expressed in the JDBC 4.0 specification:
* <p>
* <i>columnLabel - the label for the column specified with the SQL AS
* clause. If the SQL AS clause was not specified, then the label is the
* name of the column</i>.
*
* @return the column name to use
* @param resultSetMetaData
* the current meta data to use
* @param columnIndex
* the index of the column for the look up
* @throws SQLException
* in case of lookup failure
*/
public static String lookupColumnName(ResultSetMetaData resultSetMetaData, int columnIndex)
throws SQLException {
String name = resultSetMetaData.getColumnLabel(columnIndex);
if (name == null || name.length() < 1) {
name = resultSetMetaData.getColumnName(columnIndex);
}
return name;
}
/**
* Retrieve a JDBC column value from a ResultSet, using the most appropriate
* value type. The returned value should be a detached value object, not
* having any ties to the active ResultSet: in particular, it should not be
* a Blob or Clob object but rather a byte array respectively String
* representation.
* <p>
* Uses the <code>getObject(index)</code> method, but includes additional
* "hacks" to get around Oracle 10g returning a non-standard object for its
* TIMESTAMP datatype and a <code>java.sql.Date</code> for DATE columns
* leaving out the time portion: These columns will explicitly be extracted
* as standard <code>java.sql.Timestamp</code> object.
*
* @param rs
* is the ResultSet holding the data
* @param index
* is the column index
* @param readStringsAsBytes TODO
* @return the value object
* @throws SQLException
* if thrown by the JDBC API
* @see java.sql.Blob
* @see java.sql.Clob
* @see java.sql.Timestamp
*/
public static Object getResultSetValue(ResultSet rs, int index, boolean readStringsAsBytes) throws SQLException {
ResultSetMetaData metaData = rs.getMetaData();
Object obj = null;
int jdbcType = metaData.getColumnType(index);
if (readStringsAsBytes && TypeMap.isTextType(jdbcType)) {
byte[] bytes = rs.getBytes(index);
if (bytes != null) {
obj = new String(bytes);
}
} else {
obj = rs.getObject(index);
}
String className = null;
if (obj != null) {
className = obj.getClass().getName();
}
if (obj instanceof Blob) {
Blob blob = (Blob) obj;
InputStream is = blob.getBinaryStream();
try {
obj = IOUtils.toByteArray(is);
} catch (IOException e) {
throw new SqlException(e);
} finally {
IOUtils.closeQuietly(is);
}
} else if (obj instanceof Clob) {
Clob clob = (Clob) obj;
Reader reader = clob.getCharacterStream();
try {
obj = IOUtils.toString(reader);
} catch (IOException e) {
throw new SqlException(e);
} finally {
IOUtils.closeQuietly(reader);
}
} else if (className != null && ("oracle.sql.TIMESTAMP".equals(className))) {
obj = rs.getTimestamp(index);
} else if (className != null && "oracle.sql.TIMESTAMPTZ".equals(className)) {
obj = rs.getString(index);
} else if (className != null && "oracle.sql.TIMESTAMPLTZ".equals(className)) {
obj = rs.getString(index);
} else if (className != null && className.startsWith("oracle.sql.DATE")) {
String metaDataClassName = metaData.getColumnClassName(index);
if ("java.sql.Timestamp".equals(metaDataClassName)
|| "oracle.sql.TIMESTAMP".equals(metaDataClassName)) {
obj = rs.getTimestamp(index);
} else {
obj = rs.getDate(index);
}
} else if (obj instanceof java.sql.Date) {
String metaDataClassName = metaData.getColumnClassName(index);
if ("java.sql.Timestamp".equals(metaDataClassName)) {
obj = rs.getTimestamp(index);
}
} else if (obj instanceof Timestamp) {
String typeName = metaData.getColumnTypeName(index);
if (typeName != null && typeName.equals("timestamptz")) {
obj = rs.getString(index);
}
}
return obj;
}
public static void close(ResultSet rs) {
try {
if (rs != null) {
rs.close();
}
} catch (Throwable ex) {
}
}
public static void close(PreparedStatement ps) {
try {
if (ps != null) {
ps.close();
}
} catch (Throwable ex) {
}
}
public static void close(Statement stmt) {
try {
if (stmt != null) {
stmt.close();
}
} catch (Throwable ex) {
}
}
public static void close(boolean autoCommitValue, Connection c) {
try {
if (c != null) {
c.setAutoCommit(autoCommitValue);
}
} catch (Throwable ex) {
} finally {
close(c);
}
}
public static void close(boolean autoCommitValue, int transactionIsolationLevel, Connection c) {
try {
if (c != null) {
c.setAutoCommit(autoCommitValue);
if (c.getTransactionIsolation() != transactionIsolationLevel) {
c.setTransactionIsolation(transactionIsolationLevel);
}
}
} catch (Throwable ex) {
} finally {
close(c);
}
}
public static void close(Connection c) {
try {
if (c != null) {
c.close();
}
} catch (Throwable ex) {
}
}
public int getDatabaseMajorVersion() {
return execute(new IConnectionCallback<Integer>() {
public Integer execute(Connection con) throws SQLException {
return con.getMetaData().getDatabaseMajorVersion();
}
});
}
public int getDatabaseMinorVersion() {
return execute(new IConnectionCallback<Integer>() {
public Integer execute(Connection con) throws SQLException {
return con.getMetaData().getDatabaseMinorVersion();
}
});
}
public String getDatabaseProductName() {
return execute(new IConnectionCallback<String>() {
public String execute(Connection con) throws SQLException {
return con.getMetaData().getDatabaseProductName();
}
});
}
public boolean isStoresMixedCaseQuotedIdentifiers() {
return execute(new IConnectionCallback<Boolean>() {
public Boolean execute(Connection con) throws SQLException {
return con.getMetaData().storesMixedCaseQuotedIdentifiers();
}
});
}
public boolean isStoresUpperCaseIdentifiers() {
return execute(new IConnectionCallback<Boolean>() {
public Boolean execute(Connection con) throws SQLException {
return con.getMetaData().storesUpperCaseIdentifiers();
}
});
}
public boolean isStoresLowerCaseIdentifiers() {
return execute(new IConnectionCallback<Boolean>() {
public Boolean execute(Connection con) throws SQLException {
return con.getMetaData().storesLowerCaseIdentifiers();
}
});
}
public String getDatabaseProductVersion() {
return execute(new IConnectionCallback<String>() {
public String execute(Connection con) throws SQLException {
return con.getMetaData().getDatabaseProductVersion();
}
});
}
public String getDriverName() {
return execute(new IConnectionCallback<String>() {
public String execute(Connection con) throws SQLException {
return con.getMetaData().getDriverName();
}
});
}
public String getDriverVersion() {
return execute(new IConnectionCallback<String>() {
public String execute(Connection con) throws SQLException {
return con.getMetaData().getDriverVersion();
}
});
}
public Set<String> getSqlKeywords() {
return execute(new IConnectionCallback<Set<String>>() {
public Set<String> execute(Connection con) throws SQLException {
DatabaseMetaData sqlTemplateData = con.getMetaData();
return new HashSet<String>(Arrays.asList(sqlTemplateData.getSQLKeywords()
.split(",")));
}
});
}
public boolean supportsGetGeneratedKeys() {
if (supportsGetGeneratedKeys == null) {
supportsGetGeneratedKeys = execute(new IConnectionCallback<Boolean>() {
public Boolean execute(Connection con) throws SQLException {
return con.getMetaData().supportsGetGeneratedKeys();
}
});
}
return supportsGetGeneratedKeys;
}
public boolean supportsReturningKeys() {
return false;
}
protected boolean allowsNullForIdentityColumn() {
return true;
}
protected String getSelectLastInsertIdSql(String sequenceName) {
throw new UnsupportedOperationException();
}
public long insertWithGeneratedKey(final String sql, final String column,
final String sequenceName, final Object[] args, final int[] types) {
return execute(new IConnectionCallback<Long>() {
public Long execute(Connection conn) throws SQLException {
return insertWithGeneratedKey(conn, sql, column, sequenceName, args, types);
}
});
}
protected long insertWithGeneratedKey(Connection conn, String sql, String column,
String sequenceName, Object[] args, int[] types) throws SQLException {
long key = 0;
PreparedStatement ps = null;
try {
boolean supportsGetGeneratedKeys = supportsGetGeneratedKeys();
boolean supportsReturningKeys = supportsReturningKeys();
if (allowsNullForIdentityColumn()) {
if (supportsGetGeneratedKeys) {
ps = conn.prepareStatement(sql, new int[] { 1 });
} else if (supportsReturningKeys) {
ps = conn.prepareStatement(sql + " returning " + column);
} else {
ps = conn.prepareStatement(sql);
}
} else {
String replaceSql = sql.replaceFirst("\\([\"|\\w]*,", "(").replaceFirst("\\(null,",
"(");
if (supportsGetGeneratedKeys) {
ps = conn.prepareStatement(replaceSql, Statement.RETURN_GENERATED_KEYS);
} else {
ps = conn.prepareStatement(replaceSql);
}
}
ps.setQueryTimeout(settings.getQueryTimeout());
setValues(ps, args, types, lobHandler.getDefaultHandler());
ResultSet rs = null;
if (supportsGetGeneratedKeys) {
ps.execute();
try {
rs = ps.getGeneratedKeys();
if (rs.next()) {
key = rs.getLong(1);
}
} finally {
close(rs);
}
} else if (supportsReturningKeys) {
try {
rs = ps.executeQuery();
if (rs.next()) {
key = rs.getLong(1);
}
} finally {
close(rs);
}
} else {
Statement st = null;
ps.execute();
try {
st = conn.createStatement();
rs = st.executeQuery(getSelectLastInsertIdSql(sequenceName));
if (rs.next()) {
key = rs.getLong(1);
}
} finally {
close(rs);
close(st);
}
}
} finally {
close(ps);
}
return key;
}
public boolean isUniqueKeyViolation(Throwable ex) {
boolean primaryKeyViolation = false;
if (primaryKeyViolationCodes != null || primaryKeyViolationSqlStates != null) {
SQLException sqlEx = findSQLException(ex);
if (sqlEx != null) {
if (primaryKeyViolationCodes != null) {
int errorCode = sqlEx.getErrorCode();
for (int primaryKeyViolationCode : primaryKeyViolationCodes) {
if (primaryKeyViolationCode == errorCode) {
primaryKeyViolation = true;
break;
}
}
}
if (primaryKeyViolationSqlStates != null) {
String sqlState = sqlEx.getSQLState();
if (sqlState != null) {
for (String primaryKeyViolationSqlState : primaryKeyViolationSqlStates) {
if (primaryKeyViolationSqlState != null
&& primaryKeyViolationSqlState.equals(sqlState)) {
primaryKeyViolation = true;
break;
}
}
}
}
if (primaryKeyViolationMessageParts != null) {
String sqlMessage = sqlEx.getMessage();
if (sqlMessage != null) {
sqlMessage = sqlMessage.toLowerCase();
for (String primaryKeyViolationMessagePart : primaryKeyViolationMessageParts) {
if (primaryKeyViolationMessagePart != null && sqlMessage.contains(primaryKeyViolationMessagePart.toLowerCase())) {
primaryKeyViolation = true;
break;
}
}
}
}
}
}
return primaryKeyViolation;
}
public boolean isForeignKeyViolation(Throwable ex) {
boolean foreignKeyViolation = false;
if (foreignKeyViolationCodes != null || foreignKeyViolationSqlStates != null) {
SQLException sqlEx = findSQLException(ex);
if (sqlEx != null) {
if (foreignKeyViolationCodes != null) {
int errorCode = sqlEx.getErrorCode();
for (int foreignKeyViolationCode : foreignKeyViolationCodes) {
if (foreignKeyViolationCode == errorCode) {
foreignKeyViolation = true;
break;
}
}
}
if (foreignKeyViolationSqlStates != null) {
String sqlState = sqlEx.getSQLState();
if (sqlState != null) {
for (String foreignKeyViolationSqlState : foreignKeyViolationSqlStates) {
if (foreignKeyViolationSqlState != null
&& foreignKeyViolationSqlState.equals(sqlState)) {
foreignKeyViolation = true;
break;
}
}
}
}
if (foreignKeyViolationMessageParts != null) {
String sqlMessage = sqlEx.getMessage();
if (sqlMessage != null) {
sqlMessage = sqlMessage.toLowerCase();
for (String foreignKeyViolationMessagePart : foreignKeyViolationMessageParts) {
if (foreignKeyViolationMessagePart != null && sqlMessage.contains(foreignKeyViolationMessagePart.toLowerCase())) {
foreignKeyViolation = true;
break;
}
}
}
}
}
}
return foreignKeyViolation;
}
protected SQLException findSQLException(Throwable ex) {
if (ex instanceof SQLException) {
return (SQLException) ex;
} else {
Throwable cause = ex.getCause();
if (cause != null && !cause.equals(ex)) {
return findSQLException(cause);
}
}
return null;
}
@SuppressWarnings("unchecked")
public <T> T getObjectFromResultSet(ResultSet rs, Class<T> clazz) throws SQLException {
T result;
if (Date.class.isAssignableFrom(clazz)) {
result = (T) rs.getTimestamp(1);
} else if (String.class.isAssignableFrom(clazz)) {
result = (T) rs.getString(1);
} else if (Long.class.isAssignableFrom(clazz)) {
result = (T)new Long(rs.getLong(1));
} else if (Integer.class.isAssignableFrom(clazz)) {
result = (T)new Integer(rs.getInt(1));
} else if (Float.class.isAssignableFrom(clazz)) {
result = (T)new Float(rs.getFloat(1));
} else if (Double.class.isAssignableFrom(clazz)) {
result = (T)new Double(rs.getDouble(1));
} else if (BigDecimal.class.isAssignableFrom(clazz)) {
result = (T)rs.getBigDecimal(1);
} else {
result = (T) rs.getObject(1);
}
return result;
}
public void setValues(PreparedStatement ps, Object[] args, int[] argTypes,
LobHandler lobHandler) throws SQLException {
for (int i = 1; i <= args.length; i++) {
Object arg = args[i - 1];
int argType = argTypes != null && argTypes.length >= i ? argTypes[i - 1] : SqlTypeValue.TYPE_UNKNOWN;
if (argType == Types.BLOB && lobHandler != null && arg instanceof byte[]) {
lobHandler.getLobCreator().setBlobAsBytes(ps, i, (byte[]) arg);
} else if (argType == Types.BLOB && lobHandler != null && arg instanceof String) {
lobHandler.getLobCreator().setBlobAsBytes(ps, i, arg.toString().getBytes());
} else if (argType == Types.CLOB && lobHandler != null) {
lobHandler.getLobCreator().setClobAsString(ps, i, (String) arg);
} else if ((argType == Types.DECIMAL || argType == Types.NUMERIC) && arg != null) {
setDecimalValue(ps, i, arg, argType);
} else if (argType == Types.TINYINT) {
setTinyIntValue(ps, i, arg, argType);
} else {
StatementCreatorUtils.setParameterValue(ps, i, verifyArgType(arg, argType), arg);
}
}
}
protected void setTinyIntValue(PreparedStatement ps, int i, Object arg, int argType) throws SQLException {
StatementCreatorUtils.setParameterValue(ps, i, verifyArgType(arg, argType), arg);
}
protected void setDecimalValue(PreparedStatement ps, int i, Object arg, int argType) throws SQLException {
StatementCreatorUtils.setParameterValue(ps, i, verifyArgType(arg, argType), arg);
}
protected int verifyArgType(Object arg, int argType) {
if (argType == ORACLE_TIMESTAMPTZ || argType == ORACLE_TIMESTAMPLTZ || argType == Types.OTHER) {
return SqlTypeValue.TYPE_UNKNOWN;
} else if ((argType == Types.INTEGER && arg instanceof BigInteger) ||
(argType == Types.BIGINT && arg instanceof BigDecimal)) {
return Types.DECIMAL;
} else {
return argType;
}
}
public void setValues(PreparedStatement ps, Object[] args) throws SQLException {
if (args != null) {
for (int i = 0; i < args.length; i++) {
Object arg = args[i];
doSetValue(ps, i + 1, arg);
}
}
}
/**
* Set the value for prepared statements specified parameter index using the
* passed in value. This method can be overridden by sub-classes if needed.
*
* @param ps
* the PreparedStatement
* @param parameterPosition
* index of the parameter position
* @param argValue
* the value to set
* @throws SQLException
*/
public void doSetValue(PreparedStatement ps, int parameterPosition, Object argValue)
throws SQLException {
StatementCreatorUtils.setParameterValue(ps, parameterPosition, SqlTypeValue.TYPE_UNKNOWN, argValue);
}
}