Spring/spring-data-relational
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

DATAJDBC-386 - Introduce quoting for all database identifier.

Browse Source 
All database identifiers, i.e. table names, column names and so on, now get quoted.
For most databases this means they get enclosed with double quotes.
For some databases this makes the the identifiers case sensitive.
In order to minimize the impact we convert identifiers their default letter casing.
This should be upper case according to the SQL standard but isn't for some databases.

The exact behavior regarding quoting and default letter casing gets controlled by a database specific `Dialect`.

Future changes will make the quoting of annotated columns and the default quoting behavior configurable.

Original pull request: #182.
This commit is contained in:
Jens Schauder
2019-12-02 14:50:53 +01:00
committed by Mark Paluch
parent a7bb561dec
commit 558e7386dc
73 changed files with 2418 additions and 1119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/DefaultJdbcInterpreter.java
View File

@@ -266,7 +266,7 @@ class DefaultJdbcInterpreter implements Interpreter {
.getRequiredPersistentEntity(idOwningAction.getEntityType());
Object identifier = persistentEntity.getIdentifierAccessor(idOwningAction.getEntity()).getIdentifier();
Assert.state(identifier != null, "Couldn't get obtain a required id value");
Assert.state(identifier != null, "Couldn't obtain a required id value");
return identifier;
}

9
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/BasicJdbcConverter.java
View File

@@ -37,12 +37,14 @@ import org.springframework.data.mapping.context.MappingContext;
import org.springframework.data.mapping.model.SimpleTypeHolder;
import org.springframework.data.relational.core.conversion.BasicRelationalConverter;
import org.springframework.data.relational.core.conversion.RelationalConverter;
import org.springframework.data.relational.core.dialect.HsqlDbDialect;
import org.springframework.data.relational.core.mapping.Embedded;
import org.springframework.data.relational.core.mapping.Embedded.OnEmpty;
import org.springframework.data.relational.core.mapping.PersistentPropertyPathExtension;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.data.util.ClassTypeInformation;
import org.springframework.data.util.TypeInformation;
import org.springframework.lang.Nullable;
@@ -69,6 +71,7 @@ public class BasicJdbcConverter extends BasicRelationalConverter implements Jdbc
private static final Converter<Iterable<?>, Map<?, ?>> ITERABLE_OF_ENTRY_TO_MAP_CONVERTER = new IterableOfEntryToMapConverter();
private final JdbcTypeFactory typeFactory;
private final IdentifierProcessing identifierProcessing = HsqlDbDialect.INSTANCE.getIdentifierProcessing();
private RelationResolver relationResolver;
@@ -374,7 +377,8 @@ public class BasicJdbcConverter extends BasicRelationalConverter implements Jdbc
return readEntityFrom(property, path);
}
Object value = getObjectFromResultSet(path.extendBy(property).getColumnAlias());
Object value = getObjectFromResultSet(
path.extendBy(property).getColumnAlias().toColumnName(identifierProcessing));
return readValue(value, property.getTypeInformation());
}
@@ -428,7 +432,8 @@ public class BasicJdbcConverter extends BasicRelationalConverter implements Jdbc
if (idProperty != null) {
idValue = newContext.readFrom(idProperty);
} else {
idValue = newContext.getObjectFromResultSet(path.extendBy(property).getReverseColumnNameAlias());
idValue = newContext.getObjectFromResultSet(
path.extendBy(property).getReverseColumnNameAlias().toColumnName(identifierProcessing));
}
if (idValue == null) {

3
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/CascadingDataAccessStrategy.java
View File

@@ -24,6 +24,7 @@ import java.util.function.Function;
import org.springframework.data.mapping.PersistentPropertyPath;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.SqlIdentifier;
/**
* Delegates each methods to the {@link DataAccessStrategy}s passed to the constructor in turn until the first that does
@@ -47,7 +48,7 @@ public class CascadingDataAccessStrategy implements DataAccessStrategy {
* @see org.springframework.data.jdbc.core.DataAccessStrategy#insert(java.lang.Object, java.lang.Class, java.util.Map)
*/
@Override
public <T> Object insert(T instance, Class<T> domainType, Map<String, Object> additionalParameters) {
public <T> Object insert(T instance, Class<T> domainType, Map<SqlIdentifier, Object> additionalParameters) {
return collect(das -> das.insert(instance, domainType, additionalParameters));
}

14
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/DataAccessStrategy.java
View File

@@ -22,6 +22,7 @@ import org.springframework.data.jdbc.core.JdbcAggregateOperations;
import org.springframework.data.mapping.PersistentPropertyPath;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.lang.Nullable;
/**
@@ -46,7 +47,8 @@ public interface DataAccessStrategy extends RelationResolver {
* @deprecated since 1.1, use {@link #insert(Object, Class, Identifier)} instead.
*/
@Deprecated
<T> Object insert(T instance, Class<T> domainType, Map<String, Object> additionalParameters);
@Nullable
<T> Object insert(T instance, Class<T> domainType, Map<SqlIdentifier, Object> additionalParameters);
/**
* Inserts a the data of a single entity. Referenced entities don't get handled.
@@ -76,8 +78,8 @@ public interface DataAccessStrategy extends RelationResolver {
<T> boolean update(T instance, Class<T> domainType);
/**
* Updates the data of a single entity in the database and enforce optimistic record locking using the {@code previousVersion}
* property. Referenced entities don't get handled.
* Updates the data of a single entity in the database and enforce optimistic record locking using the
* {@code previousVersion} property. Referenced entities don't get handled.
* <P>
* The statement will be of the form : {@code UPDATE … SET … WHERE ID = :id and VERSION_COLUMN = :previousVersion }
* and throw an optimistic record locking exception if no rows have been updated.
@@ -87,7 +89,8 @@ public interface DataAccessStrategy extends RelationResolver {
* @param previousVersion The previous version assigned to the instance being saved.
* @param <T> the type of the instance to save.
* @return whether the update actually updated a row.
* @throws OptimisticLockingFailureException if the update fails to update at least one row assuming the the optimistic locking version check failed.
* @throws OptimisticLockingFailureException if the update fails to update at least one row assuming the the
* optimistic locking version check failed.
* @since 2.0
*/
<T> boolean updateWithVersion(T instance, Class<T> domainType, Number previousVersion);
@@ -113,7 +116,8 @@ public interface DataAccessStrategy extends RelationResolver {
* @param domainType the type of entity to be deleted. Implicitly determines the table to operate on. Must not be
* {@code null}.
* @param previousVersion The previous version assigned to the instance being saved.
* @throws OptimisticLockingFailureException if the update fails to update at least one row assuming the the optimistic locking version check failed.
* @throws OptimisticLockingFailureException if the update fails to update at least one row assuming the the
* optimistic locking version check failed.
* @since 2.0
*/
<T> void deleteWithVersion(Object id, Class<T> domainType, Number previousVersion);

136
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/DefaultDataAccessStrategy.java
View File

@@ -15,13 +15,11 @@
*/
package org.springframework.data.jdbc.core.convert;
import static org.springframework.data.jdbc.core.convert.SqlGenerator.VERSION_SQL_PARAMETER_NAME;
import static org.springframework.data.jdbc.core.convert.SqlGenerator.*;
import java.sql.JDBCType;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
@@ -36,15 +34,16 @@ import org.springframework.data.mapping.PersistentProperty;
import org.springframework.data.mapping.PersistentPropertyAccessor;
import org.springframework.data.mapping.PersistentPropertyPath;
import org.springframework.data.mapping.PropertyHandler;
import org.springframework.data.relational.core.conversion.RelationalEntityVersionUtils;
import org.springframework.data.relational.core.mapping.PersistentPropertyPathExtension;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.JdbcUtils;
import org.springframework.jdbc.support.KeyHolder;
@@ -98,7 +97,8 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
* @see org.springframework.data.jdbc.core.DataAccessStrategy#insert(java.lang.Object, java.lang.Class, java.util.Map)
*/
@Override
public <T> Object insert(T instance, Class<T> domainType, Map<String, Object> additionalParameters) {
@Nullable
public <T> Object insert(T instance, Class<T> domainType, Map<SqlIdentifier, Object> additionalParameters) {
return insert(instance, domainType, Identifier.from(additionalParameters));
}
@@ -109,11 +109,11 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
@Override
public <T> Object insert(T instance, Class<T> domainType, Identifier identifier) {
KeyHolder holder = new GeneratedKeyHolder();
SqlGenerator sqlGenerator = sql(domainType);
RelationalPersistentEntity<T> persistentEntity = getRequiredPersistentEntity(domainType);
MapSqlParameterSource parameterSource = getParameterSource(instance, persistentEntity, "",
PersistentProperty::isIdProperty);
SqlIdentifierParameterSource parameterSource = getParameterSource(instance, persistentEntity, "",
PersistentProperty::isIdProperty, getIdentifierProcessing());
identifier.forEach((name, value, type) -> addConvertedPropertyValue(parameterSource, name, value, type));
@@ -124,8 +124,10 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
addConvertedPropertyValue(parameterSource, idProperty, idValue, idProperty.getColumnName());
}
KeyHolder holder = new GeneratedKeyHolder();
operations.update( //
sql(domainType).getInsert(new HashSet<>(Arrays.asList(parameterSource.getParameterNames()))), //
sqlGenerator.getInsert(new HashSet<>(parameterSource.getIdentifiers())), //
parameterSource, //
holder //
);
@@ -142,7 +144,7 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
RelationalPersistentEntity<S> persistentEntity = getRequiredPersistentEntity(domainType);
return operations.update(sql(domainType).getUpdate(),
getParameterSource(instance, persistentEntity, "", Predicates.includeAll())) != 0;
getParameterSource(instance, persistentEntity, "", Predicates.includeAll(), getIdentifierProcessing())) != 0;
}
/*
@@ -155,13 +157,14 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
RelationalPersistentEntity<S> persistentEntity = getRequiredPersistentEntity(domainType);
// Adjust update statement to set the new version and use the old version in where clause.
MapSqlParameterSource parameterSource = getParameterSource(instance, persistentEntity, "",
Predicates.includeAll());
parameterSource.addValue(VERSION_SQL_PARAMETER_NAME, previousVersion);
SqlIdentifierParameterSource parameterSource = getParameterSource(instance, persistentEntity, "",
Predicates.includeAll(), getIdentifierProcessing());
parameterSource.addValue(VERSION_SQL_PARAMETER, previousVersion);
int affectedRows = operations.update(sql(domainType).getUpdateWithVersion(), parameterSource);
if (affectedRows == 0) {
throw new OptimisticLockingFailureException(
String.format("Optimistic lock exception on saving entity of type %s.", persistentEntity.getName()));
}
@@ -177,7 +180,7 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
public void delete(Object id, Class<?> domainType) {
String deleteByIdSql = sql(domainType).getDeleteById();
MapSqlParameterSource parameter = createIdParameterSource(id, domainType);
SqlParameterSource parameter = createIdParameterSource(id, domainType);
operations.update(deleteByIdSql, parameter);
}
@@ -193,8 +196,8 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
RelationalPersistentEntity<T> persistentEntity = getRequiredPersistentEntity(domainType);
MapSqlParameterSource parameterSource = createIdParameterSource(id, domainType);
parameterSource.addValue(VERSION_SQL_PARAMETER_NAME, previousVersion);
SqlIdentifierParameterSource parameterSource = createIdParameterSource(id, domainType);
parameterSource.addValue(VERSION_SQL_PARAMETER, previousVersion);
int affectedRows = operations.update(sql(domainType).getDeleteByIdAndVersion(), parameterSource);
if (affectedRows == 0) {
@@ -216,11 +219,11 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
RelationalPersistentProperty referencingProperty = propertyPath.getLeafProperty();
Assert.notNull(referencingProperty, "No property found matching the PropertyPath " + propertyPath);
String format = sql(rootEntity.getType()).createDeleteByPath(propertyPath);
String delete = sql(rootEntity.getType()).createDeleteByPath(propertyPath);
HashMap<String, Object> parameters = new HashMap<>();
parameters.put("rootId", rootId);
operations.update(format, parameters);
SqlIdentifierParameterSource parameters = new SqlIdentifierParameterSource(getIdentifierProcessing());
parameters.addValue(ROOT_ID_PARAMETER, rootId);
operations.update(delete, parameters);
}
/*
@@ -265,7 +268,7 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
public <T> T findById(Object id, Class<T> domainType) {
String findOneSql = sql(domainType).getFindOne();
MapSqlParameterSource parameter = createIdParameterSource(id, domainType);
SqlIdentifierParameterSource parameter = createIdParameterSource(id, domainType);
try {
return operations.queryForObject(findOneSql, parameter, (RowMapper<T>) getEntityRowMapper(domainType));
@@ -297,9 +300,9 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
}
RelationalPersistentProperty idProperty = getRequiredPersistentEntity(domainType).getRequiredIdProperty();
MapSqlParameterSource parameterSource = new MapSqlParameterSource();
SqlIdentifierParameterSource parameterSource = new SqlIdentifierParameterSource(getIdentifierProcessing());
addConvertedPropertyValuesAsList(parameterSource, idProperty, ids, "ids");
addConvertedPropertyValuesAsList(parameterSource, idProperty, ids, IDS_SQL_PARAMETER);
String findAllInListSql = sql(domainType).getFindAllInList();
@@ -324,12 +327,20 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
String findAllByProperty = sql(actualType) //
.getFindAllByProperty(identifier, path.getQualifierColumn(), path.isOrdered());
MapSqlParameterSource parameters = new MapSqlParameterSource(identifier.toMap());
RowMapper<?> rowMapper = path.isMap() ? this.getMapEntityRowMapper(path, identifier)
: this.getEntityRowMapper(path, identifier);
return operations.query(findAllByProperty, parameters, (RowMapper<Object>) rowMapper);
return operations.query(findAllByProperty, createParameterSource(identifier, getIdentifierProcessing()),
(RowMapper<Object>) rowMapper);
}
private SqlParameterSource createParameterSource(Identifier identifier, IdentifierProcessing identifierProcessing) {
SqlIdentifierParameterSource parameterSource = new SqlIdentifierParameterSource(identifierProcessing);
identifier.toMap().forEach(parameterSource::addValue);
return parameterSource;
}
/*
@@ -355,7 +366,7 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
public <T> boolean existsById(Object id, Class<T> domainType) {
String existsSql = sql(domainType).getExists();
MapSqlParameterSource parameter = createIdParameterSource(id, domainType);
SqlParameterSource parameter = createIdParameterSource(id, domainType);
Boolean result = operations.queryForObject(existsSql, parameter, Boolean.class);
Assert.state(result != null, "The result of an exists query must not be null");
@@ -363,10 +374,11 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
return result;
}
private <S, T> MapSqlParameterSource getParameterSource(@Nullable S instance, RelationalPersistentEntity<S> persistentEntity,
String prefix, Predicate<RelationalPersistentProperty> skipProperty) {
private <S, T> SqlIdentifierParameterSource getParameterSource(@Nullable S instance,
RelationalPersistentEntity<S> persistentEntity, String prefix,
Predicate<RelationalPersistentProperty> skipProperty, IdentifierProcessing identifierProcessing) {
MapSqlParameterSource parameters = new MapSqlParameterSource();
SqlIdentifierParameterSource parameters = new SqlIdentifierParameterSource(identifierProcessing);
PersistentPropertyAccessor<S> propertyAccessor = instance != null ? persistentEntity.getPropertyAccessor(instance)
: NoValuePropertyAccessor.instance();
@@ -384,13 +396,14 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
Object value = propertyAccessor.getProperty(property);
RelationalPersistentEntity<?> embeddedEntity = context.getPersistentEntity(property.getType());
MapSqlParameterSource additionalParameters = getParameterSource((T) value,
(RelationalPersistentEntity<T>) embeddedEntity, prefix + property.getEmbeddedPrefix(), skipProperty);
parameters.addValues(additionalParameters.getValues());
SqlIdentifierParameterSource additionalParameters = getParameterSource((T) value,
(RelationalPersistentEntity<T>) embeddedEntity, prefix + property.getEmbeddedPrefix(), skipProperty,
identifierProcessing);
parameters.addAll(additionalParameters);
} else {
Object value = propertyAccessor.getProperty(property);
String paramName = prefix + property.getColumnName();
SqlIdentifier paramName = property.getColumnName().prefix(prefix);
addConvertedPropertyValue(parameters, property, value, paramName);
}
@@ -434,7 +447,7 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
return null;
}
return keys.get(persistentEntity.getIdColumn());
return keys.get(persistentEntity.getIdColumn().toColumnName(getIdentifierProcessing()));
}
}
@@ -448,55 +461,58 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
private RowMapper<?> getMapEntityRowMapper(PersistentPropertyPathExtension path, Identifier identifier) {
String keyColumn = path.getQualifierColumn();
SqlIdentifier keyColumn = path.getQualifierColumn();
Assert.notNull(keyColumn, () -> "KeyColumn must not be null for " + path);
return new MapEntityRowMapper<>(path, converter, identifier, keyColumn);
return new MapEntityRowMapper<>(path, converter, identifier, keyColumn, getIdentifierProcessing());
}
private <T> MapSqlParameterSource createIdParameterSource(Object id, Class<T> domainType) {
private <T> SqlIdentifierParameterSource createIdParameterSource(Object id, Class<T> domainType) {
MapSqlParameterSource parameterSource = new MapSqlParameterSource();
SqlIdentifierParameterSource parameterSource = new SqlIdentifierParameterSource(getIdentifierProcessing());
addConvertedPropertyValue( //
parameterSource, //
getRequiredPersistentEntity(domainType).getRequiredIdProperty(), //
id, //
"id" //
ID_SQL_PARAMETER //
);
return parameterSource;
}
private void addConvertedPropertyValue(MapSqlParameterSource parameterSource, RelationalPersistentProperty property,
@Nullable Object value, String paramName) {
JdbcValue jdbcValue = converter.writeJdbcValue( //
value, //
property.getColumnType(), //
property.getSqlType() //
);
parameterSource.addValue(paramName, jdbcValue.getValue(), JdbcUtil.sqlTypeFor(jdbcValue.getJdbcType()));
private IdentifierProcessing getIdentifierProcessing() {
return sqlGeneratorSource.getDialect().getIdentifierProcessing();
}
private void addConvertedPropertyValue(MapSqlParameterSource parameterSource, String name, Object value,
Class<?> type) {
private void addConvertedPropertyValue(SqlIdentifierParameterSource parameterSource,
RelationalPersistentProperty property, @Nullable Object value, SqlIdentifier name) {
addConvertedValue(parameterSource, value, name, property.getColumnType(), property.getSqlType());
}
private void addConvertedPropertyValue(SqlIdentifierParameterSource parameterSource, SqlIdentifier name, Object value,
Class<?> javaType) {
addConvertedValue(parameterSource, value, name, javaType, JdbcUtil.sqlTypeFor(javaType));
}
private void addConvertedValue(SqlIdentifierParameterSource parameterSource, @Nullable Object value,
SqlIdentifier paramName, Class<?> javaType, int sqlType) {
JdbcValue jdbcValue = converter.writeJdbcValue( //
value, //
type, //
JdbcUtil.sqlTypeFor(type) //
javaType, //
sqlType //
);
parameterSource.addValue( //
name, //
paramName, //
jdbcValue.getValue(), //
JdbcUtil.sqlTypeFor(jdbcValue.getJdbcType()) //
);
JdbcUtil.sqlTypeFor(jdbcValue.getJdbcType()));
}
private void addConvertedPropertyValuesAsList(MapSqlParameterSource parameterSource,
RelationalPersistentProperty property, Iterable<?> values, String paramName) {
private void addConvertedPropertyValuesAsList(SqlIdentifierParameterSource parameterSource,
RelationalPersistentProperty property, Iterable<?> values, SqlIdentifier paramName) {
List<Object> convertedIds = new ArrayList<>();
JdbcValue jdbcValue = null;

4
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/DelegatingDataAccessStrategy.java
View File

@@ -20,6 +20,7 @@ import java.util.Map;
import org.springframework.data.mapping.PersistentPropertyPath;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.util.Assert;
/**
@@ -39,7 +40,7 @@ public class DelegatingDataAccessStrategy implements DataAccessStrategy {
* @see org.springframework.data.jdbc.core.DataAccessStrategy#insert(java.lang.Object, java.lang.Class, java.util.Map)
*/
@Override
public <T> Object insert(T instance, Class<T> domainType, Map<String, Object> additionalParameters) {
public <T> Object insert(T instance, Class<T> domainType, Map<SqlIdentifier, Object> additionalParameters) {
return delegate.insert(instance, domainType, additionalParameters);
}
@@ -70,6 +71,7 @@ public class DelegatingDataAccessStrategy implements DataAccessStrategy {
return delegate.updateWithVersion(instance, domainType, nextVersion);
}
/*
* (non-Javadoc)
* @see org.springframework.data.jdbc.core.DataAccessStrategy#delete(java.lang.Object, org.springframework.data.mapping.PersistentPropertyPath)

9
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/MapEntityRowMapper.java
View File

@@ -24,6 +24,8 @@ import java.util.Map;
import org.springframework.data.relational.core.mapping.PersistentPropertyPathExtension;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.lang.NonNull;
@@ -40,13 +42,14 @@ class MapEntityRowMapper<T> implements RowMapper<Map.Entry<Object, T>> {
private final PersistentPropertyPathExtension path;
private final JdbcConverter converter;
private final Identifier identifier;
private final String keyColumn;
private final SqlIdentifier keyColumn;
private final IdentifierProcessing identifierProcessing;
@NonNull
@Override
public Map.Entry<Object, T> mapRow(ResultSet rs, int rowNum) throws SQLException {
Object key = rs.getObject(keyColumn);
Object key = rs.getObject(keyColumn.toColumnName(identifierProcessing));
return new HashMap.SimpleEntry<>(key, mapEntity(rs, key));
}

27
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/SqlContext.java
View File

@@ -20,6 +20,8 @@ import org.springframework.data.relational.core.mapping.RelationalPersistentEnti
import org.springframework.data.relational.core.sql.Column;
import org.springframework.data.relational.core.sql.SQL;
import org.springframework.data.relational.core.sql.Table;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.data.relational.domain.SqlIdentifier;
/**
* Utility to get from path to SQL DSL elements.
@@ -33,36 +35,41 @@ class SqlContext {
private final RelationalPersistentEntity<?> entity;
private final Table table;
private final IdentifierProcessing identifierProcessing;
SqlContext(RelationalPersistentEntity<?> entity) {
SqlContext(RelationalPersistentEntity<?> entity, IdentifierProcessing identifierProcessing) {
this.identifierProcessing = identifierProcessing;
this.entity = entity;
this.table = SQL.table(entity.getTableName());
this.table = SQL.table(entity.getTableName().toSql(this.identifierProcessing));
}
Column getIdColumn() {
return table.column(entity.getIdColumn());
return table.column(entity.getIdColumn().toSql(identifierProcessing));
}
Column getVersionColumn() {
return table.column(entity.getRequiredVersionProperty().getColumnName());
return table.column(entity.getRequiredVersionProperty().getColumnName().toSql(identifierProcessing));
}
Table getTable() {
return table;
}
Table getTable(PersistentPropertyPathExtension path) {
String tableAlias = path.getTableAlias();
Table table = SQL.table(path.getTableName());
return tableAlias == null ? table : table.as(tableAlias);
SqlIdentifier tableAlias = path.getTableAlias();
Table table = SQL.table(path.getTableName().toSql(identifierProcessing));
return tableAlias == null ? table : table.as(tableAlias.toSql(identifierProcessing));
}
Column getColumn(PersistentPropertyPathExtension path) {
return getTable(path).column(path.getColumnName()).as(path.getColumnAlias());
return getTable(path).column(path.getColumnName().toSql(identifierProcessing))
.as(path.getColumnAlias().toSql(identifierProcessing));
}
Column getReverseColumn(PersistentPropertyPathExtension path) {
return getTable(path).column(path.getReverseColumnName()).as(path.getReverseColumnNameAlias());
return getTable(path).column(path.getReverseColumnName().toSql(identifierProcessing))
.as(path.getReverseColumnNameAlias().toSql(identifierProcessing));
}
}

140
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/SqlGenerator.java
View File

@@ -17,14 +17,7 @@ package org.springframework.data.jdbc.core.convert;
import lombok.Value;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.function.Function;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
@@ -40,6 +33,8 @@ import org.springframework.data.relational.core.mapping.RelationalPersistentProp
import org.springframework.data.relational.core.sql.*;
import org.springframework.data.relational.core.sql.render.SqlRenderer;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.data.util.Lazy;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
@@ -57,11 +52,15 @@ import org.springframework.util.Assert;
*/
class SqlGenerator {
static final String VERSION_SQL_PARAMETER_NAME = "___oldOptimisticLockingVersion";
static final SqlIdentifier VERSION_SQL_PARAMETER = SqlIdentifier.unquoted("___oldOptimisticLockingVersion");
static final SqlIdentifier ID_SQL_PARAMETER = SqlIdentifier.unquoted("id");
static final SqlIdentifier IDS_SQL_PARAMETER = SqlIdentifier.unquoted("ids");
static final SqlIdentifier ROOT_ID_PARAMETER = SqlIdentifier.unquoted("rootId");
private static final Pattern parameterPattern = Pattern.compile("\\W");
private final RelationalPersistentEntity<?> entity;
private final MappingContext<RelationalPersistentEntity<?>, RelationalPersistentProperty> mappingContext;
private final IdentifierProcessing identifierProcessing;
private final SqlContext sqlContext;
private final Columns columns;
@@ -82,15 +81,18 @@ class SqlGenerator {
/**
* Create a new {@link SqlGenerator} given {@link RelationalMappingContext} and {@link RelationalPersistentEntity}.
*
*
* @param mappingContext must not be {@literal null}.
* @param entity must not be {@literal null}.
* @param identifierProcessing must not be {@literal null}.
*/
SqlGenerator(RelationalMappingContext mappingContext, RelationalPersistentEntity<?> entity) {
SqlGenerator(RelationalMappingContext mappingContext, RelationalPersistentEntity<?> entity,
IdentifierProcessing identifierProcessing) {
this.mappingContext = mappingContext;
this.entity = entity;
this.sqlContext = new SqlContext(entity);
this.identifierProcessing = identifierProcessing;
this.sqlContext = new SqlContext(entity, identifierProcessing);
this.columns = new Columns(entity, mappingContext);
}
@@ -103,7 +105,7 @@ class SqlGenerator {
* @param filterColumn the column to apply the IN-condition to.
* @return the IN condition
*/
private static Condition getSubselectCondition(PersistentPropertyPathExtension path,
private Condition getSubselectCondition(PersistentPropertyPathExtension path,
Function<Column, Condition> rootCondition, Column filterColumn) {
PersistentPropertyPathExtension parentPath = path.getParentPath();
@@ -115,9 +117,10 @@ class SqlGenerator {
return rootCondition.apply(filterColumn);
}
Table subSelectTable = SQL.table(parentPath.getTableName());
Column idColumn = subSelectTable.column(parentPath.getIdColumnName());
Column selectFilterColumn = subSelectTable.column(parentPath.getEffectiveIdColumnName());
Table subSelectTable = SQL.table(parentPath.getTableName().toSql(identifierProcessing));
Column idColumn = subSelectTable.column(parentPath.getIdColumnName().toSql(identifierProcessing));
Column selectFilterColumn = subSelectTable
.column(parentPath.getEffectiveIdColumnName().toSql(identifierProcessing));
Condition innerCondition;
@@ -139,8 +142,8 @@ class SqlGenerator {
return filterColumn.in(select);
}
private static BindMarker getBindMarker(String columnName) {
return SQL.bindMarker(":" + parameterPattern.matcher(columnName).replaceAll(""));
private BindMarker getBindMarker(SqlIdentifier columnName) {
return SQL.bindMarker(":" + parameterPattern.matcher(columnName.toColumnName(identifierProcessing)).replaceAll(""));
}
/**
@@ -174,7 +177,7 @@ class SqlGenerator {
* keyColumn must not be {@code null}.
* @return a SQL String.
*/
String getFindAllByProperty(Identifier parentIdentifier, @Nullable String keyColumn, boolean ordered) {
String getFindAllByProperty(Identifier parentIdentifier, @Nullable SqlIdentifier keyColumn, boolean ordered) {
Assert.isTrue(keyColumn != null || !ordered,
"If the SQL statement should be ordered a keyColumn to order by must be provided.");
@@ -182,7 +185,7 @@ class SqlGenerator {
SelectBuilder.SelectWhere builder = selectBuilder( //
keyColumn == null //
? Collections.emptyList() //
: Collections.singleton(keyColumn) //
: Collections.singleton(keyColumn.toSql(identifierProcessing)) //
);
Table table = getTable();
@@ -191,7 +194,9 @@ class SqlGenerator {
SelectBuilder.SelectWhereAndOr withWhereClause = builder.where(condition);
Select select = ordered //
? withWhereClause.orderBy(table.column(keyColumn).as(keyColumn)).build() //
? withWhereClause
.orderBy(table.column(keyColumn.toSql(identifierProcessing)).as(keyColumn.toSql(identifierProcessing)))
.build() //
: withWhereClause.build();
return render(select);
@@ -200,9 +205,10 @@ class SqlGenerator {
private Condition buildConditionForBackReference(Identifier parentIdentifier, Table table) {
Condition condition = null;
for (String backReferenceColumn : parentIdentifier.toMap().keySet()) {
for (SqlIdentifier backReferenceColumn : parentIdentifier.toMap().keySet()) {
Condition newCondition = table.column(backReferenceColumn).isEqualTo(getBindMarker(backReferenceColumn));
Condition newCondition = table.column(backReferenceColumn.toSql(identifierProcessing))
.isEqualTo(getBindMarker(backReferenceColumn));
condition = condition == null ? newCondition : condition.and(newCondition);
}
@@ -214,7 +220,7 @@ class SqlGenerator {
/**
* Create a {@code SELECT COUNT(id) FROM … WHERE :id = …} statement.
*
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String getExists() {
return existsSql.get();
@@ -223,7 +229,7 @@ class SqlGenerator {
/**
* Create a {@code SELECT … FROM … WHERE :id = …} statement.
*
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String getFindOne() {
return findOneSql.get();
@@ -232,16 +238,16 @@ class SqlGenerator {
/**
* Create a {@code INSERT INTO … (…) VALUES(…)} statement.
*
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String getInsert(Set<String> additionalColumns) {
String getInsert(Set<SqlIdentifier> additionalColumns) {
return createInsertSql(additionalColumns);
}
/**
* Create a {@code UPDATE … SET …} statement.
*
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String getUpdate() {
return updateSql.get();
@@ -250,7 +256,7 @@ class SqlGenerator {
/**
* Create a {@code UPDATE … SET … WHERE ID = :id and VERSION_COLUMN = :___oldOptimisticLockingVersion } statement.
*
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String getUpdateWithVersion() {
return updateWithVersionSql.get();
@@ -259,7 +265,7 @@ class SqlGenerator {
/**
* Create a {@code SELECT COUNT(*) FROM …} statement.
*
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String getCount() {
return countSql.get();
@@ -268,7 +274,7 @@ class SqlGenerator {
/**
* Create a {@code DELETE FROM … WHERE :id = …} statement.
*
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String getDeleteById() {
return deleteByIdSql.get();
@@ -277,7 +283,7 @@ class SqlGenerator {
/**
* Create a {@code DELETE FROM … WHERE :id = … and :___oldOptimisticLockingVersion = ...} statement.
*
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String getDeleteByIdAndVersion() {
return deleteByIdAndVersionSql.get();
@@ -286,7 +292,7 @@ class SqlGenerator {
/**
* Create a {@code DELETE FROM … WHERE :ids in (…)} statement.
*
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String getDeleteByList() {
return deleteByListSql.get();
@@ -296,7 +302,7 @@ class SqlGenerator {
* Create a {@code DELETE} query and optionally filter by {@link PersistentPropertyPath}.
*
* @param path can be {@literal null}.
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String createDeleteAllSql(@Nullable PersistentPropertyPath<RelationalPersistentProperty> path) {
@@ -315,16 +321,16 @@ class SqlGenerator {
* Create a {@code DELETE} query and filter by {@link PersistentPropertyPath}.
*
* @param path must not be {@literal null}.
* @return
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
String createDeleteByPath(PersistentPropertyPath<RelationalPersistentProperty> path) {
return createDeleteByPathAndCriteria(new PersistentPropertyPathExtension(mappingContext, path),
filterColumn -> filterColumn.isEqualTo(getBindMarker("rootId")));
filterColumn -> filterColumn.isEqualTo(getBindMarker(ROOT_ID_PARAMETER)));
}
private String createFindOneSql() {
Select select = selectBuilder().where(getIdColumn().isEqualTo(getBindMarker("id"))) //
Select select = selectBuilder().where(getIdColumn().isEqualTo(getBindMarker(ID_SQL_PARAMETER))) //
.build();
return render(select);
@@ -379,8 +385,8 @@ class SqlGenerator {
/**
* Create a {@link Column} for {@link PersistentPropertyPathExtension}.
*
* @param path
* @return
* @param path the path to the column in question.
* @return the statement as a {@link String}. Guaranteed to be not {@literal null}.
*/
@Nullable
Column getColumn(PersistentPropertyPathExtension path) {
@@ -425,14 +431,14 @@ class SqlGenerator {
return new Join( //
currentTable, //
currentTable.column(path.getReverseColumnName()), //
parentTable.column(idDefiningParentPath.getIdColumnName()) //
currentTable.column(path.getReverseColumnName().toSql(identifierProcessing)), //
parentTable.column(idDefiningParentPath.getIdColumnName().toSql(identifierProcessing)) //
);
}
private String createFindAllInListSql() {
Select select = selectBuilder().where(getIdColumn().in(getBindMarker("ids"))).build();
Select select = selectBuilder().where(getIdColumn().in(getBindMarker(IDS_SQL_PARAMETER))).build();
return render(select);
}
@@ -444,7 +450,7 @@ class SqlGenerator {
Select select = StatementBuilder //
.select(Functions.count(getIdColumn())) //
.from(table) //
.where(getIdColumn().isEqualTo(getBindMarker("id"))) //
.where(getIdColumn().isEqualTo(getBindMarker(ID_SQL_PARAMETER))) //
.build();
return render(select);
@@ -462,21 +468,22 @@ class SqlGenerator {
return render(select);
}
private String createInsertSql(Set<String> additionalColumns) {
private String createInsertSql(Set<SqlIdentifier> additionalColumns) {
Table table = getTable();
Set<String> columnNamesForInsert = new LinkedHashSet<>(columns.getInsertableColumns());
Set<SqlIdentifier> columnNamesForInsert = new TreeSet<>(Comparator.comparing(id -> id.toSql(identifierProcessing)));
columnNamesForInsert.addAll(columns.getInsertableColumns());
columnNamesForInsert.addAll(additionalColumns);
InsertBuilder.InsertIntoColumnsAndValuesWithBuild insert = Insert.builder().into(table);
for (String cn : columnNamesForInsert) {
insert = insert.column(table.column(cn));
for (SqlIdentifier cn : columnNamesForInsert) {
insert = insert.column(table.column(cn.toSql(identifierProcessing)));
}
InsertBuilder.InsertValuesWithBuild insertWithValues = null;
for (String cn : columnNamesForInsert) {
for (SqlIdentifier cn : columnNamesForInsert) {
insertWithValues = (insertWithValues == null ? insert : insertWithValues).values(getBindMarker(cn));
}
@@ -490,7 +497,8 @@ class SqlGenerator {
private String createUpdateWithVersionSql() {
Update update = createBaseUpdate() //
.and(getVersionColumn().isEqualTo(SQL.bindMarker(":" + VERSION_SQL_PARAMETER_NAME))) //
.and(getVersionColumn()
.isEqualTo(SQL.bindMarker(":" + VERSION_SQL_PARAMETER.toColumnName(identifierProcessing)))) //
.build();
return render(update);
@@ -503,7 +511,7 @@ class SqlGenerator {
List<AssignValue> assignments = columns.getUpdateableColumns() //
.stream() //
.map(columnName -> Assignments.value( //
table.column(columnName), //
table.column(columnName.toSql(identifierProcessing)), //
getBindMarker(columnName))) //
.collect(Collectors.toList());
@@ -520,7 +528,8 @@ class SqlGenerator {
private String createDeleteByIdAndVersionSql() {
Delete delete = createBaseDeleteById(getTable()) //
.and(getVersionColumn().isEqualTo(SQL.bindMarker(":" + VERSION_SQL_PARAMETER_NAME))) //
.and(getVersionColumn()
.isEqualTo(SQL.bindMarker(":" + VERSION_SQL_PARAMETER.toColumnName(identifierProcessing)))) //
.build();
return render(delete);
@@ -533,13 +542,13 @@ class SqlGenerator {
private String createDeleteByPathAndCriteria(PersistentPropertyPathExtension path,
Function<Column, Condition> rootCondition) {
Table table = SQL.table(path.getTableName());
Table table = SQL.table(path.getTableName().toSql(identifierProcessing));
DeleteBuilder.DeleteWhere builder = Delete.builder() //
.from(table);
Delete delete;
Column filterColumn = table.column(path.getReverseColumnName());
Column filterColumn = table.column(path.getReverseColumnName().toSql(identifierProcessing));
if (path.getLength() == 1) {
@@ -561,7 +570,7 @@ class SqlGenerator {
Delete delete = Delete.builder() //
.from(table) //
.where(getIdColumn().in(getBindMarker("ids"))) //
.where(getIdColumn().in(getBindMarker(IDS_SQL_PARAMETER))) //
.build();
return render(delete);
@@ -609,17 +618,18 @@ class SqlGenerator {
* Value object encapsulating column name caches.
*
* @author Mark Paluch
* @author Jens Schauder
*/
static class Columns {
private final MappingContext<RelationalPersistentEntity<?>, RelationalPersistentProperty> mappingContext;
private final List<String> columnNames = new ArrayList<>();
private final List<String> idColumnNames = new ArrayList<>();
private final List<String> nonIdColumnNames = new ArrayList<>();
private final Set<String> readOnlyColumnNames = new HashSet<>();
private final Set<String> insertableColumns;
private final Set<String> updateableColumns;
private final List<SqlIdentifier> columnNames = new ArrayList<>();
private final List<SqlIdentifier> idColumnNames = new ArrayList<>();
private final List<SqlIdentifier> nonIdColumnNames = new ArrayList<>();
private final Set<SqlIdentifier> readOnlyColumnNames = new HashSet<>();
private final Set<SqlIdentifier> insertableColumns;
private final Set<SqlIdentifier> updateableColumns;
Columns(RelationalPersistentEntity<?> entity,
MappingContext<RelationalPersistentEntity<?>, RelationalPersistentProperty> mappingContext) {
@@ -628,12 +638,12 @@ class SqlGenerator {
populateColumnNameCache(entity, "");
Set<String> insertable = new LinkedHashSet<>(nonIdColumnNames);
Set<SqlIdentifier> insertable = new LinkedHashSet<>(nonIdColumnNames);
insertable.removeAll(readOnlyColumnNames);
this.insertableColumns = Collections.unmodifiableSet(insertable);
Set<String> updateable = new LinkedHashSet<>(columnNames);
Set<SqlIdentifier> updateable = new LinkedHashSet<>(columnNames);
updateable.removeAll(idColumnNames);
updateable.removeAll(readOnlyColumnNames);
@@ -656,7 +666,7 @@ class SqlGenerator {
private void initSimpleColumnName(RelationalPersistentProperty property, String prefix) {
String columnName = prefix + property.getColumnName();
SqlIdentifier columnName = property.getColumnName().prefix(prefix);
columnNames.add(columnName);
@@ -684,14 +694,14 @@ class SqlGenerator {
/**
* @return Column names that can be used for {@code INSERT}.
*/
Set<String> getInsertableColumns() {
Set<SqlIdentifier> getInsertableColumns() {
return insertableColumns;
}
/**
* @return Column names that can be used for {@code UPDATE}.
*/
Set<String> getUpdateableColumns() {
Set<SqlIdentifier> getUpdateableColumns() {
return updateableColumns;
}
}

13
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/SqlGeneratorSource.java
View File

@@ -19,7 +19,9 @@ import lombok.RequiredArgsConstructor;
import java.util.Map;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.util.ConcurrentReferenceHashMap;
/**
@@ -33,8 +35,17 @@ public class SqlGeneratorSource {
private final Map<Class<?>, SqlGenerator> CACHE = new ConcurrentReferenceHashMap<>();
private final RelationalMappingContext context;
private final Dialect dialect;
/**
* @return the {@link Dialect} used by the created {@link SqlGenerator} instances. Guaranteed to be not {@literal null}.
*/
public Dialect getDialect() {
return dialect;
}
SqlGenerator getSqlGenerator(Class<?> domainType) {
return CACHE.computeIfAbsent(domainType, t -> new SqlGenerator(context, context.getRequiredPersistentEntity(t)));
return CACHE.computeIfAbsent(domainType, t -> new SqlGenerator(context, context.getRequiredPersistentEntity(t), dialect.getIdentifierProcessing()));
}
}

84
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/SqlIdentifierParameterSource.java Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.jdbc.core.convert;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.jdbc.core.namedparam.AbstractSqlParameterSource;
/**
* Implementation of the {@link org.springframework.jdbc.core.namedparam.SqlParameterSource} interface based on
* {@link SqlIdentifier} instead of {@link String} for names.
*
* @author Jens Schauder
* @since 2.0
*/
class SqlIdentifierParameterSource extends AbstractSqlParameterSource {
private final IdentifierProcessing identifierProcessing;
private final Set<SqlIdentifier> identifiers = new HashSet<>();
private final Map<String, Object> namesToValues = new HashMap<>();
SqlIdentifierParameterSource(IdentifierProcessing identifierProcessing) {
this.identifierProcessing = identifierProcessing;
}
@Override
public boolean hasValue(String paramName) {
return namesToValues.containsKey(paramName);
}
@Override
public Object getValue(String paramName) throws IllegalArgumentException {
return namesToValues.get(paramName);
}
@Override
public String[] getParameterNames() {
return namesToValues.keySet().toArray(new String[0]);
}
Set<SqlIdentifier> getIdentifiers() {
return Collections.unmodifiableSet(identifiers);
}
void addValue(SqlIdentifier name, Object value) {
addValue(name, value, Integer.MIN_VALUE);
}
void addValue(SqlIdentifier identifier, Object value, int sqlType) {
identifiers.add(identifier);
String name = identifier.toColumnName(identifierProcessing);
namesToValues.put(name, value);
registerSqlType(name, sqlType);
}
void addAll(SqlIdentifierParameterSource others) {
for (SqlIdentifier identifier : others.getIdentifiers()) {
String name = identifier.toColumnName(identifierProcessing);
addValue(identifier, others.getValue(name), others.getSqlType(name));
}
}
}

113
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/mybatis/MyBatisDataAccessStrategy.java
View File

@@ -15,11 +15,11 @@
*/
package org.springframework.data.jdbc.mybatis;
import static java.util.Arrays.asList;
import static java.util.Arrays.*;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.ibatis.exceptions.PersistenceException;
import org.apache.ibatis.session.SqlSession;
@@ -34,9 +34,12 @@ import org.springframework.data.jdbc.core.convert.JdbcConverter;
import org.springframework.data.jdbc.core.convert.SqlGeneratorSource;
import org.springframework.data.mapping.PersistentPropertyPath;
import org.springframework.data.mapping.PropertyPath;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
import org.springframework.util.Assert;
@@ -61,6 +64,7 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
private static final String VERSION_SQL_PARAMETER_NAME_OLD = "___oldOptimisticLockingVersion";
private final SqlSession sqlSession;
private final IdentifierProcessing identifierProcessing;
private NamespaceStrategy namespaceStrategy = NamespaceStrategy.DEFAULT_INSTANCE;
/**
@@ -68,8 +72,9 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
* uses a {@link DefaultDataAccessStrategy}
*/
public static DataAccessStrategy createCombinedAccessStrategy(RelationalMappingContext context,
JdbcConverter converter, NamedParameterJdbcOperations operations, SqlSession sqlSession) {
return createCombinedAccessStrategy(context, converter, operations, sqlSession, NamespaceStrategy.DEFAULT_INSTANCE);
JdbcConverter converter, NamedParameterJdbcOperations operations, SqlSession sqlSession, Dialect dialect) {
return createCombinedAccessStrategy(context, converter, operations, sqlSession, NamespaceStrategy.DEFAULT_INSTANCE,
dialect);
}
/**
@@ -78,19 +83,20 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
*/
public static DataAccessStrategy createCombinedAccessStrategy(RelationalMappingContext context,
JdbcConverter converter, NamedParameterJdbcOperations operations, SqlSession sqlSession,
NamespaceStrategy namespaceStrategy) {
NamespaceStrategy namespaceStrategy, Dialect dialect) {
// the DefaultDataAccessStrategy needs a reference to the returned DataAccessStrategy. This creates a dependency
// cycle. In order to create it, we need something that allows to defer closing the cycle until all the elements are
// created. That is the purpose of the DelegatingAccessStrategy.
DelegatingDataAccessStrategy delegatingDataAccessStrategy = new DelegatingDataAccessStrategy();
MyBatisDataAccessStrategy myBatisDataAccessStrategy = new MyBatisDataAccessStrategy(sqlSession, context, converter);
MyBatisDataAccessStrategy myBatisDataAccessStrategy = new MyBatisDataAccessStrategy(sqlSession,
dialect.getIdentifierProcessing());
myBatisDataAccessStrategy.setNamespaceStrategy(namespaceStrategy);
CascadingDataAccessStrategy cascadingDataAccessStrategy = new CascadingDataAccessStrategy(
asList(myBatisDataAccessStrategy, delegatingDataAccessStrategy));
SqlGeneratorSource sqlGeneratorSource = new SqlGeneratorSource(context);
SqlGeneratorSource sqlGeneratorSource = new SqlGeneratorSource(context, dialect);
DefaultDataAccessStrategy defaultDataAccessStrategy = new DefaultDataAccessStrategy( //
sqlGeneratorSource, //
context, //
@@ -109,13 +115,17 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
* Use a {@link SqlSessionTemplate} for {@link SqlSession} or a similar implementation tying the session to the proper
* transaction. Note that the resulting {@link DataAccessStrategy} only handles MyBatis. It does not include the
* functionality of the {@link DefaultDataAccessStrategy} which one normally still wants. Use
* {@link #createCombinedAccessStrategy(RelationalMappingContext, JdbcConverter, NamedParameterJdbcOperations, SqlSession, NamespaceStrategy)}
* {@link #createCombinedAccessStrategy(RelationalMappingContext, JdbcConverter, NamedParameterJdbcOperations, SqlSession, NamespaceStrategy, Dialect)}
* to create such a {@link DataAccessStrategy}.
*
* @param sqlSession Must be non {@literal null}.
* @param identifierProcessing the {@link IdentifierProcessing} applied to {@link SqlIdentifier} instances in order to
* turn them into {@link String}
*/
public MyBatisDataAccessStrategy(SqlSession sqlSession, RelationalMappingContext context, JdbcConverter converter) {
public MyBatisDataAccessStrategy(SqlSession sqlSession, IdentifierProcessing identifierProcessing) {
this.sqlSession = sqlSession;
this.identifierProcessing = identifierProcessing;
}
/**
@@ -135,9 +145,10 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
* @see org.springframework.data.jdbc.core.DataAccessStrategy#insert(java.lang.Object, java.lang.Class, java.util.Map)
*/
@Override
public <T> Object insert(T instance, Class<T> domainType, Map<String, Object> additionalParameters) {
public <T> Object insert(T instance, Class<T> domainType, Map<SqlIdentifier, Object> additionalParameters) {
MyBatisContext myBatisContext = new MyBatisContext(null, instance, domainType, additionalParameters);
MyBatisContext myBatisContext = new MyBatisContext(null, instance, domainType,
convertToParameterMap(additionalParameters));
sqlSession().insert(namespace(domainType) + ".insert", myBatisContext);
return myBatisContext.getId();
@@ -150,7 +161,8 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
@Override
public <T> Object insert(T instance, Class<T> domainType, Identifier identifier) {
MyBatisContext myBatisContext = new MyBatisContext(null, instance, domainType, identifier.toMap());
MyBatisContext myBatisContext = new MyBatisContext(null, instance, domainType,
convertToParameterMap(identifier.toMap()));
sqlSession().insert(namespace(domainType) + ".insert", myBatisContext);
return myBatisContext.getId();
@@ -174,9 +186,10 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
@Override
public <S> boolean updateWithVersion(S instance, Class<S> domainType, Number previousVersion) {
return sqlSession().update(namespace(domainType) + ".updateWithVersion",
new MyBatisContext(null, instance, domainType, Collections.singletonMap(VERSION_SQL_PARAMETER_NAME_OLD, previousVersion))) != 0;
String statement = namespace(domainType) + ".updateWithVersion";
MyBatisContext parameter = new MyBatisContext(null, instance, domainType,
Collections.singletonMap(VERSION_SQL_PARAMETER_NAME_OLD, previousVersion));
return sqlSession().update(statement, parameter) != 0;
}
/*
@@ -186,8 +199,9 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
@Override
public void delete(Object id, Class<?> domainType) {
sqlSession().delete(namespace(domainType) + ".delete",
new MyBatisContext(id, null, domainType, Collections.emptyMap()));
String statement = namespace(domainType) + ".delete";
MyBatisContext parameter = new MyBatisContext(id, null, domainType, Collections.emptyMap());
sqlSession().delete(statement, parameter);
}
/*
@@ -197,8 +211,10 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
@Override
public <T> void deleteWithVersion(Object id, Class<T> domainType, Number previousVersion) {
sqlSession().delete(namespace(domainType) + ".deleteWithVersion",
new MyBatisContext(id, null, domainType, Collections.singletonMap(VERSION_SQL_PARAMETER_NAME_OLD, previousVersion)));
String statement = namespace(domainType) + ".deleteWithVersion";
MyBatisContext parameter = new MyBatisContext(id, null, domainType,
Collections.singletonMap(VERSION_SQL_PARAMETER_NAME_OLD, previousVersion));
sqlSession().delete(statement, parameter);
}
/*
@@ -208,10 +224,12 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
@Override
public void delete(Object rootId, PersistentPropertyPath<RelationalPersistentProperty> propertyPath) {
sqlSession().delete(
namespace(propertyPath.getBaseProperty().getOwner().getType()) + ".delete-" + toDashPath(propertyPath),
new MyBatisContext(rootId, null, propertyPath.getRequiredLeafProperty().getTypeInformation().getType(),
Collections.emptyMap()));
Class<?> ownerType = propertyPath.getBaseProperty().getOwner().getType();
String statement = namespace(ownerType) + ".delete-" + toDashPath(propertyPath);
Class<?> leafType = propertyPath.getRequiredLeafProperty().getTypeInformation().getType();
MyBatisContext parameter = new MyBatisContext(rootId, null, leafType, Collections.emptyMap());
sqlSession().delete(statement, parameter);
}
/*
@@ -221,10 +239,9 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
@Override
public <T> void deleteAll(Class<T> domainType) {
sqlSession().delete( //
namespace(domainType) + ".deleteAll", //
new MyBatisContext(null, null, domainType, Collections.emptyMap()) //
);
String statement = namespace(domainType) + ".deleteAll";
MyBatisContext parameter = new MyBatisContext(null, null, domainType, Collections.emptyMap());
sqlSession().delete(statement, parameter);
}
/*
@@ -237,10 +254,9 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
Class<?> baseType = propertyPath.getBaseProperty().getOwner().getType();
Class<?> leafType = propertyPath.getRequiredLeafProperty().getTypeInformation().getType();
sqlSession().delete( //
namespace(baseType) + ".deleteAll-" + toDashPath(propertyPath), //
new MyBatisContext(null, null, leafType, Collections.emptyMap()) //
);
String statement = namespace(baseType) + ".deleteAll-" + toDashPath(propertyPath);
MyBatisContext parameter = new MyBatisContext(null, null, leafType, Collections.emptyMap());
sqlSession().delete(statement, parameter);
}
/*
@@ -249,8 +265,10 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
*/
@Override
public <T> T findById(Object id, Class<T> domainType) {
return sqlSession().selectOne(namespace(domainType) + ".findById",
new MyBatisContext(id, null, domainType, Collections.emptyMap()));
String statement = namespace(domainType) + ".findById";
MyBatisContext parameter = new MyBatisContext(id, null, domainType, Collections.emptyMap());
return sqlSession().selectOne(statement, parameter);
}
/*
@@ -259,8 +277,10 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
*/
@Override
public <T> Iterable<T> findAll(Class<T> domainType) {
return sqlSession().selectList(namespace(domainType) + ".findAll",
new MyBatisContext(null, null, domainType, Collections.emptyMap()));
String statement = namespace(domainType) + ".findAll";
MyBatisContext parameter = new MyBatisContext(null, null, domainType, Collections.emptyMap());
return sqlSession().selectList(statement, parameter);
}
/*
@@ -299,9 +319,9 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
@Override
public <T> Iterable<T> findAllByProperty(Object rootId, RelationalPersistentProperty property) {
return sqlSession().selectList(
namespace(property.getOwner().getType()) + ".findAllByProperty-" + property.getName(),
new MyBatisContext(rootId, null, property.getType(), Collections.emptyMap()));
String statement = namespace(property.getOwner().getType()) + ".findAllByProperty-" + property.getName();
MyBatisContext parameter = new MyBatisContext(rootId, null, property.getType(), Collections.emptyMap());
return sqlSession().selectList(statement, parameter);
}
/*
@@ -311,8 +331,9 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
@Override
public <T> boolean existsById(Object id, Class<T> domainType) {
return sqlSession().selectOne(namespace(domainType) + ".existsById",
new MyBatisContext(id, null, domainType, Collections.emptyMap()));
String statement = namespace(domainType) + ".existsById";
MyBatisContext parameter = new MyBatisContext(id, null, domainType, Collections.emptyMap());
return sqlSession().selectOne(statement, parameter);
}
/*
@@ -321,8 +342,16 @@ public class MyBatisDataAccessStrategy implements DataAccessStrategy {
*/
@Override
public long count(Class<?> domainType) {
return sqlSession().selectOne(namespace(domainType) + ".count",
new MyBatisContext(null, null, domainType, Collections.emptyMap()));
String statement = namespace(domainType) + ".count";
MyBatisContext parameter = new MyBatisContext(null, null, domainType, Collections.emptyMap());
return sqlSession().selectOne(statement, parameter);
}
private Map<String, Object> convertToParameterMap(Map<SqlIdentifier, Object> additionalParameters) {
return additionalParameters.entrySet().stream() //
.collect(Collectors.toMap(e -> e.getKey().toSql(identifierProcessing), Map.Entry::getValue));
}
private String namespace(Class<?> domainType) {

15
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/AbstractJdbcConfiguration.java
View File

@@ -34,6 +34,8 @@ import org.springframework.data.jdbc.core.convert.RelationResolver;
import org.springframework.data.jdbc.core.convert.SqlGeneratorSource;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.relational.core.conversion.RelationalConverter;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.dialect.HsqlDbDialect;
import org.springframework.data.relational.core.mapping.NamingStrategy;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
@@ -71,8 +73,8 @@ public class AbstractJdbcConfiguration {
}
/**
* Creates a {@link RelationalConverter} using the configured {@link #jdbcMappingContext(Optional)}. Will get
* {@link #jdbcCustomConversions()} applied.
* Creates a {@link RelationalConverter} using the configured
* {@link #jdbcMappingContext(Optional, JdbcCustomConversions)}. Will get {@link #jdbcCustomConversions()} applied.
*
* @see #jdbcMappingContext(Optional, JdbcCustomConversions)
* @see #jdbcCustomConversions()
@@ -125,7 +127,12 @@ public class AbstractJdbcConfiguration {
*/
@Bean
public DataAccessStrategy dataAccessStrategyBean(NamedParameterJdbcOperations operations, JdbcConverter jdbcConverter,
RelationalMappingContext context) {
return new DefaultDataAccessStrategy(new SqlGeneratorSource(context), context, jdbcConverter, operations);
RelationalMappingContext context, Dialect dialect) {
return new DefaultDataAccessStrategy(new SqlGeneratorSource(context, dialect), context, jdbcConverter, operations);
}
@Bean
Dialect dialect() {
return HsqlDbDialect.INSTANCE;
}
}

19
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/JdbcConfiguration.java
View File

@@ -34,6 +34,8 @@ import org.springframework.data.jdbc.core.convert.RelationResolver;
import org.springframework.data.jdbc.core.convert.SqlGeneratorSource;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.relational.core.conversion.RelationalConverter;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.dialect.HsqlDbDialect;
import org.springframework.data.relational.core.mapping.NamingStrategy;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
@@ -102,12 +104,15 @@ public class JdbcConfiguration {
* @param context
* @param converter
* @param operations
* @param dialect
* @return
*/
@Bean
public JdbcAggregateOperations jdbcAggregateOperations(ApplicationEventPublisher publisher,
RelationalMappingContext context, JdbcConverter converter, NamedParameterJdbcOperations operations) {
return new JdbcAggregateTemplate(publisher, context, converter, dataAccessStrategy(context, converter, operations));
RelationalMappingContext context, JdbcConverter converter, NamedParameterJdbcOperations operations,
Dialect dialect) {
return new JdbcAggregateTemplate(publisher, context, converter,
dataAccessStrategy(context, converter, operations, dialect));
}
/**
@@ -117,11 +122,17 @@ public class JdbcConfiguration {
* @param context
* @param converter
* @param operations
* @param dialect
* @return
*/
@Bean
public DataAccessStrategy dataAccessStrategy(RelationalMappingContext context, JdbcConverter converter,
NamedParameterJdbcOperations operations) {
return new DefaultDataAccessStrategy(new SqlGeneratorSource(context), context, converter, operations);
NamedParameterJdbcOperations operations, Dialect dialect) {
return new DefaultDataAccessStrategy(new SqlGeneratorSource(context, dialect), context, converter, operations);
}
@Bean
public Dialect dialect() {
return HsqlDbDialect.INSTANCE;
}
}

5
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/config/MyBatisJdbcConfiguration.java
View File

@@ -22,6 +22,7 @@ import org.springframework.context.annotation.Configuration;
import org.springframework.data.jdbc.core.convert.DataAccessStrategy;
import org.springframework.data.jdbc.core.convert.JdbcConverter;
import org.springframework.data.jdbc.mybatis.MyBatisDataAccessStrategy;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
@@ -43,8 +44,8 @@ public class MyBatisJdbcConfiguration extends AbstractJdbcConfiguration {
@Bean
@Override
public DataAccessStrategy dataAccessStrategyBean(NamedParameterJdbcOperations operations, JdbcConverter jdbcConverter,
RelationalMappingContext context) {
RelationalMappingContext context, Dialect dialect) {
return MyBatisDataAccessStrategy.createCombinedAccessStrategy(context, jdbcConverter, operations, session);
return MyBatisDataAccessStrategy.createCombinedAccessStrategy(context, jdbcConverter, operations, session, dialect);
}
}

11
spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java
View File

@@ -28,6 +28,7 @@ import org.springframework.data.jdbc.core.convert.SqlGeneratorSource;
import org.springframework.data.jdbc.repository.QueryMappingConfiguration;
import org.springframework.data.jdbc.repository.RowMapperMap;
import org.springframework.data.mapping.callback.EntityCallbacks;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.core.support.RepositoryFactorySupport;
@@ -56,6 +57,7 @@ public class JdbcRepositoryFactoryBean<T extends Repository<S, ID>, S, ID extend
private QueryMappingConfiguration queryMappingConfiguration = QueryMappingConfiguration.EMPTY;
private NamedParameterJdbcOperations operations;
private EntityCallbacks entityCallbacks;
private Dialect dialect;
/**
* Creates a new {@link JdbcRepositoryFactoryBean} for the given repository interface.
@@ -99,6 +101,11 @@ public class JdbcRepositoryFactoryBean<T extends Repository<S, ID>, S, ID extend
this.mappingContext = mappingContext;
}
@Autowired
protected void setDialect(Dialect dialect) {
this.dialect = dialect;
}
/**
* @param dataAccessStrategy can be {@literal null}.
*/
@@ -167,7 +174,9 @@ public class JdbcRepositoryFactoryBean<T extends Repository<S, ID>, S, ID extend
this.dataAccessStrategy = this.beanFactory.getBeanProvider(DataAccessStrategy.class) //
.getIfAvailable(() -> {
SqlGeneratorSource sqlGeneratorSource = new SqlGeneratorSource(this.mappingContext);
Assert.state(this.dialect != null, "Dialect is required and must not be null!");
SqlGeneratorSource sqlGeneratorSource = new SqlGeneratorSource(this.mappingContext, this.dialect);
return new DefaultDataAccessStrategy(sqlGeneratorSource, this.mappingContext, this.converter,
this.operations);
});

23
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/DefaultJdbcInterpreterUnitTests.java
View File

@@ -15,14 +15,11 @@
*/
package org.springframework.data.jdbc.core;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.tuple;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.springframework.data.jdbc.core.PropertyPathTestingUtils.toPath;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import static org.springframework.data.jdbc.core.PropertyPathTestingUtils.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import java.util.List;
@@ -52,9 +49,8 @@ import org.springframework.data.relational.domain.Identifier;
*/
public class DefaultJdbcInterpreterUnitTests {
public static final SimpleSqlIdentifier BACK_REFERENCE = quoted("container");
static final long CONTAINER_ID = 23L;
static final String BACK_REFERENCE = "container";
RelationalMappingContext context = new JdbcMappingContext();
JdbcConverter converter = new BasicJdbcConverter(context, (Identifier, path) -> null);
DataAccessStrategy dataAccessStrategy = mock(DataAccessStrategy.class);
@@ -156,9 +152,10 @@ public class DefaultJdbcInterpreterUnitTests {
assertThat(argumentCaptor.getValue().getParts()) //
.extracting("name", "value", "targetType") //
.containsOnly(tuple("root_with_list", CONTAINER_ID, Long.class), // the top level id
tuple("root_with_list_key", 3, Integer.class), // midlevel key
tuple("with_list_key", 6, Integer.class) // lowlevel key
.containsOnly(tuple(quoted("root_with_list"), CONTAINER_ID, Long.class), // the top
// level id
tuple(quoted("root_with_list_key"), 3, Integer.class), // midlevel key
tuple(quoted("with_list_key"), 6, Integer.class) // lowlevel key
);
}

230
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/JdbcAggregateTemplateIntegrationTests.java
View File

@@ -89,6 +89,109 @@ public class JdbcAggregateTemplateIntegrationTests {
@Autowired NamedParameterJdbcOperations jdbcTemplate;
LegoSet legoSet = createLegoSet();
/**
* creates an instance of {@link NoIdListChain4} with the following properties:
* <ul>
* <li>Each element has two children with indices 0 and 1.</li>
* <li>the xxxValue of each element is a {@literal v} followed by the indices used to navigate to the given instance.
* </li>
* </ul>
*/
private static NoIdListChain4 createNoIdTree() {
NoIdListChain4 chain4 = new NoIdListChain4();
chain4.fourValue = "v";
IntStream.of(0, 1).forEach(i -> {
NoIdListChain3 c3 = new NoIdListChain3();
c3.threeValue = chain4.fourValue + i;
chain4.chain3.add(c3);
IntStream.of(0, 1).forEach(j -> {
NoIdListChain2 c2 = new NoIdListChain2();
c2.twoValue = c3.threeValue + j;
c3.chain2.add(c2);
IntStream.of(0, 1).forEach(k -> {
NoIdListChain1 c1 = new NoIdListChain1();
c1.oneValue = c2.twoValue + k;
c2.chain1.add(c1);
IntStream.of(0, 1).forEach(m -> {
NoIdListChain0 c0 = new NoIdListChain0();
c0.zeroValue = c1.oneValue + m;
c1.chain0.add(c0);
});
});
});
});
return chain4;
}
private static NoIdMapChain4 createNoIdMapTree() {
NoIdMapChain4 chain4 = new NoIdMapChain4();
chain4.fourValue = "v";
IntStream.of(0, 1).forEach(i -> {
NoIdMapChain3 c3 = new NoIdMapChain3();
c3.threeValue = chain4.fourValue + i;
chain4.chain3.put(asString(i), c3);
IntStream.of(0, 1).forEach(j -> {
NoIdMapChain2 c2 = new NoIdMapChain2();
c2.twoValue = c3.threeValue + j;
c3.chain2.put(asString(j), c2);
IntStream.of(0, 1).forEach(k -> {
NoIdMapChain1 c1 = new NoIdMapChain1();
c1.oneValue = c2.twoValue + k;
c2.chain1.put(asString(k), c1);
IntStream.of(0, 1).forEach(it -> {
NoIdMapChain0 c0 = new NoIdMapChain0();
c0.zeroValue = c1.oneValue + it;
c1.chain0.put(asString(it), c0);
});
});
});
});
return chain4;
}
private static String asString(int i) {
return "_" + i;
}
private static void assumeNot(String dbProfileName) {
Assume.assumeTrue("true"
.equalsIgnoreCase(ProfileValueUtils.retrieveProfileValueSource(JdbcAggregateTemplateIntegrationTests.class)
.get("current.database.is.not." + dbProfileName)));
}
private static LegoSet createLegoSet() {
LegoSet entity = new LegoSet();
entity.setName("Star Destroyer");
Manual manual = new Manual();
manual.setContent("Accelerates to 99% of light speed. Destroys almost everything. See https://what-if.xkcd.com/1/");
entity.setManual(manual);
return entity;
}
@Test // DATAJDBC-112
public void saveAndLoadAnEntityWithReferencedEntityById() {
@@ -550,50 +653,6 @@ public class JdbcAggregateTemplateIntegrationTests {
});
}
/**
* creates an instance of {@link NoIdListChain4} with the following properties:
* <ul>
* <li>Each element has two children with indices 0 and 1.</li>
* <li>the xxxValue of each element is a {@literal v} followed by the indices used to navigate to the given instance.
* </li>
* </ul>
*/
private static NoIdListChain4 createNoIdTree() {
NoIdListChain4 chain4 = new NoIdListChain4();
chain4.fourValue = "v";
IntStream.of(0, 1).forEach(i -> {
NoIdListChain3 c3 = new NoIdListChain3();
c3.threeValue = chain4.fourValue + i;
chain4.chain3.add(c3);
IntStream.of(0, 1).forEach(j -> {
NoIdListChain2 c2 = new NoIdListChain2();
c2.twoValue = c3.threeValue + j;
c3.chain2.add(c2);
IntStream.of(0, 1).forEach(k -> {
NoIdListChain1 c1 = new NoIdListChain1();
c1.oneValue = c2.twoValue + k;
c2.chain1.add(c1);
IntStream.of(0, 1).forEach(m -> {
NoIdListChain0 c0 = new NoIdListChain0();
c0.zeroValue = c1.oneValue + m;
c1.chain0.add(c0);
});
});
});
});
return chain4;
}
@Test // DATAJDBC-223
public void saveAndLoadLongChainOfMapsWithoutIds() {
@@ -758,57 +817,10 @@ public class JdbcAggregateTemplateIntegrationTests {
.withFailMessage("saving an aggregate with a future version should raise an exception");
}
private static NoIdMapChain4 createNoIdMapTree() {
NoIdMapChain4 chain4 = new NoIdMapChain4();
chain4.fourValue = "v";
IntStream.of(0, 1).forEach(i -> {
NoIdMapChain3 c3 = new NoIdMapChain3();
c3.threeValue = chain4.fourValue + i;
chain4.chain3.put(asString(i), c3);
IntStream.of(0, 1).forEach(j -> {
NoIdMapChain2 c2 = new NoIdMapChain2();
c2.twoValue = c3.threeValue + j;
c3.chain2.put(asString(j), c2);
IntStream.of(0, 1).forEach(k -> {
NoIdMapChain1 c1 = new NoIdMapChain1();
c1.oneValue = c2.twoValue + k;
c2.chain1.put(asString(k), c1);
IntStream.of(0, 1).forEach(it -> {
NoIdMapChain0 c0 = new NoIdMapChain0();
c0.zeroValue = c1.oneValue + it;
c1.chain0.put(asString(it), c0);
});
});
});
});
return chain4;
}
private static String asString(int i) {
return "_" + i;
}
private Long count(String tableName) {
return jdbcTemplate.queryForObject("SELECT COUNT(*) FROM " + tableName, emptyMap(), Long.class);
}
private static void assumeNot(String dbProfileName) {
Assume.assumeTrue("true"
.equalsIgnoreCase(ProfileValueUtils.retrieveProfileValueSource(JdbcAggregateTemplateIntegrationTests.class)
.get("current.database.is.not." + dbProfileName)));
}
private static class ArrayOwner {
@Id Long id;
@@ -836,18 +848,6 @@ public class JdbcAggregateTemplateIntegrationTests {
Set<String> digits = new HashSet<>();
}
private static LegoSet createLegoSet() {
LegoSet entity = new LegoSet();
entity.setName("Star Destroyer");
Manual manual = new Manual();
manual.setContent("Accelerates to 99% of light speed. Destroys almost everything. See https://what-if.xkcd.com/1/");
entity.setManual(manual);
return entity;
}
@Data
static class LegoSet {
@@ -1060,13 +1060,13 @@ public class JdbcAggregateTemplateIntegrationTests {
@Version private long version;
@Override
void setVersion(Number newVersion) {
this.version = (long) newVersion;
Number getVersion() {
return this.version;
}
@Override
Number getVersion() {
return this.version;
void setVersion(Number newVersion) {
this.version = (long) newVersion;
}
}
@@ -1088,13 +1088,13 @@ public class JdbcAggregateTemplateIntegrationTests {
@Version private int version;
@Override
void setVersion(Number newVersion) {
this.version = (int) newVersion;
Number getVersion() {
return this.version;
}
@Override
Number getVersion() {
return this.version;
void setVersion(Number newVersion) {
this.version = (int) newVersion;
}
}
@@ -1116,13 +1116,13 @@ public class JdbcAggregateTemplateIntegrationTests {
@Version private short version;
@Override
void setVersion(Number newVersion) {
this.version = (short) newVersion;
Number getVersion() {
return this.version;
}
@Override
Number getVersion() {
return this.version;
void setVersion(Number newVersion) {
this.version = (short) newVersion;
}
}

74
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/PersistentPropertyPathExtensionUnitTests.java
View File

@@ -15,9 +15,11 @@
*/
package org.springframework.data.jdbc.core;
import static org.assertj.core.api.SoftAssertions.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import java.util.List;
import org.jetbrains.annotations.NotNull;
import org.junit.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
@@ -28,8 +30,6 @@ import org.springframework.data.relational.core.mapping.PersistentPropertyPathEx
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import static org.assertj.core.api.SoftAssertions.*;
/**
* @author Jens Schauder
*/
@@ -99,13 +99,13 @@ public class PersistentPropertyPathExtensionUnitTests {
assertSoftly(softly -> {
softly.assertThat(extPath(entity).getTableName()).isEqualTo("dummy_entity");
softly.assertThat(extPath("second").getTableName()).isEqualTo("second");
softly.assertThat(extPath("second.third2").getTableName()).isEqualTo("second");
softly.assertThat(extPath("second.third2.value").getTableName()).isEqualTo("second");
softly.assertThat(extPath("secondList.third2").getTableName()).isEqualTo("second");
softly.assertThat(extPath("secondList.third2.value").getTableName()).isEqualTo("second");
softly.assertThat(extPath("secondList").getTableName()).isEqualTo("second");
softly.assertThat(extPath(entity).getTableName()).isEqualTo(quoted("dummy_entity"));
softly.assertThat(extPath("second").getTableName()).isEqualTo(quoted("second"));
softly.assertThat(extPath("second.third2").getTableName()).isEqualTo(quoted("second"));
softly.assertThat(extPath("second.third2.value").getTableName()).isEqualTo(quoted("second"));
softly.assertThat(extPath("secondList.third2").getTableName()).isEqualTo(quoted("second"));
softly.assertThat(extPath("secondList.third2.value").getTableName()).isEqualTo(quoted("second"));
softly.assertThat(extPath("secondList").getTableName()).isEqualTo(quoted("second"));
});
}
@@ -115,17 +115,17 @@ public class PersistentPropertyPathExtensionUnitTests {
assertSoftly(softly -> {
softly.assertThat(extPath(entity).getTableAlias()).isEqualTo(null);
softly.assertThat(extPath("second").getTableAlias()).isEqualTo("second");
softly.assertThat(extPath("second.third2").getTableAlias()).isEqualTo("second");
softly.assertThat(extPath("second.third2.value").getTableAlias()).isEqualTo("second");
softly.assertThat(extPath("second.third").getTableAlias()).isEqualTo("second_third");
softly.assertThat(extPath("second.third.value").getTableAlias()).isEqualTo("second_third");
softly.assertThat(extPath("secondList.third2").getTableAlias()).isEqualTo("secondList");
softly.assertThat(extPath("secondList.third2.value").getTableAlias()).isEqualTo("secondList");
softly.assertThat(extPath("secondList.third").getTableAlias()).isEqualTo("secondList_third");
softly.assertThat(extPath("secondList.third.value").getTableAlias()).isEqualTo("secondList_third");
softly.assertThat(extPath("secondList").getTableAlias()).isEqualTo("secondList");
softly.assertThat(extPath("second2.third").getTableAlias()).isEqualTo("secthird");
softly.assertThat(extPath("second").getTableAlias()).isEqualTo(quoted("second"));
softly.assertThat(extPath("second.third2").getTableAlias()).isEqualTo(quoted("second"));
softly.assertThat(extPath("second.third2.value").getTableAlias()).isEqualTo(quoted("second"));
softly.assertThat(extPath("second.third").getTableAlias()).isEqualTo(quoted("second_third"));
softly.assertThat(extPath("second.third.value").getTableAlias()).isEqualTo(quoted("second_third"));
softly.assertThat(extPath("secondList.third2").getTableAlias()).isEqualTo(quoted("secondList"));
softly.assertThat(extPath("secondList.third2.value").getTableAlias()).isEqualTo(quoted("secondList"));
softly.assertThat(extPath("secondList.third").getTableAlias()).isEqualTo(quoted("secondList_third"));
softly.assertThat(extPath("secondList.third.value").getTableAlias()).isEqualTo(quoted("secondList_third"));
softly.assertThat(extPath("secondList").getTableAlias()).isEqualTo(quoted("secondList"));
softly.assertThat(extPath("second2.third").getTableAlias()).isEqualTo(quoted("secthird"));
});
}
@@ -134,12 +134,12 @@ public class PersistentPropertyPathExtensionUnitTests {
assertSoftly(softly -> {
softly.assertThat(extPath("second.third2.value").getColumnName()).isEqualTo("thrdvalue");
softly.assertThat(extPath("second.third.value").getColumnName()).isEqualTo("value");
softly.assertThat(extPath("secondList.third2.value").getColumnName()).isEqualTo("thrdvalue");
softly.assertThat(extPath("secondList.third.value").getColumnName()).isEqualTo("value");
softly.assertThat(extPath("second2.third2.value").getColumnName()).isEqualTo("secthrdvalue");
softly.assertThat(extPath("second2.third.value").getColumnName()).isEqualTo("value");
softly.assertThat(extPath("second.third2.value").getColumnName()).isEqualTo(quoted("thrdvalue"));
softly.assertThat(extPath("second.third.value").getColumnName()).isEqualTo(quoted("value"));
softly.assertThat(extPath("secondList.third2.value").getColumnName()).isEqualTo(quoted("thrdvalue"));
softly.assertThat(extPath("secondList.third.value").getColumnName()).isEqualTo(quoted("value"));
softly.assertThat(extPath("second2.third2.value").getColumnName()).isEqualTo(quoted("secthrdvalue"));
softly.assertThat(extPath("second2.third.value").getColumnName()).isEqualTo(quoted("value"));
});
}
@@ -164,15 +164,15 @@ public class PersistentPropertyPathExtensionUnitTests {
assertSoftly(softly -> {
softly.assertThat(extPath("second.third2").getReverseColumnName()).isEqualTo("dummy_entity");
softly.assertThat(extPath("second.third").getReverseColumnName()).isEqualTo("dummy_entity");
softly.assertThat(extPath("secondList.third2").getReverseColumnName()).isEqualTo("dummy_entity");
softly.assertThat(extPath("secondList.third").getReverseColumnName()).isEqualTo("dummy_entity");
softly.assertThat(extPath("second2.third2").getReverseColumnName()).isEqualTo("dummy_entity");
softly.assertThat(extPath("second2.third").getReverseColumnName()).isEqualTo("dummy_entity");
softly.assertThat(extPath("withId.second.third2.value").getReverseColumnName()).isEqualTo("with_id");
softly.assertThat(extPath("withId.second.third").getReverseColumnName()).isEqualTo("with_id");
softly.assertThat(extPath("withId.second2.third").getReverseColumnName()).isEqualTo("with_id");
softly.assertThat(extPath("second.third2").getReverseColumnName()).isEqualTo(quoted("dummy_entity"));
softly.assertThat(extPath("second.third").getReverseColumnName()).isEqualTo(quoted("dummy_entity"));
softly.assertThat(extPath("secondList.third2").getReverseColumnName()).isEqualTo(quoted("dummy_entity"));
softly.assertThat(extPath("secondList.third").getReverseColumnName()).isEqualTo(quoted("dummy_entity"));
softly.assertThat(extPath("second2.third2").getReverseColumnName()).isEqualTo(quoted("dummy_entity"));
softly.assertThat(extPath("second2.third").getReverseColumnName()).isEqualTo(quoted("dummy_entity"));
softly.assertThat(extPath("withId.second.third2.value").getReverseColumnName()).isEqualTo(quoted("with_id"));
softly.assertThat(extPath("withId.second.third").getReverseColumnName()).isEqualTo(quoted("with_id"));
softly.assertThat(extPath("withId.second2.third").getReverseColumnName()).isEqualTo(quoted("with_id"));
});
}
@@ -200,12 +200,10 @@ public class PersistentPropertyPathExtensionUnitTests {
});
}
@NotNull
private PersistentPropertyPathExtension extPath(RelationalPersistentEntity<?> entity) {
return new PersistentPropertyPathExtension(context, entity);
}
@NotNull
private PersistentPropertyPathExtension extPath(String path) {
return new PersistentPropertyPathExtension(context, createSimplePath(path));
}

30
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/DefaultDataAccessStrategyUnitTests.java
View File

@@ -18,6 +18,7 @@ package org.springframework.data.jdbc.core.convert;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import lombok.AllArgsConstructor;
import lombok.RequiredArgsConstructor;
@@ -33,7 +34,10 @@ import org.springframework.data.annotation.Id;
import org.springframework.data.convert.ReadingConverter;
import org.springframework.data.convert.WritingConverter;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.dialect.HsqlDbDialect;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.jdbc.core.JdbcOperations;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
@@ -54,7 +58,7 @@ public class DefaultDataAccessStrategyUnitTests {
JdbcOperations jdbcOperations = mock(JdbcOperations.class);
RelationalMappingContext context = new JdbcMappingContext();
HashMap<String, Object> additionalParameters = new HashMap<>();
HashMap<SqlIdentifier, Object> additionalParameters = new HashMap<>();
ArgumentCaptor<SqlParameterSource> paramSourceCaptor = ArgumentCaptor.forClass(SqlParameterSource.class);
JdbcConverter converter;
@@ -62,12 +66,14 @@ public class DefaultDataAccessStrategyUnitTests {
@Before
public void before() {
DelegatingDataAccessStrategy relationResolver = new DelegatingDataAccessStrategy();
Dialect dialect = HsqlDbDialect.INSTANCE;
converter = new BasicJdbcConverter(context, relationResolver, new JdbcCustomConversions(),
new DefaultJdbcTypeFactory(jdbcOperations));
accessStrategy = new DefaultDataAccessStrategy( //
new SqlGeneratorSource(context), //
new SqlGeneratorSource(context, dialect), //
context, //
converter, //
namedJdbcOperations);
@@ -78,12 +84,12 @@ public class DefaultDataAccessStrategyUnitTests {
@Test // DATAJDBC-146
public void additionalParameterForIdDoesNotLeadToDuplicateParameters() {
additionalParameters.put("id", ID_FROM_ADDITIONAL_VALUES);
additionalParameters.put(SqlIdentifier.quoted("ID"), ID_FROM_ADDITIONAL_VALUES);
accessStrategy.insert(new DummyEntity(ORIGINAL_ID), DummyEntity.class, additionalParameters);
verify(namedJdbcOperations).update(eq("INSERT INTO dummy_entity (id) VALUES (:id)"), paramSourceCaptor.capture(),
any(KeyHolder.class));
verify(namedJdbcOperations).update(eq("INSERT INTO \"DUMMY_ENTITY\" (\"ID\") VALUES (:ID)"),
paramSourceCaptor.capture(), any(KeyHolder.class));
}
@Test // DATAJDBC-146
@@ -91,16 +97,16 @@ public class DefaultDataAccessStrategyUnitTests {
ArgumentCaptor<String> sqlCaptor = ArgumentCaptor.forClass(String.class);
additionalParameters.put("reference", ID_FROM_ADDITIONAL_VALUES);
additionalParameters.put(unquoted("reference"), ID_FROM_ADDITIONAL_VALUES);
accessStrategy.insert(new DummyEntity(ORIGINAL_ID), DummyEntity.class, additionalParameters);
verify(namedJdbcOperations).update(sqlCaptor.capture(), paramSourceCaptor.capture(), any(KeyHolder.class));
assertThat(sqlCaptor.getValue()) //
.containsSequence("INSERT INTO dummy_entity (", "id", ") VALUES (", ":id", ")") //
.containsSequence("INSERT INTO dummy_entity (", "reference", ") VALUES (", ":reference", ")");
assertThat(paramSourceCaptor.getValue().getValue("id")).isEqualTo(ORIGINAL_ID);
.containsSequence("INSERT INTO \"DUMMY_ENTITY\" (", "\"ID\"", ") VALUES (", ":ID", ")") //
.containsSequence("INSERT INTO \"DUMMY_ENTITY\" (", "reference", ") VALUES (", ":reference", ")");
assertThat(paramSourceCaptor.getValue().getValue("ID")).isEqualTo(ORIGINAL_ID);
}
@Test // DATAJDBC-235
@@ -113,7 +119,7 @@ public class DefaultDataAccessStrategyUnitTests {
new DefaultJdbcTypeFactory(jdbcOperations));
DefaultDataAccessStrategy accessStrategy = new DefaultDataAccessStrategy( //
new SqlGeneratorSource(context), //
new SqlGeneratorSource(context, HsqlDbDialect.INSTANCE), //
context, //
converter, //
namedJdbcOperations);
@@ -128,8 +134,8 @@ public class DefaultDataAccessStrategyUnitTests {
verify(namedJdbcOperations).update(sqlCaptor.capture(), paramSourceCaptor.capture(), any(KeyHolder.class));
assertThat(paramSourceCaptor.getValue().getValue("id")).isEqualTo(ORIGINAL_ID);
assertThat(paramSourceCaptor.getValue().getValue("flag")).isEqualTo("T");
assertThat(paramSourceCaptor.getValue().getValue("ID")).isEqualTo(ORIGINAL_ID);
assertThat(paramSourceCaptor.getValue().getValue("FLAG")).isEqualTo("T");
}
@RequiredArgsConstructor

69
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/EntityRowMapperUnitTests.java
View File

@@ -60,6 +60,7 @@ import org.springframework.data.relational.core.mapping.RelationalMappingContext
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.SqlIdentifier.SimpleSqlIdentifier;
import org.springframework.data.repository.query.Param;
import org.springframework.util.Assert;
@@ -80,15 +81,15 @@ public class EntityRowMapperUnitTests {
public static final long ID_FOR_ENTITY_NOT_REFERENCING_MAP = 23L;
public static final NamingStrategy X_APPENDING_NAMINGSTRATEGY = new NamingStrategy() {
@Override
public String getColumnName(RelationalPersistentProperty property) {
return NamingStrategy.super.getColumnName(property) + "x";
public SimpleSqlIdentifier getColumnName(RelationalPersistentProperty property) {
return NamingStrategy.super.getColumnName(property).suffix("x");
}
};
@Test // DATAJDBC-113
public void simpleEntitiesGetProperlyExtracted() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "name"), //
ResultSet rs = mockResultSet(asList("ID", "NAME"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha");
rs.next();
@@ -103,7 +104,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-181
public void namingStrategyGetsHonored() throws SQLException {
ResultSet rs = mockResultSet(asList("idx", "namex"), //
ResultSet rs = mockResultSet(asList("IDX", "NAMEX"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha");
rs.next();
@@ -118,7 +119,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-181
public void namingStrategyGetsHonoredForConstructor() throws SQLException {
ResultSet rs = mockResultSet(asList("idx", "namex"), //
ResultSet rs = mockResultSet(asList("IDX", "NAMEX"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha");
rs.next();
@@ -133,7 +134,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-427
public void simpleWithReferenceGetProperlyExtracted() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "name", "trivial_id"), //
ResultSet rs = mockResultSet(asList("ID", "NAME", "TRIVIAL_ID"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha", 100L);
rs.next();
@@ -148,7 +149,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-113
public void simpleOneToOneGetsProperlyExtracted() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "name", "child_id", "child_name"), //
ResultSet rs = mockResultSet(asList("ID", "NAME", "CHILD_ID", "CHILD_NAME"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha", 24L, "beta");
rs.next();
@@ -163,7 +164,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-286
public void immutableOneToOneGetsProperlyExtracted() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "name", "child_id", "child_name"), //
ResultSet rs = mockResultSet(asList("ID", "NAME", "CHILD_ID", "CHILD_NAME"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha", 24L, "beta");
rs.next();
@@ -178,7 +179,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-427
public void immutableWithReferenceGetsProperlyExtracted() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "name", "trivial_id"), //
ResultSet rs = mockResultSet(asList("ID", "NAME", "TRIVIAL_ID"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha", 100L);
rs.next();
@@ -194,7 +195,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-111
public void simpleEmbeddedGetsProperlyExtracted() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "name", "prefix_id", "prefix_name"), //
ResultSet rs = mockResultSet(asList("ID", "NAME", "PREFIX_ID", "PREFIX_NAME"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha", 24L, "beta");
rs.next();
@@ -209,7 +210,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-113
public void collectionReferenceGetsLoadedWithAdditionalSelect() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "name"), //
ResultSet rs = mockResultSet(asList("ID", "NAME"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha");
rs.next();
@@ -224,7 +225,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-131
public void mapReferenceGetsLoadedWithAdditionalSelect() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "name"), //
ResultSet rs = mockResultSet(asList("ID", "NAME"), //
ID_FOR_ENTITY_REFERENCING_MAP, "alpha");
rs.next();
@@ -239,7 +240,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-130
public void listReferenceGetsLoadedWithAdditionalSelect() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "name"), //
ResultSet rs = mockResultSet(asList("ID", "NAME"), //
ID_FOR_ENTITY_REFERENCING_LIST, "alpha");
rs.next();
@@ -254,7 +255,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-252
public void doesNotTryToSetPropertiesThatAreSetViaConstructor() throws SQLException {
ResultSet rs = mockResultSet(singletonList("value"), //
ResultSet rs = mockResultSet(singletonList("VALUE"), //
"value-from-resultSet");
rs.next();
@@ -267,7 +268,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-252
public void handlesMixedProperties() throws SQLException {
ResultSet rs = mockResultSet(asList("one", "two", "three"), //
ResultSet rs = mockResultSet(asList("ONE", "TWO", "THREE"), //
"111", "222", "333");
rs.next();
@@ -281,7 +282,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-273
public void handlesNonSimplePropertyInConstructor() throws SQLException {
ResultSet rs = mockResultSet(singletonList("id"), //
ResultSet rs = mockResultSet(singletonList("ID"), //
ID_FOR_ENTITY_REFERENCING_LIST);
rs.next();
@@ -297,22 +298,22 @@ public class EntityRowMapperUnitTests {
Fixture<NoIdChain4> fixture = this.<NoIdChain4> buildFixture() //
// Id of the aggregate root and backreference to it from
// the various aggregate members.
.value(4L).inColumns("four", //
"chain3_no_id_chain4", //
"chain3_chain2_no_id_chain4", //
"chain3_chain2_chain1_no_id_chain4", //
"chain3_chain2_chain1_chain0_no_id_chain4") //
.value(4L).inColumns("FOUR", //
"CHAIN3_NO_ID_CHAIN4", //
"CHAIN3_CHAIN2_NO_ID_CHAIN4", //
"CHAIN3_CHAIN2_CHAIN1_NO_ID_CHAIN4", //
"CHAIN3_CHAIN2_CHAIN1_CHAIN0_NO_ID_CHAIN4") //
.endUpIn(e -> e.four)
// values for the different entities
.value("four_value").inColumns("four_value").endUpIn(e -> e.fourValue) //
.value("four_value").inColumns("FOUR_VALUE").endUpIn(e -> e.fourValue) //
.value("three_value").inColumns("chain3_three_value").endUpIn(e -> e.chain3.threeValue) //
.value("three_value").inColumns("CHAIN3_THREE_VALUE").endUpIn(e -> e.chain3.threeValue) //
.value("two_value").inColumns("chain3_chain2_two_value").endUpIn(e -> e.chain3.chain2.twoValue) //
.value("two_value").inColumns("CHAIN3_CHAIN2_TWO_VALUE").endUpIn(e -> e.chain3.chain2.twoValue) //
.value("one_value").inColumns("chain3_chain2_chain1_one_value").endUpIn(e -> e.chain3.chain2.chain1.oneValue) //
.value("one_value").inColumns("CHAIN3_CHAIN2_CHAIN1_ONE_VALUE").endUpIn(e -> e.chain3.chain2.chain1.oneValue) //
.value("zero_value").inColumns("chain3_chain2_chain1_chain0_zero_value")
.value("zero_value").inColumns("CHAIN3_CHAIN2_CHAIN1_CHAIN0_ZERO_VALUE")
.endUpIn(e -> e.chain3.chain2.chain1.chain0.zeroValue) //
.build();
// @formatter:on
@@ -329,7 +330,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-370
public void simpleNullableImmutableEmbeddedGetsProperlyExtracted() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "value"), //
ResultSet rs = mockResultSet(asList("ID", "VALUE"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "ru'Ha'");
rs.next();
@@ -345,7 +346,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-374
public void simpleEmptyImmutableEmbeddedGetsProperlyExtracted() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "value"), //
ResultSet rs = mockResultSet(asList("ID", "VALUE"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, null);
rs.next();
@@ -361,7 +362,7 @@ public class EntityRowMapperUnitTests {
@SneakyThrows
public void simplePrimitiveImmutableEmbeddedGetsProperlyExtracted() {
ResultSet rs = mockResultSet(asList("id", "value"), //
ResultSet rs = mockResultSet(asList("ID", "VALUE"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, 24);
rs.next();
@@ -377,7 +378,7 @@ public class EntityRowMapperUnitTests {
@Test // DATAJDBC-370
public void simpleImmutableEmbeddedShouldBeNullIfAllOfTheEmbeddableAreNull() throws SQLException {
ResultSet rs = mockResultSet(asList("id", "value"), //
ResultSet rs = mockResultSet(asList("ID", "VALUE"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, null);
rs.next();
@@ -394,7 +395,7 @@ public class EntityRowMapperUnitTests {
@SneakyThrows
public void embeddedShouldBeNullWhenFieldsAreNull() {
ResultSet rs = mockResultSet(asList("id", "name", "prefix_id", "prefix_name"), //
ResultSet rs = mockResultSet(asList("ID", "NAME", "PREFIX_ID", "PREFIX_NAME"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha", null, null);
rs.next();
@@ -410,7 +411,7 @@ public class EntityRowMapperUnitTests {
@SneakyThrows
public void embeddedShouldNotBeNullWhenAtLeastOneFieldIsNotNull() {
ResultSet rs = mockResultSet(asList("id", "name", "prefix_id", "prefix_name"), //
ResultSet rs = mockResultSet(asList("ID", "NAME", "PREFIX_ID", "PREFIX_NAME"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "alpha", 24, null);
rs.next();
@@ -426,7 +427,7 @@ public class EntityRowMapperUnitTests {
@SneakyThrows
public void primitiveEmbeddedShouldBeNullWhenNoValuePresent() {
ResultSet rs = mockResultSet(asList("id", "value"), //
ResultSet rs = mockResultSet(asList("ID", "VALUE"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, null);
rs.next();
@@ -443,7 +444,7 @@ public class EntityRowMapperUnitTests {
@SneakyThrows
public void deepNestedEmbeddable() {
ResultSet rs = mockResultSet(asList("id", "level0", "level1_value", "level1_level2_value"), //
ResultSet rs = mockResultSet(asList("ID", "LEVEL0", "LEVEL1_VALUE", "LEVEL1_LEVEL2_VALUE"), //
ID_FOR_ENTITY_NOT_REFERENCING_MAP, "0", "1", "2");
rs.next();

15
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/JdbcIdentifierBuilderUnitTests.java
View File

@@ -17,6 +17,7 @@ package org.springframework.data.jdbc.core.convert;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.jdbc.core.PropertyPathTestingUtils.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import java.util.List;
import java.util.Map;
@@ -46,7 +47,7 @@ public class JdbcIdentifierBuilderUnitTests {
assertThat(identifier.getParts()) //
.extracting("name", "value", "targetType") //
.containsExactly( //
tuple("dummy_entity", "eins", UUID.class) //
tuple(quoted("dummy_entity"), "eins", UUID.class) //
);
}
@@ -63,8 +64,8 @@ public class JdbcIdentifierBuilderUnitTests {
assertThat(identifier.getParts()) //
.extracting("name", "value", "targetType") //
.containsExactlyInAnyOrder( //
tuple("dummy_entity", "parent-eins", UUID.class), //
tuple("dummy_entity_key", "map-key-eins", String.class) //
tuple(quoted("dummy_entity"), "parent-eins", UUID.class), //
tuple(quoted("dummy_entity_key"), "map-key-eins", String.class) //
);
}
@@ -81,8 +82,8 @@ public class JdbcIdentifierBuilderUnitTests {
assertThat(identifier.getParts()) //
.extracting("name", "value", "targetType") //
.containsExactlyInAnyOrder( //
tuple("dummy_entity", "parent-eins", UUID.class), //
tuple("dummy_entity_key", "list-index-eins", Integer.class) //
tuple(quoted("dummy_entity"), "parent-eins", UUID.class), //
tuple(quoted("dummy_entity_key"), "list-index-eins", Integer.class) //
);
}
@@ -96,7 +97,7 @@ public class JdbcIdentifierBuilderUnitTests {
assertThat(identifier.getParts()) //
.extracting("name", "value", "targetType") //
.containsExactly( //
tuple("dummy_entity", "parent-eins", UUID.class) //
tuple(quoted("dummy_entity"), "parent-eins", UUID.class) //
);
}
@@ -110,7 +111,7 @@ public class JdbcIdentifierBuilderUnitTests {
assertThat(identifier.getParts()) //
.extracting("name", "value", "targetType") //
.containsExactly( //
tuple("dummy_entity", "parent-eins", UUID.class) //
tuple(quoted("dummy_entity"), "parent-eins", UUID.class) //
);
}

20
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/SqlGeneratorContextBasedNamingStrategyUnitTests.java
View File

@@ -16,6 +16,7 @@
package org.springframework.data.jdbc.core.convert;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
@@ -25,7 +26,6 @@ import java.util.function.Consumer;
import org.assertj.core.api.SoftAssertions;
import org.junit.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.jdbc.core.convert.SqlGenerator;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.jdbc.core.mapping.PersistentPropertyPathTestUtils;
import org.springframework.data.mapping.PersistentPropertyPath;
@@ -33,6 +33,10 @@ import org.springframework.data.relational.core.mapping.NamingStrategy;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.domain.IdentifierProcessing.DefaultIdentifierProcessing;
import org.springframework.data.relational.domain.IdentifierProcessing.LetterCasing;
import org.springframework.data.relational.domain.IdentifierProcessing.Quoting;
import org.springframework.data.relational.domain.SqlIdentifier;
/**
* Unit tests to verify a contextual {@link NamingStrategy} implementation that customizes using a user-centric
@@ -52,8 +56,8 @@ public class SqlGeneratorContextBasedNamingStrategyUnitTests {
private final NamingStrategy contextualNamingStrategy = new NamingStrategy() {
@Override
public String getSchema() {
return userHandler.get();
public SqlIdentifier getSchema() {
return unquoted(userHandler.get());
}
};
@@ -87,8 +91,11 @@ public class SqlGeneratorContextBasedNamingStrategyUnitTests {
String sql = sqlGenerator.createDeleteByPath(getPath("ref"));
assertThat(sql).isEqualTo(
"DELETE FROM " + user + ".referenced_entity WHERE " + user + ".referenced_entity.dummy_entity = :rootId");
assertThat(sql).isEqualTo( //
"DELETE FROM " //
+ user + ".referenced_entity WHERE " //
+ user + ".referenced_entity.dummy_entity = :rootId" //
);
});
}
@@ -213,7 +220,8 @@ public class SqlGeneratorContextBasedNamingStrategyUnitTests {
RelationalMappingContext context = new JdbcMappingContext(namingStrategy);
RelationalPersistentEntity<?> persistentEntity = context.getRequiredPersistentEntity(DummyEntity.class);
return new SqlGenerator(context, persistentEntity);
return new SqlGenerator(context, persistentEntity,
new DefaultIdentifierProcessing(new Quoting(""), LetterCasing.AS_IS));
}
@SuppressWarnings("unused")

133
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/SqlGeneratorEmbeddedUnitTests.java
View File

@@ -32,6 +32,9 @@ import org.springframework.data.relational.core.mapping.PersistentPropertyPathEx
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.sql.Aliased;
import org.springframework.data.relational.domain.IdentifierProcessing.DefaultIdentifierProcessing;
import org.springframework.data.relational.domain.IdentifierProcessing.LetterCasing;
import org.springframework.data.relational.domain.IdentifierProcessing.Quoting;
/**
* Unit tests for the {@link SqlGenerator} in a context of the {@link Embedded} annotation.
@@ -50,81 +53,121 @@ public class SqlGeneratorEmbeddedUnitTests {
SqlGenerator createSqlGenerator(Class<?> type) {
RelationalPersistentEntity<?> persistentEntity = context.getRequiredPersistentEntity(type);
return new SqlGenerator(context, persistentEntity);
return new SqlGenerator(context, persistentEntity,
new DefaultIdentifierProcessing(new Quoting(""), LetterCasing.AS_IS));
}
@Test // DATAJDBC-111
public void findOne() {
final String sql = sqlGenerator.getFindOne();
SoftAssertions softAssertions = new SoftAssertions();
softAssertions.assertThat(sql).startsWith("SELECT").contains("dummy_entity.id1 AS id1")
.contains("dummy_entity.test AS test").contains("dummy_entity.attr1 AS attr1")
.contains("dummy_entity.attr2 AS attr2").contains("dummy_entity.prefix2_attr1 AS prefix2_attr1")
.contains("dummy_entity.prefix2_attr2 AS prefix2_attr2").contains("dummy_entity.prefix_test AS prefix_test")
.contains("dummy_entity.prefix_attr1 AS prefix_attr1").contains("dummy_entity.prefix_attr2 AS prefix_attr2")
.contains("dummy_entity.prefix_prefix2_attr1 AS prefix_prefix2_attr1")
.contains("dummy_entity.prefix_prefix2_attr2 AS prefix_prefix2_attr2").contains("WHERE dummy_entity.id1 = :id")
.doesNotContain("JOIN").doesNotContain("embeddable");
softAssertions.assertAll();
SoftAssertions.assertSoftly(softly -> {
softly.assertThat(sql).startsWith("SELECT") //
.contains("dummy_entity.id1 AS id1") //
.contains("dummy_entity.test AS test") //
.contains("dummy_entity.attr1 AS attr1") //
.contains("dummy_entity.attr2 AS attr2") //
.contains("dummy_entity.prefix2_attr1 AS prefix2_attr1") //
.contains("dummy_entity.prefix2_attr2 AS prefix2_attr2") //
.contains("dummy_entity.prefix_test AS prefix_test") //
.contains("dummy_entity.prefix_attr1 AS prefix_attr1") //
.contains("dummy_entity.prefix_attr2 AS prefix_attr2") //
.contains("dummy_entity.prefix_prefix2_attr1 AS prefix_prefix2_attr1") //
.contains("dummy_entity.prefix_prefix2_attr2 AS prefix_prefix2_attr2") //
.contains("WHERE dummy_entity.id1 = :id") //
.doesNotContain("JOIN").doesNotContain("embeddable"); //
});
}
@Test // DATAJDBC-111
public void findAll() {
final String sql = sqlGenerator.getFindAll();
SoftAssertions softAssertions = new SoftAssertions();
softAssertions.assertThat(sql).startsWith("SELECT").contains("dummy_entity.id1 AS id1")
.contains("dummy_entity.test AS test").contains("dummy_entity.attr1 AS attr1")
.contains("dummy_entity.attr2 AS attr2").contains("dummy_entity.prefix2_attr1 AS prefix2_attr1")
.contains("dummy_entity.prefix2_attr2 AS prefix2_attr2").contains("dummy_entity.prefix_test AS prefix_test")
.contains("dummy_entity.prefix_attr1 AS prefix_attr1").contains("dummy_entity.prefix_attr2 AS prefix_attr2")
.contains("dummy_entity.prefix_prefix2_attr1 AS prefix_prefix2_attr1")
.contains("dummy_entity.prefix_prefix2_attr2 AS prefix_prefix2_attr2").doesNotContain("JOIN")
.doesNotContain("embeddable");
softAssertions.assertAll();
SoftAssertions.assertSoftly(softly -> {
softly.assertThat(sql).startsWith("SELECT") //
.contains("dummy_entity.id1 AS id1") //
.contains("dummy_entity.test AS test") //
.contains("dummy_entity.attr1 AS attr1") //
.contains("dummy_entity.attr2 AS attr2") //
.contains("dummy_entity.prefix2_attr1 AS prefix2_attr1") //
.contains("dummy_entity.prefix2_attr2 AS prefix2_attr2") //
.contains("dummy_entity.prefix_test AS prefix_test") //
.contains("dummy_entity.prefix_attr1 AS prefix_attr1") //
.contains("dummy_entity.prefix_attr2 AS prefix_attr2") //
.contains("dummy_entity.prefix_prefix2_attr1 AS prefix_prefix2_attr1") //
.contains("dummy_entity.prefix_prefix2_attr2 AS prefix_prefix2_attr2") //
.doesNotContain("JOIN") //
.doesNotContain("embeddable");
});
}
@Test // DATAJDBC-111
public void findAllInList() {
final String sql = sqlGenerator.getFindAllInList();
SoftAssertions softAssertions = new SoftAssertions();
softAssertions.assertThat(sql).startsWith("SELECT").contains("dummy_entity.id1 AS id1")
.contains("dummy_entity.test AS test").contains("dummy_entity.attr1 AS attr1")
.contains("dummy_entity.attr2 AS attr2").contains("dummy_entity.prefix2_attr1 AS prefix2_attr1")
.contains("dummy_entity.prefix2_attr2 AS prefix2_attr2").contains("dummy_entity.prefix_test AS prefix_test")
.contains("dummy_entity.prefix_attr1 AS prefix_attr1").contains("dummy_entity.prefix_attr2 AS prefix_attr2")
.contains("dummy_entity.prefix_prefix2_attr1 AS prefix_prefix2_attr1")
.contains("dummy_entity.prefix_prefix2_attr2 AS prefix_prefix2_attr2")
.contains("WHERE dummy_entity.id1 IN (:ids)").doesNotContain("JOIN").doesNotContain("embeddable");
softAssertions.assertAll();
SoftAssertions.assertSoftly(softly -> {
softly.assertThat(sql).startsWith("SELECT") //
.contains("dummy_entity.id1 AS id1") //
.contains("dummy_entity.test AS test") //
.contains("dummy_entity.attr1 AS attr1") //
.contains("dummy_entity.attr2 AS attr2").contains("dummy_entity.prefix2_attr1 AS prefix2_attr1") //
.contains("dummy_entity.prefix2_attr2 AS prefix2_attr2") //
.contains("dummy_entity.prefix_test AS prefix_test") //
.contains("dummy_entity.prefix_attr1 AS prefix_attr1") //
.contains("dummy_entity.prefix_attr2 AS prefix_attr2") //
.contains("dummy_entity.prefix_prefix2_attr1 AS prefix_prefix2_attr1") //
.contains("dummy_entity.prefix_prefix2_attr2 AS prefix_prefix2_attr2") //
.contains("WHERE dummy_entity.id1 IN (:ids)") //
.doesNotContain("JOIN") //
.doesNotContain("embeddable");
});
}
@Test // DATAJDBC-111
public void insert() {
final String sql = sqlGenerator.getInsert(emptySet());
SoftAssertions softAssertions = new SoftAssertions();
softAssertions.assertThat(sql).startsWith("INSERT INTO").contains("dummy_entity").contains(":test")
.contains(":attr1").contains(":attr2").contains(":prefix2_attr1").contains(":prefix2_attr2")
.contains(":prefix_test").contains(":prefix_attr1").contains(":prefix_attr2").contains(":prefix_prefix2_attr1")
.contains(":prefix_prefix2_attr2");
softAssertions.assertAll();
SoftAssertions.assertSoftly(softly -> {
softly.assertThat(sql) //
.startsWith("INSERT INTO") //
.contains("dummy_entity") //
.contains(":test") //
.contains(":attr1") //
.contains(":attr2") //
.contains(":prefix2_attr1") //
.contains(":prefix2_attr2") //
.contains(":prefix_test") //
.contains(":prefix_attr1") //
.contains(":prefix_attr2") //
.contains(":prefix_prefix2_attr1") //
.contains(":prefix_prefix2_attr2");
});
}
@Test // DATAJDBC-111
public void update() {
final String sql = sqlGenerator.getUpdate();
SoftAssertions softAssertions = new SoftAssertions();
softAssertions.assertThat(sql).startsWith("UPDATE").contains("dummy_entity").contains("test = :test")
.contains("attr1 = :attr1").contains("attr2 = :attr2").contains("prefix2_attr1 = :prefix2_attr1")
.contains("prefix2_attr2 = :prefix2_attr2").contains("prefix_test = :prefix_test")
.contains("prefix_attr1 = :prefix_attr1").contains("prefix_attr2 = :prefix_attr2")
.contains("prefix_prefix2_attr1 = :prefix_prefix2_attr1")
.contains("prefix_prefix2_attr2 = :prefix_prefix2_attr2");
softAssertions.assertAll();
SoftAssertions.assertSoftly(softly -> {
softly.assertThat(sql) //
.startsWith("UPDATE") //
.contains("dummy_entity") //
.contains("test = :test") //
.contains("attr1 = :attr1") //
.contains("attr2 = :attr2") //
.contains("prefix2_attr1 = :prefix2_attr1") //
.contains("prefix2_attr2 = :prefix2_attr2") //
.contains("prefix_test = :prefix_test") //
.contains("prefix_attr1 = :prefix_attr1") //
.contains("prefix_attr2 = :prefix_attr2") //
.contains("prefix_prefix2_attr1 = :prefix_prefix2_attr1") //
.contains("prefix_prefix2_attr2 = :prefix_prefix2_attr2");
});
}
@Test // DATAJDBC-340

46
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/SqlGeneratorFixedNamingStrategyUnitTests.java
View File

@@ -16,6 +16,7 @@
package org.springframework.data.jdbc.core.convert;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import org.assertj.core.api.SoftAssertions;
import org.junit.Test;
@@ -23,10 +24,13 @@ import org.springframework.data.annotation.Id;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.jdbc.core.mapping.PersistentPropertyPathTestUtils;
import org.springframework.data.mapping.PersistentPropertyPath;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.data.relational.core.mapping.NamingStrategy;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.domain.SqlIdentifier.SimpleSqlIdentifier;
/**
* Unit tests the {@link SqlGenerator} with a fixed {@link NamingStrategy} implementation containing a hard wired
@@ -39,31 +43,31 @@ public class SqlGeneratorFixedNamingStrategyUnitTests {
final NamingStrategy fixedCustomTablePrefixStrategy = new NamingStrategy() {
@Override
public String getSchema() {
return "FixedCustomSchema";
public SqlIdentifier getSchema() {
return unquoted("FixedCustomSchema");
}
@Override
public String getTableName(Class<?> type) {
return "FixedCustomTablePrefix_" + type.getSimpleName();
public SqlIdentifier getTableName(Class<?> type) {
return unquoted("FixedCustomTablePrefix_" + type.getSimpleName());
}
@Override
public String getColumnName(RelationalPersistentProperty property) {
return "FixedCustomPropertyPrefix_" + property.getName();
public SimpleSqlIdentifier getColumnName(RelationalPersistentProperty property) {
return unquoted("FixedCustomPropertyPrefix_" + property.getName());
}
};
final NamingStrategy upperCaseLowerCaseStrategy = new NamingStrategy() {
@Override
public String getTableName(Class<?> type) {
return type.getSimpleName().toUpperCase();
public SqlIdentifier getTableName(Class<?> type) {
return unquoted(type.getSimpleName().toUpperCase());
}
@Override
public String getColumnName(RelationalPersistentProperty property) {
return property.getName().toLowerCase();
public SimpleSqlIdentifier getColumnName(RelationalPersistentProperty property) {
return unquoted(property.getName().toLowerCase());
}
};
@@ -83,8 +87,8 @@ public class SqlGeneratorFixedNamingStrategyUnitTests {
"FixedCustomSchema.FixedCustomTablePrefix_DummyEntity.FixedCustomPropertyPrefix_id AS FixedCustomPropertyPrefix_id,") //
.contains(
"FixedCustomSchema.FixedCustomTablePrefix_DummyEntity.FixedCustomPropertyPrefix_name AS FixedCustomPropertyPrefix_name,") //
.contains("ref.FixedCustomPropertyPrefix_l1id AS ref_FixedCustomPropertyPrefix_l1id") //
.contains("ref.FixedCustomPropertyPrefix_content AS ref_FixedCustomPropertyPrefix_content") //
.contains("\"REF\".FixedCustomPropertyPrefix_l1id AS ref_FixedCustomPropertyPrefix_l1id") //
.contains("\"REF\".FixedCustomPropertyPrefix_content AS ref_FixedCustomPropertyPrefix_content") //
.contains("FROM FixedCustomSchema.FixedCustomTablePrefix_DummyEntity");
softAssertions.assertAll();
}
@@ -101,8 +105,8 @@ public class SqlGeneratorFixedNamingStrategyUnitTests {
.startsWith("SELECT") //
.contains("DUMMYENTITY.id AS id,") //
.contains("DUMMYENTITY.name AS name,") //
.contains("ref.l1id AS ref_l1id") //
.contains("ref.content AS ref_content") //
.contains("\"REF\".l1id AS ref_l1id") //
.contains("\"REF\".content AS ref_content") //
.contains("FROM DUMMYENTITY");
softAssertions.assertAll();
}
@@ -115,7 +119,7 @@ public class SqlGeneratorFixedNamingStrategyUnitTests {
String sql = sqlGenerator.createDeleteByPath(getPath("ref"));
assertThat(sql).isEqualTo("DELETE FROM FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity "
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity.dummy_entity = :rootId");
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity.\"DUMMY_ENTITY\" = :rootId");
}
@Test // DATAJDBC-107
@@ -126,10 +130,10 @@ public class SqlGeneratorFixedNamingStrategyUnitTests {
String sql = sqlGenerator.createDeleteByPath(getPath("ref.further"));
assertThat(sql).isEqualTo("DELETE FROM FixedCustomSchema.FixedCustomTablePrefix_SecondLevelReferencedEntity "
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_SecondLevelReferencedEntity.referenced_entity IN "
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_SecondLevelReferencedEntity.\"REFERENCED_ENTITY\" IN "
+ "(SELECT FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity.FixedCustomPropertyPrefix_l1id "
+ "FROM FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity "
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity.dummy_entity = :rootId)");
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity.\"DUMMY_ENTITY\" = :rootId)");
}
@Test // DATAJDBC-107
@@ -150,7 +154,7 @@ public class SqlGeneratorFixedNamingStrategyUnitTests {
String sql = sqlGenerator.createDeleteAllSql(getPath("ref"));
assertThat(sql).isEqualTo("DELETE FROM FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity "
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity.dummy_entity IS NOT NULL");
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity.\"DUMMY_ENTITY\" IS NOT NULL");
}
@Test // DATAJDBC-107
@@ -161,10 +165,10 @@ public class SqlGeneratorFixedNamingStrategyUnitTests {
String sql = sqlGenerator.createDeleteAllSql(getPath("ref.further"));
assertThat(sql).isEqualTo("DELETE FROM FixedCustomSchema.FixedCustomTablePrefix_SecondLevelReferencedEntity "
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_SecondLevelReferencedEntity.referenced_entity IN "
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_SecondLevelReferencedEntity.\"REFERENCED_ENTITY\" IN "
+ "(SELECT FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity.FixedCustomPropertyPrefix_l1id "
+ "FROM FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity "
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity.dummy_entity IS NOT NULL)");
+ "WHERE FixedCustomSchema.FixedCustomTablePrefix_ReferencedEntity.\"DUMMY_ENTITY\" IS NOT NULL)");
}
@Test // DATAJDBC-113
@@ -189,7 +193,7 @@ public class SqlGeneratorFixedNamingStrategyUnitTests {
RelationalMappingContext context = new JdbcMappingContext(namingStrategy);
RelationalPersistentEntity<?> persistentEntity = context.getRequiredPersistentEntity(DummyEntity.class);
return new SqlGenerator(context, persistentEntity);
return new SqlGenerator(context, persistentEntity, IdentifierProcessing.ANSI);
}
@SuppressWarnings("unused")

128
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/SqlGeneratorUnitTests.java
View File

@@ -17,6 +17,7 @@ package org.springframework.data.jdbc.core.convert;
import static java.util.Collections.*;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import java.util.Map;
import java.util.Set;
@@ -41,6 +42,11 @@ import org.springframework.data.relational.core.mapping.RelationalPersistentProp
import org.springframework.data.relational.core.sql.Aliased;
import org.springframework.data.relational.core.sql.Table;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.data.relational.domain.IdentifierProcessing.DefaultIdentifierProcessing;
import org.springframework.data.relational.domain.IdentifierProcessing.LetterCasing;
import org.springframework.data.relational.domain.IdentifierProcessing.Quoting;
import org.springframework.data.relational.domain.SqlIdentifier.*;
/**
* Unit tests for the {@link SqlGenerator}.
@@ -54,7 +60,7 @@ import org.springframework.data.relational.domain.Identifier;
*/
public class SqlGeneratorUnitTests {
static final Identifier BACKREF = Identifier.of("backref", "some-value", String.class);
static final Identifier BACKREF = Identifier.of(unquoted("backref"), "some-value", String.class);
SqlGenerator sqlGenerator;
NamingStrategy namingStrategy = new PrefixingNamingStrategy();
@@ -67,9 +73,14 @@ public class SqlGeneratorUnitTests {
SqlGenerator createSqlGenerator(Class<?> type) {
return createSqlGenerator(type, new DefaultIdentifierProcessing(new Quoting(""), LetterCasing.AS_IS));
}
SqlGenerator createSqlGenerator(Class<?> type, IdentifierProcessing identifierProcessing) {
RelationalPersistentEntity<?> persistentEntity = context.getRequiredPersistentEntity(type);
return new SqlGenerator(context, persistentEntity);
return new SqlGenerator(context, persistentEntity, identifierProcessing);
}
@Test // DATAJDBC-112
@@ -174,8 +185,8 @@ public class SqlGeneratorUnitTests {
public void findAllByPropertyWithMultipartIdentifier() {
// this would get called when ListParent is the element type of a Set
Identifier parentIdentifier = Identifier.of("backref", "some-value", String.class) //
.withPart("backref_key", "key-value", Object.class);
Identifier parentIdentifier = Identifier.of(unquoted("backref"), "some-value", String.class) //
.withPart(unquoted("backref_key"), "key-value", Object.class);
String sql = sqlGenerator.getFindAllByProperty(parentIdentifier, null, false);
assertThat(sql).contains("SELECT", //
@@ -197,7 +208,7 @@ public class SqlGeneratorUnitTests {
public void findAllByPropertyWithKey() {
// this would get called when ListParent is th element type of a Map
String sql = sqlGenerator.getFindAllByProperty(BACKREF, "key-column", false);
String sql = sqlGenerator.getFindAllByProperty(BACKREF, unquoted("key-column"), false);
assertThat(sql).isEqualTo("SELECT dummy_entity.id1 AS id1, dummy_entity.x_name AS x_name, " //
+ "dummy_entity.x_other AS x_other, " //
@@ -219,7 +230,7 @@ public class SqlGeneratorUnitTests {
public void findAllByPropertyWithKeyOrdered() {
// this would get called when ListParent is th element type of a Map
String sql = sqlGenerator.getFindAllByProperty(BACKREF, "key-column", true);
String sql = sqlGenerator.getFindAllByProperty(BACKREF, unquoted("key-column"), true);
assertThat(sql).isEqualTo("SELECT dummy_entity.id1 AS id1, dummy_entity.x_name AS x_name, " //
+ "dummy_entity.x_other AS x_other, " //
@@ -235,16 +246,16 @@ public class SqlGeneratorUnitTests {
@Test // DATAJDBC-219
public void updateWithVersion() {
SqlGenerator sqlGenerator = createSqlGenerator(VersionedEntity.class);
SqlGenerator sqlGenerator = createSqlGenerator(VersionedEntity.class, IdentifierProcessing.ANSI);
assertThat(sqlGenerator.getUpdateWithVersion()).containsSequence( //
"UPDATE", //
"versioned_entity", //
"\"VERSIONED_ENTITY\"", //
"SET", //
"WHERE", //
"id1 = :id", //
"\"ID1\" = :ID1", //
"AND", //
"version = :___oldOptimisticLockingVersion");
"\"X_VERSION\" = :___oldOptimisticLockingVersion");
}
@Test // DATAJDBC-264
@@ -260,66 +271,69 @@ public class SqlGeneratorUnitTests {
@Test // DATAJDBC-334
public void getInsertForQuotedColumnName() {
SqlGenerator sqlGenerator = createSqlGenerator(EntityWithQuotedColumnName.class);
SqlGenerator sqlGenerator = createSqlGenerator(EntityWithQuotedColumnName.class, IdentifierProcessing.ANSI);
String insert = sqlGenerator.getInsert(emptySet());
assertThat(insert)
.isEqualTo("INSERT INTO entity_with_quoted_column_name " + "(\"test_@123\") " + "VALUES (:test_123)");
assertThat(insert).isEqualTo("INSERT INTO \"ENTITY_WITH_QUOTED_COLUMN_NAME\" " //
+ "(\"TEST\"\"_@123\") " + "VALUES (:TEST_123)");
}
@Test // DATAJDBC-266
public void joinForOneToOneWithoutIdIncludesTheBackReferenceOfTheOuterJoin() {
SqlGenerator sqlGenerator = createSqlGenerator(ParentOfNoIdChild.class);
SqlGenerator sqlGenerator = createSqlGenerator(ParentOfNoIdChild.class, IdentifierProcessing.ANSI);
String findAll = sqlGenerator.getFindAll();
assertThat(findAll).containsSequence("SELECT", "child.parent_of_no_id_child AS child_parent_of_no_id_child",
"FROM");
assertThat(findAll).containsSequence("SELECT",
"\"CHILD\".\"PARENT_OF_NO_ID_CHILD\" AS \"CHILD_PARENT_OF_NO_ID_CHILD\"", "FROM");
}
@Test // DATAJDBC-262
public void update() {
SqlGenerator sqlGenerator = createSqlGenerator(DummyEntity.class, IdentifierProcessing.ANSI);
assertThat(sqlGenerator.getUpdate()).containsSequence( //
"UPDATE", //
"dummy_entity", //
"\"DUMMY_ENTITY\"", //
"SET", //
"WHERE", //
"id1 = :id");
"\"ID1\" = :ID");
}
@Test // DATAJDBC-324
public void readOnlyPropertyExcludedFromQuery_when_generateUpdateSql() {
final SqlGenerator sqlGenerator = createSqlGenerator(EntityWithReadOnlyProperty.class);
final SqlGenerator sqlGenerator = createSqlGenerator(EntityWithReadOnlyProperty.class, IdentifierProcessing.ANSI);
assertThat(sqlGenerator.getUpdate()).isEqualToIgnoringCase( //
"UPDATE entity_with_read_only_property " //
+ "SET x_name = :x_name " //
+ "WHERE entity_with_read_only_property.x_id = :x_id" //
"UPDATE \"ENTITY_WITH_READ_ONLY_PROPERTY\" " //
+ "SET \"X_NAME\" = :X_NAME " //
+ "WHERE \"ENTITY_WITH_READ_ONLY_PROPERTY\".\"X_ID\" = :X_ID" //
);
}
@Test // DATAJDBC-334
public void getUpdateForQuotedColumnName() {
SqlGenerator sqlGenerator = createSqlGenerator(EntityWithQuotedColumnName.class);
SqlGenerator sqlGenerator = createSqlGenerator(EntityWithQuotedColumnName.class, IdentifierProcessing.ANSI);
String update = sqlGenerator.getUpdate();
assertThat(update).isEqualTo("UPDATE entity_with_quoted_column_name " + "SET \"test_@123\" = :test_123 "
+ "WHERE entity_with_quoted_column_name.\"test_@id\" = :test_id");
assertThat(update).isEqualTo("UPDATE \"ENTITY_WITH_QUOTED_COLUMN_NAME\" " //
+ "SET \"TEST\"\"_@123\" = :TEST_123 " //
+ "WHERE \"ENTITY_WITH_QUOTED_COLUMN_NAME\".\"TEST\"\"_@ID\" = :TEST_ID");
}
@Test // DATAJDBC-324
public void readOnlyPropertyExcludedFromQuery_when_generateInsertSql() {
final SqlGenerator sqlGenerator = createSqlGenerator(EntityWithReadOnlyProperty.class);
final SqlGenerator sqlGenerator = createSqlGenerator(EntityWithReadOnlyProperty.class, IdentifierProcessing.ANSI);
assertThat(sqlGenerator.getInsert(emptySet())).isEqualToIgnoringCase( //
"INSERT INTO entity_with_read_only_property (x_name) " //
"INSERT INTO \"ENTITY_WITH_READ_ONLY_PROPERTY\" (\"X_NAME\") " //
+ "VALUES (:x_name)" //
);
}
@@ -340,7 +354,7 @@ public class SqlGeneratorUnitTests {
final SqlGenerator sqlGenerator = createSqlGenerator(EntityWithReadOnlyProperty.class);
assertThat(sqlGenerator.getFindAllByProperty(BACKREF, "key-column", true)).isEqualToIgnoringCase( //
assertThat(sqlGenerator.getFindAllByProperty(BACKREF, unquoted("key-column"), true)).isEqualToIgnoringCase( //
"SELECT " //
+ "entity_with_read_only_property.x_id AS x_id, " //
+ "entity_with_read_only_property.x_name AS x_name, " //
@@ -434,14 +448,15 @@ public class SqlGeneratorUnitTests {
@Test // DATAJDBC-340
public void joinForSimpleReference() {
SqlGenerator.Join join = generateJoin("ref", DummyEntity.class);
SoftAssertions.assertSoftly(softly -> {
SqlGenerator.Join join = generateJoin("ref", DummyEntity.class);
softly.assertThat(join.getJoinTable().getName()).isEqualTo("referenced_entity");
softly.assertThat(join.getJoinTable().getName()).isEqualTo("\"REFERENCED_ENTITY\"");
softly.assertThat(join.getJoinColumn().getTable()).isEqualTo(join.getJoinTable());
softly.assertThat(join.getJoinColumn().getName()).isEqualTo("dummy_entity");
softly.assertThat(join.getParentId().getName()).isEqualTo("id1");
softly.assertThat(join.getParentId().getTable().getName()).isEqualTo("dummy_entity");
softly.assertThat(join.getJoinColumn().getName()).isEqualTo("\"DUMMY_ENTITY\"");
softly.assertThat(join.getParentId().getName()).isEqualTo("\"ID1\"");
softly.assertThat(join.getParentId().getTable().getName()).isEqualTo("\"DUMMY_ENTITY\"");
});
}
@@ -465,37 +480,39 @@ public class SqlGeneratorUnitTests {
@Test // DATAJDBC-340
public void joinForSecondLevelReference() {
SqlGenerator.Join join = generateJoin("ref.further", DummyEntity.class);
SoftAssertions.assertSoftly(softly -> {
SqlGenerator.Join join = generateJoin("ref.further", DummyEntity.class);
softly.assertThat(join.getJoinTable().getName()).isEqualTo("second_level_referenced_entity");
softly.assertThat(join.getJoinTable().getName()).isEqualTo("\"SECOND_LEVEL_REFERENCED_ENTITY\"");
softly.assertThat(join.getJoinColumn().getTable()).isEqualTo(join.getJoinTable());
softly.assertThat(join.getJoinColumn().getName()).isEqualTo("referenced_entity");
softly.assertThat(join.getParentId().getName()).isEqualTo("x_l1id");
softly.assertThat(join.getParentId().getTable().getName()).isEqualTo("referenced_entity");
softly.assertThat(join.getJoinColumn().getName()).isEqualTo("\"REFERENCED_ENTITY\"");
softly.assertThat(join.getParentId().getName()).isEqualTo("\"X_L1ID\"");
softly.assertThat(join.getParentId().getTable().getName()).isEqualTo("\"REFERENCED_ENTITY\"");
});
}
@Test // DATAJDBC-340
public void joinForOneToOneWithoutId() {
SqlGenerator.Join join = generateJoin("child", ParentOfNoIdChild.class);
Table joinTable = join.getJoinTable();
SoftAssertions.assertSoftly(softly -> {
SqlGenerator.Join join = generateJoin("child", ParentOfNoIdChild.class);
Table joinTable = join.getJoinTable();
softly.assertThat(joinTable.getName()).isEqualTo("no_id_child");
softly.assertThat(joinTable.getName()).isEqualTo("\"NO_ID_CHILD\"");
softly.assertThat(joinTable).isInstanceOf(Aliased.class);
softly.assertThat(((Aliased) joinTable).getAlias()).isEqualTo("child");
softly.assertThat(((Aliased) joinTable).getAlias()).isEqualTo("\"CHILD\"");
softly.assertThat(join.getJoinColumn().getTable()).isEqualTo(joinTable);
softly.assertThat(join.getJoinColumn().getName()).isEqualTo("parent_of_no_id_child");
softly.assertThat(join.getParentId().getName()).isEqualTo("x_id");
softly.assertThat(join.getParentId().getTable().getName()).isEqualTo("parent_of_no_id_child");
softly.assertThat(join.getJoinColumn().getName()).isEqualTo("\"PARENT_OF_NO_ID_CHILD\"");
softly.assertThat(join.getParentId().getName()).isEqualTo("\"X_ID\"");
softly.assertThat(join.getParentId().getTable().getName()).isEqualTo("\"PARENT_OF_NO_ID_CHILD\"");
});
}
private SqlGenerator.Join generateJoin(String path, Class<?> type) {
return createSqlGenerator(type)
return createSqlGenerator(type, IdentifierProcessing.ANSI)
.getJoin(new PersistentPropertyPathExtension(context, PropertyPathTestingUtils.toPath(path, type, context)));
}
@@ -504,7 +521,7 @@ public class SqlGeneratorUnitTests {
assertThat(generatedColumn("id", DummyEntity.class)) //
.extracting(c -> c.getName(), c -> c.getTable().getName(), c -> getAlias(c.getTable()), this::getAlias)
.containsExactly("id1", "dummy_entity", null, "id1");
.containsExactly("\"ID1\"", "\"DUMMY_ENTITY\"", null, "\"ID1\"");
}
@Test // DATAJDBC-340
@@ -512,7 +529,7 @@ public class SqlGeneratorUnitTests {
assertThat(generatedColumn("ref.l1id", DummyEntity.class)) //
.extracting(c -> c.getName(), c -> c.getTable().getName(), c -> getAlias(c.getTable()), this::getAlias) //
.containsExactly("x_l1id", "referenced_entity", "ref", "ref_x_l1id");
.containsExactly("\"X_L1ID\"", "\"REFERENCED_ENTITY\"", "\"REF\"", "\"REF_X_L1ID\"");
}
@Test // DATAJDBC-340
@@ -526,7 +543,8 @@ public class SqlGeneratorUnitTests {
assertThat(generatedColumn("child", ParentOfNoIdChild.class)) //
.extracting(c -> c.getName(), c -> c.getTable().getName(), c -> getAlias(c.getTable()), this::getAlias) //
.containsExactly("parent_of_no_id_child", "no_id_child", "child", "child_parent_of_no_id_child");
.containsExactly("\"PARENT_OF_NO_ID_CHILD\"", "\"NO_ID_CHILD\"", "\"CHILD\"",
"\"CHILD_PARENT_OF_NO_ID_CHILD\"");
}
private String getAlias(Object maybeAliased) {
@@ -539,7 +557,7 @@ public class SqlGeneratorUnitTests {
private org.springframework.data.relational.core.sql.Column generatedColumn(String path, Class<?> type) {
return createSqlGenerator(type)
return createSqlGenerator(type, IdentifierProcessing.ANSI)
.getColumn(new PersistentPropertyPathExtension(context, PropertyPathTestingUtils.toPath(path, type, context)));
}
@@ -599,8 +617,8 @@ public class SqlGeneratorUnitTests {
private static class PrefixingNamingStrategy implements NamingStrategy {
@Override
public String getColumnName(RelationalPersistentProperty property) {
return "x_" + NamingStrategy.super.getColumnName(property);
public SimpleSqlIdentifier getColumnName(RelationalPersistentProperty property) {
return NamingStrategy.super.getColumnName(property).prefix("x_");
}
}
@@ -621,8 +639,10 @@ public class SqlGeneratorUnitTests {
static class EntityWithQuotedColumnName {
@Id @Column("\"test_@id\"") Long id;
@Column("\"test_@123\"") String name;
// these column names behave like single double quote in the name since the get quoted and then doubling the double
// quote escapes it.
@Id @Column("test\"\"_@id") Long id;
@Column("test\"\"_@123") String name;
}
@SuppressWarnings("unused")

118
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/SqlIdentifierParameterSourceUnitTests.java Normal file
View File

@@ -0,0 +1,118 @@
/*
* Copyright 2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.jdbc.core.convert;
import org.assertj.core.api.SoftAssertions;
import org.junit.Test;
import org.springframework.data.relational.domain.IdentifierProcessing;
import org.springframework.data.relational.domain.SqlIdentifier;
/**
* Tests for {@link SqlIdentifierParameterSource}.
*
* @author Jens Schauder
*/
public class SqlIdentifierParameterSourceUnitTests {
private IdentifierProcessing identifierProcessing = IdentifierProcessing.ANSI;
@Test // DATAJDBC-386
public void empty() {
SqlIdentifierParameterSource parameters = new SqlIdentifierParameterSource(identifierProcessing);
SoftAssertions.assertSoftly(softly -> {
softly.assertThat(parameters.getParameterNames()).isEmpty();
softly.assertThat(parameters.getValue("blah")).isNull();
softly.assertThat(parameters.hasValue("blah")).isFalse();
softly.assertThat(parameters.getSqlType("blah")).isEqualTo(Integer.MIN_VALUE);
});
}
@Test // DATAJDBC-386
public void addSingleValue() {
SqlIdentifierParameterSource parameters = new SqlIdentifierParameterSource(identifierProcessing);
parameters.addValue(SqlIdentifier.unquoted("key"), 23);
SoftAssertions.assertSoftly(softly -> {
softly.assertThat(parameters.getParameterNames()).isEqualTo(new String[] { "key" });
softly.assertThat(parameters.getValue("key")).isEqualTo(23);
softly.assertThat(parameters.hasValue("key")).isTrue();
softly.assertThat(parameters.getValue("blah")).isNull();
softly.assertThat(parameters.hasValue("blah")).isFalse();
softly.assertThat(parameters.getSqlType("blah")).isEqualTo(Integer.MIN_VALUE);
});
}
@Test // DATAJDBC-386
public void addSingleValueWithType() {
SqlIdentifierParameterSource parameters = new SqlIdentifierParameterSource(identifierProcessing);
parameters.addValue(SqlIdentifier.unquoted("key"), 23, 42);
SoftAssertions.assertSoftly(softly -> {
softly.assertThat(parameters.getParameterNames()).isEqualTo(new String[] { "key" });
softly.assertThat(parameters.getValue("key")).isEqualTo(23);
softly.assertThat(parameters.hasValue("key")).isTrue();
softly.assertThat(parameters.getSqlType("key")).isEqualTo(42);
softly.assertThat(parameters.getValue("blah")).isNull();
softly.assertThat(parameters.hasValue("blah")).isFalse();
softly.assertThat(parameters.getSqlType("blah")).isEqualTo(Integer.MIN_VALUE);
});
}
@Test // DATAJDBC-386
public void addOtherDatabaseObjectIdentifierParameterSource() {
SqlIdentifierParameterSource parameters = new SqlIdentifierParameterSource(identifierProcessing);
parameters.addValue(SqlIdentifier.unquoted("key1"), 111, 11);
parameters.addValue(SqlIdentifier.unquoted("key2"), 111);
SqlIdentifierParameterSource parameters2 = new SqlIdentifierParameterSource(identifierProcessing);
parameters2.addValue(SqlIdentifier.unquoted("key2"), 222, 22);
parameters2.addValue(SqlIdentifier.unquoted("key3"), 222);
parameters.addAll(parameters2);
SoftAssertions.assertSoftly(softly -> {
softly.assertThat(parameters.getParameterNames()).isEqualTo(new String[] { "key1", "key2", "key3" });
softly.assertThat(parameters.getValue("key1")).isEqualTo(111);
softly.assertThat(parameters.hasValue("key1")).isTrue();
softly.assertThat(parameters.getSqlType("key1")).isEqualTo(11);
softly.assertThat(parameters.getValue("key2")).isEqualTo(222);
softly.assertThat(parameters.hasValue("key2")).isTrue();
softly.assertThat(parameters.getSqlType("key2")).isEqualTo(22);
softly.assertThat(parameters.getValue("key3")).isEqualTo(222);
softly.assertThat(parameters.hasValue("key3")).isTrue();
softly.assertThat(parameters.getSqlType("key3")).isEqualTo(Integer.MIN_VALUE);
softly.assertThat(parameters.getValue("blah")).isNull();
softly.assertThat(parameters.hasValue("blah")).isFalse();
softly.assertThat(parameters.getSqlType("blah")).isEqualTo(Integer.MIN_VALUE);
});
}
}

30
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/mapping/BasicJdbcPersistentPropertyUnitTests.java
View File

@@ -15,7 +15,8 @@
*/
package org.springframework.data.jdbc.core.mapping;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import lombok.Data;
@@ -27,7 +28,6 @@ import java.util.UUID;
import org.assertj.core.api.SoftAssertions;
import org.junit.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.mapping.PropertyHandler;
import org.springframework.data.relational.core.mapping.BasicRelationalPersistentProperty;
@@ -89,9 +89,9 @@ public class BasicJdbcPersistentPropertyUnitTests {
RelationalPersistentEntity<?> entity = context.getRequiredPersistentEntity(DummyEntity.class);
assertThat(entity.getRequiredPersistentProperty("name").getColumnName()).isEqualTo("dummy_name");
assertThat(entity.getRequiredPersistentProperty("name").getColumnName()).isEqualTo(quoted("dummy_name"));
assertThat(entity.getRequiredPersistentProperty("localDateTime").getColumnName())
.isEqualTo("dummy_last_updated_at");
.isEqualTo(quoted("dummy_last_updated_at"));
}
@Test // DATAJDBC-218
@@ -101,8 +101,8 @@ public class BasicJdbcPersistentPropertyUnitTests {
.getRequiredPersistentEntity(DummyEntity.class) //
.getRequiredPersistentProperty("someList");
assertThat(listProperty.getReverseColumnName()).isEqualTo("dummy_column_name");
assertThat(listProperty.getKeyColumn()).isEqualTo("dummy_key_column_name");
assertThat(listProperty.getReverseColumnName()).isEqualTo(quoted("dummy_column_name"));
assertThat(listProperty.getKeyColumn()).isEqualTo(quoted("dummy_key_column_name"));
}
@Test // DATAJDBC-221
@@ -125,8 +125,8 @@ public class BasicJdbcPersistentPropertyUnitTests {
.getRequiredPersistentEntity(WithCollections.class) //
.getRequiredPersistentProperty("someList");
assertThat(listProperty.getKeyColumn()).isEqualTo("some_key");
assertThat(listProperty.getReverseColumnName()).isEqualTo("some_value");
assertThat(listProperty.getKeyColumn()).isEqualTo(quoted("some_key"));
assertThat(listProperty.getReverseColumnName()).isEqualTo(quoted("some_value"));
}
@Test // DATAJDBC-331
@@ -136,8 +136,8 @@ public class BasicJdbcPersistentPropertyUnitTests {
.getRequiredPersistentEntity(WithCollections.class) //
.getRequiredPersistentProperty("overrideList");
assertThat(listProperty.getKeyColumn()).isEqualTo("override_key");
assertThat(listProperty.getReverseColumnName()).isEqualTo("override_id");
assertThat(listProperty.getKeyColumn()).isEqualTo(quoted("override_key"));
assertThat(listProperty.getReverseColumnName()).isEqualTo(quoted("override_id"));
}
private void checkTargetType(SoftAssertions softly, RelationalPersistentEntity<?> persistentEntity,
@@ -148,6 +148,11 @@ public class BasicJdbcPersistentPropertyUnitTests {
softly.assertThat(property.getColumnType()).describedAs(propertyName).isEqualTo(expected);
}
@SuppressWarnings("unused")
private enum SomeEnum {
ALPHA
}
@Data
@SuppressWarnings("unused")
private static class DummyEntity {
@@ -187,9 +192,4 @@ public class BasicJdbcPersistentPropertyUnitTests {
@Column(value = "some_value", keyColumn = "some_key") @MappedCollection(idColumn = "override_id",
keyColumn = "override_key") List<Integer> overrideList;
}
@SuppressWarnings("unused")
private enum SomeEnum {
ALPHA
}
}

18
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/mapping/model/NamingStrategyUnitTests.java
View File

@@ -16,6 +16,7 @@
package org.springframework.data.jdbc.mapping.model;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import lombok.Data;
@@ -27,6 +28,7 @@ import org.springframework.data.annotation.Id;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.relational.core.mapping.NamingStrategy;
import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
import org.springframework.data.relational.domain.SqlIdentifier;
/**
* Unit tests for the default {@link NamingStrategy}.
@@ -44,42 +46,42 @@ public class NamingStrategyUnitTests {
@Test // DATAJDBC-184
public void getTableName() {
assertThat(target.getTableName(persistentEntity.getType())).isEqualTo("dummy_entity");
assertThat(target.getTableName(persistentEntity.getType())).isEqualTo(quoted("dummy_entity"));
}
@Test // DATAJDBC-184
public void getColumnName() {
assertThat(target.getColumnName(persistentEntity.getPersistentProperty("id"))) //
.isEqualTo("id");
.isEqualTo(quoted("id"));
assertThat(target.getColumnName(persistentEntity.getPersistentProperty("createdAt"))) //
.isEqualTo("created_at");
.isEqualTo(quoted("created_at"));
assertThat(target.getColumnName(persistentEntity.getPersistentProperty("dummySubEntities"))) //
.isEqualTo("dummy_sub_entities");
.isEqualTo(quoted("dummy_sub_entities"));
}
@Test // DATAJDBC-184
public void getReverseColumnName() {
assertThat(target.getReverseColumnName(persistentEntity.getPersistentProperty("dummySubEntities")))
.isEqualTo("dummy_entity");
.isEqualTo(quoted("dummy_entity"));
}
@Test // DATAJDBC-184
public void getKeyColumn() {
assertThat(target.getKeyColumn(persistentEntity.getPersistentProperty("dummySubEntities"))) //
.isEqualTo("dummy_entity_key");
.isEqualTo(quoted("dummy_entity_key"));
}
@Test // DATAJDBC-184
public void getSchema() {
assertThat(target.getSchema()).isEmpty();
assertThat(target.getSchema()).isEqualTo(SqlIdentifier.EMPTY);
}
@Test // DATAJDBC-184
public void getQualifiedTableName() {
assertThat(target.getQualifiedTableName(persistentEntity.getType())).isEqualTo("dummy_entity");
assertThat(target.getQualifiedTableName(persistentEntity.getType())).isEqualTo(quoted("dummy_entity"));
}
@Data

12
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/mybatis/MyBatisCustomizingNamespaceHsqlIntegrationTests.java
View File

@@ -15,7 +15,7 @@
*/
package org.springframework.data.jdbc.mybatis;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.*;
import junit.framework.AssertionFailedError;
@@ -39,6 +39,7 @@ import org.springframework.data.jdbc.core.convert.JdbcConverter;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.jdbc.repository.config.EnableJdbcRepositories;
import org.springframework.data.jdbc.testing.TestConfiguration;
import org.springframework.data.relational.core.dialect.HsqlDbDialect;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.repository.CrudRepository;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabase;
@@ -79,6 +80,8 @@ public class MyBatisCustomizingNamespaceHsqlIntegrationTests {
assertThat(reloaded.name).isEqualTo("name " + saved.id);
}
interface DummyEntityRepository extends CrudRepository<DummyEntity, Long> {}
@org.springframework.context.annotation.Configuration
@Import(TestConfiguration.class)
@EnableJdbcRepositories(considerNestedRepositories = true)
@@ -116,8 +119,9 @@ public class MyBatisCustomizingNamespaceHsqlIntegrationTests {
RelationalMappingContext context = new JdbcMappingContext();
JdbcConverter converter = new BasicJdbcConverter(context, (Identifier, path) -> null);
MyBatisDataAccessStrategy strategy = new MyBatisDataAccessStrategy(sqlSession, context, converter);
MyBatisDataAccessStrategy strategy = new MyBatisDataAccessStrategy(sqlSession,
HsqlDbDialect.INSTANCE.getIdentifierProcessing());
strategy.setNamespaceStrategy(new NamespaceStrategy() {
@Override
@@ -129,6 +133,4 @@ public class MyBatisCustomizingNamespaceHsqlIntegrationTests {
return strategy;
}
}
interface DummyEntityRepository extends CrudRepository<DummyEntity, Long> {}
}

23
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/mybatis/MyBatisDataAccessStrategyUnitTests.java
View File

@@ -15,18 +15,12 @@
*/
package org.springframework.data.jdbc.mybatis;
import static java.util.Arrays.asList;
import static java.util.Collections.emptyList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static java.util.Arrays.*;
import static java.util.Collections.*;
import static org.assertj.core.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import java.util.Collections;
@@ -44,6 +38,7 @@ import org.springframework.data.mapping.PersistentPropertyPath;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
import org.springframework.data.relational.domain.Identifier;
import org.springframework.data.relational.domain.IdentifierProcessing;
/**
* Unit tests for the {@link MyBatisDataAccessStrategy}, mainly ensuring that the correct statements get's looked up.
@@ -60,7 +55,7 @@ public class MyBatisDataAccessStrategyUnitTests {
SqlSession session = mock(SqlSession.class);
ArgumentCaptor<MyBatisContext> captor = ArgumentCaptor.forClass(MyBatisContext.class);
MyBatisDataAccessStrategy accessStrategy = new MyBatisDataAccessStrategy(session, context, converter);
MyBatisDataAccessStrategy accessStrategy = new MyBatisDataAccessStrategy(session, IdentifierProcessing.ANSI);
PersistentPropertyPath<RelationalPersistentProperty> path = PropertyPathTestingUtils.toPath("one.two",
DummyEntity.class, context);
@@ -74,7 +69,7 @@ public class MyBatisDataAccessStrategyUnitTests {
@Test // DATAJDBC-123
public void insert() {
accessStrategy.insert("x", String.class, Collections.singletonMap("key", "value"));
accessStrategy.insert("x", String.class, Collections.singletonMap(unquoted("key"), "value"));
verify(session).insert(eq("java.lang.StringMapper.insert"), captor.capture());

64
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/mybatis/MyBatisHsqlIntegrationTests.java
View File

@@ -35,6 +35,7 @@ import org.springframework.data.jdbc.core.convert.DataAccessStrategy;
import org.springframework.data.jdbc.core.convert.JdbcConverter;
import org.springframework.data.jdbc.repository.config.EnableJdbcRepositories;
import org.springframework.data.jdbc.testing.TestConfiguration;
import org.springframework.data.relational.core.dialect.HsqlDbDialect;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.repository.CrudRepository;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
@@ -57,6 +58,36 @@ import org.springframework.transaction.annotation.Transactional;
@Transactional
public class MyBatisHsqlIntegrationTests {
@ClassRule public static final SpringClassRule classRule = new SpringClassRule();
@Rule public SpringMethodRule methodRule = new SpringMethodRule();
@Autowired SqlSessionFactory sqlSessionFactory;
@Autowired DummyEntityRepository repository;
@Test // DATAJDBC-123
public void mybatisSelfTest() {
SqlSession session = sqlSessionFactory.openSession();
session.selectList("org.springframework.data.jdbc.mybatis.DummyEntityMapper.findById");
}
@Test // DATAJDBC-123
public void myBatisGetsUsedForInsertAndSelect() {
DummyEntity entity = new DummyEntity(null, "some name");
DummyEntity saved = repository.save(entity);
assertThat(saved.id).isNotNull();
DummyEntity reloaded = repository.findById(saved.id).orElseThrow(AssertionFailedError::new);
assertThat(reloaded).isNotNull().extracting(e -> e.id, e -> e.name);
}
interface DummyEntityRepository extends CrudRepository<DummyEntity, Long> {
}
@org.springframework.context.annotation.Configuration
@Import(TestConfiguration.class)
@EnableJdbcRepositories(considerNestedRepositories = true)
@@ -94,38 +125,7 @@ public class MyBatisHsqlIntegrationTests {
SqlSession sqlSession, EmbeddedDatabase db) {
return MyBatisDataAccessStrategy.createCombinedAccessStrategy(context, converter,
new NamedParameterJdbcTemplate(db), sqlSession);
new NamedParameterJdbcTemplate(db), sqlSession, HsqlDbDialect.INSTANCE);
}
}
@ClassRule public static final SpringClassRule classRule = new SpringClassRule();
@Rule public SpringMethodRule methodRule = new SpringMethodRule();
@Autowired SqlSessionFactory sqlSessionFactory;
@Autowired DummyEntityRepository repository;
@Test // DATAJDBC-123
public void mybatisSelfTest() {
SqlSession session = sqlSessionFactory.openSession();
session.selectList("org.springframework.data.jdbc.mybatis.DummyEntityMapper.findById");
}
@Test // DATAJDBC-123
public void myBatisGetsUsedForInsertAndSelect() {
DummyEntity entity = new DummyEntity(null, "some name");
DummyEntity saved = repository.save(entity);
assertThat(saved.id).isNotNull();
DummyEntity reloaded = repository.findById(saved.id).orElseThrow(AssertionFailedError::new);
assertThat(reloaded).isNotNull().extracting(e -> e.id, e -> e.name);
}
interface DummyEntityRepository extends CrudRepository<DummyEntity, Long> {
}
}

7
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/JdbcRepositoryIdGenerationIntegrationTests.java
View File

@@ -16,6 +16,7 @@
package org.springframework.data.jdbc.repository;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import lombok.Data;
import lombok.Value;
@@ -27,7 +28,6 @@ import java.util.concurrent.atomic.AtomicLong;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
@@ -39,6 +39,7 @@ import org.springframework.data.jdbc.repository.support.JdbcRepositoryFactory;
import org.springframework.data.jdbc.repository.support.SimpleJdbcRepository;
import org.springframework.data.relational.core.mapping.NamingStrategy;
import org.springframework.data.relational.core.mapping.event.BeforeConvertCallback;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.data.repository.CrudRepository;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
@@ -166,8 +167,8 @@ public class JdbcRepositoryIdGenerationIntegrationTests {
return new NamingStrategy() {
@Override
public String getTableName(Class<?> type) {
return type.getSimpleName().toUpperCase();
public SqlIdentifier getTableName(Class<?> type) {
return unquoted(type.getSimpleName().toUpperCase());
}
};
}

3
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/SimpleJdbcRepositoryEventsUnitTests.java
View File

@@ -45,6 +45,7 @@ import org.springframework.data.jdbc.core.convert.SqlGeneratorSource;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.jdbc.repository.support.JdbcRepositoryFactory;
import org.springframework.data.jdbc.repository.support.SimpleJdbcRepository;
import org.springframework.data.relational.core.dialect.HsqlDbDialect;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.relational.core.mapping.event.AfterDeleteEvent;
import org.springframework.data.relational.core.mapping.event.AfterLoadEvent;
@@ -82,7 +83,7 @@ public class SimpleJdbcRepositoryEventsUnitTests {
DelegatingDataAccessStrategy delegatingDataAccessStrategy = new DelegatingDataAccessStrategy();
JdbcConverter converter = new BasicJdbcConverter(context, delegatingDataAccessStrategy, new JdbcCustomConversions(),
new DefaultJdbcTypeFactory(operations.getJdbcOperations()));
SqlGeneratorSource generatorSource = new SqlGeneratorSource(context);
SqlGeneratorSource generatorSource = new SqlGeneratorSource(context, HsqlDbDialect.INSTANCE);
this.dataAccessStrategy = spy(new DefaultDataAccessStrategy(generatorSource, context, converter, operations));
delegatingDataAccessStrategy.setDelegate(dataAccessStrategy);

6
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcAuditingHsqlIntegrationTests.java
View File

@@ -16,6 +16,7 @@
package org.springframework.data.jdbc.repository.config;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.relational.domain.SqlIdentifier.*;
import lombok.Data;
@@ -44,6 +45,7 @@ import org.springframework.data.domain.AuditorAware;
import org.springframework.data.relational.core.mapping.NamingStrategy;
import org.springframework.data.relational.core.mapping.event.BeforeConvertCallback;
import org.springframework.data.relational.core.mapping.event.BeforeSaveEvent;
import org.springframework.data.relational.domain.SqlIdentifier;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Component;
import org.springframework.test.context.ActiveProfiles;
@@ -271,8 +273,8 @@ public class EnableJdbcAuditingHsqlIntegrationTests {
return new NamingStrategy() {
public String getTableName(@NotNull Class<?> type) {
return "DummyEntity";
public SqlIdentifier getTableName(@NotNull Class<?> type) {
return unquoted("DummyEntity");
}
};
}

7
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/config/EnableJdbcRepositoriesIntegrationTests.java
View File

@@ -40,9 +40,9 @@ import org.springframework.data.jdbc.core.convert.SqlGeneratorSource;
import org.springframework.data.jdbc.repository.QueryMappingConfiguration;
import org.springframework.data.jdbc.repository.config.EnableJdbcRepositoriesIntegrationTests.TestConfiguration;
import org.springframework.data.jdbc.repository.support.JdbcRepositoryFactoryBean;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.repository.CrudRepository;
import org.springframework.jdbc.core.ResultSetExtractor;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
@@ -69,7 +69,6 @@ public class EnableJdbcRepositoriesIntegrationTests {
"dataAccessStrategy");
public static final RowMapper DUMMY_ENTITY_ROW_MAPPER = mock(RowMapper.class);
public static final RowMapper STRING_ROW_MAPPER = mock(RowMapper.class);
public static final ResultSetExtractor<Integer> INTEGER_RESULT_SET_EXTRACTOR = mock(ResultSetExtractor.class);
@Autowired JdbcRepositoryFactoryBean factoryBean;
@Autowired DummyRepository repository;
@@ -153,8 +152,8 @@ public class EnableJdbcRepositoriesIntegrationTests {
@Bean("qualifierDataAccessStrategy")
DataAccessStrategy defaultDataAccessStrategy(
@Qualifier("namedParameterJdbcTemplate") NamedParameterJdbcOperations template,
RelationalMappingContext context, JdbcConverter converter) {
return new DefaultDataAccessStrategy(new SqlGeneratorSource(context), context, converter, template);
RelationalMappingContext context, JdbcConverter converter, Dialect dialect) {
return new DefaultDataAccessStrategy(new SqlGeneratorSource(context, dialect), context, converter, template);
}
}
}

5
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBeanUnitTests.java
View File

@@ -37,6 +37,7 @@ import org.springframework.data.jdbc.core.convert.DataAccessStrategy;
import org.springframework.data.jdbc.core.convert.DefaultDataAccessStrategy;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.jdbc.repository.QueryMappingConfiguration;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.repository.CrudRepository;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
@@ -60,6 +61,8 @@ public class JdbcRepositoryFactoryBeanUnitTests {
@Mock DataAccessStrategy dataAccessStrategy;
@Mock ApplicationEventPublisher publisher;
@Mock(answer = Answers.RETURNS_DEEP_STUBS) ListableBeanFactory beanFactory;
@Mock
Dialect dialect;
RelationalMappingContext mappingContext;
@@ -86,6 +89,7 @@ public class JdbcRepositoryFactoryBeanUnitTests {
factoryBean.setConverter(new BasicJdbcConverter(mappingContext, dataAccessStrategy));
factoryBean.setApplicationEventPublisher(publisher);
factoryBean.setBeanFactory(beanFactory);
factoryBean.setDialect(dialect);
factoryBean.afterPropertiesSet();
assertThat(factoryBean.getObject()).isNotNull();
@@ -113,6 +117,7 @@ public class JdbcRepositoryFactoryBeanUnitTests {
factoryBean.setConverter(new BasicJdbcConverter(mappingContext, dataAccessStrategy));
factoryBean.setApplicationEventPublisher(publisher);
factoryBean.setBeanFactory(beanFactory);
factoryBean.setDialect(dialect);
factoryBean.afterPropertiesSet();
assertThat(factoryBean.getObject()).isNotNull();

7
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/HsqlDataSourceConfiguration.java
View File

@@ -21,6 +21,8 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.dialect.HsqlDbDialect;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
@@ -47,4 +49,9 @@ class HsqlDataSourceConfiguration {
.addScript(TestUtils.createScriptName(context, "hsql")) //
.build();
}
@Bean
Dialect dialect() {
return HsqlDbDialect.INSTANCE;
}
}

10
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/MariaDBDataSourceConfiguration.java
View File

@@ -22,8 +22,11 @@ import javax.script.ScriptException;
import javax.sql.DataSource;
import org.mariadb.jdbc.MariaDbDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.dialect.MariaDbDialect;
import org.testcontainers.containers.MariaDBContainer;
import org.testcontainers.jdbc.ext.ScriptUtils;
@@ -48,7 +51,9 @@ class MariaDBDataSourceConfiguration extends DataSourceConfiguration {
*/
@Override
protected DataSource createDataSource() {
try {
MariaDbDataSource dataSource = new MariaDbDataSource();
dataSource.setUrl(MARIADB_CONTAINER.getJdbcUrl());
dataSource.setUser(MARIADB_CONTAINER.getUsername());
@@ -59,6 +64,11 @@ class MariaDBDataSourceConfiguration extends DataSourceConfiguration {
}
}
@Bean
Dialect dialect() {
return MariaDbDialect.INSTANCE;
}
@PostConstruct
public void initDatabase() throws SQLException, ScriptException {
ScriptUtils.executeSqlScript(createDataSource().getConnection(), null, "DROP DATABASE test;CREATE DATABASE test;");

8
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/MySqlDataSourceConfiguration.java
View File

@@ -21,8 +21,11 @@ import javax.annotation.PostConstruct;
import javax.script.ScriptException;
import javax.sql.DataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.dialect.MySqlDialect;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.jdbc.ext.ScriptUtils;
@@ -62,6 +65,11 @@ class MySqlDataSourceConfiguration extends DataSourceConfiguration {
return dataSource;
}
@Bean
Dialect dialect() {
return MySqlDialect.INSTANCE;
}
@PostConstruct
public void initDatabase() throws SQLException, ScriptException {
ScriptUtils.executeSqlScript(createDataSource().getConnection(), null, "DROP DATABASE test;CREATE DATABASE test;");

8
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/PostgresDataSourceConfiguration.java
View File

@@ -18,8 +18,11 @@ package org.springframework.data.jdbc.testing;
import javax.sql.DataSource;
import org.postgresql.ds.PGSimpleDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.dialect.PostgresDialect;
import org.springframework.jdbc.datasource.init.ResourceDatabasePopulator;
import org.testcontainers.containers.PostgreSQLContainer;
@@ -55,6 +58,11 @@ public class PostgresDataSourceConfiguration extends DataSourceConfiguration {
return dataSource;
}
@Bean
Dialect dialect() {
return PostgresDialect.INSTANCE;
}
/*
* (non-Javadoc)
* @see org.springframework.data.jdbc.testing.DataSourceFactoryBean#customizePopulator(org.springframework.jdbc.datasource.init.ResourceDatabasePopulator)

7
spring-data-jdbc/src/test/java/org/springframework/data/jdbc/testing/TestConfiguration.java
View File

@@ -38,6 +38,7 @@ import org.springframework.data.jdbc.core.convert.RelationResolver;
import org.springframework.data.jdbc.core.convert.SqlGeneratorSource;
import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
import org.springframework.data.jdbc.repository.support.JdbcRepositoryFactory;
import org.springframework.data.relational.core.dialect.Dialect;
import org.springframework.data.relational.core.mapping.NamingStrategy;
import org.springframework.data.relational.core.mapping.RelationalMappingContext;
import org.springframework.data.repository.core.NamedQueries;
@@ -86,10 +87,10 @@ public class TestConfiguration {
@Bean
DataAccessStrategy defaultDataAccessStrategy(
@Qualifier("namedParameterJdbcTemplate") NamedParameterJdbcOperations template, RelationalMappingContext context,
JdbcConverter converter) {
JdbcConverter converter, Dialect dialect) {
DefaultDataAccessStrategy defaultDataAccessStrategy = new DefaultDataAccessStrategy(new SqlGeneratorSource(context),
context, converter, template);
DefaultDataAccessStrategy defaultDataAccessStrategy = new DefaultDataAccessStrategy(
new SqlGeneratorSource(context, dialect), context, converter, template);
return defaultDataAccessStrategy;
}

361
spring-data-jdbc/src/test/resources/org.springframework.data.jdbc.core/JdbcAggregateTemplateIntegrationTests-mysql.sql
View File

@@ -1,292 +1,297 @@
CREATE TABLE LEGO_SET
(
id1 BIGINT AUTO_INCREMENT PRIMARY KEY,
NAME VARCHAR(30)
id1 BIGINT AUTO_INCREMENT PRIMARY KEY,
NAME VARCHAR(30)
);
CREATE TABLE MANUAL
(
id2 BIGINT AUTO_INCREMENT PRIMARY KEY,
LEGO_SET BIGINT,
ALTERNATIVE BIGINT,
CONTENT VARCHAR(2000)
id2 BIGINT AUTO_INCREMENT PRIMARY KEY,
LEGO_SET BIGINT,
ALTERNATIVE BIGINT,
CONTENT VARCHAR(2000)
);
ALTER TABLE MANUAL
ADD FOREIGN KEY (LEGO_SET)
REFERENCES LEGO_SET (id1);
ADD FOREIGN KEY (LEGO_SET)
REFERENCES LEGO_SET (id1);
CREATE TABLE ONE_TO_ONE_PARENT
(
id3 BIGINT AUTO_INCREMENT PRIMARY KEY,
content VARCHAR(30)
id3 BIGINT AUTO_INCREMENT PRIMARY KEY,
content VARCHAR(30)
);
CREATE TABLE Child_No_Id
(
ONE_TO_ONE_PARENT INTEGER PRIMARY KEY,
content VARCHAR(30)
ONE_TO_ONE_PARENT INTEGER PRIMARY KEY,
content VARCHAR(30)
);
CREATE TABLE LIST_PARENT
(
id4 BIGINT AUTO_INCREMENT PRIMARY KEY,
NAME VARCHAR(100)
id4 BIGINT AUTO_INCREMENT PRIMARY KEY,
NAME VARCHAR(100)
);
CREATE TABLE element_no_id
(
content VARCHAR(100),
LIST_PARENT_key BIGINT,
LIST_PARENT BIGINT
content VARCHAR(100),
LIST_PARENT_key BIGINT,
LIST_PARENT BIGINT
);
CREATE TABLE BYTE_ARRAY_OWNER
(
ID BIGINT AUTO_INCREMENT PRIMARY KEY,
BINARY_DATA VARBINARY(20) NOT NULL
ID BIGINT AUTO_INCREMENT PRIMARY KEY,
BINARY_DATA VARBINARY(20) NOT NULL
);
CREATE TABLE CHAIN4
(
FOUR BIGINT AUTO_INCREMENT PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
FOUR BIGINT AUTO_INCREMENT PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
);
CREATE TABLE CHAIN3
(
THREE BIGINT AUTO_INCREMENT PRIMARY KEY,
THREE_VALUE VARCHAR(20),
CHAIN4 BIGINT,
FOREIGN KEY (CHAIN4) REFERENCES CHAIN4(FOUR)
THREE BIGINT AUTO_INCREMENT PRIMARY KEY,
THREE_VALUE VARCHAR(20),
CHAIN4 BIGINT,
FOREIGN KEY (CHAIN4) REFERENCES CHAIN4 (FOUR)
);
CREATE TABLE CHAIN2
(
TWO BIGINT AUTO_INCREMENT PRIMARY KEY,
TWO_VALUE VARCHAR(20),
CHAIN3 BIGINT,
FOREIGN KEY (CHAIN3) REFERENCES CHAIN3(THREE)
TWO BIGINT AUTO_INCREMENT PRIMARY KEY,
TWO_VALUE VARCHAR(20),
CHAIN3 BIGINT,
FOREIGN KEY (CHAIN3) REFERENCES CHAIN3 (THREE)
);
CREATE TABLE CHAIN1
(
ONE BIGINT AUTO_INCREMENT PRIMARY KEY,
ONE_VALUE VARCHAR(20),
CHAIN2 BIGINT,
FOREIGN KEY (CHAIN2) REFERENCES CHAIN2(TWO)
ONE BIGINT AUTO_INCREMENT PRIMARY KEY,
ONE_VALUE VARCHAR(20),
CHAIN2 BIGINT,
FOREIGN KEY (CHAIN2) REFERENCES CHAIN2 (TWO)
);
CREATE TABLE CHAIN0
(
ZERO BIGINT AUTO_INCREMENT PRIMARY KEY,
ZERO_VALUE VARCHAR(20),
CHAIN1 BIGINT,
FOREIGN KEY (CHAIN1) REFERENCES CHAIN1(ONE)
ZERO BIGINT AUTO_INCREMENT PRIMARY KEY,
ZERO_VALUE VARCHAR(20),
CHAIN1 BIGINT,
FOREIGN KEY (CHAIN1) REFERENCES CHAIN1 (ONE)
);
CREATE TABLE NO_ID_CHAIN4
(
FOUR BIGINT AUTO_INCREMENT PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
FOUR BIGINT AUTO_INCREMENT PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
);
CREATE TABLE NO_ID_CHAIN3
(
THREE_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
THREE_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_CHAIN2
(
TWO_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
TWO_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_CHAIN1
(
ONE_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
ONE_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_CHAIN0
(
ZERO_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
ZERO_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_LIST_CHAIN4
(
FOUR BIGINT AUTO_INCREMENT PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
FOUR BIGINT AUTO_INCREMENT PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
);
CREATE TABLE NO_ID_LIST_CHAIN3
(
THREE_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY),
FOREIGN KEY (NO_ID_LIST_CHAIN4) REFERENCES NO_ID_LIST_CHAIN4 (FOUR)
THREE_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY),
FOREIGN KEY (NO_ID_LIST_CHAIN4) REFERENCES NO_ID_LIST_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_LIST_CHAIN2
(
TWO_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY
) REFERENCES NO_ID_LIST_CHAIN3 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY
)
TWO_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY
) REFERENCES NO_ID_LIST_CHAIN3 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY
)
);
CREATE TABLE NO_ID_LIST_CHAIN1
(
ONE_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
NO_ID_LIST_CHAIN2_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY
) REFERENCES NO_ID_LIST_CHAIN2 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY
)
ONE_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
NO_ID_LIST_CHAIN2_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY
) REFERENCES NO_ID_LIST_CHAIN2 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY
)
);
CREATE TABLE NO_ID_LIST_CHAIN0
(
ZERO_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
NO_ID_LIST_CHAIN2_KEY BIGINT,
NO_ID_LIST_CHAIN1_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY,
NO_ID_LIST_CHAIN1_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY
) REFERENCES NO_ID_LIST_CHAIN1 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY
)
ZERO_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
NO_ID_LIST_CHAIN2_KEY BIGINT,
NO_ID_LIST_CHAIN1_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY,
NO_ID_LIST_CHAIN1_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY
) REFERENCES NO_ID_LIST_CHAIN1 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY
)
);
CREATE TABLE NO_ID_MAP_CHAIN4
(
FOUR BIGINT AUTO_INCREMENT PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
FOUR BIGINT AUTO_INCREMENT PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
);
CREATE TABLE NO_ID_MAP_CHAIN3
(
THREE_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY),
FOREIGN KEY (NO_ID_MAP_CHAIN4) REFERENCES NO_ID_MAP_CHAIN4 (FOUR)
THREE_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY),
FOREIGN KEY (NO_ID_MAP_CHAIN4) REFERENCES NO_ID_MAP_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_MAP_CHAIN2
(
TWO_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY
) REFERENCES NO_ID_MAP_CHAIN3 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY
)
TWO_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY
) REFERENCES NO_ID_MAP_CHAIN3 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY
)
);
CREATE TABLE NO_ID_MAP_CHAIN1
(
ONE_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
NO_ID_MAP_CHAIN2_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY
) REFERENCES NO_ID_MAP_CHAIN2 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY
)
ONE_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
NO_ID_MAP_CHAIN2_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY
) REFERENCES NO_ID_MAP_CHAIN2 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY
)
);
CREATE TABLE NO_ID_MAP_CHAIN0
(
ZERO_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
NO_ID_MAP_CHAIN2_KEY VARCHAR(20),
NO_ID_MAP_CHAIN1_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY,
NO_ID_MAP_CHAIN1_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY
) REFERENCES NO_ID_MAP_CHAIN1 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY
)
ZERO_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
NO_ID_MAP_CHAIN2_KEY VARCHAR(20),
NO_ID_MAP_CHAIN1_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY,
NO_ID_MAP_CHAIN1_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY
) REFERENCES NO_ID_MAP_CHAIN1 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY
)
);
CREATE TABLE VERSIONED_AGGREGATE
(
ID BIGINT AUTO_INCREMENT PRIMARY KEY,
VERSION BIGINT
ID BIGINT AUTO_INCREMENT PRIMARY KEY,
VERSION BIGINT
);
CREATE TABLE WITH_READ_ONLY
(
ID BIGINT AUTO_INCREMENT PRIMARY KEY,
NAME VARCHAR(200),
READ_ONLY VARCHAR(200) DEFAULT 'from-db'
);

369
spring-data-jdbc/src/test/resources/org.springframework.data.jdbc.core/JdbcAggregateTemplateIntegrationTests-postgres.sql
View File

@@ -11,302 +11,309 @@ DROP TABLE CHAIN3;
DROP TABLE CHAIN2;
DROP TABLE CHAIN1;
DROP TABLE CHAIN0;
DROP TABLE WITH_READ_ONLY;
CREATE TABLE LEGO_SET
(
id1 SERIAL PRIMARY KEY,
NAME VARCHAR(30)
id1 SERIAL PRIMARY KEY,
NAME VARCHAR(30)
);
CREATE TABLE MANUAL
(
id2 SERIAL PRIMARY KEY,
LEGO_SET BIGINT,
ALTERNATIVE BIGINT,
CONTENT VARCHAR(2000)
id2 SERIAL PRIMARY KEY,
LEGO_SET BIGINT,
ALTERNATIVE BIGINT,
CONTENT VARCHAR(2000)
);
ALTER TABLE MANUAL
ADD FOREIGN KEY (LEGO_SET)
REFERENCES LEGO_SET (id1);
ADD FOREIGN KEY (LEGO_SET)
REFERENCES LEGO_SET (id1);
CREATE TABLE ONE_TO_ONE_PARENT
(
id3 SERIAL PRIMARY KEY,
content VARCHAR(30)
id3 SERIAL PRIMARY KEY,
content VARCHAR(30)
);
CREATE TABLE Child_No_Id
(
ONE_TO_ONE_PARENT INTEGER PRIMARY KEY,
content VARCHAR(30)
ONE_TO_ONE_PARENT INTEGER PRIMARY KEY,
content VARCHAR(30)
);
CREATE TABLE LIST_PARENT
(
id4 SERIAL PRIMARY KEY,
NAME VARCHAR(100)
id4 SERIAL PRIMARY KEY,
NAME VARCHAR(100)
);
CREATE TABLE element_no_id
(
content VARCHAR(100),
LIST_PARENT_key BIGINT,
LIST_PARENT INTEGER
content VARCHAR(100),
LIST_PARENT_key BIGINT,
LIST_PARENT INTEGER
);
CREATE TABLE ARRAY_OWNER
(
ID SERIAL PRIMARY KEY,
DIGITS VARCHAR(20)[10],
MULTIDIMENSIONAL VARCHAR(20)[10][10]
ID SERIAL PRIMARY KEY,
DIGITS VARCHAR(20)[10],
MULTIDIMENSIONAL VARCHAR(20)[10][10]
);
CREATE TABLE BYTE_ARRAY_OWNER
(
ID SERIAL PRIMARY KEY,
BINARY_DATA BYTEA NOT NULL
ID SERIAL PRIMARY KEY,
BINARY_DATA BYTEA NOT NULL
);
CREATE TABLE CHAIN4
(
FOUR SERIAL PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
FOUR SERIAL PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
);
CREATE TABLE CHAIN3
(
THREE SERIAL PRIMARY KEY,
THREE_VALUE VARCHAR(20),
CHAIN4 BIGINT,
FOREIGN KEY (CHAIN4) REFERENCES CHAIN4 (FOUR)
THREE SERIAL PRIMARY KEY,
THREE_VALUE VARCHAR(20),
CHAIN4 BIGINT,
FOREIGN KEY (CHAIN4) REFERENCES CHAIN4 (FOUR)
);
CREATE TABLE CHAIN2
(
TWO SERIAL PRIMARY KEY,
TWO_VALUE VARCHAR(20),
CHAIN3 BIGINT,
FOREIGN KEY (CHAIN3) REFERENCES CHAIN3 (THREE)
TWO SERIAL PRIMARY KEY,
TWO_VALUE VARCHAR(20),
CHAIN3 BIGINT,
FOREIGN KEY (CHAIN3) REFERENCES CHAIN3 (THREE)
);
CREATE TABLE CHAIN1
(
ONE SERIAL PRIMARY KEY,
ONE_VALUE VARCHAR(20),
CHAIN2 BIGINT,
FOREIGN KEY (CHAIN2) REFERENCES CHAIN2 (TWO)
ONE SERIAL PRIMARY KEY,
ONE_VALUE VARCHAR(20),
CHAIN2 BIGINT,
FOREIGN KEY (CHAIN2) REFERENCES CHAIN2 (TWO)
);
CREATE TABLE CHAIN0
(
ZERO SERIAL PRIMARY KEY,
ZERO_VALUE VARCHAR(20),
CHAIN1 BIGINT,
FOREIGN KEY (CHAIN1) REFERENCES CHAIN1 (ONE)
ZERO SERIAL PRIMARY KEY,
ZERO_VALUE VARCHAR(20),
CHAIN1 BIGINT,
FOREIGN KEY (CHAIN1) REFERENCES CHAIN1 (ONE)
);
CREATE TABLE NO_ID_CHAIN4
(
FOUR SERIAL PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
FOUR SERIAL PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
);
CREATE TABLE NO_ID_CHAIN3
(
THREE_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
THREE_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_CHAIN2
(
TWO_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
TWO_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_CHAIN1
(
ONE_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
ONE_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_CHAIN0
(
ZERO_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
ZERO_VALUE VARCHAR(20),
NO_ID_CHAIN4 BIGINT,
FOREIGN KEY (NO_ID_CHAIN4) REFERENCES NO_ID_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_LIST_CHAIN4
(
FOUR SERIAL PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
FOUR SERIAL PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
);
CREATE TABLE NO_ID_LIST_CHAIN3
(
THREE_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY),
FOREIGN KEY (NO_ID_LIST_CHAIN4) REFERENCES NO_ID_LIST_CHAIN4 (FOUR)
THREE_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY),
FOREIGN KEY (NO_ID_LIST_CHAIN4) REFERENCES NO_ID_LIST_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_LIST_CHAIN2
(
TWO_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY
) REFERENCES NO_ID_LIST_CHAIN3 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY
)
TWO_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY
) REFERENCES NO_ID_LIST_CHAIN3 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY
)
);
CREATE TABLE NO_ID_LIST_CHAIN1
(
ONE_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
NO_ID_LIST_CHAIN2_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY
) REFERENCES NO_ID_LIST_CHAIN2 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY
)
ONE_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
NO_ID_LIST_CHAIN2_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY
) REFERENCES NO_ID_LIST_CHAIN2 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY
)
);
CREATE TABLE NO_ID_LIST_CHAIN0
(
ZERO_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
NO_ID_LIST_CHAIN2_KEY BIGINT,
NO_ID_LIST_CHAIN1_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY,
NO_ID_LIST_CHAIN1_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY
) REFERENCES NO_ID_LIST_CHAIN1 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY
)
ZERO_VALUE VARCHAR(20),
NO_ID_LIST_CHAIN4 BIGINT,
NO_ID_LIST_CHAIN4_KEY BIGINT,
NO_ID_LIST_CHAIN3_KEY BIGINT,
NO_ID_LIST_CHAIN2_KEY BIGINT,
NO_ID_LIST_CHAIN1_KEY BIGINT,
PRIMARY KEY (NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY,
NO_ID_LIST_CHAIN1_KEY),
FOREIGN KEY (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY
) REFERENCES NO_ID_LIST_CHAIN1 (
NO_ID_LIST_CHAIN4,
NO_ID_LIST_CHAIN4_KEY,
NO_ID_LIST_CHAIN3_KEY,
NO_ID_LIST_CHAIN2_KEY
)
);
CREATE TABLE NO_ID_MAP_CHAIN4
(
FOUR SERIAL PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
FOUR SERIAL PRIMARY KEY,
FOUR_VALUE VARCHAR(20)
);
CREATE TABLE NO_ID_MAP_CHAIN3
(
THREE_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY),
FOREIGN KEY (NO_ID_MAP_CHAIN4) REFERENCES NO_ID_MAP_CHAIN4 (FOUR)
THREE_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY),
FOREIGN KEY (NO_ID_MAP_CHAIN4) REFERENCES NO_ID_MAP_CHAIN4 (FOUR)
);
CREATE TABLE NO_ID_MAP_CHAIN2
(
TWO_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY
) REFERENCES NO_ID_MAP_CHAIN3 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY
)
TWO_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY
) REFERENCES NO_ID_MAP_CHAIN3 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY
)
);
CREATE TABLE NO_ID_MAP_CHAIN1
(
ONE_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
NO_ID_MAP_CHAIN2_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY
) REFERENCES NO_ID_MAP_CHAIN2 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY
)
ONE_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
NO_ID_MAP_CHAIN2_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY
) REFERENCES NO_ID_MAP_CHAIN2 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY
)
);
CREATE TABLE NO_ID_MAP_CHAIN0
(
ZERO_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
NO_ID_MAP_CHAIN2_KEY VARCHAR(20),
NO_ID_MAP_CHAIN1_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY,
NO_ID_MAP_CHAIN1_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY
) REFERENCES NO_ID_MAP_CHAIN1 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY
)
ZERO_VALUE VARCHAR(20),
NO_ID_MAP_CHAIN4 BIGINT,
NO_ID_MAP_CHAIN4_KEY VARCHAR(20),
NO_ID_MAP_CHAIN3_KEY VARCHAR(20),
NO_ID_MAP_CHAIN2_KEY VARCHAR(20),
NO_ID_MAP_CHAIN1_KEY VARCHAR(20),
PRIMARY KEY (NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY,
NO_ID_MAP_CHAIN1_KEY),
FOREIGN KEY (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY
) REFERENCES NO_ID_MAP_CHAIN1 (
NO_ID_MAP_CHAIN4,
NO_ID_MAP_CHAIN4_KEY,
NO_ID_MAP_CHAIN3_KEY,
NO_ID_MAP_CHAIN2_KEY
)
);
CREATE TABLE VERSIONED_AGGREGATE
(
ID SERIAL PRIMARY KEY,
VERSION BIGINT
ID SERIAL PRIMARY KEY,
VERSION BIGINT
);
CREATE TABLE WITH_READ_ONLY
(
ID SERIAL PRIMARY KEY,
NAME VARCHAR(200),
READ_ONLY VARCHAR(200) DEFAULT 'from-db'
);