Example usage for org.springframework.jdbc.support KeyHolder getKeyList

List of usage examples for org.springframework.jdbc.support KeyHolder getKeyList

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.jdbc.support.*
  5. KeyHolder
  6. getKeyList

Introduction

In this page you can find the example usage for org.springframework.jdbc.support KeyHolder getKeyList.

Prototype

List<Map<String, Object>> getKeyList();

Source Link

Document

Return a reference to the List that contains the keys.

Usage

From source file:cc.tooyoung.common.db.JdbcTemplate.java

@SuppressWarnings("unchecked")
public int update(final PreparedStatementCreator psc, final KeyHolder generatedKeyHolder)
        throws DataAccessException {

    Assert.notNull(generatedKeyHolder, "KeyHolder must not be null");
    if (ApiLogger.isTraceEnabled()) {
        ApiLogger.trace("Executing SQL update and returning generated keys");
    }//ww  w.  j  av a2s.c  o m

    Integer result = (Integer) execute(psc, new PreparedStatementCallback() {
        public Object doInPreparedStatement(PreparedStatement ps) throws SQLException {
            int rows = ps.executeUpdate();
            List generatedKeys = generatedKeyHolder.getKeyList();
            generatedKeys.clear();
            ResultSet keys = ps.getGeneratedKeys();
            if (keys != null) {
                try {
                    RowMapper rowMapper = getColumnMapRowMapper();
                    RowMapperResultSetExtractor rse = new RowMapperResultSetExtractor(rowMapper, 1);
                    generatedKeys.addAll((List) rse.extractData(keys));
                } finally {
                    JdbcUtils.closeResultSet(keys);
                }
            }
            if (ApiLogger.isTraceEnabled()) {
                ApiLogger.trace(
                        "SQL update affected " + rows + " rows and returned " + generatedKeys.size() + " keys");
            }
            return new Integer(rows);
        }
    }, true);
    return result.intValue();
}

From source file:lib.JdbcTemplate.java

@Override
public int update(final PreparedStatementCreator psc, final KeyHolder generatedKeyHolder)
        throws DataAccessException {

    Assert.notNull(generatedKeyHolder, "KeyHolder must not be null");
    logger.debug("Executing SQL update and returning generated keys");

    return execute(psc, new PreparedStatementCallback<Integer>() {
        @Override//w w w. j av  a2 s .co m
        public Integer doInPreparedStatement(PreparedStatement ps) throws SQLException {
            int rows = ps.executeUpdate();
            List<Map<String, Object>> generatedKeys = generatedKeyHolder.getKeyList();
            generatedKeys.clear();
            ResultSet keys = ps.getGeneratedKeys();
            if (keys != null) {
                try {
                    RowMapperResultSetExtractor<Map<String, Object>> rse = new RowMapperResultSetExtractor<Map<String, Object>>(
                            getColumnMapRowMapper(), 1);
                    generatedKeys.addAll(rse.extractData(keys));
                } finally {
                    JdbcUtils.closeResultSet(keys);
                }
            }
            if (logger.isDebugEnabled()) {
                logger.debug(
                        "SQL update affected " + rows + " rows and returned " + generatedKeys.size() + " keys");
            }
            return rows;
        }
    });
}

From source file:com.nortal.petit.orm.statement.InsertStatement.java

@Override
public void exec() {
    prepare();/*from  w  w w.  ja  v a 2 s.  co  m*/
    if (!CollectionUtils.isEmpty(getBeans())) {
        if (getMapping().id() == null) {
            execBatchUpdate();
        } else {
            final KeyHolder keyHolder = new GeneratedKeyHolder();
            final InterceptorCalls interceptorCalls = new InterceptorCalls();
            getJdbcTemplate().execute(new PreparedStatementCreator() {
                @Override
                public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
                    return con.prepareStatement(getSql(), Statement.RETURN_GENERATED_KEYS);
                }
            }, new PreparedStatementCallback<Object>() {
                @Override
                public Object doInPreparedStatement(PreparedStatement ps)
                        throws SQLException, DataAccessException {
                    MappingParamFunction<B> paramFunction = new MappingParamFunction<B>(getMapping());

                    for (B bean : getBeans()) {
                        paramFunction.setBean(bean);
                        Object[] params = getParams(paramFunction);
                        Object[] queryParams = params.length == 1 && params[0] instanceof Object[]
                                ? (Object[]) params[0]
                                : params;
                        interceptorCalls.setBeanValues(bean, queryParams);
                        ArgPreparedStatementSetter.setValues(ps, queryParams, 1);

                        ps.executeUpdate();
                        extractKeys(ps);
                    }
                    return null;
                }

                /**
                 * @param ps
                 * @throws SQLException
                 */
                private void extractKeys(PreparedStatement ps) throws SQLException {
                    ResultSet keys = ps.getGeneratedKeys();
                    if (keys != null) {
                        try {
                            RowMapperResultSetExtractor<Map<String, Object>> rse = new RowMapperResultSetExtractor<Map<String, Object>>(
                                    new ColumnMapRowMapper(), 1);
                            keyHolder.getKeyList().addAll(rse.extractData(keys));
                        } finally {
                            JdbcUtils.closeResultSet(keys);
                        }
                    }
                }
            });

            try {
                Property<B, Object> idProperty = getMapping().id();
                for (int i = 0; i < getBeans().size(); i++) {
                    B bean = getBeans().get(i);
                    Object key = keyHolder.getKeyList().get(i).get(idProperty.column());
                    idProperty.write(bean, key);
                    interceptorCalls.setBeanId(bean, key);
                }
            } catch (Exception e) {
                throw new PersistenceException("InsertStatement.exec: unable to write bean primary key", e);
            }
            interceptorCalls.callInterceptor();
        }
    } else {
        getJdbcTemplate().update(getSql(), getParams(null));
    }
}

From source file:com.prosnav.oms.dao.CustDao.java

public int insertAndGetKey(final String sql, final Object[] o, String id) {
    KeyHolder keyHolder = new GeneratedKeyHolder();
    jt.update(new PreparedStatementCreator() {
        public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {

            // String sql_sms = "insert into
            // sms(title,content,date_s,form,sffs,by1,by2,by3) values
            // (?,?,'"+dates+"',?,?,?,?,?)";
            PreparedStatement ps = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
            for (int i = 0; i < o.length; i++) {
                ps.setObject(i + 1, o[i]);
            }//from   ww w .  j a  va  2  s  . c o  m

            return ps;
        }
    }, keyHolder);
    Map<String, Object> generatedId = keyHolder.getKeyList().get(0);
    Integer com_id = (Integer) generatedId.get(id);
    // Long generatedId = keyHolder.getKey().longValue();
    // int a =Integer.parseInt(o_id);
    return com_id;
}

From source file:org.springframework.jdbc.core.JdbcTemplate.java

public int update(final PreparedStatementCreator psc, final KeyHolder generatedKeyHolder)
        throws DataAccessException {
    if (logger.isDebugEnabled()) {
        String sql = getSql(psc);
        logger.debug(//from  w  w  w  .  j av a 2  s.c  om
                "Executing SQL update and returning generated keys" + (sql != null ? " [" + sql + "]" : ""));
    }
    Integer result = (Integer) execute(psc, new PreparedStatementCallback() {
        public Object doInPreparedStatement(PreparedStatement ps) throws SQLException {
            int rows = ps.executeUpdate();
            List generatedKeys = generatedKeyHolder.getKeyList();
            generatedKeys.clear();
            ResultSet keys = ps.getGeneratedKeys();
            if (keys != null) {
                ListResultSetExtractor lrse = new ListResultSetExtractor();
                generatedKeys.addAll((List) lrse.extractData(keys));
            }
            if (logger.isDebugEnabled()) {
                logger.debug(
                        "SQL update affected " + rows + " rows and returned " + generatedKeys.size() + " keys");
            }
            return new Integer(rows);
        }
    });
    return result.intValue();
}

From source file:org.springframework.jdbc.core.simple.AbstractJdbcInsert.java

/**
 * Delegate method to execute the insert, generating any number of keys.
 *//*from ww  w.jav  a 2  s  .  c om*/
private KeyHolder executeInsertAndReturnKeyHolderInternal(final List<?> values) {
    if (logger.isDebugEnabled()) {
        logger.debug("The following parameters are used for call " + getInsertString() + " with: " + values);
    }
    final KeyHolder keyHolder = new GeneratedKeyHolder();

    if (this.tableMetaDataContext.isGetGeneratedKeysSupported()) {
        getJdbcTemplate().update(con -> {
            PreparedStatement ps = prepareStatementForGeneratedKeys(con);
            setParameterValues(ps, values, getInsertTypes());
            return ps;
        }, keyHolder);
    }

    else {
        if (!this.tableMetaDataContext.isGetGeneratedKeysSimulated()) {
            throw new InvalidDataAccessResourceUsageException(
                    "The getGeneratedKeys feature is not supported by this database");
        }
        if (getGeneratedKeyNames().length < 1) {
            throw new InvalidDataAccessApiUsageException("Generated Key Name(s) not specified. "
                    + "Using the generated keys features requires specifying the name(s) of the generated column(s)");
        }
        if (getGeneratedKeyNames().length > 1) {
            throw new InvalidDataAccessApiUsageException(
                    "Current database only supports retrieving the key for a single column. There are "
                            + getGeneratedKeyNames().length + " columns specified: "
                            + Arrays.asList(getGeneratedKeyNames()));
        }

        Assert.state(getTableName() != null, "No table name set");
        final String keyQuery = this.tableMetaDataContext.getSimulationQueryForGetGeneratedKey(getTableName(),
                getGeneratedKeyNames()[0]);
        Assert.state(keyQuery != null, "Query for simulating get generated keys can't be null");

        // This is a hack to be able to get the generated key from a database that doesn't support
        // get generated keys feature. HSQL is one, PostgreSQL is another. Postgres uses a RETURNING
        // clause while HSQL uses a second query that has to be executed with the same connection.

        if (keyQuery.toUpperCase().startsWith("RETURNING")) {
            Long key = getJdbcTemplate().queryForObject(getInsertString() + " " + keyQuery,
                    values.toArray(new Object[values.size()]), Long.class);
            Map<String, Object> keys = new HashMap<>(1);
            keys.put(getGeneratedKeyNames()[0], key);
            keyHolder.getKeyList().add(keys);
        } else {
            getJdbcTemplate().execute((ConnectionCallback<Object>) con -> {
                // Do the insert
                PreparedStatement ps = null;
                try {
                    ps = con.prepareStatement(getInsertString());
                    setParameterValues(ps, values, getInsertTypes());
                    ps.executeUpdate();
                } finally {
                    JdbcUtils.closeStatement(ps);
                }
                //Get the key
                Statement keyStmt = null;
                ResultSet rs = null;
                Map<String, Object> keys = new HashMap<>(1);
                try {
                    keyStmt = con.createStatement();
                    rs = keyStmt.executeQuery(keyQuery);
                    if (rs.next()) {
                        long key = rs.getLong(1);
                        keys.put(getGeneratedKeyNames()[0], key);
                        keyHolder.getKeyList().add(keys);
                    }
                } finally {
                    JdbcUtils.closeResultSet(rs);
                    JdbcUtils.closeStatement(keyStmt);
                }
                return null;
            });
        }
    }

    return keyHolder;
}

From source file:org.springframework.jdbc.object.SqlUpdateTests.java

public void testUpdateAndGeneratedKeys() throws SQLException {
    ctrlResultSetMetaData = MockControl.createControl(ResultSetMetaData.class);
    mockResultSetMetaData = (ResultSetMetaData) ctrlResultSetMetaData.getMock();
    mockResultSetMetaData.getColumnCount();
    ctrlResultSetMetaData.setReturnValue(1);
    mockResultSetMetaData.getColumnLabel(1);
    ctrlResultSetMetaData.setReturnValue("1", 2);

    ctrlResultSet = MockControl.createControl(ResultSet.class);
    mockResultSet = (ResultSet) ctrlResultSet.getMock();
    mockResultSet.getMetaData();//  w ww  .ja  v  a  2  s  . co m
    ctrlResultSet.setReturnValue(mockResultSetMetaData);
    mockResultSet.next();
    ctrlResultSet.setReturnValue(true);
    mockResultSet.getObject(1);
    ctrlResultSet.setReturnValue(new Integer(11));
    mockResultSet.next();
    ctrlResultSet.setReturnValue(false);
    mockResultSet.close();
    ctrlResultSet.setVoidCallable();

    mockPreparedStatement.setString(1, "rod");
    ctrlPreparedStatement.setVoidCallable();
    mockPreparedStatement.executeUpdate();
    ctrlPreparedStatement.setReturnValue(1);
    mockPreparedStatement.getGeneratedKeys();
    ctrlPreparedStatement.setReturnValue(mockResultSet);
    if (debugEnabled) {
        mockPreparedStatement.getWarnings();
        ctrlPreparedStatement.setReturnValue(null);
    }
    mockPreparedStatement.close();
    ctrlPreparedStatement.setVoidCallable();

    mockConnection.prepareStatement(INSERT_GENERATE_KEYS, PreparedStatement.RETURN_GENERATED_KEYS);
    ctrlConnection.setReturnValue(mockPreparedStatement);

    replay();
    ctrlResultSet.replay();
    ctrlResultSetMetaData.replay();

    GeneratedKeysUpdater pc = new GeneratedKeysUpdater();
    KeyHolder generatedKeyHolder = new GeneratedKeyHolder();
    int rowsAffected = pc.run("rod", generatedKeyHolder);
    assertEquals(1, rowsAffected);
    assertEquals(1, generatedKeyHolder.getKeyList().size());
    assertEquals(11, generatedKeyHolder.getKey().intValue());
}