1277 lines
47 KiB
Java
1277 lines
47 KiB
Java
/*
|
|
* BEGIN_HEADER - DO NOT EDIT
|
|
*
|
|
* The contents of this file are subject to the terms
|
|
* of the Common Development and Distribution License
|
|
* (the "License"). You may not use this file except
|
|
* in compliance with the License.
|
|
*
|
|
* You can obtain a copy of the license at
|
|
* https://open-jbi-components.dev.java.net/public/CDDLv1.0.html.
|
|
* See the License for the specific language governing
|
|
* permissions and limitations under the License.
|
|
*
|
|
* When distributing Covered Code, include this CDDL
|
|
* HEADER in each file and include the License file at
|
|
* https://open-jbi-components.dev.java.net/public/CDDLv1.0.html.
|
|
* If applicable add the following below this CDDL HEADER,
|
|
* with the fields enclosed by brackets "[]" replaced with
|
|
* your own identifying information: Portions Copyright
|
|
* [year] [name of copyright owner]
|
|
*/
|
|
|
|
/*
|
|
* @(#)JDBCDenormalizer.java
|
|
*
|
|
* Copyright 2004-2007 Sun Microsystems, Inc. All Rights Reserved.
|
|
*
|
|
* END_HEADER - DO NOT EDIT
|
|
*/
|
|
package org.glassfish.openesb.databasebc;
|
|
|
|
import java.io.StringWriter;
|
|
import java.sql.CallableStatement;
|
|
import java.sql.DatabaseMetaData;
|
|
import java.sql.ParameterMetaData;
|
|
import java.sql.PreparedStatement;
|
|
import java.sql.ResultSet;
|
|
|
|
import org.glassfish.openesb.databasebc.model.metadata.DBMetaData;
|
|
import java.sql.SQLException;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.StringTokenizer;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
import javax.jbi.messaging.MessagingException;
|
|
import javax.jbi.messaging.NormalizedMessage;
|
|
import javax.wsdl.Input;
|
|
import javax.wsdl.Message;
|
|
import javax.wsdl.Operation;
|
|
import javax.wsdl.Part;
|
|
import javax.xml.namespace.QName;
|
|
import javax.xml.transform.Source;
|
|
import javax.xml.transform.Transformer;
|
|
import javax.xml.transform.TransformerConfigurationException;
|
|
import javax.xml.transform.TransformerException;
|
|
import javax.xml.transform.TransformerFactory;
|
|
import javax.xml.transform.dom.DOMResult;
|
|
import javax.xml.transform.stream.StreamResult;
|
|
import org.w3c.dom.Document;
|
|
import org.w3c.dom.Element;
|
|
import org.w3c.dom.Node;
|
|
import org.w3c.dom.NodeList;
|
|
import com.ibm.wsdl.util.xml.DOMUtils;
|
|
import com.sun.jbi.internationalization.Messages;
|
|
import org.glassfish.openesb.databasebc.extensions.JDBCOperationInput;
|
|
import com.sun.jbi.nms.wsdl11wrapper.HelperFactory;
|
|
import com.sun.jbi.nms.wsdl11wrapper.WrapperParser;
|
|
import java.io.InputStream;
|
|
import java.io.Reader;
|
|
import java.util.Scanner;
|
|
import javax.xml.transform.stream.StreamSource;
|
|
import org.glassfish.openesb.databasebc.extensions.SPOperationInput;
|
|
import org.glassfish.openesb.databasebc.util.CachedQueryParameter;
|
|
import org.glassfish.openesb.databasebc.util.ParamMetadataCache;
|
|
|
|
/**
|
|
*
|
|
* JDBCDenormalizer
|
|
*
|
|
*/
|
|
public class JDBCDenormalizer {
|
|
|
|
private static final Messages mMessages = Messages.getMessages(
|
|
JDBCDenormalizer.class);
|
|
private static final Logger mLogger = Messages.getLogger(
|
|
JDBCDenormalizer.class);
|
|
private String dbName = null;
|
|
private String catalog = null;
|
|
private ArrayList outParamIndex = new ArrayList();
|
|
private HashMap<Integer, String> outParamTypes =
|
|
new HashMap<Integer, String>();
|
|
private HashMap<Integer, String> outParamNames =
|
|
new HashMap<Integer, String>();
|
|
private HashMap<String, String> mColNamesTypes =
|
|
new HashMap<String, String>();
|
|
private String mRecordPrefix = null; //113494
|
|
private String driverName_;
|
|
|
|
/**
|
|
*
|
|
* @param normalizedMessage
|
|
* @param opMetaData
|
|
* @param ps
|
|
* @throws MessagingException
|
|
*/
|
|
protected void denormalizeOutbound(final NormalizedMessage normalizedMessage,
|
|
String dbName, final OperationMetaData opMetaData, final PreparedStatement ps)
|
|
throws MessagingException {
|
|
if (opMetaData != null) {
|
|
final JDBCOperationInput mJdbcOperationInput = opMetaData.
|
|
getJDBCOperationInput();
|
|
final String operationType = mJdbcOperationInput.getOperationType();
|
|
mColNamesTypes = mJdbcOperationInput.getColNamesTypes();
|
|
//if (JDBCUtil.opList.contains(operationType)) {
|
|
try {
|
|
Element element =
|
|
transformMessage(normalizedMessage, opMetaData);
|
|
if (element != null)
|
|
populatePreparedStatement(element, dbName, opMetaData, ps);
|
|
} catch (final SQLException ex) {
|
|
final String msg =
|
|
JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_E00709.JDBCDN_FailedPopulate_PS") +
|
|
"Reason: " + ex.getLocalizedMessage() + " SQLState: " + ex.
|
|
getSQLState() + " ErrorCode:" + ex.getErrorCode();
|
|
throw new MessagingException(msg, ex);
|
|
} catch (final Exception ex) {
|
|
final String msg = JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_E00709.JDBCDN_FailedPopulate_PS") +
|
|
"Reason: " + ex.getLocalizedMessage();
|
|
throw new MessagingException(msg, ex);
|
|
}
|
|
//}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param normalizedMessage
|
|
* @param opMetaData
|
|
* @param dbmeta
|
|
* @param cs
|
|
* @throws MessagingException
|
|
*/
|
|
protected void denormalizeOutboundProc(final NormalizedMessage normalizedMessage,
|
|
final OperationMetaData opMetaData, final DatabaseMetaData dbmeta, final CallableStatement cs)
|
|
throws MessagingException {
|
|
if (opMetaData != null) {
|
|
final SPOperationInput mJdbcOperationInput = opMetaData.
|
|
getJDBCSPOperationInput();
|
|
final String operationType = mJdbcOperationInput.getOperationType();
|
|
|
|
try {
|
|
Element element =
|
|
transformMessage(normalizedMessage, opMetaData);
|
|
if (element != null)
|
|
populateProcedure(element, opMetaData, dbmeta, cs);
|
|
} catch (final SQLException ex) {
|
|
final String msg =
|
|
JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_E00711.DN_FailedPopulate_Proc") +
|
|
"Reason: " + ex.getLocalizedMessage() + " SQLState: " + ex.
|
|
getSQLState() + " ErrorCode:" + ex.getErrorCode();
|
|
throw new MessagingException(msg, ex);
|
|
} catch (final Throwable th) {
|
|
final String msg = JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_E00712.DN_Failed_Proc") + "Reason: " + th.
|
|
getLocalizedMessage();
|
|
throw new MessagingException(msg, th);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param tableElem
|
|
* @param opMetaData
|
|
* @param cs
|
|
* @throws SQLException
|
|
* @throws MessagingException
|
|
* @throws Exception
|
|
*/
|
|
@SuppressWarnings("empty-statement")
|
|
private void populateProcedure(final Element tableElem,
|
|
final OperationMetaData opMetaData, final DatabaseMetaData dbmeta, CallableStatement cs)
|
|
throws SQLException, MessagingException, Exception {
|
|
final SPOperationInput jdbcSql = opMetaData.getJDBCSPOperationInput();
|
|
driverName_ = dbmeta.getDriverName();
|
|
String sqltext = jdbcSql.getExecutionString();
|
|
String procName = getProcName(sqltext);
|
|
/*
|
|
* Modified by Logicoy for [ task #20 ] DB BC - Insert statement should return primary key auto-increment value inserted
|
|
*/
|
|
String pcatalog = null;
|
|
String pschema = null;
|
|
if (dbName != null)
|
|
pschema = dbName;
|
|
if (catalog != null)
|
|
pcatalog = catalog;
|
|
ResultSet rs = null;
|
|
if (mLogger.isLoggable(Level.INFO))
|
|
mLogger.log(Level.INFO, JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00716.JDBCDN_StartPopulateProc"));
|
|
if (jdbcSql != null) {
|
|
final String dbURL = dbmeta.getURL();
|
|
ParamMetadataCache paramsCache = ParamMetadataCache.instance();
|
|
ArrayList<CachedQueryParameter> params = paramsCache.getMetadata(
|
|
dbURL, opMetaData);
|
|
|
|
if (params == null) {
|
|
try {
|
|
final String dbms = dbmeta.getDatabaseProductName().
|
|
toLowerCase();
|
|
final String colNamePattern =
|
|
((dbms.contains("sql server") || dbms.contains(
|
|
"adaptive server")) && sqltext.contains("=")) ? null : "%";
|
|
|
|
rs = dbmeta.getProcedureColumns(pcatalog, pschema, procName,
|
|
colNamePattern);
|
|
} catch (final SQLException ex) {
|
|
if (mLogger.isLoggable(Level.FINE))
|
|
mLogger.log(Level.SEVERE, JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00721.JDBCDN_UnableToProcessMedataData"),
|
|
ex);
|
|
else if (mLogger.isLoggable(Level.INFO))
|
|
mLogger.log(Level.SEVERE, JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00721.JDBCDN_UnableToProcessMedataData"));
|
|
}
|
|
|
|
if (rs != null)
|
|
params = cacheQueryParameters(rs);
|
|
else {
|
|
final String msg = JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00721.JDBCDN_UnableToProcessMedataData");
|
|
MessagingException me = new MessagingException(msg);
|
|
mLogger.log(Level.SEVERE, msg);
|
|
throw me;
|
|
}
|
|
|
|
try {
|
|
rs.close();
|
|
} catch (SQLException e) {
|
|
mLogger.log(Level.WARNING,
|
|
JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00727.JDBCDN_CursorLeak") + procName);
|
|
}
|
|
paramsCache.storeMetadata(dbURL, opMetaData, params);
|
|
}
|
|
|
|
|
|
for (int i = 0; i < params.size(); ++i) {
|
|
if (mLogger.isLoggable(Level.FINE))
|
|
mLogger.log(Level.FINE,
|
|
JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00719.JDBCDN_ProcessColumn"));
|
|
CachedQueryParameter param = params.get(i);
|
|
String columnName = param.getName();
|
|
// strip off "@" in front of columnName
|
|
// In case if it is function, for RETURN parameter coulumnName will be null.
|
|
if (columnName != null && columnName.charAt(0) == '@')
|
|
columnName = columnName.substring(1);
|
|
|
|
int targetSqlType = param.getType();
|
|
int colType = param.getDirection();
|
|
String type_Name = param.getTypeName();
|
|
short numericScale = param.getPrecision();
|
|
|
|
final int columnNumber = i + 1;
|
|
if (colType == DatabaseMetaData.procedureColumnIn) {
|
|
if ((targetSqlType == 1111) && (type_Name.equals(
|
|
"PL/SQL TABLE")))
|
|
targetSqlType = -14;
|
|
|
|
if ((targetSqlType == 1111) && (type_Name.equals(
|
|
"PL/SQL RECORD")))
|
|
targetSqlType = -14;
|
|
|
|
if ((targetSqlType == 1111) && (type_Name.equals("CLOB")))
|
|
targetSqlType = 2005;
|
|
|
|
if ((targetSqlType == 1111) && (type_Name.equals("NVARCHAR2")))
|
|
targetSqlType = 12;
|
|
final Element columnElem = findMatchingColumnElement(
|
|
columnName,
|
|
tableElem, mRecordPrefix); //113494
|
|
|
|
if (columnElem != null) {
|
|
final String value = DOMUtils.getChildCharacterData(
|
|
columnElem);
|
|
String isNull = "";
|
|
try {
|
|
isNull = columnElem.getAttribute("isNull");
|
|
} catch (Exception e) {
|
|
mLogger.log(Level.FINE, JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00722.JDBCDN_IsNullNotSet"));
|
|
}
|
|
if (((value != null) && !value.trim().equals("")) || (!isNull.
|
|
equalsIgnoreCase("true")))
|
|
if (dbmeta.getDriverName().toLowerCase().contains(
|
|
"oracle") && targetSqlType == java.sql.Types.BLOB)
|
|
cs.setBinaryStream(columnNumber,
|
|
(java.io.ByteArrayInputStream) JDBCUtil.convert(value,
|
|
targetSqlType, cs.getConnection()), value.length());
|
|
else if (dbmeta.getDriverName().toLowerCase().
|
|
contains("oracle") && targetSqlType == java.sql.Types.CLOB)
|
|
cs.setCharacterStream(columnNumber,
|
|
(java.io.StringReader) JDBCUtil.convert(
|
|
value, targetSqlType, cs.getConnection()),
|
|
value.length());
|
|
else
|
|
cs.setObject(columnNumber,
|
|
JDBCUtil.convert(value, targetSqlType,
|
|
cs.getConnection()), targetSqlType);
|
|
else
|
|
cs.setNull(columnNumber, targetSqlType);
|
|
}//end of if
|
|
}//end of if
|
|
|
|
if (colType == DatabaseMetaData.procedureColumnInOut || colType == DatabaseMetaData.procedureColumnOut)
|
|
try {
|
|
// if the parameter is a cursor type, add its index to the arraylist
|
|
if ((targetSqlType == 1111) && (type_Name.equals(
|
|
"REF CURSOR"))) {
|
|
targetSqlType = -10;
|
|
cs.registerOutParameter(columnNumber, targetSqlType);
|
|
} else if ((targetSqlType == 1111) && (type_Name.equals("CLOB"))) {
|
|
targetSqlType = 2005;
|
|
cs.registerOutParameter(columnNumber, targetSqlType,
|
|
type_Name);
|
|
} else if (dbmeta.getDatabaseProductName().
|
|
toLowerCase().contains("oracle"))
|
|
cs.registerOutParameter(columnNumber, targetSqlType);
|
|
else
|
|
cs.registerOutParameter(columnNumber, targetSqlType,
|
|
type_Name);
|
|
outParamIndex.add(Integer.valueOf(Double.valueOf(
|
|
columnNumber).intValue()));
|
|
outParamTypes.put(columnNumber, type_Name);
|
|
outParamNames.put(columnNumber, columnName);
|
|
} catch (SQLException e) {
|
|
if (mLogger.isLoggable(Level.FINE))
|
|
mLogger.log(Level.WARNING, e.getLocalizedMessage(),
|
|
e);
|
|
else if (mLogger.isLoggable(Level.INFO))
|
|
mLogger.log(Level.WARNING, e.getLocalizedMessage());
|
|
throw e;
|
|
}
|
|
|
|
// check if the parameter is RETURN type (i.e. it is a function)
|
|
if (colType == DatabaseMetaData.procedureColumnReturn)
|
|
try {
|
|
// if the parameter is a cursor type, add its index to the arraylist
|
|
if ((targetSqlType == 1111) && (type_Name.equals(
|
|
"REF CURSOR"))) {
|
|
targetSqlType = -10;
|
|
cs.registerOutParameter(columnNumber, targetSqlType);
|
|
} else if ((dbmeta.getDatabaseProductName().
|
|
toLowerCase().contains("sql server") ||
|
|
dbmeta.getDatabaseProductName().
|
|
toLowerCase().contains("adaptive server")) &&
|
|
columnName.equals("RETURN_VALUE"))
|
|
cs.registerOutParameter(columnNumber, targetSqlType,
|
|
type_Name);
|
|
else
|
|
cs.registerOutParameter(columnNumber, targetSqlType,
|
|
numericScale);
|
|
|
|
outParamIndex.add(Integer.valueOf(Double.valueOf(
|
|
columnNumber).intValue()));
|
|
outParamTypes.put(columnNumber, type_Name);
|
|
//columnName will be null for RETURN type. However DB BC wizard puts it as param1.
|
|
//So hardcoding it so that normalizes return value.
|
|
if (columnName == null)
|
|
columnName = "param1";
|
|
outParamNames.put(columnNumber, columnName);
|
|
} catch (SQLException e) {
|
|
if (mLogger.isLoggable(Level.FINE))
|
|
mLogger.log(Level.WARNING, e.getLocalizedMessage(),
|
|
e);
|
|
else if (mLogger.isLoggable(Level.INFO))
|
|
mLogger.log(Level.WARNING, e.getLocalizedMessage());
|
|
throw e;
|
|
}
|
|
|
|
//i++;
|
|
if (mLogger.isLoggable(Level.FINEST)) {
|
|
mLogger.log(Level.FINEST,
|
|
JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00717.JDBCDN_ColumnName") + " == " + columnName);
|
|
mLogger.log(Level.FINEST,
|
|
JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00718.JDBCDN_ColumnType") + " == " + type_Name);
|
|
}
|
|
|
|
}//end of While
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param tableElem
|
|
* @param opMetaData
|
|
* @param ps
|
|
* @throws SQLException
|
|
* @throws MessagingException
|
|
* @throws Exception
|
|
*/
|
|
private void populatePreparedStatement(final Element tableElem, String dbName,
|
|
final OperationMetaData opMetaData, final PreparedStatement ps)
|
|
throws SQLException, MessagingException, Exception {
|
|
/*
|
|
* Modified by Logicoy for [ task #20 ] DB BC - Insert statement should return primary key auto-increment value inserted
|
|
*/
|
|
DatabaseMetaData dbMeta = ps.getConnection().getMetaData();
|
|
|
|
final JDBCOperationInput jdbcSql = opMetaData.getJDBCSql();
|
|
|
|
/**
|
|
/*
|
|
* Modified by Logicoy for [ task #20 ] DB BC - Insert statement should return primary key auto-increment value inserted
|
|
*
|
|
* When generatedKey is specified, parameterMetaData's count includes the generatedKey's parameter also.
|
|
* So we need to reduce the param count value by 1 so that it matches the number of columns specified in paramOrder.
|
|
* This is applicable only for Oracle.
|
|
*/
|
|
String generatedKey = jdbcSql.getGeneratedKey();
|
|
boolean isOracle = dbMeta.getDriverName().toLowerCase().contains(
|
|
"oracle");
|
|
boolean reduceParamCountFromParamMetaData = false;
|
|
if (generatedKey != null && !generatedKey.equals("") && isOracle)
|
|
reduceParamCountFromParamMetaData = true;
|
|
/* Logicoy - changes ends here */
|
|
|
|
if (mLogger.isLoggable(Level.FINE))
|
|
mLogger.log(Level.FINE, JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00720.JDBCDN_StartPopulatePS"));
|
|
|
|
if (jdbcSql != null) {
|
|
|
|
//113494 start
|
|
mRecordPrefix = opMetaData.getJDBCSql().getTableName();
|
|
// see if the table name is null (SQL SE)
|
|
// then take the query name as the prefix
|
|
if (mRecordPrefix == null) {
|
|
mRecordPrefix = opMetaData.getJDBCOperationOutput().getName();
|
|
mRecordPrefix = mRecordPrefix.substring(0,
|
|
mRecordPrefix.indexOf("Response"));
|
|
}
|
|
|
|
//113494 end
|
|
ArrayList<CachedQueryParameter> paramsList =
|
|
ParamMetadataCache.instance().getMetadata(dbMeta.getURL(),
|
|
opMetaData);
|
|
if (paramsList == null) {
|
|
ParameterMetaData paramMetaData = null;
|
|
try {
|
|
paramMetaData = ps.getParameterMetaData();
|
|
} catch (final SQLException ex) {
|
|
mLogger.log(Level.WARNING, ex.getLocalizedMessage());
|
|
}
|
|
|
|
if (paramMetaData != null) {
|
|
/*
|
|
* Modified by Logicoy for [ task #20 ] DB BC - Insert statement should return primary key auto-increment value inserted
|
|
*/
|
|
/**
|
|
* Modified by Logicoy.
|
|
* When generatedKey is specified, parameterMetaData's count includes the generatedKey's parameter also.
|
|
* So we need to reduce the param count value by 1 so that it matches the number of columns specified in paramOrder.
|
|
* This is applicable only for Oracle.
|
|
*/
|
|
int parameters = paramMetaData.getParameterCount();
|
|
|
|
if (reduceParamCountFromParamMetaData)
|
|
parameters = parameters - 1;
|
|
|
|
|
|
if (parameters > 0) {// If there are no parameter we do not need to set anything /* Logicoy - changes ends here */
|
|
// on Prepared statement
|
|
String paramOrder = jdbcSql.getParamOrder();
|
|
|
|
// changed for SQLSE since the user cannot enter param
|
|
// ordering in sqlprojects.
|
|
// we should generate a default param ordering.
|
|
if (paramOrder == null || paramOrder.trim().equals(""))
|
|
paramOrder = getDefaultParameterOrderString(
|
|
parameters);
|
|
|
|
final List columns = extractColumns(paramOrder);
|
|
|
|
if (mLogger.isLoggable(Level.FINE))
|
|
mLogger.log(Level.FINE,
|
|
JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00722.JDBCDN_TotalColumns") + columns.size());
|
|
|
|
paramsList =
|
|
cacheQueryParameters(columns, paramMetaData,
|
|
reduceParamCountFromParamMetaData);
|
|
|
|
} else
|
|
paramsList = cacheEmptyQueryParams();
|
|
|
|
ParamMetadataCache.instance().storeMetadata(dbMeta.getURL(),
|
|
opMetaData, paramsList);
|
|
}
|
|
}
|
|
if (paramsList != null)
|
|
for (int i = 0; i < paramsList.size(); i++) {
|
|
if (mLogger.isLoggable(Level.FINE))
|
|
mLogger.log(Level.FINE, JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00724.JDBCDN_ProcessParam"));
|
|
|
|
CachedQueryParameter param = paramsList.get(i);
|
|
final String columnName = param.getName();
|
|
final int columnNumber = i + 1;
|
|
final Element columnElement = findMatchingColumnElement(
|
|
columnName, tableElem, mRecordPrefix); //113494 Issue
|
|
|
|
if (columnElement != null) {
|
|
final String value = DOMUtils.getChildCharacterData(
|
|
columnElement);
|
|
String isNull = "";
|
|
String isDefaultColumn = "";
|
|
try {
|
|
isNull = columnElement.getAttribute("isNull");
|
|
} catch (Exception e) {
|
|
mLogger.log(Level.FINE, JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00722.JDBCDN_IsNullNotSet"));
|
|
}
|
|
|
|
try {
|
|
isDefaultColumn = columnElement.getAttribute(
|
|
"isDefaultColumn");
|
|
} catch (Exception e) {
|
|
mLogger.log(Level.FINE, JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_R00723.JDBCDN_IsDefaultNotSet"));
|
|
}
|
|
/*
|
|
* Modified by Logicoy Inc.,
|
|
* Open ESB Bug No: 107 - Throws error during insert when any of the parameter has empty value
|
|
* The below condition checks if value is not empty, not isNull and not isDefault. Changed the OR condition (BUG) to AND condition
|
|
*
|
|
*/
|
|
if ((((value != null) && !value.trim().equals("")) && (!isNull.equalsIgnoreCase("true"))) &&
|
|
(((value != null) && !value.trim().equals("")) && (!isDefaultColumn.equalsIgnoreCase("true")))) {
|
|
/*
|
|
* Logiocy Inc.,
|
|
* Bug 107 - changes ends here
|
|
*/
|
|
int columnType = param.getType();
|
|
if (ps.getConnection().getMetaData().getDriverName().
|
|
toLowerCase().contains("oracle") && columnType == java.sql.Types.BLOB)
|
|
ps.setBinaryStream(columnNumber,
|
|
(java.io.ByteArrayInputStream) JDBCUtil.convert(value,
|
|
columnType, ps.getConnection()), value.length());
|
|
else if (ps.getConnection().getMetaData().
|
|
getDriverName().toLowerCase().contains(
|
|
"oracle") && columnType == java.sql.Types.CLOB)
|
|
ps.setCharacterStream(columnNumber,
|
|
(java.io.StringReader) JDBCUtil.convert(
|
|
value, columnType, ps.getConnection()),
|
|
value.length());
|
|
else
|
|
ps.setObject(columnNumber, JDBCUtil.convert(
|
|
value, columnType, ps.getConnection()),
|
|
columnType);
|
|
|
|
if (mLogger.isLoggable(Level.FINEST)) {
|
|
mLogger.log(Level.FINEST,
|
|
mMessages.getString(
|
|
"DBBC_R00717.JDBCDN_ColumnName") + " == " + columnName);
|
|
mLogger.log(Level.FINEST,
|
|
mMessages.getString(
|
|
"DBBC_R00726.JDBCDN_ColumnType") + " == " + columnType);
|
|
}
|
|
|
|
} else {
|
|
int columnType = param.getType();
|
|
|
|
if ((!isNull.equalsIgnoreCase("true")) && (isDefaultColumn != null && isDefaultColumn.
|
|
equalsIgnoreCase("true"))) {
|
|
if (!param.defaultSet()) {
|
|
ResultSet rs = ps.getConnection().
|
|
getMetaData().getColumns(null, null,
|
|
jdbcSql.getTableName(), "%");
|
|
while (rs.next())
|
|
if (columnName.equalsIgnoreCase(rs.getString("COLUMN_NAME")) && rs.
|
|
getString("COLUMN_DEF") != null)
|
|
//ps.setObject(columnNumber, JDBCUtil.convert(rs.getString("COLUMN_DEF"), columnType, ps.getConnection()), columnType);
|
|
param.setDefault(rs.getString(
|
|
"COLUMN_DEF"));
|
|
param.setDefault(null);
|
|
}
|
|
|
|
if (param.hasDefault())
|
|
ps.setObject(columnNumber, JDBCUtil.convert(
|
|
param.getDefault(), columnType, ps.getConnection()),
|
|
columnType);
|
|
else
|
|
ps.setNull(columnNumber, columnType);
|
|
|
|
} else
|
|
ps.setNull(columnNumber, columnType);
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
else {
|
|
final String msg = mMessages.getString(
|
|
"DBBC_E00714.JDBCDN_Failed_PS_Param");
|
|
throw new MessagingException(msg);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param dbColumnName
|
|
* @param tableElem
|
|
* @return
|
|
*/
|
|
private Element findMatchingColumnElement(final String dbColumnName,
|
|
final Element tableElem, String recordPrefix) { // 113494 Issue
|
|
Element columnElem = null;
|
|
NodeList childNodes = tableElem.getChildNodes();
|
|
|
|
for (int i = 0; i < childNodes.getLength(); i++) {
|
|
final Node child = childNodes.item(i);
|
|
if ((child instanceof Element) &&
|
|
child.getLocalName().equalsIgnoreCase(
|
|
recordPrefix + "_Record")) { // 113494 Issue
|
|
if (mLogger.isLoggable(Level.FINEST))
|
|
mLogger.log(Level.FINEST, recordPrefix + "_Record");
|
|
columnElem = (Element) child;
|
|
childNodes = columnElem.getChildNodes();
|
|
}
|
|
}
|
|
for (int i = 0; i < childNodes.getLength(); i++) {
|
|
final Node child = childNodes.item(i);
|
|
if ((child instanceof Element) &&
|
|
child.getLocalName().equalsIgnoreCase(dbColumnName)) {
|
|
columnElem = (Element) child;
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
if (null == columnElem) {
|
|
//throw new MessagingException(String.format(JDBCDenormalizer.mMessages.getString("DBBC_E00727.JDBCDN_FailedFindColumnElem"), dbColumnName));
|
|
columnElem =
|
|
tableElem.getOwnerDocument().createElement(dbColumnName);
|
|
columnElem.setAttribute("isNull", "true");
|
|
}
|
|
|
|
return columnElem;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param paramOrder
|
|
* @return
|
|
*/
|
|
private List<String> extractColumns(final String paramOrder) {
|
|
final List<String> columnList = new ArrayList<String>();
|
|
|
|
if (paramOrder != null) {
|
|
final Scanner tok = new Scanner(paramOrder).useDelimiter(
|
|
"\\s*" + "," + "\\s*");
|
|
|
|
while (tok.hasNext()) {
|
|
final String column = tok.next();
|
|
columnList.add(column.trim());
|
|
}
|
|
|
|
}
|
|
|
|
return columnList;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param parent
|
|
* @param msgQName
|
|
* @return
|
|
*/
|
|
private Element findChildElement(final Element parent,
|
|
final QName msgQName) {
|
|
final String ns = msgQName.getNamespaceURI();
|
|
final String localName = msgQName.getLocalPart();
|
|
NodeList nl = null;
|
|
|
|
if ((ns != null) && !ns.trim().equals(""))
|
|
nl = parent.getElementsByTagNameNS(ns, localName);
|
|
else
|
|
nl = parent.getElementsByTagName(localName);
|
|
|
|
if ((nl != null) && (nl.getLength() > 0)) {
|
|
if (JDBCDenormalizer.mLogger.isLoggable(Level.INFO))
|
|
JDBCDenormalizer.mLogger.log(Level.INFO, "found element");
|
|
|
|
if (JDBCDenormalizer.mLogger.isLoggable(Level.FINEST))
|
|
JDBCDenormalizer.mLogger.log(Level.FINEST,
|
|
"found element with name, " + localName);
|
|
|
|
final Element e2 = (Element) nl.item(0);
|
|
|
|
return e2;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param root
|
|
* @param elemName
|
|
* @return
|
|
*/
|
|
private Element findPart(final Element root,
|
|
final String elemName) {
|
|
// parts wrappers never have namespace
|
|
final NodeList nl = root.getElementsByTagName(elemName);
|
|
|
|
if ((nl != null) && (nl.getLength() > 0)) {
|
|
if (JDBCDenormalizer.mLogger.isLoggable(Level.INFO))
|
|
JDBCDenormalizer.mLogger.log(Level.INFO,
|
|
"found element with name, " + elemName);
|
|
|
|
final Element e2 = (Element) nl.item(0);
|
|
|
|
return e2;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
** Used by SQLSE to get the default parameter ordering.
|
|
* @param pmeta
|
|
* @return
|
|
*/
|
|
/*
|
|
* Modified by Logicoy for [ task #20 ] DB BC - Insert statement should return primary key auto-increment value inserted
|
|
*/
|
|
/**
|
|
* Modified by Logicoy
|
|
* Refactored this method to pass the parameterMetaData's count instead of passing the ParameterMetaDataObject itself
|
|
* since we only need the count value.
|
|
*/
|
|
private String getDefaultParameterOrderString(int numParams) {
|
|
String parameterOrderString = null;
|
|
//int numParams = 0;
|
|
|
|
//if (pmeta != null) {
|
|
/*try {
|
|
numParams = pmeta.getParameterCount();
|
|
} catch (final SQLException sqle) {
|
|
JDBCDenormalizer.mLogger.log(Level.WARNING,
|
|
JDBCDenormalizer.mMessages.getString("JDBCDN_Failed_ParamCount"));
|
|
|
|
return null;
|
|
}*/
|
|
|
|
if (numParams > 0)
|
|
for (int i = 1; i <=
|
|
numParams; i++) {
|
|
final String paramname = "param" + String.valueOf(i);
|
|
parameterOrderString =
|
|
(parameterOrderString == null)
|
|
? paramname : (parameterOrderString + "," + paramname);
|
|
}
|
|
//}
|
|
|
|
return parameterOrderString;
|
|
}
|
|
//register out parameters
|
|
|
|
private void registerOutParameters(CallableStatement cstmt, final DatabaseMetaData dbmeta)
|
|
throws SQLException, NullPointerException {
|
|
String errMsg = "";
|
|
int colCount = 0;
|
|
boolean isFunction = false;
|
|
boolean hasParameters = true;
|
|
// indicates if the procedure is within a package or standalone
|
|
boolean isPackaged = true;
|
|
ArrayList paramIndices = new ArrayList();
|
|
ArrayList result = new ArrayList();
|
|
int paramIndex = 0;
|
|
try {
|
|
ParameterMetaData pmeta = cstmt.getParameterMetaData();
|
|
if (pmeta != null) {
|
|
int numParams = pmeta.getParameterCount();
|
|
if (numParams > 0)
|
|
// get info for each parameter
|
|
for (int i = 1; i <=
|
|
numParams; i++) {
|
|
// try to get the sql type info - default to VARCHAR
|
|
String sqlType = "VARCHAR";
|
|
try {
|
|
sqlType = DBMetaData.getSQLTypeDescription(pmeta.getParameterType(
|
|
i));
|
|
} catch (SQLException e) {
|
|
mLogger.log(Level.WARNING,
|
|
"Could not get SQL Type Description from DBMetadata",
|
|
e.getLocalizedMessage());
|
|
}
|
|
|
|
// try to get the java type info - default to String
|
|
/**
|
|
* Changing it to not use metadata class name and instead use the HashMap SQLTOJAVATYPES.
|
|
* Without the change the parameter datatypes java.lang.Double and WSDLGenerator look up list
|
|
* exepects native type double, float, short etc.
|
|
**/
|
|
String javaType = "java.lang.String";
|
|
javaType =
|
|
DBMetaData.getJavaFromSQLTypeDescription(sqlType);
|
|
|
|
// added abey for Procedure ResultSet
|
|
try {
|
|
if ((pmeta.getParameterType(i) == java.sql.Types.OTHER) && (pmeta.
|
|
getParameterTypeName(i).equalsIgnoreCase(
|
|
"REF CURSOR"))) {
|
|
sqlType = "RESULTSET";
|
|
javaType =
|
|
"java.sql.ResultSet";
|
|
}
|
|
|
|
} catch (SQLException e) {
|
|
mLogger.log(Level.WARNING,
|
|
"Could not get Java type information from DBMetadata",
|
|
e.getLocalizedMessage());
|
|
}
|
|
|
|
// try to get the param type, default to IN
|
|
// always default it since getParameterMode() in data direct 3.3 throws exception
|
|
// and 3.4 return UNKNOWN type
|
|
String paramType = "IN";
|
|
|
|
try {
|
|
paramType = DBMetaData.getPrepStmtParamTypeDescription(pmeta.
|
|
getParameterMode((i)));
|
|
} catch (SQLException e) {
|
|
mLogger.log(Level.WARNING,
|
|
"Could not get PreparedStatement Parameter Description",
|
|
e.getLocalizedMessage());
|
|
}
|
|
|
|
// set defalut type
|
|
int sqlTypeCode = java.sql.Types.VARCHAR;
|
|
if (paramType.equalsIgnoreCase("INOUT") || paramType.
|
|
equalsIgnoreCase("OUT"))
|
|
try {
|
|
|
|
// if the parameter is a cursor type, add its index to the arraylist
|
|
if ((pmeta.getParameterType(i) == 1111) && (paramType.equals(
|
|
"OTHER")))
|
|
sqlTypeCode = java.sql.Types.OTHER;
|
|
|
|
} catch (SQLException e) {
|
|
mLogger.log(Level.WARNING,
|
|
"Driver Does not support getting the Datatypes",
|
|
e.getLocalizedMessage());
|
|
}
|
|
if (paramType.equals("RETURN"))
|
|
try {
|
|
// if the parameter is a cursor type, add its index to the arraylist
|
|
if ((pmeta.getParameterType(i) == 1111) && (paramType.equals(
|
|
"OTHER"))) {
|
|
//sqlTypeCode = java.sql.Types.OTHER;
|
|
}
|
|
|
|
} catch (SQLException e) {
|
|
mLogger.log(Level.WARNING,
|
|
"Driver Does not support getting the Datatypes",
|
|
e.getLocalizedMessage());
|
|
}
|
|
cstmt.registerOutParameter(paramIndex, sqlTypeCode);
|
|
outParamIndex.add(Integer.valueOf(Double.valueOf(
|
|
paramIndex).intValue()));
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
} catch (SQLException e) {
|
|
mLogger.log(Level.WARNING, "Could not get Parameter MetaData", e);
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
private String getProcName(String sqlText) {
|
|
String proc_name = "";
|
|
String schema = "";
|
|
final Scanner tok = new Scanner(sqlText).useDelimiter("\\s*" + " " + "\\s*");
|
|
|
|
while (tok.hasNext()) {
|
|
String column = tok.next();
|
|
int cnt = 0;
|
|
column=column.toLowerCase();
|
|
if(column.endsWith("call")){
|
|
cnt++;
|
|
proc_name=tok.next();
|
|
if(proc_name.contains(".")){
|
|
final Scanner tok1 = new Scanner(proc_name).useDelimiter("\\s*" + "." + "\\s*");
|
|
schema=tok1.next();
|
|
proc_name=tok1.next();
|
|
}
|
|
if(proc_name.contains("(")){
|
|
int i = proc_name.indexOf("(");
|
|
proc_name=proc_name.substring(0, i);
|
|
}
|
|
if(proc_name.contains("}")){
|
|
int i = proc_name.indexOf("}");
|
|
proc_name=proc_name.substring(0, i);
|
|
}
|
|
}
|
|
if(cnt>0)
|
|
break;
|
|
}
|
|
return proc_name;
|
|
}
|
|
*/
|
|
public String getProcName(
|
|
String sqlText) {
|
|
String proc_name = "";
|
|
String schema = "";
|
|
final StringTokenizer tok = new StringTokenizer(sqlText, " ");
|
|
|
|
while (tok.hasMoreElements()) {
|
|
String column = (String) tok.nextElement();
|
|
int cnt = 0;
|
|
column =
|
|
column.toLowerCase();
|
|
if (column.endsWith("call")) {
|
|
cnt++;
|
|
proc_name =
|
|
(String) tok.nextElement();
|
|
if (proc_name.contains(".")) {
|
|
//final StringTokenizer tok1 = new StringTokenizer(proc_name, ".");
|
|
//catalog = tok1.nextToken();
|
|
//final String beforeDot1 = tok1.nextToken();
|
|
//proc_name = tok1.nextToken();
|
|
String[] procData = proc_name.split("\\.");
|
|
final int len = procData.length;
|
|
proc_name =
|
|
procData[len - 1];
|
|
String catName = null;
|
|
String schemaName = null;
|
|
if (len == 3) {
|
|
catName = procData[0];
|
|
schemaName =
|
|
procData[1];
|
|
} else
|
|
schemaName = procData[0];
|
|
|
|
if (driverName_.toLowerCase().contains("oracle")) {
|
|
catalog = schemaName;
|
|
dbName =
|
|
catName;
|
|
} else {
|
|
catalog = catName;
|
|
dbName =
|
|
schemaName;
|
|
}
|
|
|
|
}
|
|
if (proc_name.contains("(")) {
|
|
int i = proc_name.indexOf("(");
|
|
proc_name =
|
|
proc_name.substring(0, i);
|
|
}
|
|
|
|
if (proc_name.contains("}")) {
|
|
int i = proc_name.indexOf("}");
|
|
proc_name =
|
|
proc_name.substring(0, i);
|
|
}
|
|
|
|
}
|
|
if (cnt > 0)
|
|
break;
|
|
|
|
}
|
|
return proc_name;
|
|
}
|
|
|
|
private final Element transformMessage(final NormalizedMessage normalizedMessage,
|
|
final OperationMetaData opMetaData) throws MessagingException {
|
|
Element element = null;
|
|
try {
|
|
final TransformerFactory tFactory = TransformerFactory.newInstance();
|
|
final Transformer trans = tFactory.newTransformer();
|
|
final Source source = normalizedMessage.getContent();
|
|
final DOMResult result = new DOMResult();
|
|
trans.transform(source, result);
|
|
|
|
if (source instanceof StreamSource) {
|
|
StreamSource stream = (StreamSource) source;
|
|
InputStream inputStream = stream.getInputStream();
|
|
if (inputStream != null)
|
|
inputStream.reset();
|
|
|
|
Reader reader = stream.getReader();
|
|
if (reader != null)
|
|
reader.reset();
|
|
|
|
}
|
|
|
|
final Node node = result.getNode();
|
|
final StringWriter strWriter = new StringWriter();
|
|
final StreamResult sResult = new StreamResult(strWriter);
|
|
trans.transform(source, sResult);
|
|
|
|
if (source instanceof StreamSource) {
|
|
StreamSource stream = (StreamSource) source;
|
|
InputStream inputStream = stream.getInputStream();
|
|
if (inputStream != null)
|
|
inputStream.reset();
|
|
|
|
Reader reader = stream.getReader();
|
|
if (reader != null)
|
|
reader.reset();
|
|
|
|
}
|
|
if (node != null) {
|
|
Document normalDoc = null;
|
|
|
|
if (node instanceof Document)
|
|
normalDoc = (Document) node;
|
|
else
|
|
normalDoc = ((Element) node).getOwnerDocument();
|
|
|
|
final Element normalRoot = normalDoc.getDocumentElement();
|
|
//final BindingOperation bindingOperation = opMetaData.getBindingOperation();
|
|
final Operation operation = opMetaData.getOperation();
|
|
final Input input = operation.getInput();
|
|
final Message inputMessage = input.getMessage();
|
|
|
|
if (HelperFactory.WRAPPER_ENABLED) {
|
|
final WrapperParser wrapperParser = HelperFactory.createParser();
|
|
wrapperParser.parse(normalDoc, inputMessage);
|
|
|
|
final Map parts = inputMessage.getParts();
|
|
final Iterator it = parts.values().iterator();
|
|
|
|
while (it.hasNext()) {
|
|
final Part part = (Part) it.next();
|
|
|
|
if (wrapperParser.hasPart(part.getName())) {
|
|
final QName elementQName = part.getElementName();
|
|
|
|
if (elementQName == null) {
|
|
final String msgEx = JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_E00706.DN_Failed_Denormalize") +
|
|
part.getName() +
|
|
"should have element attribute defined.";
|
|
throw new MessagingException(msgEx);
|
|
}
|
|
|
|
//Element element = null;
|
|
final NodeList unwrappedList = wrapperParser.getPartNodes(part.
|
|
getName());
|
|
|
|
for (int j = 0;
|
|
j < unwrappedList.getLength();
|
|
j++) {
|
|
final Node unwrapped = unwrappedList.item(j);
|
|
|
|
if ((unwrapped.getNodeType() == Node.ELEMENT_NODE) &&
|
|
(unwrapped.getLocalName() != null) &&
|
|
unwrapped.getLocalName().equals(elementQName.
|
|
getLocalPart())) {
|
|
element = (Element) unwrapped;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*if (element != null) {
|
|
populateProcedure(element, opMetaData,
|
|
dbmeta,cs);
|
|
//registerOutParameters(cs);
|
|
} else {
|
|
final String msgEx = JDBCDenormalizer.mMessages.getString(
|
|
"JDBCDN_Failed_Finding_Node") +
|
|
elementQName.getLocalPart() +
|
|
", in the part wrapper";
|
|
JDBCDenormalizer.mLogger.log(Level.WARNING, msgEx);
|
|
throw new MessagingException(msgEx);
|
|
}*/
|
|
}
|
|
}
|
|
} else {
|
|
final Element messageElement = normalRoot;
|
|
|
|
if (messageElement != null) {
|
|
final Map parts = inputMessage.getParts();
|
|
final Iterator it = parts.values().iterator();
|
|
|
|
while (it.hasNext()) {
|
|
final Part part = (Part) it.next();
|
|
|
|
final Element partElement = findPart(messageElement,
|
|
part.getName());
|
|
|
|
if (partElement != null) {
|
|
final QName elementQName = part.getElementName();
|
|
|
|
if (elementQName != null)
|
|
element = findChildElement(partElement,
|
|
elementQName);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (final TransformerConfigurationException ex) {
|
|
final String msg = JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_E00708.DN_Failed_Convert_NM");
|
|
throw new MessagingException(msg, ex);
|
|
} catch (final TransformerException ex) {
|
|
final String msg = JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_E00708.DN_Failed_Convert_NM");
|
|
throw new MessagingException(msg, ex);
|
|
} catch (final Throwable th) {
|
|
final String msg = JDBCDenormalizer.mMessages.getString(
|
|
"DBBC_E00712.DN_Failed_Proc");
|
|
throw new MessagingException(msg, th);
|
|
}
|
|
return element;
|
|
}
|
|
|
|
protected void setDatabaseName(String databaseName) {
|
|
dbName = databaseName;
|
|
}
|
|
|
|
protected ArrayList getOutParamIndex() {
|
|
return outParamIndex;
|
|
}
|
|
|
|
protected HashMap getOutParamTypes() {
|
|
return outParamTypes;
|
|
}
|
|
|
|
protected HashMap getOutParamNames() {
|
|
return outParamNames;
|
|
}
|
|
|
|
/*
|
|
* Modified by Logicoy for [ task #20 ] DB BC - Insert statement should return primary key auto-increment value inserted
|
|
*/
|
|
/*
|
|
* Modified by Logicoy
|
|
* Added reduceParamCountFromParamMetaData
|
|
*/
|
|
protected ArrayList<CachedQueryParameter> cacheQueryParameters(List<String> paramNames, ParameterMetaData paramMeta, boolean reduceParamCountFromParamMetaData) throws SQLException {
|
|
int size = paramNames.size();
|
|
int paramCount = paramMeta.getParameterCount();
|
|
if (reduceParamCountFromParamMetaData)
|
|
paramCount = paramCount - 1;
|
|
if (size != paramCount)
|
|
return null;
|
|
|
|
ArrayList<CachedQueryParameter> params =
|
|
new ArrayList<CachedQueryParameter>(size);
|
|
for (int i = 0; i < size; ++i) {
|
|
final int metaIdx = i + 1;
|
|
String name = paramNames.get(i);
|
|
int type = -1;
|
|
try { //Oracle doesn't support this feature. Shame on them!
|
|
type = paramMeta.getParameterType(metaIdx);
|
|
} catch (SQLException e) {
|
|
type = (int) JDBCUtil.builtInTypes.get(mColNamesTypes.get(name));
|
|
}
|
|
/*String typeName = null;
|
|
try{ // ... and this
|
|
typeName = paramMeta.getParameterTypeName(metaIdx);
|
|
}
|
|
catch(SQLException e){
|
|
}
|
|
int direction = paramMeta.getParameterMode(metaIdx);
|
|
short precision = (short) paramMeta.getPrecision(metaIdx);*/
|
|
CachedQueryParameter cp = new CachedQueryParameter(name, type);
|
|
params.add(cp);
|
|
}
|
|
|
|
return params;
|
|
}
|
|
|
|
protected ArrayList<CachedQueryParameter> cacheEmptyQueryParams() {
|
|
return new ArrayList<CachedQueryParameter>(0);
|
|
}
|
|
|
|
protected ArrayList<CachedQueryParameter> cacheQueryParameters(ResultSet paramsInfo) throws SQLException {
|
|
if (paramsInfo == null)
|
|
return null;
|
|
|
|
ArrayList<CachedQueryParameter> params =
|
|
new ArrayList<CachedQueryParameter>();
|
|
while (paramsInfo.next()) {
|
|
String name = paramsInfo.getString("COLUMN_NAME");
|
|
int type = (int) java.sql.Types.VARCHAR;
|
|
try {
|
|
type = paramsInfo.getInt("DATA_TYPE");
|
|
|
|
} catch (final SQLException e) {
|
|
type = (int) JDBCUtil.builtInTypes.get(mColNamesTypes.get(name));
|
|
if (mLogger.isLoggable(Level.FINEST))
|
|
mLogger.log(Level.WARNING,
|
|
"DBBC_R00723.JDBCDN_DriverNoSupportForMetaData", e);
|
|
else if (mLogger.isLoggable(Level.INFO))
|
|
mLogger.log(Level.WARNING,
|
|
"DBBC_R00723.JDBCDN_DriverNoSupportForMetaData", e.
|
|
getLocalizedMessage());
|
|
|
|
}
|
|
String typeName = "VARCHAR";
|
|
try {
|
|
typeName = paramsInfo.getString("TYPE_NAME");
|
|
} catch (final SQLException e) {
|
|
//typeName = JDBCUtil.builtInTypes.get(mColNamesTypes.get(name));
|
|
if (mLogger.isLoggable(Level.FINEST))
|
|
mLogger.log(Level.WARNING,
|
|
"DBBC_R00723.JDBCDN_DriverNoSupportForMetaData", e);
|
|
else if (mLogger.isLoggable(Level.INFO))
|
|
mLogger.log(Level.WARNING,
|
|
"DBBC_R00723.JDBCDN_DriverNoSupportForMetaData", e.
|
|
getLocalizedMessage());
|
|
|
|
}
|
|
int direction = Integer.valueOf(ParameterMetaData.parameterModeIn);
|
|
try {
|
|
direction = paramsInfo.getInt("COLUMN_TYPE");
|
|
} catch (final SQLException e) {
|
|
if (mLogger.isLoggable(Level.FINEST))
|
|
mLogger.log(Level.WARNING,
|
|
"DBBC_R00723.JDBCDN_DriverNoSupportForMetaData", e);
|
|
else if (mLogger.isLoggable(Level.INFO))
|
|
mLogger.log(Level.WARNING,
|
|
"DBBC_R00723.JDBCDN_DriverNoSupportForMetaData", e.
|
|
getLocalizedMessage());
|
|
|
|
}
|
|
short precision = 0;
|
|
try {
|
|
precision = paramsInfo.getShort("SCALE");
|
|
} catch (final SQLException e) {
|
|
if (mLogger.isLoggable(Level.FINEST))
|
|
mLogger.log(Level.WARNING,
|
|
"DBBC_R00723.JDBCDN_DriverNoSupportForMetaData", e);
|
|
else if (mLogger.isLoggable(Level.INFO))
|
|
mLogger.log(Level.WARNING,
|
|
"DBBC_R00723.JDBCDN_DriverNoSupportForMetaData", e.
|
|
getLocalizedMessage());
|
|
|
|
}
|
|
CachedQueryParameter cp = new CachedQueryParameter(name, type,
|
|
typeName, direction, precision);
|
|
params.add(cp);
|
|
}
|
|
|
|
return params;
|
|
}
|
|
}
|