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.Map;
021:
022: import javax.sql.DataSource;
023:
024: import org.springframework.jdbc.core.JdbcTemplate;
025: import org.springframework.jdbc.core.namedparam.SqlParameterSource;
026: import org.springframework.jdbc.support.KeyHolder;
027:
028: /**
029: * A SimpleJdbcInsert is a multi-threaded, reusable object providing easy insert
030: * capabilities for a table. It provides meta data processing to simplify the code
031: * needed to construct a basic insert statement. All you need to provide is the
032: * name of the table and a Map containing the column names and the column values.
033: *
034: * <p>The meta data processing is based on the DatabaseMetaData provided by the
035: * JDBC driver. As long as the JBDC driver can provide the names of the columns
036: * for a specifed table than we can rely on this auto-detection feature. If that
037: * is not the case then the column names must be specified explicitly.
038: *
039: * <p>The actual insert is being handled using Spring's
040: * {@link org.springframework.jdbc.core.JdbcTemplate}.
041: *
042: * <p>Many of the configuration methods return the current instance of the SimpleJdbcInsert
043: * to provide the ablity to string multiple ones together in a "fluid" interface style.
044: *
045: * @author Thomas Risberg
046: * @since 2.5
047: * @see java.sql.DatabaseMetaData
048: * @see org.springframework.jdbc.core.JdbcTemplate
049: */
050: public class SimpleJdbcInsert extends AbstractJdbcInsert implements
051: SimpleJdbcInsertOperations {
052:
053: /**
054: * Constructor that takes one parameter with the JDBC DataSource to use when creating the
055: * JdbcTemplate.
056: * @param dataSource the <code>DataSource</code> to use
057: * @see org.springframework.jdbc.core.JdbcTemplate#setDataSource
058: */
059: public SimpleJdbcInsert(DataSource dataSource) {
060: super (dataSource);
061: }
062:
063: /**
064: * Alternative Constructor that takes one parameter with the JdbcTemplate to be used.
065: * @param jdbcTemplate the <code>JdbcTemplate</code> to use
066: * @see org.springframework.jdbc.core.JdbcTemplate#setDataSource
067: */
068: public SimpleJdbcInsert(JdbcTemplate jdbcTemplate) {
069: super (jdbcTemplate);
070: }
071:
072: public SimpleJdbcInsert withTableName(String tableName) {
073: setTableName(tableName);
074: return this ;
075: }
076:
077: public SimpleJdbcInsert withSchemaName(String schemaName) {
078: setSchemaName(schemaName);
079: return this ;
080: }
081:
082: public SimpleJdbcInsert withCatalogName(String catalogName) {
083: setCatalogName(catalogName);
084: return this ;
085: }
086:
087: public SimpleJdbcInsert usingColumns(String... columnNames) {
088: setColumnNames(Arrays.asList(columnNames));
089: return this ;
090: }
091:
092: public SimpleJdbcInsert usingGeneratedKeyColumns(
093: String... columnNames) {
094: setGeneratedKeyNames(columnNames);
095: return this ;
096: }
097:
098: public int execute(Map<String, Object> args) {
099: return doExecute(args);
100: }
101:
102: public int execute(SqlParameterSource parameterSource) {
103: return doExecute(parameterSource);
104: }
105:
106: public Number executeAndReturnKey(Map<String, Object> args) {
107: return doExecuteAndReturnKey(args);
108: }
109:
110: public Number executeAndReturnKey(SqlParameterSource parameterSource) {
111: return doExecuteAndReturnKey(parameterSource);
112: }
113:
114: public KeyHolder executeAndReturnKeyHolder(Map<String, Object> args) {
115: return doExecuteAndReturnKeyHolder(args);
116: }
117:
118: public KeyHolder executeAndReturnKeyHolder(
119: SqlParameterSource parameterSource) {
120: return doExecuteAndReturnKeyHolder(parameterSource);
121: }
122:
123: public int[] executeBatch(Map<String, Object>[] batch) {
124: return doExecuteBatch(batch);
125: }
126:
127: public int[] executeBatch(SqlParameterSource[] batch) {
128: return doExecuteBatch(batch);
129: }
130:
131: }
|