Polishing.

Switch to value expressions to allow property-placeholder usage. Add tests. Add missing support for MappedCollection.idColumn() expressions.

See #1524
Original pull request: #2077

Author: mp911de

spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/BasicRelationalPersistentEntity.java

@@ -17,14 +17,14 @@
 
 import java.util.Optional;
 
+import org.springframework.data.expression.ValueExpression;
+import org.springframework.data.expression.ValueExpressionParser;
 import org.springframework.data.mapping.model.BasicPersistentEntity;
 import org.springframework.data.relational.core.sql.SqlIdentifier;
 import org.springframework.data.util.Lazy;
 import org.springframework.data.util.TypeInformation;
 import org.springframework.expression.Expression;
-import org.springframework.expression.ParserContext;
 import org.springframework.expression.common.LiteralExpression;
-import org.springframework.expression.spel.standard.SpelExpressionParser;
 import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;
 
@@ -38,16 +38,17 @@
  * @author Mikhail Polivakha
  * @author Kurt Niemi
  * @author Sergey Korotaev
+ * @author Mark Paluch
  */
 class BasicRelationalPersistentEntity<T> extends BasicPersistentEntity<T, RelationalPersistentProperty>
 		implements RelationalPersistentEntity<T> {
 
-	private static final SpelExpressionParser PARSER = new SpelExpressionParser();
+	private static final ValueExpressionParser PARSER = ValueExpressionParser.create();
 
 	private final Lazy<SqlIdentifier> tableName;
-	private final @Nullable Expression tableNameExpression;
+	private final @Nullable ValueExpression tableNameExpression;
 	private final Lazy<Optional<SqlIdentifier>> schemaName;
-	private final @Nullable Expression schemaNameExpression;
+	private final @Nullable ValueExpression schemaNameExpression;
 	private final SqlIdentifierExpressionEvaluator sqlIdentifierExpressionEvaluator;
 	private boolean forceQuote = true;
 
@@ -97,14 +98,14 @@ class BasicRelationalPersistentEntity<T> extends BasicPersistentEntity<T, Relati
 	 * @return can be {@literal null}.
 	 */
 	@Nullable
-	private static Expression detectExpression(@Nullable String potentialExpression) {
+	private static ValueExpression detectExpression(@Nullable String potentialExpression) {
 
 		if (!StringUtils.hasText(potentialExpression)) {
 			return null;
 		}
 
-		Expression expression = PARSER.parseExpression(potentialExpression, ParserContext.TEMPLATE_EXPRESSION);
-		return expression instanceof LiteralExpression ? null : expression;
+		ValueExpression expression = PARSER.parse(potentialExpression);
+		return expression.isLiteral() ? null : expression;
 	}
 
 	private SqlIdentifier createSqlIdentifier(String name) {

spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/BasicRelationalPersistentProperty.java

@@ -18,6 +18,8 @@
 import java.util.Optional;
 import java.util.Set;
 
+import org.springframework.data.expression.ValueExpression;
+import org.springframework.data.expression.ValueExpressionParser;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.model.AnnotationBasedPersistentProperty;
@@ -28,9 +30,7 @@
 import org.springframework.data.spel.EvaluationContextProvider;
 import org.springframework.data.util.Lazy;
 import org.springframework.expression.Expression;
-import org.springframework.expression.ParserContext;
 import org.springframework.expression.common.LiteralExpression;
-import org.springframework.expression.spel.standard.SpelExpressionParser;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
@@ -44,19 +44,21 @@
  * @author Bastian Wilhelm
  * @author Kurt Niemi
  * @author Sergey Korotaev
+ * @author Mark Paluch
  */
 public class BasicRelationalPersistentProperty extends AnnotationBasedPersistentProperty<RelationalPersistentProperty>
 		implements RelationalPersistentProperty {
 
-	private static final SpelExpressionParser PARSER = new SpelExpressionParser();
+	private static final ValueExpressionParser PARSER = ValueExpressionParser.create();
 
 	private final Lazy<SqlIdentifier> columnName;
 	private final boolean hasExplicitColumnName;
-	private final @Nullable Expression columnNameExpression;
+	private final @Nullable ValueExpression columnNameExpression;
 	private final SqlIdentifier sequence;
 	private final Lazy<Optional<SqlIdentifier>> collectionIdColumnName;
+	private final @Nullable ValueExpression collectionIdColumnNameExpression;
 	private final Lazy<SqlIdentifier> collectionKeyColumnName;
-	private final @Nullable Expression collectionKeyColumnNameExpression;
+	private final @Nullable ValueExpression collectionKeyColumnNameExpression;
 	private final boolean isEmbedded;
 	private final String embeddedPrefix;
 
@@ -99,6 +101,7 @@ public BasicRelationalPersistentProperty(Property property, PersistentEntity<?,
 			if (StringUtils.hasText(mappedCollection.idColumn())) {
 				collectionIdColumnName = Lazy.of(() -> Optional.of(createSqlIdentifier(mappedCollection.idColumn())));
 			}
+			this.collectionIdColumnNameExpression = detectExpression(mappedCollection.idColumn());
 
 			collectionKeyColumnName = Lazy.of(
 					() -> StringUtils.hasText(mappedCollection.keyColumn()) ? createSqlIdentifier(mappedCollection.keyColumn())
@@ -107,6 +110,7 @@ public BasicRelationalPersistentProperty(Property property, PersistentEntity<?,
 			this.collectionKeyColumnNameExpression = detectExpression(mappedCollection.keyColumn());
 		} else {
 
+			this.collectionIdColumnNameExpression = null;
 			this.collectionKeyColumnNameExpression = null;
 		}
 
@@ -151,14 +155,14 @@ void setSqlIdentifierExpressionEvaluator(SqlIdentifierExpressionEvaluator sqlIde
 	 * @return can be {@literal null}.
 	 */
 	@Nullable
-	private static Expression detectExpression(@Nullable String potentialExpression) {
+	private static ValueExpression detectExpression(@Nullable String potentialExpression) {
 
 		if (!StringUtils.hasText(potentialExpression)) {
 			return null;
 		}
 
-		Expression expression = PARSER.parseExpression(potentialExpression, ParserContext.TEMPLATE_EXPRESSION);
-		return expression instanceof LiteralExpression ? null : expression;
+		ValueExpression expression = PARSER.parse(potentialExpression);
+		return expression.isLiteral() ? null : expression;
 	}
 
 	private SqlIdentifier createSqlIdentifier(String name) {
@@ -210,8 +214,13 @@ public RelationalPersistentEntity<?> getOwner() {
 	@Override
 	public SqlIdentifier getReverseColumnName(RelationalPersistentEntity<?> owner) {
 
-		return collectionIdColumnName.get()
-				.orElseGet(() -> createDerivedSqlIdentifier(this.namingStrategy.getReverseColumnName(owner)));
+		if (collectionIdColumnNameExpression == null) {
+
+			return collectionIdColumnName.get()
+					.orElseGet(() -> createDerivedSqlIdentifier(this.namingStrategy.getReverseColumnName(owner)));
+		}
+
+		return sqlIdentifierExpressionEvaluator.evaluate(collectionIdColumnNameExpression, isForceQuote());
 	}
 
 	@Override

spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/Column.java

@@ -27,15 +27,18 @@
  * @author Kazuki Shimizu
  * @author Florian Lüdiger
  * @author Bastian Wilhelm
+ * @author Mark Paluch
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE })
 @Documented
 public @interface Column {
 
 	/**
-	 * The column name. The attribute supports SpEL expressions to dynamically calculate the column name on a
-	 * per-operation basis.
+	 * The column name. The attribute supports Value Expressions to dynamically obtain the column name on a per-operation
+	 * basis. Expressions returning a {@code String} are {@link SqlIdentifierSanitizer sanitized} prior usage. Expressions
+	 * can also return a {@link org.springframework.data.relational.core.sql.SqlIdentifier} directly that is used as-is
+	 * without further sanitization.
 	 */
 	String value() default "";
 

spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/MappedCollection.java

@@ -27,30 +27,36 @@
 /**
  * The annotation to configure the mapping for a {@link List}, {@link Set} or {@link Map} property in the database.
  *
- * @since 1.1
  * @author Bastian Wilhelm
  * @author Mark Paluch
+ * @since 1.1
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE })
 @Documented
 public @interface MappedCollection {
 
 	/**
-	 * The column name for id column in the corresponding relationship table. The attribute supports SpEL expressions to
-	 * dynamically calculate the column name on a per-operation basis. Defaults to {@link NamingStrategy} usage if the
-	 * value is empty.
+	 * The column name for id column in the corresponding relationship table. The attribute supports Value Expressions to
+	 * dynamically obtain the column name on a per-operation basis. Defaults to {@link NamingStrategy} usage if the value
+	 * is empty. Expressions returning a {@code String} are {@link SqlIdentifierSanitizer sanitized} prior usage.
+	 * Expressions can also return a {@link org.springframework.data.relational.core.sql.SqlIdentifier} directly that is
+	 * used as-is without further sanitization.
 	 *
 	 * @see NamingStrategy#getReverseColumnName(RelationalPersistentProperty)
 	 */
 	String idColumn() default "";
 
 	/**
 	 * The column name for key columns of {@link List} or {@link Map} collections in the corresponding relationship table.
-	 * The attribute supports SpEL expressions to dynamically calculate the column name on a per-operation basis. Defaults
-	 * to {@link NamingStrategy} usage if the value is empty.
+	 * The attribute supports Value Expressions to dynamically obtain the column name on a per-operation basis. Defaults
+	 * to {@link NamingStrategy} usage if the value is empty. Expressions returning a {@code String} are
+	 * {@link SqlIdentifierSanitizer sanitized} prior usage. Expressions can also return a
+	 * {@link org.springframework.data.relational.core.sql.SqlIdentifier} directly that is used as-is without further
+	 * sanitization.
 	 *
 	 * @see NamingStrategy#getKeyColumn(RelationalPersistentProperty)
 	 */
 	String keyColumn() default "";
+
 }

spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/RelationalMappingContext.java

@@ -20,6 +20,7 @@
 
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
+import org.springframework.core.env.Environment;
 import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.mapping.context.AbstractMappingContext;
 import org.springframework.data.mapping.context.MappingContext;
@@ -112,6 +113,12 @@ public void setApplicationContext(ApplicationContext applicationContext) throws
 		this.sqlIdentifierExpressionEvaluator.setProvider(new ExtensionAwareEvaluationContextProvider(applicationContext));
 	}
 
+	@Override
+	public void setEnvironment(Environment environment) {
+		this.sqlIdentifierExpressionEvaluator.setEnvironment(environment);
+		super.setEnvironment(environment);
+	}
+
 	@Nullable
 	@Override
 	public RelationalPersistentEntity<?> getPersistentEntity(RelationalPersistentProperty persistentProperty) {

spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/SqlIdentifierExpressionEvaluator.java

@@ -1,9 +1,13 @@
 package org.springframework.data.relational.core.mapping;
 
+import org.springframework.core.env.Environment;
+import org.springframework.core.env.StandardEnvironment;
+import org.springframework.data.expression.ValueEvaluationContext;
+import org.springframework.data.expression.ValueExpression;
 import org.springframework.data.relational.core.sql.SqlIdentifier;
 import org.springframework.data.spel.EvaluationContextProvider;
+import org.springframework.expression.EvaluationContext;
 import org.springframework.expression.EvaluationException;
-import org.springframework.expression.Expression;
 import org.springframework.util.Assert;
 
 /**
@@ -15,6 +19,7 @@
  *
  * @author Kurt Niemi
  * @author Sergey Korotaev
+ * @author Mark Paluch
  * @see SqlIdentifierSanitizer
  * @since 3.2
  */
@@ -23,21 +28,29 @@ class SqlIdentifierExpressionEvaluator {
 	private EvaluationContextProvider provider;
 
 	private SqlIdentifierSanitizer sanitizer = SqlIdentifierSanitizer.words();
+	private Environment environment = new StandardEnvironment();
 
 	public SqlIdentifierExpressionEvaluator(EvaluationContextProvider provider) {
 		this.provider = provider;
 	}
 
-	public SqlIdentifier evaluate(Expression expression, boolean isForceQuote) throws EvaluationException {
+	public SqlIdentifier evaluate(ValueExpression expression, boolean isForceQuote) throws EvaluationException {
 
 		Assert.notNull(expression, "Expression must not be null.");
 
-		Object value = expression.getValue(provider.getEvaluationContext(null), Object.class);
+		EvaluationContext evaluationContext = provider.getEvaluationContext(null);
+		ValueEvaluationContext valueEvaluationContext = ValueEvaluationContext.of(environment, evaluationContext);
+
+		Object value = expression.evaluate(valueEvaluationContext);
 		if (value instanceof SqlIdentifier sqlIdentifier) {
 			return sqlIdentifier;
 		}
 
-		String sanitizedResult = sanitizer.sanitize((String) value);
+		if (value == null) {
+			throw new EvaluationException("Expression '%s' evaluated to 'null'".formatted(expression));
+		}
+
+		String sanitizedResult = sanitizer.sanitize(value.toString());
 		return isForceQuote ? SqlIdentifier.quoted(sanitizedResult) : SqlIdentifier.unquoted(sanitizedResult);
 	}
 
@@ -49,6 +62,16 @@ public void setSanitizer(SqlIdentifierSanitizer sanitizer) {
 	}
 
 	public void setProvider(EvaluationContextProvider provider) {
+
+		Assert.notNull(provider, "EvaluationContextProvider must not be null");
+
 		this.provider = provider;
 	}
+
+	public void setEnvironment(Environment environment) {
+
+		Assert.notNull(environment, "Environment must not be null");
+
+		this.environment = environment;
+	}
 }

spring-data-relational/src/main/java/org/springframework/data/relational/core/mapping/Table.java

@@ -30,6 +30,7 @@
  * @author Kazuki Shimizu
  * @author Bastian Wilhelm
  * @author Mikhail Polivakha
+ * @author Mark Paluch
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
@@ -38,26 +39,35 @@
 public @interface Table {
 
 	/**
-	 * The table name. The attribute supports SpEL expressions to dynamically calculate the table name on a per-operation
-	 * basis.
+	 * The table name. The attribute supports value expressions to dynamically obtain the table name on a per-operation
+	 * basis. Expressions returning a {@code String} are {@link SqlIdentifierSanitizer sanitized} prior usage. Expressions
+	 * can also return a {@link org.springframework.data.relational.core.sql.SqlIdentifier} directly that is used as-is
+	 * without further sanitization.
 	 */
 	@AliasFor("name")
 	String value() default "";
 
 	/**
-	 * The table name. The attribute supports SpEL expressions to dynamically calculate the table name on a per-operation
-	 * basis.
+	 * The table name. The attribute supports value expressions to dynamically obtain the table name on a per-operation
+	 * basis. Expressions returning a {@code String} are {@link SqlIdentifierSanitizer sanitized} prior usage. Expressions
+	 * can also return a {@link org.springframework.data.relational.core.sql.SqlIdentifier} directly that is used as-is
+	 * without further sanitization.
 	 */
 	@AliasFor("value")
 	String name() default "";
 
 	/**
-	 * Name of the schema (or user, for example in case of oracle), in which this table resides in The behavior is the
+	 * Name of the schema (or user, for example in case of Oracle), in which this table resides in The behavior is the
 	 * following: <br/>
 	 * If the {@link Table#schema()} is specified, then it will be used as a schema of current table, i.e. as a prefix to
 	 * the name of the table, which can be specified in {@link Table#value()}. <br/>
 	 * If the {@link Table#schema()} is not specified, then spring data will assume the default schema, The default schema
-	 * itself can be provided by the means of {@link NamingStrategy#getSchema()}
+	 * itself can be provided by the means of {@link NamingStrategy#getSchema()}. The attribute supports value expressions
+	 * to dynamically obtain the schema name on a per-operation basis. Expressions returning a {@code String} are
+	 * {@link SqlIdentifierSanitizer sanitized} prior usage. Expressions can also return a
+	 * {@link org.springframework.data.relational.core.sql.SqlIdentifier} directly that is used as-is without further
+	 * sanitization.
 	 */
 	String schema() default "";
+
 }