Performance refinements.

Author: mp911de

spring-data-jdbc/src/jmh/java/org/springframework/data/jdbc/CompositeIdBenchmarks.java

@@ -17,6 +17,8 @@
 
 import static org.assertj.core.api.Assertions.*;
 
+import java.sql.Connection;
+import java.sql.SQLException;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicLong;
@@ -39,8 +41,10 @@
 import org.springframework.data.relational.core.mapping.Embedded;
 import org.springframework.data.relational.core.mapping.Table;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
+import org.springframework.jdbc.datasource.ConnectionHolder;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
 
 /**
  * Benchmarks for Composite Ids in Spring Data JDBC.
@@ -82,7 +86,7 @@ public static class BenchmarkState {
 		SimpleEntity alpha;
 
 		@Setup
-		public void setup() {
+		public void setup() throws SQLException {
 
 			context = new AnnotationConfigApplicationContext();
 			context.register(BenchmarkConfiguration.class);
@@ -91,6 +95,12 @@ public void setup() {
 
 			template = context.getBean(JdbcAggregateTemplate.class);
 			named = context.getBean(NamedParameterJdbcTemplate.class);
+			DataSource dataSource = context.getBean(DataSource.class);
+
+			Connection connection = dataSource.getConnection();
+			ConnectionHolder holder = new ConnectionHolder(connection, true);
+			holder.setSynchronizedWithTransaction(true);
+			TransactionSynchronizationManager.bindResource(dataSource, holder);
 
 			alpha = template.insert(new SimpleEntity(new WrappedPk(l.incrementAndGet()), "alpha"));
 		}
@@ -160,7 +170,7 @@ public void deleteSingleSimpleEntityWithEmbeddedPk(BenchmarkState state) {
 		List<SimpleEntityWithEmbeddedPk> entities = (List<SimpleEntityWithEmbeddedPk>) state.template
 				.insertAll(List.of(new SimpleEntityWithEmbeddedPk(new EmbeddedPk(23L, "x"), "alpha")));
 
-		state.template.delete(entities.get(1));
+		state.template.delete(entities.get(0));
 	}
 
 	@Benchmark

spring-data-jdbc/src/jmh/java/org/springframework/data/jdbc/Profiler.java

@@ -29,6 +29,14 @@ abstract class BindParameterNameSanitizer {
 	private static final Pattern parameterPattern = Pattern.compile("\\W");
 
 	static String sanitize(String rawName) {
-		return parameterPattern.matcher(rawName).replaceAll("");
+
+		for (int i = 0; i < rawName.length(); i++) {
+			char c = rawName.charAt(i);
+			if ((c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && (c < '0' || c > '9') && c != '_') {
+				return parameterPattern.matcher(rawName).replaceAll("");
+			}
+		}
+
+		return rawName;
 	}
 }

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

@@ -24,21 +24,28 @@
 import java.util.Map;
 
 import org.springframework.util.ClassUtils;
+import org.springframework.util.ConcurrentLruCache;
 
 /**
  * Utility that determines the necessary type conversions between Java types used in the domain model and types
  * compatible with JDBC drivers.
  *
  * @author Jens Schauder
+ * @author Mark Paluch
  * @since 2.0
  */
 public enum JdbcColumnTypes {
 
 	INSTANCE {
 
+		private final ConcurrentLruCache<Class<?>, Class<?>> cache = new ConcurrentLruCache<>(64, this::doResolve);
+
 		@SuppressWarnings({ "unchecked", "rawtypes" })
 		public Class<?> resolvePrimitiveType(Class<?> type) {
+			return cache.get(type);
+		}
 
+		private Class<?> doResolve(Class<?> type) {
 			return javaToDbType.entrySet().stream() //
 					.filter(e -> e.getKey().isAssignableFrom(type)) //
 					.map(e -> (Class<?>) e.getValue()) //

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

@@ -35,8 +35,8 @@
  */
 class SqlIdentifierParameterSource extends AbstractSqlParameterSource {
 
-	private final Set<SqlIdentifier> identifiers = new HashSet<>();
-	private final Map<String, Object> namesToValues = new HashMap<>();
+	private final Set<SqlIdentifier> identifiers = new HashSet<>(16, 1f);
+	private final Map<String, Object> namesToValues = new HashMap<>(16, 1f);
 
 	@Override
 	public boolean hasValue(String paramName) {
@@ -73,7 +73,7 @@ void addAll(SqlIdentifierParameterSource others) {
 
 		for (SqlIdentifier identifier : others.getIdentifiers()) {
 
-			String name = BindParameterNameSanitizer.sanitize( identifier.getReference());
+			String name = BindParameterNameSanitizer.sanitize(identifier.getReference());
 			addValue(identifier, others.getValue(name), others.getSqlType(name));
 		}
 	}

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

@@ -208,8 +208,11 @@ private BiFunction<Object, AggregatePath, Object> getIdMapper(@Nullable Relation
 			return (id, aggregatePath) -> id;
 		}
 
-		return (id, aggregatePath) -> complexId.getPropertyPathAccessor(id)
-				.getProperty(aggregatePath.getRequiredPersistentPropertyPath());
+		return (id, aggregatePath) -> {
+
+			PersistentPropertyAccessor<Object> accessor = complexId.getPropertyAccessor(id);
+			return accessor.getProperty(aggregatePath.getRequiredLeafProperty());
+		};
 	}
 
 	private void addConvertedPropertyValue(SqlIdentifierParameterSource parameterSource,

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

@@ -27,7 +27,7 @@
 import java.util.Map;
 
 import org.springframework.jdbc.support.JdbcUtils;
-import org.springframework.util.Assert;
+import org.springframework.util.ConcurrentLruCache;
 
 /**
  * Contains methods dealing with the quirks of JDBC, independent of any Entity, Aggregate or Repository abstraction.
@@ -58,7 +58,10 @@ public String toString() {
 			return getName();
 		}
 	};
+
 	private static final Map<Class<?>, SQLType> sqlTypeMappings = new HashMap<>();
+	private static ConcurrentLruCache<Class<?>, SQLType> sqlTypeCache = new ConcurrentLruCache<>(64,
+			JdbcUtil::doGetSqlType);
 
 	static {
 
@@ -97,9 +100,10 @@ private JdbcUtil() {
 	 * @return a matching {@link SQLType} or {@link #TYPE_UNKNOWN}.
 	 */
 	public static SQLType targetSqlTypeFor(Class<?> type) {
+		return sqlTypeCache.get(type);
+	}
 
-		Assert.notNull(type, "Type must not be null");
-
+	private static SQLType doGetSqlType(Class<?> type) {
 		return sqlTypeMappings.keySet().stream() //
 				.filter(k -> k.isAssignableFrom(type)) //
 				.findFirst() //