| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to you under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.jmeter.protocol.jdbc; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.Reader; |
| import java.io.UnsupportedEncodingException; |
| import java.lang.reflect.Field; |
| import java.math.BigDecimal; |
| import java.nio.charset.StandardCharsets; |
| import java.sql.Blob; |
| import java.sql.CallableStatement; |
| import java.sql.Clob; |
| import java.sql.Connection; |
| import java.sql.Date; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.ResultSetMetaData; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| import java.sql.Time; |
| import java.sql.Timestamp; |
| import java.sql.Types; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.apache.commons.io.IOUtils; |
| import org.apache.commons.lang3.StringUtils; |
| import org.apache.jmeter.samplers.SampleResult; |
| import org.apache.jmeter.save.CSVSaveService; |
| import org.apache.jmeter.testelement.AbstractTestElement; |
| import org.apache.jmeter.threads.JMeterVariables; |
| import org.apache.jmeter.util.JMeterUtils; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * A base class for all JDBC test elements handling the basics of a SQL request. |
| * |
| */ |
| public abstract class AbstractJDBCTestElement extends AbstractTestElement { |
| private static final long serialVersionUID = 235L; |
| |
| private static final Logger log = LoggerFactory.getLogger(AbstractJDBCTestElement.class); |
| |
| private static final String COMMA = ","; // $NON-NLS-1$ |
| private static final char COMMA_CHAR = ','; |
| |
| private static final String UNDERSCORE = "_"; // $NON-NLS-1$ |
| |
| // String used to indicate a null value |
| private static final String NULL_MARKER = |
| JMeterUtils.getPropDefault("jdbcsampler.nullmarker","]NULL["); // $NON-NLS-1$ |
| |
| private static final String INOUT = "INOUT"; // $NON-NLS-1$ |
| |
| private static final String OUT = "OUT"; // $NON-NLS-1$ |
| |
| // TODO - should the encoding be configurable? |
| protected static final String ENCODING = StandardCharsets.UTF_8.name(); |
| |
| // key: name (lowercase) from java.sql.Types; entry: corresponding int value |
| private static final Map<String, Integer> mapJdbcNameToInt; |
| // read-only after class init |
| |
| static { |
| // based on e291. Getting the Name of a JDBC Type from javaalmanac.com |
| // http://javaalmanac.com/egs/java.sql/JdbcInt2Str.html |
| mapJdbcNameToInt = new HashMap<>(); |
| |
| //Get all fields in java.sql.Types and store the corresponding int values |
| Field[] fields = java.sql.Types.class.getFields(); |
| for (Field field : fields) { |
| try { |
| String name = field.getName(); |
| Integer value = (Integer) field.get(null); |
| mapJdbcNameToInt.put(name.toLowerCase(java.util.Locale.ENGLISH), value); |
| } catch (IllegalAccessException e) { |
| throw new RuntimeException(e); // should not happen |
| } |
| } |
| } |
| |
| // Query types (used to communicate with GUI) |
| // N.B. These must not be changed, as they are used in the JMX files |
| static final String SELECT = "Select Statement"; // $NON-NLS-1$ |
| static final String UPDATE = "Update Statement"; // $NON-NLS-1$ |
| static final String CALLABLE = "Callable Statement"; // $NON-NLS-1$ |
| static final String PREPARED_SELECT = "Prepared Select Statement"; // $NON-NLS-1$ |
| static final String PREPARED_UPDATE = "Prepared Update Statement"; // $NON-NLS-1$ |
| static final String COMMIT = "Commit"; // $NON-NLS-1$ |
| static final String ROLLBACK = "Rollback"; // $NON-NLS-1$ |
| static final String AUTOCOMMIT_FALSE = "AutoCommit(false)"; // $NON-NLS-1$ |
| static final String AUTOCOMMIT_TRUE = "AutoCommit(true)"; // $NON-NLS-1$ |
| |
| static final String RS_STORE_AS_STRING = "Store as String"; // $NON-NLS-1$ |
| static final String RS_STORE_AS_OBJECT = "Store as Object"; // $NON-NLS-1$ |
| static final String RS_COUNT_RECORDS = "Count Records"; // $NON-NLS-1$ |
| |
| private String query = ""; // $NON-NLS-1$ |
| |
| private String dataSource = ""; // $NON-NLS-1$ |
| |
| private String queryType = SELECT; |
| private String queryArguments = ""; // $NON-NLS-1$ |
| private String queryArgumentsTypes = ""; // $NON-NLS-1$ |
| private String variableNames = ""; // $NON-NLS-1$ |
| private String resultSetHandler = RS_STORE_AS_STRING; |
| private String resultVariable = ""; // $NON-NLS-1$ |
| private String queryTimeout = ""; // $NON-NLS-1$ |
| private String resultSetMaxRows = ""; // $NON-NLS-1$ |
| |
| private static final int MAX_RETAIN_SIZE = JMeterUtils.getPropDefault("jdbcsampler.max_retain_result_size", 64 * 1024); |
| |
| /** |
| * Creates a JDBCSampler. |
| */ |
| protected AbstractJDBCTestElement() { |
| } |
| |
| /** |
| * Execute the test element. |
| * |
| * @param conn a {@link Connection} |
| * @return the result of the execute command |
| * @throws SQLException if a database error occurs |
| * @throws IOException when I/O error occurs |
| * @throws UnsupportedOperationException if the user provided incorrect query type |
| */ |
| protected byte[] execute(Connection conn) throws SQLException, IOException, UnsupportedOperationException { // NOSONAR |
| return execute(conn, new SampleResult()); |
| } |
| |
| /** |
| * Execute the test element. |
| * Use the sample given as argument to set time to first byte in the "latency" field of the SampleResult. |
| * |
| * @param conn a {@link Connection} |
| * @param sample a {@link SampleResult} to save the latency |
| * @return the result of the execute command |
| * @throws SQLException if a database error occurs |
| * @throws IOException when I/O error occurs |
| * @throws UnsupportedOperationException if the user provided incorrect query type |
| */ |
| protected byte[] execute(Connection conn, SampleResult sample) throws SQLException, IOException, UnsupportedOperationException { |
| log.debug("executing jdbc:{}", getQuery()); |
| // Based on query return value, get results |
| String currentQueryType = getQueryType(); |
| if (SELECT.equals(currentQueryType)) { |
| try (Statement stmt = conn.createStatement()) { |
| setQueryTimeout(stmt, getIntegerQueryTimeout()); |
| configureMaxRows(stmt); |
| ResultSet rs = null; |
| try { |
| rs = stmt.executeQuery(getQuery()); |
| sample.latencyEnd(); |
| return getStringFromResultSet(rs).getBytes(ENCODING); |
| } finally { |
| close(rs); |
| } |
| } |
| } else if (CALLABLE.equals(currentQueryType)) { |
| try (CallableStatement cstmt = getCallableStatement(conn)) { |
| int[] out = setArguments(cstmt); |
| // A CallableStatement can return more than 1 ResultSets |
| // plus a number of update counts. |
| boolean hasResultSet = cstmt.execute(); |
| sample.latencyEnd(); |
| String sb = resultSetsToString(cstmt,hasResultSet, out); |
| return sb.getBytes(ENCODING); |
| } |
| } else if (UPDATE.equals(currentQueryType)) { |
| try (Statement stmt = conn.createStatement()) { |
| setQueryTimeout(stmt, getIntegerQueryTimeout()); |
| stmt.executeUpdate(getQuery()); |
| sample.latencyEnd(); |
| int updateCount = stmt.getUpdateCount(); |
| String results = updateCount + " updates"; |
| return results.getBytes(ENCODING); |
| } |
| } else if (PREPARED_SELECT.equals(currentQueryType)) { |
| try (PreparedStatement pstmt = getPreparedStatement(conn)) { |
| setArguments(pstmt); |
| configureMaxRows(pstmt); |
| ResultSet rs = null; |
| try { |
| rs = pstmt.executeQuery(); |
| sample.latencyEnd(); |
| return getStringFromResultSet(rs).getBytes(ENCODING); |
| } finally { |
| close(rs); |
| } |
| } |
| } else if (PREPARED_UPDATE.equals(currentQueryType)) { |
| try (PreparedStatement pstmt = getPreparedStatement(conn)) { |
| setArguments(pstmt); |
| pstmt.executeUpdate(); |
| sample.latencyEnd(); |
| String sb = resultSetsToString(pstmt,false,null); |
| return sb.getBytes(ENCODING); |
| } |
| } else if (ROLLBACK.equals(currentQueryType)){ |
| conn.rollback(); |
| sample.latencyEnd(); |
| return ROLLBACK.getBytes(ENCODING); |
| } else if (COMMIT.equals(currentQueryType)){ |
| conn.commit(); |
| sample.latencyEnd(); |
| return COMMIT.getBytes(ENCODING); |
| } else if (AUTOCOMMIT_FALSE.equals(currentQueryType)){ |
| conn.setAutoCommit(false); |
| sample.latencyEnd(); |
| return AUTOCOMMIT_FALSE.getBytes(ENCODING); |
| } else if (AUTOCOMMIT_TRUE.equals(currentQueryType)){ |
| conn.setAutoCommit(true); |
| sample.latencyEnd(); |
| return AUTOCOMMIT_TRUE.getBytes(ENCODING); |
| } else { // User provided incorrect query type |
| throw new UnsupportedOperationException("Unexpected query type: "+currentQueryType); |
| } |
| } |
| |
| private void configureMaxRows(Statement stmt) throws SQLException { |
| int maxRows = getIntegerResultSetMaxRows(); |
| if (maxRows >= 0) { |
| stmt.setMaxRows(maxRows); |
| } |
| } |
| |
| private String resultSetsToString(PreparedStatement pstmt, boolean result, int[] out) throws SQLException, UnsupportedEncodingException { |
| configureMaxRows(pstmt); |
| StringBuilder sb = new StringBuilder(); |
| int updateCount = 0; |
| boolean currentResult = result; |
| if (!currentResult) { |
| updateCount = pstmt.getUpdateCount(); |
| } |
| do { |
| if (currentResult) { |
| ResultSet rs = null; |
| try { |
| rs = pstmt.getResultSet(); |
| sb.append(getStringFromResultSet(rs)).append("\n"); // $NON-NLS-1$ |
| } finally { |
| close(rs); |
| } |
| } else { |
| sb.append(updateCount).append(" updates.\n"); |
| } |
| currentResult = pstmt.getMoreResults(); |
| if (!currentResult) { |
| updateCount = pstmt.getUpdateCount(); |
| } |
| } while (currentResult || (updateCount != -1)); |
| if (out!=null && pstmt instanceof CallableStatement){ |
| List<Object> outputValues = new ArrayList<>(); |
| CallableStatement cs = (CallableStatement) pstmt; |
| sb.append("Output variables by position:\n"); |
| for(int i=0; i < out.length; i++){ |
| if (out[i]!=java.sql.Types.NULL){ |
| Object o = cs.getObject(i+1); |
| outputValues.add(o); |
| sb.append("["); |
| sb.append(i+1); |
| sb.append("] "); |
| sb.append(o); |
| if( o instanceof java.sql.ResultSet && RS_COUNT_RECORDS.equals(resultSetHandler)) { |
| sb.append(" ").append(countRows((ResultSet) o)).append(" rows"); |
| } |
| sb.append("\n"); |
| } |
| } |
| String[] varnames = getVariableNames().split(COMMA); |
| if(varnames.length > 0) { |
| JMeterVariables jmvars = getThreadContext().getVariables(); |
| for(int i = 0; i < varnames.length && i < outputValues.size(); i++) { |
| String name = varnames[i].trim(); |
| if (name.length()>0){ // Save the value in the variable if present |
| Object o = outputValues.get(i); |
| if( o instanceof java.sql.ResultSet ) { |
| putIntoVar(jmvars, name, (java.sql.ResultSet) o); |
| } else if (o instanceof java.sql.Clob) { |
| putIntoVar(jmvars, name, (java.sql.Clob) o); |
| } else if (o instanceof java.sql.Blob) { |
| putIntoVar(jmvars, name, (java.sql.Blob) o); |
| } |
| else { |
| jmvars.put(name, o == null ? null : o.toString()); |
| } |
| } |
| } |
| } |
| } |
| return sb.toString(); |
| } |
| |
| private void putIntoVar(final JMeterVariables jmvars, final String name, |
| final ResultSet resultSet) throws SQLException { |
| if (RS_STORE_AS_OBJECT.equals(resultSetHandler)) { |
| jmvars.putObject(name, resultSet); |
| } else if (RS_COUNT_RECORDS.equals(resultSetHandler)) { |
| jmvars.put(name, resultSet.toString() + " " + countRows(resultSet) |
| + " rows"); |
| } else { |
| jmvars.put(name, resultSet.toString()); |
| } |
| } |
| |
| private static void putIntoVar(final JMeterVariables jmvars, final String name, |
| final Clob clob) throws SQLException { |
| try { |
| if (clob.length() > MAX_RETAIN_SIZE) { |
| try (Reader reader = clob.getCharacterStream(0,MAX_RETAIN_SIZE)) { |
| jmvars.put( |
| name, |
| IOUtils.toString(reader) |
| + "<result cut off, it is too big>"); |
| } |
| } else { |
| try (Reader reader = clob.getCharacterStream()) { |
| jmvars.put(name, IOUtils.toString(reader)); |
| } |
| } |
| } catch (IOException e) { |
| log.warn("Could not read CLOB into {}", name, e); |
| } |
| } |
| |
| private void putIntoVar(final JMeterVariables jmvars, final String name, |
| final Blob blob) throws SQLException { |
| if (RS_STORE_AS_OBJECT.equals(resultSetHandler)) { |
| try { |
| long length = Math.max(blob.length(), MAX_RETAIN_SIZE); |
| jmvars.putObject(name, |
| IOUtils.toByteArray(blob.getBinaryStream(0, length))); |
| } catch (IOException e) { |
| log.warn("Could not read BLOB into {} as object.", name, e); |
| } |
| } else if (RS_COUNT_RECORDS.equals(resultSetHandler)) { |
| jmvars.put(name, blob.length() + " bytes"); |
| } else { |
| try { |
| long length = Math.max(blob.length(), MAX_RETAIN_SIZE); |
| try (InputStream is = blob.getBinaryStream(0, length)) { |
| jmvars.put(name, IOUtils.toString(is, ENCODING)); |
| } |
| } catch (IOException e) { |
| log.warn("Can't convert BLOB to String using {}", ENCODING, e); |
| } |
| } |
| } |
| |
| /** |
| * Count rows in result set |
| * @param resultSet {@link ResultSet} |
| * @return number of rows in resultSet |
| * @throws SQLException |
| */ |
| private int countRows(ResultSet resultSet) throws SQLException { |
| int resultSetMaxRows = getIntegerResultSetMaxRows(); |
| if (resultSetMaxRows >= 0) { |
| resultSet.absolute(resultSetMaxRows); |
| if (!resultSet.isAfterLast()) { |
| return resultSet.getRow(); |
| } |
| } |
| return resultSet.last() ? resultSet.getRow() : 0; |
| } |
| |
| private int[] setArguments(PreparedStatement pstmt) throws SQLException, IOException { |
| if (getQueryArguments().trim().length()==0) { |
| return new int[]{}; |
| } |
| String[] arguments = CSVSaveService.csvSplitString(getQueryArguments(), COMMA_CHAR); |
| String[] argumentsTypes = getQueryArgumentsTypes().split(COMMA); |
| if (arguments.length != argumentsTypes.length) { |
| throw new SQLException("number of arguments ("+arguments.length+") and number of types ("+argumentsTypes.length+") are not equal"); |
| } |
| int[] outputs= new int[arguments.length]; |
| for (int i = 0; i < arguments.length; i++) { |
| String argument = arguments[i]; |
| String argumentType = argumentsTypes[i]; |
| String[] arg = argumentType.split(" "); |
| String inputOutput=""; |
| if (arg.length > 1) { |
| argumentType = arg[1]; |
| inputOutput=arg[0]; |
| } |
| int targetSqlType = getJdbcType(argumentType); |
| try { |
| if (!OUT.equalsIgnoreCase(inputOutput)){ |
| if (argument.equals(NULL_MARKER)){ |
| pstmt.setNull(i+1, targetSqlType); |
| } else { |
| setArgument(pstmt, argument, targetSqlType, i+1); |
| } |
| } |
| if (OUT.equalsIgnoreCase(inputOutput)||INOUT.equalsIgnoreCase(inputOutput)) { |
| CallableStatement cs = (CallableStatement) pstmt; |
| cs.registerOutParameter(i+1, targetSqlType); |
| outputs[i]=targetSqlType; |
| } else { |
| outputs[i]=java.sql.Types.NULL; // can't have an output parameter type null |
| } |
| } catch (NullPointerException e) { // thrown by Derby JDBC (at least) if there are no "?" markers in statement |
| throw new SQLException("Could not set argument no: "+(i+1)+" - missing parameter marker?", e); |
| } |
| } |
| return outputs; |
| } |
| |
| private static void setArgument(PreparedStatement pstmt, String argument, int targetSqlType, int index) throws SQLException { |
| switch (targetSqlType) { |
| case Types.INTEGER: |
| pstmt.setInt(index, Integer.parseInt(argument)); |
| break; |
| case Types.DECIMAL: |
| case Types.NUMERIC: |
| pstmt.setBigDecimal(index, new BigDecimal(argument)); |
| break; |
| case Types.DOUBLE: |
| case Types.FLOAT: |
| pstmt.setDouble(index, Double.parseDouble(argument)); |
| break; |
| case Types.CHAR: |
| case Types.LONGVARCHAR: |
| case Types.VARCHAR: |
| pstmt.setString(index, argument); |
| break; |
| case Types.BIT: |
| case Types.BOOLEAN: |
| pstmt.setBoolean(index, Boolean.parseBoolean(argument)); |
| break; |
| case Types.BIGINT: |
| pstmt.setLong(index, Long.parseLong(argument)); |
| break; |
| case Types.DATE: |
| pstmt.setDate(index, Date.valueOf(argument)); |
| break; |
| case Types.REAL: |
| pstmt.setFloat(index, Float.parseFloat(argument)); |
| break; |
| case Types.TINYINT: |
| pstmt.setByte(index, Byte.parseByte(argument)); |
| break; |
| case Types.SMALLINT: |
| pstmt.setShort(index, Short.parseShort(argument)); |
| break; |
| case Types.TIMESTAMP: |
| pstmt.setTimestamp(index, Timestamp.valueOf(argument)); |
| break; |
| case Types.TIME: |
| pstmt.setTime(index, Time.valueOf(argument)); |
| break; |
| case Types.BINARY: |
| case Types.VARBINARY: |
| case Types.LONGVARBINARY: |
| pstmt.setBytes(index, argument.getBytes(StandardCharsets.UTF_8)); |
| break; |
| case Types.NULL: |
| pstmt.setNull(index, targetSqlType); |
| break; |
| default: |
| pstmt.setObject(index, argument, targetSqlType); |
| } |
| } |
| |
| |
| private static int getJdbcType(String jdbcType) throws SQLException { |
| Integer entry = mapJdbcNameToInt.get(jdbcType.toLowerCase(java.util.Locale.ENGLISH)); |
| if (entry == null) { |
| try { |
| entry = Integer.decode(jdbcType); |
| } catch (NumberFormatException e) { |
| throw new SQLException("Invalid data type: "+jdbcType, e); |
| } |
| } |
| return entry; |
| } |
| |
| |
| private CallableStatement getCallableStatement(Connection conn) throws SQLException { |
| return (CallableStatement) getPreparedStatement(conn,true); |
| |
| } |
| private PreparedStatement getPreparedStatement(Connection conn) throws SQLException { |
| return getPreparedStatement(conn,false); |
| } |
| |
| private PreparedStatement getPreparedStatement(Connection conn, boolean callable) throws SQLException { |
| PreparedStatement pstmt; |
| if (callable) { |
| pstmt = conn.prepareCall(getQuery()); // NOSONAR closed by caller |
| } else { |
| pstmt = conn.prepareStatement(getQuery()); // NOSONAR closed by caller |
| } |
| setQueryTimeout(pstmt, getIntegerQueryTimeout()); |
| return pstmt; |
| } |
| |
| /** |
| * @param stmt {@link Statement} Statement for which we want to set timeout |
| * @param timeout int timeout value in seconds, if < 0 setQueryTimeout will not be called |
| * @throws SQLException |
| */ |
| private static void setQueryTimeout(Statement stmt, int timeout) throws SQLException { |
| if(timeout >= 0) { |
| stmt.setQueryTimeout(timeout); |
| } |
| } |
| |
| /** |
| * Gets a Data object from a ResultSet. |
| * |
| * @param rs |
| * ResultSet passed in from a database query |
| * @return a Data object |
| * @throws java.sql.SQLException |
| * @throws UnsupportedEncodingException |
| */ |
| private String getStringFromResultSet(ResultSet rs) throws SQLException, UnsupportedEncodingException { |
| ResultSetMetaData meta = rs.getMetaData(); |
| |
| StringBuilder sb = new StringBuilder(); |
| |
| int numColumns = meta.getColumnCount(); |
| for (int i = 1; i <= numColumns; i++) { |
| sb.append(meta.getColumnLabel(i)); |
| if (i==numColumns){ |
| sb.append('\n'); |
| } else { |
| sb.append('\t'); |
| } |
| } |
| |
| |
| JMeterVariables jmvars = getThreadContext().getVariables(); |
| String[] varNames = getVariableNames().split(COMMA); |
| String currentResultVariable = getResultVariable().trim(); |
| List<Map<String, Object> > results = null; |
| if(!currentResultVariable.isEmpty()) { |
| results = new ArrayList<>(); |
| jmvars.putObject(currentResultVariable, results); |
| } |
| int currentIterationIndex = 0; |
| int resultSetMaxRows = getIntegerResultSetMaxRows(); |
| if (resultSetMaxRows < 0) { |
| while (rs.next()) { |
| currentIterationIndex = processRow(rs, meta, sb, numColumns, jmvars, varNames, results, currentIterationIndex); |
| } |
| } else { |
| while (currentIterationIndex < resultSetMaxRows && rs.next()) { |
| currentIterationIndex = processRow(rs, meta, sb, numColumns, jmvars, varNames, results, currentIterationIndex); |
| } |
| } |
| // Remove any additional values from previous sample |
| for (String varName : varNames) { |
| String name = varName.trim(); |
| if (name.length() > 0 && jmvars != null) { |
| final String varCount = name + "_#"; // $NON-NLS-1$ |
| // Get the previous count |
| String prevCount = jmvars.get(varCount); |
| if (prevCount != null) { |
| int prev = Integer.parseInt(prevCount); |
| for (int n = currentIterationIndex + 1; n <= prev; n++) { |
| jmvars.remove(name + UNDERSCORE + n); |
| } |
| } |
| jmvars.put(varCount, Integer.toString(currentIterationIndex)); // save the current count |
| } |
| } |
| |
| return sb.toString(); |
| } |
| |
| private static int processRow(ResultSet rs, ResultSetMetaData meta, StringBuilder sb, int numColumns, |
| JMeterVariables jmvars, String[] varNames, List<? super Map<String, Object>> results, int currentIterationIndex) |
| throws SQLException, UnsupportedEncodingException { |
| Map<String, Object> row = null; |
| currentIterationIndex++; |
| for (int i = 1; i <= numColumns; i++) { |
| Object o = rs.getObject(i); |
| if(results != null) { |
| if(row == null) { |
| row = new HashMap<>(numColumns); |
| results.add(row); |
| } |
| row.put(meta.getColumnLabel(i), o); |
| } |
| if (o instanceof byte[]) { |
| o = new String((byte[]) o, ENCODING); |
| } |
| sb.append(o); |
| if (i==numColumns){ |
| sb.append('\n'); |
| } else { |
| sb.append('\t'); |
| } |
| if (i <= varNames.length) { // i starts at 1 |
| String name = varNames[i - 1].trim(); |
| if (name.length()>0){ // Save the value in the variable if present |
| jmvars.put(name+UNDERSCORE+currentIterationIndex, o == null ? null : o.toString()); |
| } |
| } |
| } |
| return currentIterationIndex; |
| } |
| |
| public static void close(Connection c) { |
| try { |
| if (c != null) { |
| c.close(); |
| } |
| } catch (SQLException e) { |
| log.warn("Error closing Connection", e); |
| } |
| } |
| |
| public static void close(Statement s) { |
| try { |
| if (s != null) { |
| s.close(); |
| } |
| } catch (SQLException e) { |
| log.warn("Error closing Statement {}", s, e); |
| } |
| } |
| |
| public static void close(ResultSet rs) { |
| try { |
| if (rs != null) { |
| rs.close(); |
| } |
| } catch (SQLException e) { |
| log.warn("Error closing ResultSet", e); |
| } |
| } |
| |
| /** |
| * @return the integer representation queryTimeout |
| */ |
| public int getIntegerQueryTimeout() { |
| int timeout; |
| if(StringUtils.isEmpty(queryTimeout)) { |
| return 0; |
| } else { |
| try { |
| timeout = Integer.parseInt(queryTimeout); |
| } catch (NumberFormatException nfe) { |
| timeout = 0; |
| } |
| } |
| return timeout; |
| } |
| |
| /** |
| * @return the queryTimeout |
| */ |
| public String getQueryTimeout() { |
| return queryTimeout ; |
| } |
| |
| /** |
| * @param queryTimeout query timeout in seconds |
| */ |
| public void setQueryTimeout(String queryTimeout) { |
| this.queryTimeout = queryTimeout; |
| } |
| |
| /** |
| * @return the integer representation resultSetMaxRows |
| */ |
| public int getIntegerResultSetMaxRows() { |
| int maxrows; |
| if(StringUtils.isEmpty(resultSetMaxRows)) { |
| return -1; |
| } else { |
| try { |
| maxrows = Integer.parseInt(resultSetMaxRows); |
| } catch (NumberFormatException nfe) { |
| maxrows = -1; |
| } |
| } |
| return maxrows; |
| } |
| |
| /** |
| * @return the resultSetMaxRows |
| */ |
| public String getResultSetMaxRows() { |
| return resultSetMaxRows ; |
| } |
| |
| /** |
| * @param resultSetMaxRows max number of rows to iterate through the ResultSet |
| */ |
| public void setResultSetMaxRows(String resultSetMaxRows) { |
| this.resultSetMaxRows = resultSetMaxRows; |
| } |
| |
| public String getQuery() { |
| return query; |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder(80); |
| sb.append("["); // $NON-NLS-1$ |
| sb.append(getQueryType()); |
| sb.append("] "); // $NON-NLS-1$ |
| sb.append(getQuery()); |
| sb.append("\n"); |
| sb.append(getQueryArguments()); |
| sb.append("\n"); |
| sb.append(getQueryArgumentsTypes()); |
| return sb.toString(); |
| } |
| |
| /** |
| * @param query |
| * The query to set. |
| */ |
| public void setQuery(String query) { |
| this.query = query; |
| } |
| |
| /** |
| * @return Returns the dataSource. |
| */ |
| public String getDataSource() { |
| return dataSource; |
| } |
| |
| /** |
| * @param dataSource |
| * The dataSource to set. |
| */ |
| public void setDataSource(String dataSource) { |
| this.dataSource = dataSource; |
| } |
| |
| /** |
| * @return Returns the queryType. |
| */ |
| public String getQueryType() { |
| return queryType; |
| } |
| |
| /** |
| * @param queryType The queryType to set. |
| */ |
| public void setQueryType(String queryType) { |
| this.queryType = queryType; |
| } |
| |
| public String getQueryArguments() { |
| return queryArguments; |
| } |
| |
| public void setQueryArguments(String queryArguments) { |
| this.queryArguments = queryArguments; |
| } |
| |
| public String getQueryArgumentsTypes() { |
| return queryArgumentsTypes; |
| } |
| |
| public void setQueryArgumentsTypes(String queryArgumentsType) { |
| this.queryArgumentsTypes = queryArgumentsType; |
| } |
| |
| /** |
| * @return the variableNames |
| */ |
| public String getVariableNames() { |
| return variableNames; |
| } |
| |
| /** |
| * @param variableNames the variableNames to set |
| */ |
| public void setVariableNames(String variableNames) { |
| this.variableNames = variableNames; |
| } |
| |
| /** |
| * @return the resultSetHandler |
| */ |
| public String getResultSetHandler() { |
| return resultSetHandler; |
| } |
| |
| /** |
| * @param resultSetHandler the resultSetHandler to set |
| */ |
| public void setResultSetHandler(String resultSetHandler) { |
| this.resultSetHandler = resultSetHandler; |
| } |
| |
| /** |
| * @return the resultVariable |
| */ |
| public String getResultVariable() { |
| return resultVariable ; |
| } |
| |
| /** |
| * @param resultVariable the variable name in which results will be stored |
| */ |
| public void setResultVariable(String resultVariable) { |
| this.resultVariable = resultVariable; |
| } |
| } |
