Skip to content

Commit cfee29e

Browse files
mipo256mipo256
committed
Added Sequence generation support
1 parent 52fdadd commit cfee29e

File tree

37 files changed

+596
-50
lines changed

37 files changed

+596
-50
lines changed

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/JdbcAggregateChangeExecutionContext.java

+1-1
Original file line numberDiff line numberDiff line change
@@ -298,7 +298,7 @@ private <S> Object setIdAndCascadingProperties(DbAction.WithEntity<S> action, @N
298298
PersistentPropertyPathAccessor<S> propertyAccessor = converter.getPropertyAccessor(persistentEntity,
299299
originalEntity);
300300

301-
if (IdValueSource.GENERATED.equals(action.getIdValueSource())) {
301+
if (IdValueSource.isGeneratedByDatabased(action.getIdValueSource())) {
302302
propertyAccessor.setProperty(persistentEntity.getRequiredIdProperty(), generatedId);
303303
}
304304

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/DefaultDataAccessStrategy.java

+93-15
Original file line numberDiff line numberDiff line change
@@ -19,9 +19,16 @@
1919

2020
import java.sql.ResultSet;
2121
import java.sql.SQLException;
22+
import java.util.Arrays;
2223
import java.util.Collections;
2324
import java.util.List;
25+
import java.util.Map;
26+
import java.util.Objects;
2427
import java.util.Optional;
28+
import java.util.Set;
29+
import java.util.stream.Collectors;
30+
import java.util.stream.IntStream;
31+
import java.util.stream.LongStream;
2532

2633
import org.springframework.dao.EmptyResultDataAccessException;
2734
import org.springframework.dao.OptimisticLockingFailureException;
@@ -37,6 +44,7 @@
3744
import org.springframework.data.relational.core.query.Query;
3845
import org.springframework.data.relational.core.sql.LockMode;
3946
import org.springframework.data.relational.core.sql.SqlIdentifier;
47+
import org.springframework.data.util.Pair;
4048
import org.springframework.jdbc.core.RowMapper;
4149
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
4250
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
@@ -102,31 +110,35 @@ public DefaultDataAccessStrategy(SqlGeneratorSource sqlGeneratorSource, Relation
102110
@Override
103111
public <T> Object insert(T instance, Class<T> domainType, Identifier identifier, IdValueSource idValueSource) {
104112

105-
SqlIdentifierParameterSource parameterSource = sqlParametersFactory.forInsert(instance, domainType, identifier,
106-
idValueSource);
113+
RelationalPersistentEntity<?> persistentEntity = context.getRequiredPersistentEntity(domainType);
114+
115+
Optional<Long> idFromSequence = getIdFromSequenceIfAnyDefined(idValueSource, persistentEntity);
116+
117+
SqlIdentifierParameterSource parameterSource = idFromSequence
118+
.map(it -> sqlParametersFactory.forInsert(instance, domainType, identifier, it))
119+
.orElseGet(() -> sqlParametersFactory.forInsert(instance, domainType, identifier, idValueSource));
107120

108121
String insertSql = sql(domainType).getInsert(parameterSource.getIdentifiers());
109122

110-
return insertStrategyFactory.insertStrategy(idValueSource, getIdColumn(domainType)).execute(insertSql,
111-
parameterSource);
112-
}
123+
Object idAfterExecute = insertStrategyFactory.insertStrategy(idValueSource, getIdColumn(domainType))
124+
.execute(insertSql, parameterSource);
125+
126+
return idFromSequence.map(it -> (Object) it).orElse(idAfterExecute);
127+
}
113128

114129
@Override
115130
public <T> Object[] insert(List<InsertSubject<T>> insertSubjects, Class<T> domainType, IdValueSource idValueSource) {
116131

117132
Assert.notEmpty(insertSubjects, "Batch insert must contain at least one InsertSubject");
118-
SqlIdentifierParameterSource[] sqlParameterSources = insertSubjects.stream()
119-
.map(insertSubject -> sqlParametersFactory.forInsert(insertSubject.getInstance(), domainType,
120-
insertSubject.getIdentifier(), idValueSource))
121-
.toArray(SqlIdentifierParameterSource[]::new);
122133

123-
String insertSql = sql(domainType).getInsert(sqlParameterSources[0].getIdentifiers());
134+
if (IdValueSource.SEQUENCE.equals(idValueSource)) {
135+
return executeBatchInsertWithSequenceAsIdSource(insertSubjects, domainType, idValueSource);
136+
} else {
137+
return executeBatchInsert(insertSubjects, domainType, idValueSource);
138+
}
139+
}
124140

125-
return insertStrategyFactory.batchInsertStrategy(idValueSource, getIdColumn(domainType)).execute(insertSql,
126-
sqlParameterSources);
127-
}
128-
129-
@Override
141+
@Override
130142
public <S> boolean update(S instance, Class<S> domainType) {
131143

132144
SqlIdentifierParameterSource parameterSource = sqlParametersFactory.forUpdate(instance, domainType);
@@ -446,4 +458,70 @@ private Class<?> getBaseType(PersistentPropertyPath<RelationalPersistentProperty
446458
return baseProperty.getOwner().getType();
447459
}
448460

461+
private <T> Object[] executeBatchInsert(List<InsertSubject<T>> insertSubjects, Class<T> domainType, IdValueSource idValueSource) {
462+
SqlIdentifierParameterSource[] sqlParameterSources = insertSubjects
463+
.stream()
464+
.map(insertSubject -> sqlParametersFactory.forInsert(
465+
insertSubject.getInstance(), domainType,
466+
insertSubject.getIdentifier(), idValueSource)
467+
)
468+
.toArray(SqlIdentifierParameterSource[]::new);
469+
470+
String insertSql = sql(domainType).getInsert(sqlParameterSources[0].getIdentifiers());
471+
472+
return insertStrategyFactory.batchInsertStrategy(idValueSource, getIdColumn(domainType))
473+
.execute(insertSql, sqlParameterSources);
474+
}
475+
476+
private <T> Object[] executeBatchInsertWithSequenceAsIdSource(List<InsertSubject<T>> insertSubjects, Class<T> domainType, IdValueSource idValueSource) {
477+
List<Pair<Long, SqlIdentifierParameterSource>> sqlParameterSources = createBatchParameterSourcesWithSequence(insertSubjects, domainType,
478+
context.getPersistentEntity(domainType).getIdTargetSequence()
479+
);
480+
481+
String insertSql = sql(domainType).getInsert(sqlParameterSources.get(0).getSecond().getIdentifiers());
482+
483+
insertStrategyFactory.batchInsertStrategy(idValueSource, getIdColumn(domainType))
484+
.execute(insertSql, sqlParameterSources.stream()
485+
.map(Pair::getSecond)
486+
.toArray(SqlIdentifierParameterSource[]::new));
487+
488+
return sqlParameterSources.stream().map(Pair::getFirst).toArray(Object[]::new);
489+
}
490+
491+
private <T> List<Pair<Long, SqlIdentifierParameterSource>> createBatchParameterSourcesWithSequence(List<InsertSubject<T>> insertSubjects, Class<T> domainType, Optional<String> idTargetSequence) {
492+
List<Pair<Long, SqlIdentifierParameterSource>> sqlParameterSources;
493+
int subjectsSize = insertSubjects.size();
494+
495+
List<Long> generatedIds = getMultipleIdsFromSequence(idTargetSequence.get(), subjectsSize);
496+
497+
sqlParameterSources = IntStream
498+
.range(0, subjectsSize)
499+
.mapToObj(index -> {
500+
InsertSubject<T> subject = insertSubjects.get(index);
501+
Long generatedId = generatedIds.get(index);
502+
return Pair.of(generatedId, sqlParametersFactory.forInsert(
503+
subject.getInstance(), domainType,
504+
subject.getIdentifier(), generatedId
505+
));
506+
})
507+
.collect(Collectors.toList());
508+
return sqlParameterSources;
509+
}
510+
511+
private Optional<Long> getIdFromSequenceIfAnyDefined(IdValueSource idValueSource, RelationalPersistentEntity<?> persistentEntity) {
512+
if (IdValueSource.SEQUENCE.equals(idValueSource) && persistentEntity.getIdTargetSequence().isPresent()) {
513+
String nextSequenceValueSelect = insertStrategyFactory.getDialect().nextValueFromSequenceSelect(persistentEntity.getIdTargetSequence().get());
514+
return Optional.of(operations.queryForObject(nextSequenceValueSelect, Map.of(), (rs, rowNum) -> rs.getLong(1)));
515+
}
516+
return Optional.empty();
517+
}
518+
519+
private List<Long> getMultipleIdsFromSequence(String sequenceName, Integer requiredIds) {
520+
String nextSequenceValueSelect = insertStrategyFactory.getDialect().nextValueFromSequenceSelect(sequenceName);
521+
522+
return IntStream.range(0, requiredIds)
523+
.mapToObj(operand -> operations.queryForObject(nextSequenceValueSelect, Map.of(), (rs, rowNum) -> rs.getLong(1)))
524+
.collect(Collectors.toList());
525+
}
526+
449527
}

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/InsertStrategyFactory.java

+3
Original file line numberDiff line numberDiff line change
@@ -102,4 +102,7 @@ public Object[] execute(String sql, SqlParameterSource[] sqlParameterSources) {
102102
}
103103
}
104104

105+
public Dialect getDialect() {
106+
return this.dialect;
107+
}
105108
}

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/SqlIdentifierParameterSource.java

+27-6
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@
2222
import java.util.Set;
2323

2424
import org.springframework.data.relational.core.sql.SqlIdentifier;
25+
import org.springframework.data.util.Pair;
2526
import org.springframework.jdbc.core.namedparam.AbstractSqlParameterSource;
2627

2728
/**
@@ -35,9 +36,11 @@
3536
*/
3637
class SqlIdentifierParameterSource extends AbstractSqlParameterSource {
3738

38-
private final Set<SqlIdentifier> identifiers = new HashSet<>();
39+
private final Set<SqlIdentifier> sqlIdentifiers = new HashSet<>();
3940
private final Map<String, Object> namesToValues = new HashMap<>();
4041

42+
private Pair<SqlIdentifier, Object> idToValue;
43+
4144
@Override
4245
public boolean hasValue(String paramName) {
4346
return namesToValues.containsKey(paramName);
@@ -54,17 +57,31 @@ public String[] getParameterNames() {
5457
}
5558

5659
Set<SqlIdentifier> getIdentifiers() {
57-
return Collections.unmodifiableSet(identifiers);
60+
return Collections.unmodifiableSet(sqlIdentifiers);
5861
}
5962

6063
void addValue(SqlIdentifier name, Object value) {
6164
addValue(name, value, Integer.MIN_VALUE);
6265
}
6366

64-
void addValue(SqlIdentifier identifier, Object value, int sqlType) {
67+
void addValue(SqlIdentifier sqlIdentifier, Object value, int sqlType) {
68+
69+
sqlIdentifiers.add(sqlIdentifier);
70+
String name = prepareSqlIdentifierName(sqlIdentifier);
71+
namesToValues.put(name, value);
72+
registerSqlType(name, sqlType);
73+
}
74+
75+
/**
76+
* Adds an Id of the record
77+
* @param sqlIdentifier
78+
* @param value
79+
* @param sqlType
80+
*/
81+
void addId(SqlIdentifier sqlIdentifier, Object value, int sqlType) {
6582

66-
identifiers.add(identifier);
67-
String name = BindParameterNameSanitizer.sanitize(identifier.getReference());
83+
sqlIdentifiers.add(sqlIdentifier);
84+
String name = prepareSqlIdentifierName(sqlIdentifier);
6885
namesToValues.put(name, value);
6986
registerSqlType(name, sqlType);
7087
}
@@ -73,11 +90,15 @@ void addAll(SqlIdentifierParameterSource others) {
7390

7491
for (SqlIdentifier identifier : others.getIdentifiers()) {
7592

76-
String name = BindParameterNameSanitizer.sanitize( identifier.getReference());
93+
String name = prepareSqlIdentifierName(identifier);
7794
addValue(identifier, others.getValue(name), others.getSqlType(name));
7895
}
7996
}
8097

98+
private static String prepareSqlIdentifierName(SqlIdentifier sqlIdentifier) {
99+
return BindParameterNameSanitizer.sanitize(sqlIdentifier.getReference());
100+
}
101+
81102
int size() {
82103
return namesToValues.size();
83104
}

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/SqlParametersFactory.java

+46-10
Original file line numberDiff line numberDiff line change
@@ -15,21 +15,28 @@
1515
*/
1616
package org.springframework.data.jdbc.core.convert;
1717

18+
import java.sql.ResultSet;
19+
import java.sql.SQLException;
1820
import java.sql.SQLType;
1921
import java.util.ArrayList;
2022
import java.util.List;
2123
import java.util.Map;
24+
import java.util.Optional;
2225
import java.util.function.Predicate;
2326

2427
import org.springframework.data.jdbc.core.mapping.JdbcValue;
2528
import org.springframework.data.jdbc.support.JdbcUtil;
2629
import org.springframework.data.mapping.PersistentProperty;
2730
import org.springframework.data.mapping.PersistentPropertyAccessor;
2831
import org.springframework.data.relational.core.conversion.IdValueSource;
32+
import org.springframework.data.relational.core.dialect.Dialect;
2933
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
3034
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
3135
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
3236
import org.springframework.data.relational.core.sql.SqlIdentifier;
37+
import org.springframework.jdbc.core.RowMapper;
38+
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
39+
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
3340
import org.springframework.jdbc.support.JdbcUtils;
3441
import org.springframework.lang.Nullable;
3542
import org.springframework.util.Assert;
@@ -46,13 +53,15 @@
4653
public class SqlParametersFactory {
4754
private final RelationalMappingContext context;
4855
private final JdbcConverter converter;
56+
private final Dialect dialect;
4957

50-
/**
51-
* @since 3.1
52-
*/
53-
public SqlParametersFactory(RelationalMappingContext context, JdbcConverter converter) {
58+
private final NamedParameterJdbcOperations operations;
59+
60+
public SqlParametersFactory(RelationalMappingContext context, JdbcConverter converter, Dialect dialect, NamedParameterJdbcOperations operations) {
5461
this.context = context;
5562
this.converter = converter;
63+
this.dialect = dialect;
64+
this.operations = operations;
5665
}
5766

5867
/**
@@ -70,18 +79,38 @@ public SqlParametersFactory(RelationalMappingContext context, JdbcConverter conv
7079
<T> SqlIdentifierParameterSource forInsert(T instance, Class<T> domainType, Identifier identifier,
7180
IdValueSource idValueSource) {
7281

82+
RelationalPersistentEntity<T> persistentEntity = getRequiredPersistentEntity(domainType);
83+
84+
Object idValue = null;
85+
86+
if (IdValueSource.PROVIDED.equals(idValueSource)) {
87+
idValue = persistentEntity.getIdentifierAccessor(instance).getRequiredIdentifier();
88+
}
89+
return forInsert(instance, domainType, identifier, idValue);
90+
}
91+
92+
/**
93+
* Creates the parameters for a SQL insert operation. That method is different from its sibling
94+
* {@link #forInsert(Object, Class, Identifier, IdValueSource) forInsert method} in the sense, that
95+
* this method is invoked when we actually know the id to be added to the {@link SqlParameterSource paarameter source}.
96+
* It might be null, meaning, that we know for sure the id should be coming from the database, or
97+
* it could be not null, meaning, that we've got the id from some source (user provided by himself,
98+
* or we have queried the sequence for instance)
99+
*/
100+
<T> SqlIdentifierParameterSource forInsert(T instance, Class<T> domainType, Identifier identifier,
101+
@Nullable Object id) {
102+
73103
RelationalPersistentEntity<T> persistentEntity = getRequiredPersistentEntity(domainType);
74104
SqlIdentifierParameterSource parameterSource = getParameterSource(instance, persistentEntity, "",
75105
PersistentProperty::isIdProperty);
76106

77107
identifier.forEach((name, value, type) -> addConvertedPropertyValue(parameterSource, name, value, type));
78108

79-
if (IdValueSource.PROVIDED.equals(idValueSource)) {
80-
81-
RelationalPersistentProperty idProperty = persistentEntity.getRequiredIdProperty();
82-
Object idValue = persistentEntity.getIdentifierAccessor(instance).getRequiredIdentifier();
83-
addConvertedPropertyValue(parameterSource, idProperty, idValue, idProperty.getColumnName());
84-
}
109+
RelationalPersistentProperty idProperty = persistentEntity.getIdProperty();
110+
Optional
111+
.ofNullable(id)
112+
.filter(it -> idProperty != null)
113+
.ifPresent(it -> addConvertedPropertyValue(parameterSource, idProperty, it, idProperty.getColumnName()));
85114
return parameterSource;
86115
}
87116

@@ -178,6 +207,13 @@ private void addConvertedPropertyValue(SqlIdentifierParameterSource parameterSou
178207
converter.getTargetSqlType(property));
179208
}
180209

210+
private void addConvertedIdPropertyValue(SqlIdentifierParameterSource parameterSource,
211+
RelationalPersistentProperty property, @Nullable Object value, SqlIdentifier name) {
212+
213+
addConvertedValue(parameterSource, value, name, converter.getColumnType(property),
214+
converter.getTargetSqlType(property));
215+
}
216+
181217
private void addConvertedPropertyValue(SqlIdentifierParameterSource parameterSource, SqlIdentifier name, Object value,
182218
Class<?> javaType) {
183219

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/mybatis/MyBatisDataAccessStrategy.java

+1-1
Original file line numberDiff line numberDiff line change
@@ -86,7 +86,7 @@ public static DataAccessStrategy createCombinedAccessStrategy(RelationalMappingC
8686
NamespaceStrategy namespaceStrategy, Dialect dialect) {
8787

8888
SqlGeneratorSource sqlGeneratorSource = new SqlGeneratorSource(context, converter, dialect);
89-
SqlParametersFactory sqlParametersFactory = new SqlParametersFactory(context, converter);
89+
SqlParametersFactory sqlParametersFactory = new SqlParametersFactory(context, converter, dialect, operations);
9090
InsertStrategyFactory insertStrategyFactory = new InsertStrategyFactory(operations, dialect);
9191

9292
DataAccessStrategy defaultDataAccessStrategy = new DataAccessStrategyFactory( //

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/AbstractJdbcConfiguration.java

+1-1
Original file line numberDiff line numberDiff line change
@@ -207,7 +207,7 @@ public DataAccessStrategy dataAccessStrategyBean(NamedParameterJdbcOperations op
207207

208208
SqlGeneratorSource sqlGeneratorSource = new SqlGeneratorSource(context, jdbcConverter, dialect);
209209
DataAccessStrategyFactory factory = new DataAccessStrategyFactory(sqlGeneratorSource, jdbcConverter, operations,
210-
new SqlParametersFactory(context, jdbcConverter),
210+
new SqlParametersFactory(context, jdbcConverter, dialect, operations),
211211
new InsertStrategyFactory(operations, dialect));
212212

213213
return factory.create();

‎spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java

+1-1
Original file line numberDiff line numberDiff line change
@@ -177,7 +177,7 @@ public void afterPropertiesSet() {
177177

178178
SqlGeneratorSource sqlGeneratorSource = new SqlGeneratorSource(this.mappingContext, this.converter,
179179
this.dialect);
180-
SqlParametersFactory sqlParametersFactory = new SqlParametersFactory(this.mappingContext, this.converter);
180+
SqlParametersFactory sqlParametersFactory = new SqlParametersFactory(this.mappingContext, this.converter, this.dialect, this.operations);
181181
InsertStrategyFactory insertStrategyFactory = new InsertStrategyFactory(this.operations, this.dialect);
182182

183183
DataAccessStrategyFactory factory = new DataAccessStrategyFactory(sqlGeneratorSource, this.converter,

0 commit comments

Comments
 (0)