001: /*
002: * Copyright 2002-2007 the original author or authors.
003: *
004: * Licensed under the Apache License, Version 2.0 (the "License");
005: * you may not use this file except in compliance with the License.
006: * You may obtain a copy of the License at
007: *
008: * http://www.apache.org/licenses/LICENSE-2.0
009: *
010: * Unless required by applicable law or agreed to in writing, software
011: * distributed under the License is distributed on an "AS IS" BASIS,
012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013: * See the License for the specific language governing permissions and
014: * limitations under the License.
015: */
016:
017: package org.springframework.jdbc.core.simple;
018:
019: import java.util.Arrays;
020: import java.util.HashMap;
021: import java.util.HashSet;
022: import java.util.Map;
023:
024: import javax.sql.DataSource;
025:
026: import org.springframework.jdbc.core.JdbcTemplate;
027: import org.springframework.jdbc.core.SqlParameter;
028: import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
029: import org.springframework.jdbc.core.namedparam.SqlParameterSource;
030:
031: /**
032: * A SimpleJdbcCall is a multi-threaded, reusable object representing a call
033: * to a stored procedure or a stored function. It provides meta data processing
034: * to simplify the code needed to access basic stored procedures/functions.
035: * All you need to provide is the name of the procedure/fumnction and a Map
036: * containing the parameters when you execute the call. The names of the
037: * supplied parameters will be matched up with in and out parameters declared
038: * when the stored procedure was created.
039: *
040: * <p>The meta data processing is based on the DatabaseMetaData provided by
041: * the JDBC driver. Since we rely on the JDBC driver this "auto-detection"
042: * can only be used for databases that are known to provide accurate meta data.
043: * These currently include Derby, MySQL, Microsoft SQL Server, Oracle and DB2.
044: * For any other databases you are required to declare all parameters explicitly.
045: * You can of course declare all parameters explictly even if the database provides
046: * the necessary meta data. In that case your declared parameters will take precedence.
047: * You can also turn off any mete data processing if you want to use parameter names
048: * that do not match what is declared during the stored procedure compilation.
049: *
050: * <p>The actual insert is being handled using Spring's
051: * {@link org.springframework.jdbc.core.JdbcTemplate}.
052: *
053: * <p>Many of the configuration methods return the current instance of the SimpleJdbcCall
054: * to provide the ablity to string multiple ones together in a "fluid" interface style.
055: *
056: * @author Thomas Risberg
057: * @since 2.5
058: * @see java.sql.DatabaseMetaData
059: * @see org.springframework.jdbc.core.JdbcTemplate
060: */
061: public class SimpleJdbcCall extends AbstractJdbcCall implements
062: SimpleJdbcCallOperations {
063:
064: /**
065: * Constructor that takes one parameter with the JDBC DataSource to use when creating the
066: * JdbcTemplate.
067: * @param dataSource the <code>DataSource</code> to use
068: * @see org.springframework.jdbc.core.JdbcTemplate#setDataSource
069: */
070: public SimpleJdbcCall(DataSource dataSource) {
071: super (dataSource);
072: }
073:
074: /**
075: * Alternative Constructor that takes one parameter with the JdbcTemplate to be used.
076: * @param jdbcTemplate the <code>JdbcTemplate</code> to use
077: * @see org.springframework.jdbc.core.JdbcTemplate#setDataSource
078: */
079: public SimpleJdbcCall(JdbcTemplate jdbcTemplate) {
080: super (jdbcTemplate);
081: }
082:
083: public SimpleJdbcCall withProcedureName(String procedureName) {
084: setProcedureName(procedureName);
085: setFunction(false);
086: return this ;
087: }
088:
089: public SimpleJdbcCall withFunctionName(String functionName) {
090: setProcedureName(functionName);
091: setFunction(true);
092: return this ;
093: }
094:
095: public SimpleJdbcCall withSchemaName(String schemaName) {
096: setSchemaName(schemaName);
097: return this ;
098: }
099:
100: public SimpleJdbcCall withCatalogName(String catalogName) {
101: setCatalogName(catalogName);
102: return this ;
103: }
104:
105: public SimpleJdbcCall withReturnValue() {
106: setReturnValueRequired(true);
107: return this ;
108: }
109:
110: public SimpleJdbcCall declareParameters(
111: SqlParameter... sqlParameters) {
112: for (SqlParameter sqlParameter : sqlParameters) {
113: if (sqlParameter != null) {
114: addDeclaredParameter(sqlParameter);
115: }
116: }
117: return this ;
118: }
119:
120: public SimpleJdbcCall useInParameterNames(
121: String... inParameterNames) {
122: setInParameterNames(new HashSet<String>(Arrays
123: .asList(inParameterNames)));
124: return this ;
125: }
126:
127: public SimpleJdbcCall returningResultSet(String parameterName,
128: ParameterizedRowMapper rowMapper) {
129: addDeclaredRowMapper(parameterName, rowMapper);
130: return this ;
131: }
132:
133: public SimpleJdbcCall withoutProcedureColumnMetaDataAccess() {
134: setAccessCallParameterMetaData(false);
135: return this ;
136: }
137:
138: @SuppressWarnings("unchecked")
139: public <T> T executeFunction(Class<T> returnType, Map args) {
140: return (T) execute(args).get(getScalarOutParameterName());
141: }
142:
143: @SuppressWarnings("unchecked")
144: public <T> T executeFunction(Class<T> returnType,
145: MapSqlParameterSource args) {
146: return (T) execute(args).get(getScalarOutParameterName());
147:
148: }
149:
150: @SuppressWarnings("unchecked")
151: public <T> T executeObject(Class<T> returnType, Map args) {
152: return (T) execute(args).get(getScalarOutParameterName());
153:
154: }
155:
156: @SuppressWarnings("unchecked")
157: public <T> T executeObject(Class<T> returnType,
158: MapSqlParameterSource args) {
159: return (T) execute(args).get(getScalarOutParameterName());
160:
161: }
162:
163: public Map<String, Object> execute() {
164: return execute(new HashMap<String, Object>());
165: }
166:
167: public Map<String, Object> execute(Map<String, Object> args) {
168: return doExecute(args);
169: }
170:
171: public Map<String, Object> execute(
172: SqlParameterSource parameterSource) {
173: return doExecute(parameterSource);
174: }
175:
176: }
|