Support for in line queries for tables.

`InlineQuery` can be used wherever a `Table` was used up to now.

```
Table one = ...;
Select select = Select.builder()
		.select(one.column("id"), employee.column("name"))
		.from(one)
		.build();

InlineQuery inline = InlineQuery.create(select, "inline");
Select select = Select.builder()
		.select(inline.column("id"), inline.column("name"))
		.from(inline)
		.build();
```

Join and From renderer now use the same FromTableVisitor.
Also the SelectListVisitor reuses now the ExpressionVisitor.

Fixes #1003
Original pull request: #1018.

Author: schauder

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

@@ -121,7 +121,7 @@ Expression getMappedObject(Expression expression, @Nullable RelationalPersistent
 
 			Column column = (Column) expression;
 			Field field = createPropertyField(entity, column.getName());
-			Table table = column.getTable();
+			TableLike table = column.getTable();
 
 			Assert.state(table != null, String.format("The column %s must have a table set.", column));
 

spring-data-relational/src/main/java/org/springframework/data/relational/core/dialect/PostgresDialect.java

@@ -23,11 +23,11 @@
 import java.util.function.Consumer;
 
 import org.springframework.data.relational.core.sql.IdentifierProcessing;
-import org.springframework.data.relational.core.sql.LockOptions;
-import org.springframework.data.relational.core.sql.SqlIdentifier;
-import org.springframework.data.relational.core.sql.Table;
 import org.springframework.data.relational.core.sql.IdentifierProcessing.LetterCasing;
 import org.springframework.data.relational.core.sql.IdentifierProcessing.Quoting;
+import org.springframework.data.relational.core.sql.LockOptions;
+import org.springframework.data.relational.core.sql.SqlIdentifier;
+import org.springframework.data.relational.core.sql.TableLike;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
@@ -139,7 +139,7 @@ static class PostgresLockClause implements LockClause {
 		@Override
 		public String getLock(LockOptions lockOptions) {
 
-			List<Table> tables = lockOptions.getFrom().getTables();
+			List<TableLike> tables = lockOptions.getFrom().getTables();
 			if (tables.isEmpty()) {
 				return "";
 			}

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

@@ -18,23 +18,17 @@
 /**
  * {@link Segment} to select all columns from a {@link Table}.
  * <p/>
- * * Renders to: {@code
- *
-<table>
- * .*} as in {@code SELECT
- *
-<table>
- * .* FROM …}.
+ * Renders to: {@code <table>.*} as in {@code SELECT <table>.* FROM …}.
  *
  * @author Mark Paluch
  * @since 1.1
  * @see Table#asterisk()
  */
 public class AsteriskFromTable extends AbstractSegment implements Expression {
 
-	private final Table table;
+	private final TableLike table;
 
-	AsteriskFromTable(Table table) {
+	AsteriskFromTable(TableLike table) {
 		super(table);
 		this.table = table;
 	}
@@ -46,7 +40,7 @@ public static AsteriskFromTable create(Table table) {
 	/**
 	 * @return the associated {@link Table}.
 	 */
-	public Table getTable() {
+	public TableLike getTable() {
 		return table;
 	}
 

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

@@ -30,9 +30,9 @@
 public class Column extends AbstractSegment implements Expression, Named {
 
 	private final SqlIdentifier name;
-	private final Table table;
+	private final TableLike table;
 
-	Column(String name, Table table) {
+	Column(String name, TableLike table) {
 
 		super(table);
 		Assert.notNull(name, "Name must not be null");
@@ -41,7 +41,7 @@ public class Column extends AbstractSegment implements Expression, Named {
 		this.table = table;
 	}
 
-	Column(SqlIdentifier name, Table table) {
+	Column(SqlIdentifier name, TableLike table) {
 
 		super(table);
 		Assert.notNull(name, "Name must not be null");
@@ -57,7 +57,7 @@ public class Column extends AbstractSegment implements Expression, Named {
 	 * @param table the table, must not be {@literal null}.
 	 * @return the new {@link Column}.
 	 */
-	public static Column create(String name, Table table) {
+	public static Column create(String name, TableLike table) {
 
 		Assert.hasText(name, "Name must not be null or empty");
 		Assert.notNull(table, "Table must not be null");
@@ -341,7 +341,7 @@ public SqlIdentifier getReferenceName() {
 	 *         {@link Table}.
 	 */
 	@Nullable
-	public Table getTable() {
+	public TableLike getTable() {
 		return table;
 	}
 
@@ -370,12 +370,12 @@ static class AliasedColumn extends Column implements Aliased {
 
 		private final SqlIdentifier alias;
 
-		private AliasedColumn(String name, Table table, String alias) {
+		private AliasedColumn(String name, TableLike table, String alias) {
 			super(name, table);
 			this.alias = SqlIdentifier.unquoted(alias);
 		}
 
-		private AliasedColumn(SqlIdentifier name, Table table, SqlIdentifier alias) {
+		private AliasedColumn(SqlIdentifier name, TableLike table, SqlIdentifier alias) {
 			super(name, table);
 			this.alias = alias;
 		}

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

@@ -42,7 +42,7 @@ class DefaultSelect implements Select {
 	private final List<OrderByField> orderBy;
 	private final @Nullable LockMode lockMode;
 
-	DefaultSelect(boolean distinct, List<Expression> selectList, List<Table> from, long limit, long offset,
+	DefaultSelect(boolean distinct, List<Expression> selectList, List<TableLike> from, long limit, long offset,
 			List<Join> joins, @Nullable Condition where, List<OrderByField> orderBy, @Nullable LockMode lockMode) {
 
 		this.distinct = distinct;

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

@@ -38,7 +38,7 @@ class DefaultSelectBuilder implements SelectBuilder, SelectAndFrom, SelectFromAn
 
 	private boolean distinct = false;
 	private List<Expression> selectList = new ArrayList<>();
-	private List<Table> from = new ArrayList<>();
+	private List<TableLike> from = new ArrayList<>();
 	private long limit = -1;
 	private long offset = -1;
 	private List<Join> joins = new ArrayList<>();
@@ -107,7 +107,7 @@ public SelectFromAndJoin from(String table) {
 	 * @see org.springframework.data.relational.core.sql.SelectBuilder.SelectAndFrom#from(org.springframework.data.relational.core.sql.Table)
 	 */
 	@Override
-	public SelectFromAndJoin from(Table table) {
+	public SelectFromAndJoin from(TableLike table) {
 		from.add(table);
 		return this;
 	}
@@ -117,7 +117,7 @@ public SelectFromAndJoin from(Table table) {
 	 * @see org.springframework.data.relational.core.sql.SelectBuilder.SelectAndFrom#from(org.springframework.data.relational.core.sql.Table[])
 	 */
 	@Override
-	public SelectFromAndJoin from(Table... tables) {
+	public SelectFromAndJoin from(TableLike... tables) {
 		from.addAll(Arrays.asList(tables));
 		return this;
 	}
@@ -127,7 +127,7 @@ public SelectFromAndJoin from(Table... tables) {
 	 * @see org.springframework.data.relational.core.sql.SelectBuilder.SelectAndFrom#from(java.util.Collection)
 	 */
 	@Override
-	public SelectFromAndJoin from(Collection<? extends Table> tables) {
+	public SelectFromAndJoin from(Collection<? extends TableLike> tables) {
 		from.addAll(tables);
 		return this;
 	}
@@ -248,7 +248,7 @@ public SelectOn join(String table) {
 	 * @see org.springframework.data.relational.core.sql.SelectBuilder.SelectJoin#join(org.springframework.data.relational.core.sql.Table)
 	 */
 	@Override
-	public SelectOn join(Table table) {
+	public SelectOn join(TableLike table) {
 		return new JoinBuilder(table, this);
 	}
 
@@ -257,7 +257,7 @@ public SelectOn join(Table table) {
 	 * @see org.springframework.data.relational.core.sql.SelectBuilder.SelectJoin#join(org.springframework.data.relational.core.sql.Table)
 	 */
 	@Override
-	public SelectOn leftOuterJoin(Table table) {
+	public SelectOn leftOuterJoin(TableLike table) {
 		return new JoinBuilder(table, this, JoinType.LEFT_OUTER_JOIN);
 	}
 
@@ -295,21 +295,21 @@ public Select build() {
 	 */
 	static class JoinBuilder implements SelectOn, SelectOnConditionComparison, SelectFromAndJoinCondition {
 
-		private final Table table;
+		private final TableLike table;
 		private final DefaultSelectBuilder selectBuilder;
 		private final JoinType joinType;
 		private @Nullable Expression from;
 		private @Nullable Expression to;
 		private @Nullable Condition condition;
 
-		JoinBuilder(Table table, DefaultSelectBuilder selectBuilder, JoinType joinType) {
+		JoinBuilder(TableLike table, DefaultSelectBuilder selectBuilder, JoinType joinType) {
 
 			this.table = table;
 			this.selectBuilder = selectBuilder;
 			this.joinType = joinType;
 		}
 
-		JoinBuilder(Table table, DefaultSelectBuilder selectBuilder) {
+		JoinBuilder(TableLike table, DefaultSelectBuilder selectBuilder) {
 			this(table, selectBuilder, JoinType.JOIN);
 		}
 
@@ -417,7 +417,7 @@ public SelectOn join(String table) {
 		 * @see org.springframework.data.relational.core.sql.SelectBuilder.SelectJoin#join(org.springframework.data.relational.core.sql.Table)
 		 */
 		@Override
-		public SelectOn join(Table table) {
+		public SelectOn join(TableLike table) {
 			selectBuilder.join(finishJoin());
 			return selectBuilder.join(table);
 		}
@@ -427,7 +427,7 @@ public SelectOn join(Table table) {
 		 * @see org.springframework.data.relational.core.sql.SelectBuilder.SelectJoin#leftOuterJoin(org.springframework.data.relational.core.sql.Table)
 		 */
 		@Override
-		public SelectOn leftOuterJoin(Table table) {
+		public SelectOn leftOuterJoin(TableLike table) {
 			selectBuilder.join(finishJoin());
 			return selectBuilder.leftOuterJoin(table);
 		}

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

@@ -29,20 +29,20 @@
  */
 public class From extends AbstractSegment {
 
-	private final List<Table> tables;
+	private final List<TableLike> tables;
 
-	From(Table... tables) {
+	From(TableLike... tables) {
 		this(Arrays.asList(tables));
 	}
 
-	From(List<Table> tables) {
+	From(List<TableLike> tables) {
 
-		super(tables.toArray(new Table[] {}));
+		super(tables.toArray(new TableLike[] {}));
 
 		this.tables = Collections.unmodifiableList(tables);
 	}
 
-	public List<Table> getTables() {
+	public List<TableLike> getTables() {
 		return this.tables;
 	}
 

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

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2019-2021 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.relational.core.sql;
+
+import org.springframework.util.Assert;
+
+/**
+ * Represents a inline query within a SQL statement. Typically used in {@code FROM} or {@code JOIN} clauses.
+ * <p/>
+ * Renders to: {@code (<SELECT>) AS <ALIAS>} in a from or join clause, and to {@code <ALIAS>} when used in an
+ * expression.
+ * <p/>
+ * Note that this does not implement {@link Aliased} because the Alias is not optional but required and therefore more
+ * like a name although the SQL term is "alias".
+ * 
+ * @author Jens Schauder
+ * @since 2.3
+ */
+public class InlineQuery extends AbstractSegment implements TableLike {
+
+	private final Select select;
+	private final SqlIdentifier alias;
+
+	InlineQuery(Select select, SqlIdentifier alias) {
+
+		super(select);
+
+		this.select = select;
+		this.alias = alias;
+	}
+
+	/**
+	 * Creates a new {@link InlineQuery} using an {@code alias}.
+	 *
+	 * @param select must not be {@literal null}.
+	 * @param alias must not be {@literal null} or empty.
+	 * @return the new {@link InlineQuery} using the {@code alias}.
+	 */
+	public static InlineQuery create(Select select, SqlIdentifier alias) {
+
+		Assert.notNull(select, "Select must not be null!");
+		Assert.notNull(alias, "Alias must not be null or empty!");
+
+		return new InlineQuery(select, alias);
+	}
+
+	/**
+	 * Creates a new {@link InlineQuery} using an {@code alias}.
+	 *
+	 * @param select must not be {@literal null} or empty.
+	 * @param alias must not be {@literal null} or empty.
+	 * @return the new {@link InlineQuery} using the {@code alias}.
+	 */
+	public static InlineQuery create(Select select, String alias) {
+		return create(select, SqlIdentifier.unquoted(alias));
+	}
+
+	/**
+	 * @return the table name.
+	 */
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.relational.core.sql.Named#getName()
+	 */
+	public SqlIdentifier getName() {
+		return alias;
+	}
+
+	/**
+	 * @return the table name as it is used in references. This can be the actual {@link #getName() name} or an
+	 *         {@link Aliased#getAlias() alias}.
+	 */
+	public SqlIdentifier getReferenceName() {
+		return alias;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
+	@Override
+	public String toString() {
+		return "(" + select + ") AS " + alias;
+	}
+
+}

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

@@ -29,10 +29,10 @@
 public class Join extends AbstractSegment {
 
 	private final JoinType type;
-	private final Table joinTable;
+	private final TableLike joinTable;
 	private final Condition on;
 
-	Join(JoinType type, Table joinTable, Condition on) {
+	Join(JoinType type, TableLike joinTable, Condition on) {
 
 		super(joinTable, on);
 
@@ -51,7 +51,7 @@ public JoinType getType() {
 	/**
 	 * @return the joined {@link Table}.
 	 */
-	public Table getJoinTable() {
+	public TableLike getJoinTable() {
 		return joinTable;
 	}