Polishing.

Introduce factory methods to create mapping contexts that use quoting and that use plain identifiers for easier creation of the correct mapping context.

See #1993
Original pull request #2066

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/mapping/JdbcMappingContext.java

@@ -54,6 +54,61 @@ public class JdbcMappingContext extends RelationalMappingContext {
 		setSimpleTypeHolder(JdbcSimpleTypes.HOLDER);
 	}
 
+	/**
+	 * Create a new {@code JdbcMappingContext} using {@link #setForceQuote(boolean) plain identifiers}. Plain
+	 * {@link org.springframework.data.relational.core.sql.SqlIdentifier identifiers} (i.e. table and column names) are
+	 * typically not case-sensitive (case-sensitivity can be still enforced by specific database configurations).
+	 *
+	 * @return a new {@code JdbcMappingContext} using plain identifiers.
+	 * @since 4.0
+	 */
+	public static JdbcMappingContext forPlainIdentifiers() {
+		JdbcMappingContext context = forQuotedIdentifiers();
+		context.setForceQuote(false);
+		return context;
+	}
+
+	/**
+	 * Create a new {@code JdbcMappingContext} using {@link #setForceQuote(boolean) plain identifiers} and the given
+	 * {@link NamingStrategy}. Plain {@link org.springframework.data.relational.core.sql.SqlIdentifier identifiers} (i.e.
+	 * table and column names) are typically not case-sensitive (case-sensitivity can be still enforced by specific
+	 * database configurations).
+	 *
+	 * @param namingStrategy must not be {@literal null}.
+	 * @return a new {@code JdbcMappingContext} using plain identifiers.
+	 * @since 4.0
+	 */
+	public static JdbcMappingContext forPlainIdentifiers(NamingStrategy namingStrategy) {
+		JdbcMappingContext context = forQuotedIdentifiers(namingStrategy);
+		context.setForceQuote(false);
+		return context;
+	}
+
+	/**
+	 * Create a new {@code JdbcMappingContext} using {@link #setForceQuote(boolean) quoted identifiers} (default
+	 * behavior). Quoted {@link org.springframework.data.relational.core.sql.SqlIdentifier identifiers} (i.e. table and
+	 * column names) are typically case-sensitive.
+	 *
+	 * @return a new {@code JdbcMappingContext} using quoted identifiers.
+	 * @since 4.0
+	 */
+	public static JdbcMappingContext forQuotedIdentifiers() {
+		return new JdbcMappingContext();
+	}
+
+	/**
+	 * Create a new {@code JdbcMappingContext} using {@link #setForceQuote(boolean) quoted identifiers} (default behavior)
+	 * and the given {@link NamingStrategy}. Quoted {@link org.springframework.data.relational.core.sql.SqlIdentifier
+	 * identifiers} (i.e. table and column names) are typically case-sensitive.
+	 *
+	 * @param namingStrategy must not be {@literal null}.
+	 * @return a new {@code JdbcMappingContext} using quoted identifiers.
+	 * @since 4.0
+	 */
+	public static JdbcMappingContext forQuotedIdentifiers(NamingStrategy namingStrategy) {
+		return new JdbcMappingContext(namingStrategy);
+	}
+
 	@Override
 	protected RelationalPersistentProperty createPersistentProperty(Property property,
 			RelationalPersistentEntity<?> owner, SimpleTypeHolder simpleTypeHolder) {

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

@@ -116,7 +116,8 @@ public class AbstractJdbcConfiguration implements ApplicationContextAware {
 	public JdbcMappingContext jdbcMappingContext(Optional<NamingStrategy> namingStrategy,
 			JdbcCustomConversions customConversions, RelationalManagedTypes jdbcManagedTypes) {
 
-		JdbcMappingContext mappingContext = new JdbcMappingContext(namingStrategy.orElse(DefaultNamingStrategy.INSTANCE));
+		JdbcMappingContext mappingContext = JdbcMappingContext
+				.forQuotedIdentifiers(namingStrategy.orElse(DefaultNamingStrategy.INSTANCE));
 		mappingContext.setSimpleTypeHolder(customConversions.getSimpleTypeHolder());
 		mappingContext.setManagedTypes(jdbcManagedTypes);
 

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

@@ -1032,7 +1032,7 @@ public class EntityRowMapperUnitTests {
 	@SuppressWarnings("unchecked")
 	private <T> EntityRowMapper<T> createRowMapper(Class<T> type, NamingStrategy namingStrategy) {
 
-		RelationalMappingContext context = new JdbcMappingContext(namingStrategy);
+		RelationalMappingContext context = JdbcMappingContext.forQuotedIdentifiers(namingStrategy);
 
 		DataAccessStrategy accessStrategy = mock(DataAccessStrategy.class);
 

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

@@ -40,7 +40,7 @@ import org.springframework.data.relational.core.mapping.RelationalPersistentEnti
  */
 class JdbcIdentifierBuilderUnitTests {
 
-	JdbcMappingContext context = new JdbcMappingContext();
+	JdbcMappingContext context = JdbcMappingContext.forQuotedIdentifiers();
 	JdbcConverter converter = new MappingJdbcConverter(context, (identifier, path) -> {
 		throw new UnsupportedOperationException();
 	});

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/MappingJdbcConverterUnitTests.java

@@ -165,7 +165,7 @@ class MappingJdbcConverterUnitTests {
 	@Test // GH-1750
 	void readByteArrayToNestedUuidWithCustomConverter() {
 
-		JdbcMappingContext context = new JdbcMappingContext();
+		JdbcMappingContext context = JdbcMappingContext.forQuotedIdentifiers();
 		StubbedJdbcTypeFactory typeFactory = new StubbedJdbcTypeFactory();
 		Converter<byte[], UUID> customConverter = new ByteArrayToUuid();
 		MappingJdbcConverter converter = new MappingJdbcConverter( //

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/RowDocumentResultSetExtractorUnitTests.java

@@ -48,7 +48,7 @@ import org.springframework.data.relational.domain.RowDocument;
  */
 public class RowDocumentResultSetExtractorUnitTests {
 
-	RelationalMappingContext context = new JdbcMappingContext(new DefaultNamingStrategy());
+	RelationalMappingContext context = JdbcMappingContext.forQuotedIdentifiers(new DefaultNamingStrategy());
 
 	private final PathToColumnMapping column = new PathToColumnMapping() {
 		@Override

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

@@ -212,7 +212,7 @@ public class SqlGeneratorContextBasedNamingStrategyUnitTests {
 	 */
 	private SqlGenerator configureSqlGenerator(NamingStrategy namingStrategy) {
 
-		RelationalMappingContext context = new JdbcMappingContext(namingStrategy);
+		RelationalMappingContext context = JdbcMappingContext.forQuotedIdentifiers(namingStrategy);
 		JdbcConverter converter = new MappingJdbcConverter(context, (identifier, path) -> {
 			throw new UnsupportedOperationException();
 		});

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

@@ -46,7 +46,7 @@ import org.springframework.lang.Nullable;
  */
 class SqlGeneratorEmbeddedUnitTests {
 
-	private RelationalMappingContext context = new JdbcMappingContext();
+	private RelationalMappingContext context = JdbcMappingContext.forPlainIdentifiers();
 	private JdbcConverter converter = new MappingJdbcConverter(context, (identifier, path) -> {
 		throw new UnsupportedOperationException();
 	});
@@ -54,7 +54,6 @@ class SqlGeneratorEmbeddedUnitTests {
 
 	@BeforeEach
 	void setUp() {
-		this.context.setForceQuote(false);
 		this.sqlGenerator = createSqlGenerator(DummyEntity.class);
 	}
 

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

@@ -196,7 +196,7 @@ class SqlGeneratorFixedNamingStrategyUnitTests {
 	 */
 	private SqlGenerator configureSqlGenerator(NamingStrategy namingStrategy) {
 
-		context = new JdbcMappingContext(namingStrategy);
+		context = JdbcMappingContext.forQuotedIdentifiers(namingStrategy);
 		JdbcConverter converter = new MappingJdbcConverter(context, (identifier, path) -> {
 			throw new UnsupportedOperationException();
 		});

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

@@ -15,17 +15,11 @@
  */
 package org.springframework.data.jdbc.core.convert;
 
-import static java.util.Collections.emptySet;
+import static java.util.Collections.*;
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.*;
-import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.SoftAssertions.*;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.springframework.data.relational.core.mapping.ForeignKeyNaming.*;
-import static org.assertj.core.api.Assertions.entry;
+import static org.springframework.data.relational.core.sql.SqlIdentifier.*;
-import static org.assertj.core.api.SoftAssertions.assertSoftly;
-import static org.springframework.data.relational.core.mapping.ForeignKeyNaming.APPLY_RENAMING;
-import static org.springframework.data.relational.core.mapping.ForeignKeyNaming.IGNORE_RENAMING;
-import static org.springframework.data.relational.core.sql.SqlIdentifier.EMPTY;
-import static org.springframework.data.relational.core.sql.SqlIdentifier.quoted;
-import static org.springframework.data.relational.core.sql.SqlIdentifier.unquoted;
 
 import java.util.Map;
 import java.util.Set;
@@ -87,7 +81,7 @@ class SqlGeneratorUnitTests {
 	private static final Identifier BACKREF = Identifier.of(unquoted("backref"), "some-value", String.class);
 
 	private final PrefixingNamingStrategy namingStrategy = new PrefixingNamingStrategy();
-	private RelationalMappingContext context = new JdbcMappingContext(namingStrategy);
+	private RelationalMappingContext context = JdbcMappingContext.forQuotedIdentifiers(namingStrategy);
 	private final JdbcConverter converter = new MappingJdbcConverter(context, (identifier, path) -> {
 		throw new UnsupportedOperationException();
 	});
@@ -977,7 +971,7 @@ class SqlGeneratorUnitTests {
 	void backReferenceShouldConsiderRenamedParent() {
 
 		namingStrategy.setForeignKeyNaming(APPLY_RENAMING);
-		context = new JdbcMappingContext(namingStrategy);
+		context = JdbcMappingContext.forQuotedIdentifiers(namingStrategy);
 
 		String sql = sqlGenerator.createDeleteInByPath(getPath("ref", RenamedDummy.class));
 
@@ -988,7 +982,7 @@ class SqlGeneratorUnitTests {
 	void backReferenceShouldIgnoreRenamedParent() {
 
 		namingStrategy.setForeignKeyNaming(IGNORE_RENAMING);
-		context = new JdbcMappingContext(namingStrategy);
+		context = JdbcMappingContext.forQuotedIdentifiers(namingStrategy);
 
 		String sql = sqlGenerator.createDeleteInByPath(getPath("ref", RenamedDummy.class));
 
@@ -999,7 +993,7 @@ class SqlGeneratorUnitTests {
 	void keyColumnShouldConsiderRenamedParent() {
 
 		namingStrategy.setForeignKeyNaming(APPLY_RENAMING);
-		context = new JdbcMappingContext(namingStrategy);
+		context = JdbcMappingContext.forQuotedIdentifiers(namingStrategy);
 
 		SqlGenerator sqlGenerator = createSqlGenerator(ReferencedEntity.class);
 		String sql = sqlGenerator.getFindAllByProperty(Identifier.of(unquoted("parentId"), 23, RenamedDummy.class),
@@ -1012,7 +1006,7 @@ class SqlGeneratorUnitTests {
 	void keyColumnShouldIgnoreRenamedParent() {
 
 		namingStrategy.setForeignKeyNaming(IGNORE_RENAMING);
-		context = new JdbcMappingContext(namingStrategy);
+		context = JdbcMappingContext.forQuotedIdentifiers(namingStrategy);
 
 		SqlGenerator sqlGenerator = createSqlGenerator(ReferencedEntity.class);
 		String sql = sqlGenerator.getFindAllByProperty(Identifier.of(unquoted("parentId"), 23, RenamedDummy.class),

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/mapping/model/DefaultNamingStrategyUnitTests.java

@@ -15,18 +15,19 @@
  */
 package org.springframework.data.jdbc.mapping.model;
 
+import static org.assertj.core.api.Assertions.*;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
 import org.junit.jupiter.api.Test;
+
 import org.springframework.data.annotation.Id;
 import org.springframework.data.jdbc.core.mapping.JdbcMappingContext;
 import org.springframework.data.relational.core.mapping.DefaultNamingStrategy;
 import org.springframework.data.relational.core.mapping.NamingStrategy;
 import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
 
-import java.time.LocalDateTime;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.*;
-
 /**
  * Unit tests for the default {@link NamingStrategy}.
  *
@@ -39,7 +40,7 @@ public class DefaultNamingStrategyUnitTests {
 	private final NamingStrategy target = DefaultNamingStrategy.INSTANCE;
 
 	private final RelationalPersistentEntity<?> persistentEntity = //
-			new JdbcMappingContext(target).getRequiredPersistentEntity(DummyEntity.class);
+			JdbcMappingContext.forQuotedIdentifiers(target).getRequiredPersistentEntity(DummyEntity.class);
 
 	@Test // DATAJDBC-184
 	public void getTableName() {

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/repository/DeclaredQueryRepositoryUnitTests.java

@@ -16,15 +16,13 @@
 
 package org.springframework.data.jdbc.repository;
 
-import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
+import static org.mockito.Mockito.*;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
 
 import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;
+
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.jdbc.core.convert.DataAccessStrategy;
@@ -98,7 +96,7 @@ public class DeclaredQueryRepositoryUnitTests {
 
 		Dialect dialect = JdbcHsqlDbDialect.INSTANCE;
 
-		RelationalMappingContext context = new JdbcMappingContext();
+		RelationalMappingContext context = JdbcMappingContext.forQuotedIdentifiers();
 
 		DelegatingDataAccessStrategy delegatingDataAccessStrategy = new DelegatingDataAccessStrategy();
 		JdbcConverter converter = new MappingJdbcConverter(context, delegatingDataAccessStrategy,

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

@@ -125,7 +125,8 @@ public class TestConfiguration {
 	JdbcMappingContext jdbcMappingContextWithOutSingleQueryLoading(Optional<NamingStrategy> namingStrategy,
 			CustomConversions conversions) {
 
-		JdbcMappingContext mappingContext = new JdbcMappingContext(namingStrategy.orElse(DefaultNamingStrategy.INSTANCE));
+		JdbcMappingContext mappingContext = JdbcMappingContext
+				.forQuotedIdentifiers(namingStrategy.orElse(DefaultNamingStrategy.INSTANCE));
 		mappingContext.setSimpleTypeHolder(conversions.getSimpleTypeHolder());
 		return mappingContext;
 	}
@@ -135,7 +136,8 @@ public class TestConfiguration {
 	JdbcMappingContext jdbcMappingContextWithSingleQueryLoading(Optional<NamingStrategy> namingStrategy,
 			CustomConversions conversions) {
 
-		JdbcMappingContext mappingContext = new JdbcMappingContext(namingStrategy.orElse(DefaultNamingStrategy.INSTANCE));
+		JdbcMappingContext mappingContext = JdbcMappingContext
+				.forQuotedIdentifiers(namingStrategy.orElse(DefaultNamingStrategy.INSTANCE));
 		mappingContext.setSimpleTypeHolder(conversions.getSimpleTypeHolder());
 		mappingContext.setSingleQueryLoadingEnabled(true);
 		return mappingContext;

spring-data-r2dbc/src/main/java/org/springframework/data/r2dbc/config/AbstractR2dbcConfiguration.java

@@ -177,7 +177,8 @@ public abstract class AbstractR2dbcConfiguration implements ApplicationContextAw
 
 		Assert.notNull(namingStrategy, "NamingStrategy must not be null");
 
-		R2dbcMappingContext context = new R2dbcMappingContext(namingStrategy.orElse(DefaultNamingStrategy.INSTANCE));
+		R2dbcMappingContext context = R2dbcMappingContext
+				.forQuotedIdentifiers(namingStrategy.orElse(DefaultNamingStrategy.INSTANCE));
 		context.setSimpleTypeHolder(r2dbcCustomConversions.getSimpleTypeHolder());
 		context.setManagedTypes(r2dbcManagedTypes);
 

spring-data-r2dbc/src/main/java/org/springframework/data/r2dbc/mapping/R2dbcMappingContext.java

@@ -43,6 +43,62 @@ public class R2dbcMappingContext extends RelationalMappingContext {
 		super(namingStrategy);
 	}
 
+	/**
+	 * Create a new {@code R2dbcMappingContext} using {@link #setForceQuote(boolean) plain identifiers}. Plain
+	 * {@link org.springframework.data.relational.core.sql.SqlIdentifier identifiers} (i.e. table and column names) are
+	 * typically not case-sensitive (case-sensitivity can be still enforced by specific database configurations).
+	 *
+	 * @return a new {@code R2dbcMappingContext} using plain identifiers.
+	 * @since 4.0
+	 */
+	public static R2dbcMappingContext forPlainIdentifiers() {
+		R2dbcMappingContext context = forQuotedIdentifiers();
+		context.setForceQuote(false);
+		return context;
+	}
+
+	/**
+	 * Create a new {@code R2dbcMappingContext} using {@link #setForceQuote(boolean) plain identifiers} and the given
+	 * {@link NamingStrategy}. Plain {@link org.springframework.data.relational.core.sql.SqlIdentifier identifiers} (i.e.
+	 * table and column names) are typically not case-sensitive (case-sensitivity can be still enforced by specific
+	 * database configurations).
+	 *
+	 * @param namingStrategy must not be {@literal null}.
+	 * @return a new {@code R2dbcMappingContext} using plain identifiers.
+	 * @since 4.0
+	 */
+	public static R2dbcMappingContext forPlainIdentifiers(NamingStrategy namingStrategy) {
+		R2dbcMappingContext context = forQuotedIdentifiers(namingStrategy);
+		context.setForceQuote(false);
+		return context;
+	}
+
+	/**
+	 * Create a new {@code R2dbcMappingContext} using {@link #setForceQuote(boolean) quoted identifiers} (default
+	 * behavior). Quoted {@link org.springframework.data.relational.core.sql.SqlIdentifier identifiers} (i.e. table and
+	 * column names) are typically case-sensitive.
+	 *
+	 * @return a new {@code R2dbcMappingContext} using quoted identifiers.
+	 * @since 4.0
+	 */
+	public static R2dbcMappingContext forQuotedIdentifiers() {
+		return new R2dbcMappingContext();
+	}
+
+	/**
+	 * Create a new {@code R2dbcMappingContext} using {@link #setForceQuote(boolean) quoted identifiers} (default
+	 * behavior) and the given {@link NamingStrategy}. Quoted
+	 * {@link org.springframework.data.relational.core.sql.SqlIdentifier identifiers} (i.e. table and column names) are
+	 * typically case-sensitive.
+	 *
+	 * @param namingStrategy must not be {@literal null}.
+	 * @return a new {@code R2dbcMappingContext} using quoted identifiers.
+	 * @since 4.0
+	 */
+	public static R2dbcMappingContext forQuotedIdentifiers(NamingStrategy namingStrategy) {
+		return new R2dbcMappingContext(namingStrategy);
+	}
+
 	@Override
 	protected boolean shouldCreatePersistentEntityFor(TypeInformation<?> type) {
 

spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/convert/MappingR2dbcConverterUnitTests.java

@@ -55,7 +55,7 @@ import org.springframework.r2dbc.core.Parameter;
  */
 public class MappingR2dbcConverterUnitTests {
 
-	private RelationalMappingContext mappingContext = new R2dbcMappingContext();
+	private RelationalMappingContext mappingContext = R2dbcMappingContext.forPlainIdentifiers();
 	private MappingR2dbcConverter converter = new MappingR2dbcConverter(mappingContext);
 
 	@BeforeEach
@@ -67,7 +67,6 @@ public class MappingR2dbcConverterUnitTests {
 						StringToSimplePersonConverter.INSTANCE));
 
 		mappingContext.setSimpleTypeHolder(conversions.getSimpleTypeHolder());
-		mappingContext.setForceQuote(false);
 		converter = new MappingR2dbcConverter(mappingContext, conversions);
 	}
 

spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/core/PostgresReactiveDataAccessStrategyTests.java

@@ -55,27 +55,24 @@ public class PostgresReactiveDataAccessStrategyTests extends ReactiveDataAccessS
 	private R2dbcMappingContext context;
 	private final ReactiveDataAccessStrategy strategy;
 
-	{
+	PostgresReactiveDataAccessStrategyTests() {
-		context = new R2dbcMappingContext();
-		context.setForceQuote(false);
 
-		DefaultReactiveDataAccessStrategy strategy1 = createReactiveDataAccessStrategy(DurationToIntervalConverter.INSTANCE,
+		context = R2dbcMappingContext.forPlainIdentifiers();
+		strategy = createReactiveDataAccessStrategy(DurationToIntervalConverter.INSTANCE,
 				IntervalToDurationConverter.INSTANCE);
-		strategy = strategy1;
 	}
 
 	private DefaultReactiveDataAccessStrategy createReactiveDataAccessStrategy(Object... converters) {
+
 		R2dbcCustomConversions customConversions = R2dbcCustomConversions.of(PostgresDialect.INSTANCE, converters);
 
 		MappingR2dbcConverter converter = new MappingR2dbcConverter(context, customConversions);
-		DefaultReactiveDataAccessStrategy strategy1 = new DefaultReactiveDataAccessStrategy(PostgresDialect.INSTANCE,
+		return new DefaultReactiveDataAccessStrategy(PostgresDialect.INSTANCE,
 				converter);
-		return strategy1;
 	}
 
 	@Override
 	protected ReactiveDataAccessStrategy getStrategy() {
-
 		return strategy;
 	}
 

spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/core/SqlServerReactiveDataAccessStrategyTests.java

@@ -28,7 +28,7 @@ public class SqlServerReactiveDataAccessStrategyTests extends ReactiveDataAccess
 
 	private final ReactiveDataAccessStrategy strategy = new DefaultReactiveDataAccessStrategy(SqlServerDialect.INSTANCE);
 
-	{
+	SqlServerReactiveDataAccessStrategyTests() {
 		((R2dbcMappingContext) strategy.getConverter().getMappingContext()).setForceQuote(false);
 	}
 

spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/query/QueryMapperUnitTests.java

@@ -69,8 +69,7 @@ class QueryMapperUnitTests {
 
 		R2dbcCustomConversions conversions = R2dbcCustomConversions.of(dialect, Arrays.asList(converters));
 
-		R2dbcMappingContext context = new R2dbcMappingContext();
+		R2dbcMappingContext context = R2dbcMappingContext.forPlainIdentifiers();
-		context.setForceQuote(false);
 		context.setSimpleTypeHolder(conversions.getSimpleTypeHolder());
 		context.afterPropertiesSet();
 

spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/query/UpdateMapperUnitTests.java

@@ -46,14 +46,10 @@ import org.springframework.r2dbc.core.binding.BindTarget;
  */
 public class UpdateMapperUnitTests {
 
-	private final R2dbcConverter converter = new MappingR2dbcConverter(new R2dbcMappingContext());
+	private final R2dbcConverter converter = new MappingR2dbcConverter(R2dbcMappingContext.forPlainIdentifiers());
 	private final UpdateMapper mapper = new UpdateMapper(PostgresDialect.INSTANCE, converter);
 	private final BindTarget bindTarget = mock(BindTarget.class);
 
-	{
-		((R2dbcMappingContext) converter.getMappingContext()).setForceQuote(false);
-	}
-
 	@Test // gh-64
 	void shouldMapFieldNamesInUpdate() {
 

spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/repository/OracleR2dbcRepositoryIntegrationTests.java

@@ -19,21 +19,28 @@ import io.r2dbc.spi.ConnectionFactory;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import java.util.Optional;
+
 import javax.sql.DataSource;
 
 import org.junit.jupiter.api.condition.DisabledOnOs;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.api.extension.RegisterExtension;
+
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan.Filter;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.FilterType;
 import org.springframework.data.r2dbc.config.AbstractR2dbcConfiguration;
+import org.springframework.data.r2dbc.convert.R2dbcCustomConversions;
+import org.springframework.data.r2dbc.mapping.R2dbcMappingContext;
 import org.springframework.data.r2dbc.repository.config.EnableR2dbcRepositories;
 import org.springframework.data.r2dbc.repository.support.R2dbcRepositoryFactory;
 import org.springframework.data.r2dbc.testing.EnabledOnClass;
 import org.springframework.data.r2dbc.testing.ExternalDatabase;
 import org.springframework.data.r2dbc.testing.OracleTestSupport;
+import org.springframework.data.relational.RelationalManagedTypes;
+import org.springframework.data.relational.core.mapping.NamingStrategy;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 
@@ -60,6 +67,15 @@ public class OracleR2dbcRepositoryIntegrationTests extends AbstractR2dbcReposito
 		public ConnectionFactory connectionFactory() {
 			return OracleTestSupport.createConnectionFactory(database);
 		}
+
+		@Override
+		public R2dbcMappingContext r2dbcMappingContext(Optional<NamingStrategy> namingStrategy,
+				R2dbcCustomConversions r2dbcCustomConversions, RelationalManagedTypes r2dbcManagedTypes) {
+			R2dbcMappingContext mappingContext = super.r2dbcMappingContext(namingStrategy, r2dbcCustomConversions,
+					r2dbcManagedTypes);
+			mappingContext.setForceQuote(false);
+			return mappingContext;
+		}
 	}
 
 	@Override

spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/repository/ProjectingRepositoryIntegrationTests.java

@@ -112,8 +112,7 @@ public class ProjectingRepositoryIntegrationTests {
 		return H2TestSupport.createConnectionFactory();
 	}
 
-	@Test
+	@Test // GH-1687
-	// GH-1687
 	void shouldApplyProjectionDirectly() {
 
 		repository.findProjectionByEmail("heisenberg@the-white-family.com") //
@@ -123,8 +122,7 @@ public class ProjectingRepositoryIntegrationTests {
 				}).verifyComplete();
 	}
 
-	@Test
+	@Test // GH-1687
-	// GH-1687
 	void shouldApplyEntityQueryProjectionDirectly() {
 
 		repository.findAllByEmail("heisenberg@the-white-family.com") //

spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/repository/query/PartTreeR2dbcQueryUnitTests.java

@@ -99,8 +99,7 @@ class PartTreeR2dbcQueryUnitTests {
 
 		when(r2dbcConverter.writeValue(any(), any())).thenAnswer(invocation -> invocation.getArgument(0));
 
-		mappingContext = new R2dbcMappingContext();
+		mappingContext = R2dbcMappingContext.forPlainIdentifiers();
-		mappingContext.setForceQuote(false);
 		doReturn(mappingContext).when(r2dbcConverter).getMappingContext();
 
 		R2dbcDialect dialect = DialectResolver.getDialect(connectionFactory);
@@ -691,8 +690,7 @@ class PartTreeR2dbcQueryUnitTests {
 				.from(TABLE);
 	}
 
-	@Test
+	@Test // GH-475, GH-1687
-	// GH-475, GH-1687
 	void createsDtoProjectionQuery() throws Exception {
 
 		R2dbcQueryMethod queryMethod = getQueryMethod("findAsDtoProjectionByAge", Integer.TYPE);

spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/repository/query/R2dbcQueryMethodUnitTests.java

@@ -58,8 +58,7 @@ class R2dbcQueryMethodUnitTests {
 	@BeforeEach
 	void setUp() {
 
-		this.context = new R2dbcMappingContext();
+		this.context = R2dbcMappingContext.forPlainIdentifiers();
-		this.context.setForceQuote(false);
 	}
 
 	@Test

spring-data-r2dbc/src/test/java/org/springframework/data/r2dbc/repository/support/SqlInspectingR2dbcRepositoryUnitTests.java

@@ -57,8 +57,7 @@ public class SqlInspectingR2dbcRepositoryUnitTests {
 	@SuppressWarnings("unchecked")
 	public void before() {
 
-		context = new R2dbcMappingContext();
+		context = R2dbcMappingContext.forPlainIdentifiers();
-		context.setForceQuote(false);
 		r2dbcConverter = new MappingR2dbcConverter(context);
 		dataAccessStrategy = new DefaultReactiveDataAccessStrategy(H2Dialect.INSTANCE, r2dbcConverter);