jdbcsampler.java

测试工具

			}
			result = pstmt.getMoreResults();
			if (!result) {
				updateCount = pstmt.getUpdateCount();
			}
		} while (result || (updateCount != -1));
		if (out!=null && pstmt instanceof CallableStatement){
			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){
					sb.append("[");
					sb.append(i+1);
					sb.append("] ");
					sb.append(cs.getObject(i+1));
					sb.append("\n");
				}
			}
		}
		return sb.toString();
	}


	private int[] setArguments(PreparedStatement pstmt) throws SQLException {
		if (getQueryArguments().trim().length()==0) {
			return new int[]{};
		}
		String[] arguments = getQueryArguments().split(","); // $NON-NLS-1$
		String[] argumentsTypes = getQueryArgumentsTypes().split(","); // $NON-NLS-1$
		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 {
			    		pstmt.setObject(i+1, argument, targetSqlType);
			    	}
		    	}
		    	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?");
			}
		}
		return outputs;
	}
    
    
    private static int getJdbcType(String jdbcType) throws SQLException {
    	Integer entry = (Integer)mapJdbcNameToInt.get(jdbcType.toLowerCase());
    	if (entry == null) {
    		throw new SQLException("Invalid data type: "+jdbcType);
    	}
		return (entry).intValue();
    }
	

	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 {
		Map preparedStatementMap = (Map) perConnCache.get(conn); 
		if (null == preparedStatementMap ) {
		    // MRU PreparedStatements cache. 
			preparedStatementMap = new LinkedHashMap(MAX_ENTRIES) {
				protected boolean removeEldestEntry(java.util.Map.Entry arg0) {
					final int theSize = size();
					if (theSize > MAX_ENTRIES) {
						Object value = arg0.getValue();
						if (value instanceof PreparedStatement) {
							PreparedStatement pstmt = (PreparedStatement) value;
							close(pstmt);
						}
						return true;
					}
					return false;
				}
			};
			perConnCache.put(conn, preparedStatementMap);
		}
		PreparedStatement pstmt = (PreparedStatement) preparedStatementMap.get(getQuery());
		if (null == pstmt) {
			if (callable) {
				pstmt = conn.prepareCall(getQuery());
			} else {
				pstmt = conn.prepareStatement(getQuery());
			}
			preparedStatementMap.put(getQuery(), pstmt);
		}
		pstmt.clearParameters();
		return pstmt;
	}

	private static void closeAllStatements(Collection collection) {
		Iterator iterator = collection.iterator();
		while (iterator.hasNext()) {
			PreparedStatement pstmt = (PreparedStatement) iterator.next();
			close(pstmt);
		}		
	}

	/**
	 * Gets a Data object from a ResultSet.
	 * 
	 * @param rs
	 *            ResultSet passed in from a database query
	 * @return a Data object
	 * @throws java.sql.SQLException
	 */
	private Data getDataFromResultSet(ResultSet rs) throws SQLException {
		ResultSetMetaData meta = rs.getMetaData();
		Data data = new Data();

		int numColumns = meta.getColumnCount();
		String[] dbCols = new String[numColumns];
		for (int i = 0; i < numColumns; i++) {
			dbCols[i] = meta.getColumnName(i + 1);
			data.addHeader(dbCols[i]);
		}

		while (rs.next()) {
			data.next();
			for (int i = 0; i < numColumns; i++) {
				Object o = rs.getObject(i + 1);
				if (o instanceof byte[]) {
					o = new String((byte[]) o);
				}
				data.addColumnValue(dbCols[i], o);
			}
		}
		return data;
	}

	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.toString(), e);
		}
	}

	public static void close(ResultSet rs) {
		try {
			if (rs != null) rs.close();
		} catch (SQLException e) {
			log.warn("Error closing ResultSet", e);
		}
	}

	public String getQuery() {
		return query;
	}

	public String toString() {
        StringBuffer sb = new StringBuffer(80);
        sb.append("["); // $NON-NLS-1$
        sb.append(getQueryType());
        sb.append("] "); // $NON-NLS-1$
        sb.append(getQuery());
		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;
	}
}