TupleExpressions: move maybeWrap and renamed it.

Author: schauder

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

@@ -197,7 +197,7 @@ private Condition getSubselectCondition(AggregatePath path,
 	}
 
 	private Expression toExpression(Map<AggregatePath, Column> columnsMap) {
-		return TupleExpression.maybeWrap(new ArrayList<>(columnsMap.values()));
+		return Expressions.of(new ArrayList<>(columnsMap.values()));
 	}
 
 	private BindMarker getBindMarker(SqlIdentifier columnName) {

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/JdbcDeleteQueryCreator.java

@@ -140,7 +140,7 @@ private void deleteRelations(List<Delete> deleteChain, RelationalPersistentEntit
 
 				List<Column> reverseColumns = aggregatePath.getTableInfo().backReferenceColumnInfos()
 						.toList(ci -> table.column(ci.name()));
-				Expression expression = TupleExpression.maybeWrap(reverseColumns);
+				Expression expression = Expressions.of(reverseColumns);
 
 				Condition inCondition = Conditions.in(expression, parentSelect);
 

spring-data-relational/src/main/java/org/springframework/data/relational/core/sql/Expressions.java

@@ -15,15 +15,17 @@
  */
 package org.springframework.data.relational.core.sql;
 
+import java.util.List;
+
 /**
  * Factory for common {@link Expression}s.
  *
  * @author Mark Paluch
  * @author Jens Schauder
- * @since 1.1
  * @see SQL
  * @see Conditions
  * @see Functions
+ * @since 1.1
  */
 public abstract class Expressions {
 
@@ -61,8 +63,29 @@ public static Expression cast(Expression expression, String targetType) {
 		return Cast.create(expression, targetType);
 	}
 
+	/**
+	 * Creates an {@link Expression} based on the provided list of {@link Column}s.
+	 * <p>
+	 * If the list contains only a single column, this method returns that column directly
+	 * as the resulting {@link Expression}. Otherwise, it creates and returns a
+	 * {@link TupleExpression} that represents multiple columns as a single expression.
+	 *
+	 * @param columns the list of {@link Column}s to include in the expression;
+	 *                must not be {@literal null}.
+	 * @return an {@link Expression} corresponding to the input columns: either a single column or a {@link TupleExpression} for multiple columns.
+	 * @since 3.5
+	 */
+	public static Expression of(List<Column> columns) {
+
+		if (columns.size() == 1) {
+			return columns.get(0);
+		}
+		return new TupleExpression(columns);
+	}
+
 	// Utility constructor.
-	private Expressions() {}
+	private Expressions() {
+	}
 
 	static public class SimpleExpression extends AbstractSegment implements Expression {
 

spring-data-relational/src/main/java/org/springframework/data/relational/core/sql/TupleExpression.java

@@ -38,7 +38,7 @@ private static Segment[] children(List<? extends Expression> expressions) {
 		return expressions.toArray(new Segment[0]);
 	}
 
-	private TupleExpression(List<? extends Expression> expressions) {
+	TupleExpression(List<? extends Expression> expressions) {
 
 		super(children(expressions));
 
@@ -53,14 +53,6 @@ public static TupleExpression create(List<? extends Expression> expressions) {
 		return new TupleExpression(expressions);
 	}
 
-	public static Expression maybeWrap(List<Column> columns) {
-
-		if (columns.size() == 1) {
-			return columns.get(0);
-		}
-		return new TupleExpression(columns);
-	}
-
 	@Override
 	public String toString() {
 		return "(" + expressions.stream().map(Expression::toString).collect(joining(", ")) + ")";

spring-data-relational/src/test/java/org/springframework/data/relational/core/sql/TupleExpressionUnitTests.java

@@ -34,7 +34,7 @@ void singleExpressionDoesNotGetWrapped() {
 
 		Column testColumn = Column.create("name", Table.create("employee"));
 
-		Expression wrapped = TupleExpression.maybeWrap(List.of(testColumn));
+		Expression wrapped = Expressions.of(List.of(testColumn));
 
 		assertThat(wrapped).isSameAs(testColumn);
 	}
@@ -45,7 +45,7 @@ void multipleExpressionsDoGetWrapped() {
 		Column testColumn1 = Column.create("first", Table.create("employee"));
 		Column testColumn2 = Column.create("last", Table.create("employee"));
 
-		Expression wrapped = TupleExpression.maybeWrap(List.of(testColumn1, testColumn2));
+		Expression wrapped = Expressions.of(List.of(testColumn1, testColumn2));
 
 		assertThat(wrapped).isInstanceOf(TupleExpression.class);
 	}