DATACASS-810 - Add DataClassRowMapper.

DataClassRowMapper can map Cassandra results onto a class following the data class pattern (using constructor properties) or by setting bean properties.

data class Person(val firstname: String, val age: Int)

cqlTemplate.query("SELECT * FROM person", DataClassRowMapper<Person>())

Author: mp911de

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/BeanPropertyRowMapper.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2020 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.cassandra.core.cql;
+
+import java.lang.reflect.Constructor;
+
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.TypeConverter;
+import org.springframework.core.convert.ConversionService;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+import com.datastax.oss.driver.api.core.cql.Row;
+
+/**
+ * {@link RowMapper} implementation that converts a row into a new instance of the specified mapped target class. The
+ * mapped target class must be a top-level class and may either expose a data class constructor with named parameters
+ * corresponding to column names or classic bean property setters (or even a combination of both).
+ * <p>
+ * Note that this class extends {@link BeanPropertyRowMapper} and can therefore serve as a common choice for any mapped
+ * target class, flexibly adapting to constructor style versus setter methods in the mapped class.
+ *
+ * @author Mark Paluch
+ * @since 3.1
+ * @param <T> the result type
+ */
+public class DataClassRowMapper<T> extends BeanPropertyRowMapper<T> {
+
+	private @Nullable Constructor<T> mappedConstructor;
+
+	private @Nullable String[] constructorParameterNames;
+
+	private @Nullable Class<?>[] constructorParameterTypes;
+
+	/**
+	 * Create a new {@code DataClassRowMapper}.
+	 *
+	 * @param mappedClass the class that each row should be mapped to.
+	 */
+	public DataClassRowMapper(Class<T> mappedClass) {
+		super(mappedClass);
+	}
+
+	@Override
+	protected void initialize(Class<T> mappedClass) {
+
+		super.initialize(mappedClass);
+
+		this.mappedConstructor = BeanUtils.getResolvableConstructor(mappedClass);
+		if (this.mappedConstructor.getParameterCount() > 0) {
+			this.constructorParameterNames = BeanUtils.getParameterNames(this.mappedConstructor);
+			this.constructorParameterTypes = this.mappedConstructor.getParameterTypes();
+		}
+	}
+
+	@Override
+	protected T constructMappedInstance(Row row, TypeConverter tc) {
+
+		Assert.state(this.mappedConstructor != null, "Mapped constructor was not initialized");
+
+		Object[] args;
+		if (this.constructorParameterNames != null && this.constructorParameterTypes != null) {
+			args = new Object[this.constructorParameterNames.length];
+			for (int i = 0; i < args.length; i++) {
+				String name = underscoreName(this.constructorParameterNames[i]);
+				Class<?> type = this.constructorParameterTypes[i];
+				args[i] = tc.convertIfNecessary(getColumnValue(row, row.getColumnDefinitions().firstIndexOf(name), type), type);
+			}
+		} else {
+			args = new Object[0];
+		}
+
+		return BeanUtils.instantiateClass(this.mappedConstructor, args);
+	}
+
+	/**
+	 * Static factory method to create a new {@code DataClassRowMapper}.
+	 *
+	 * @param mappedClass the class that each row should be mapped to.
+	 * @see #newInstance(Class, ConversionService)
+	 */
+	public static <T> DataClassRowMapper<T> newInstance(Class<T> mappedClass) {
+		return new DataClassRowMapper<>(mappedClass);
+	}
+
+	/**
+	 * Static factory method to create a new {@code DataClassRowMapper}.
+	 *
+	 * @param mappedClass the class that each row should be mapped to.
+	 * @param conversionService the {@link ConversionService} for binding Cassandra values to bean properties, or
+	 *          {@code null} for none.
+	 * @see #newInstance(Class)
+	 * @see #setConversionService
+	 */
+	public static <T> DataClassRowMapper<T> newInstance(Class<T> mappedClass,
+			@Nullable ConversionService conversionService) {
+
+		DataClassRowMapper<T> rowMapper = newInstance(mappedClass);
+		rowMapper.setConversionService(conversionService);
+		return rowMapper;
+	}
+
+}

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/DataClassRowMapper.java

@@ -29,7 +29,7 @@
 public interface KeyspacePopulator {
 
 	/**
-	 * Populate, initialize, or clean up the database using the provided JDBC connection.
+	 * Populate, initialize, or clean up the database using the provided CqlSession connection.
 	 * <p>
 	 * Concrete implementations <em>may</em> throw a {@link RuntimeException} if an error is encountered but are
 	 * <em>strongly encouraged</em> to throw a specific {@link ScriptException} instead. For example, Spring's

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/session/init/KeyspacePopulator.java

@@ -18,7 +18,7 @@
 import org.springframework.core.io.support.EncodedResource;
 
 /**
- * Thrown by {@link ScriptUtils} if a statement in an SQL script failed when executing it against the target database.
+ * Thrown by {@link ScriptUtils} if a statement in an CQL script failed when executing it against the target database.
  *
  * @author Mark Paluch
  * @since 3.0

spring-data-cassandra/src/main/java/org/springframework/data/cassandra/core/cql/session/init/ScriptStatementFailedException.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2020 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.cassandra.core.cql
+
+/**
+ * Extensions for [DataClassRowMapper].
+ *
+ * @author Mark Paluch
+ * @since 3.1
+ */
+
+/**
+ * Extension for [DataClassRowMapper] leveraging reified type parameters.
+ */
+inline fun <reified T : Any> DataClassRowMapper(): DataClassRowMapper<T> =
+		DataClassRowMapper(T::class.java)

spring-data-cassandra/src/main/kotlin/org/springframework/data/cassandra/core/cql/DataClassRowMapperExtensions.kt

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2020 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.cassandra.core.cql;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.mockito.junit.jupiter.MockitoSettings;
+import org.mockito.quality.Strictness;
+
+import org.springframework.dao.InvalidDataAccessApiUsageException;
+
+import com.datastax.oss.driver.api.core.CqlIdentifier;
+import com.datastax.oss.driver.api.core.cql.ColumnDefinition;
+import com.datastax.oss.driver.api.core.cql.ColumnDefinitions;
+import com.datastax.oss.driver.api.core.cql.Row;
+
+/**
+ * Unit tests for {@link BeanPropertyRowMapper}.
+ *
+ * @author Mark Paluch
+ */
+@ExtendWith(MockitoExtension.class)
+@MockitoSettings(strictness = Strictness.LENIENT)
+class BeanPropertyRowMapperUnitTests {
+
+	@Mock Row row;
+
+	@Test // DATACASS-810
+	void createBeanFromRow() {
+
+		ColumnDefinitions definitions = forColumns("firstname", "age");
+		when(row.getColumnDefinitions()).thenReturn(definitions);
+		when(row.get(0, String.class)).thenReturn("Walter");
+		when(row.get(1, int.class)).thenReturn(42);
+
+		BeanPropertyRowMapper<Person> rowMapper = new BeanPropertyRowMapper<>(Person.class);
+
+		Person person = rowMapper.mapRow(row, 0);
+
+		assertThat(person.firstname).isEqualTo("Walter");
+		assertThat(person.age).isEqualTo(42);
+	}
+
+	@Test // DATACASS-810
+	void createBeanFromRowWithNullDefault() {
+
+		ColumnDefinitions definitions = forColumns("firstname", "age");
+		when(row.getColumnDefinitions()).thenReturn(definitions);
+		when(row.get(0, String.class)).thenReturn("Walter");
+
+		BeanPropertyRowMapper<Person> rowMapper = new BeanPropertyRowMapper<>(Person.class);
+		rowMapper.setPrimitivesDefaultedForNullValue(true);
+
+		Person person = rowMapper.mapRow(row, 0);
+
+		assertThat(person.firstname).isEqualTo("Walter");
+		assertThat(person.age).isEqualTo(0);
+	}
+
+	@Test // DATACASS-810
+	void shouldRefusePartiallyPopulatedResult() {
+
+		ColumnDefinitions definitions = forColumns("age");
+		when(row.getColumnDefinitions()).thenReturn(definitions);
+		when(row.get(0, int.class)).thenReturn(42);
+
+		BeanPropertyRowMapper<Person> rowMapper = new BeanPropertyRowMapper<>(Person.class);
+		rowMapper.setCheckFullyPopulated(true);
+
+		assertThatExceptionOfType(InvalidDataAccessApiUsageException.class).isThrownBy(() -> rowMapper.mapRow(row, 0));
+	}
+
+	static class Person {
+
+		String firstname;
+		int age;
+
+		public String getFirstname() {
+			return firstname;
+		}
+
+		public void setFirstname(String firstname) {
+			this.firstname = firstname;
+		}
+
+		public int getAge() {
+			return age;
+		}
+
+		public void setAge(int age) {
+			this.age = age;
+		}
+	}
+
+	private static ColumnDefinitions forColumns(String... columns) {
+
+		ColumnDefinitions definitions = mock(ColumnDefinitions.class);
+
+		int index = 0;
+		for (String column : columns) {
+
+			ColumnDefinition columnDefinition = mock(ColumnDefinition.class);
+			when(columnDefinition.getName()).thenReturn(CqlIdentifier.fromInternal(column));
+
+			when(definitions.get(index++)).thenReturn(columnDefinition);
+		}
+
+		when(definitions.size()).thenReturn(index);
+
+		return definitions;
+	}
+
+}

spring-data-cassandra/src/test/java/org/springframework/data/cassandra/core/cql/BeanPropertyRowMapperUnitTests.java

@@ -33,6 +33,7 @@
 
 import com.datastax.oss.driver.api.core.CqlIdentifier;
 import com.datastax.oss.driver.api.core.cql.SimpleStatement;
+import com.datastax.oss.driver.api.core.data.UdtValue;
 
 /**
  * Integration tests for {@link CqlTemplate}.
@@ -41,6 +42,7 @@
  * @author Tomasz Lelek
  */
 class CqlTemplateIntegrationTests extends AbstractKeyspaceCreatingIntegrationTests {
+
 	private static final Version CASSANDRA_4 = Version.parse("4.0");
 	private static final AtomicBoolean initialized = new AtomicBoolean();
 	private CqlTemplate template;
@@ -50,11 +52,17 @@ class CqlTemplateIntegrationTests extends AbstractKeyspaceCreatingIntegrationTes
 	void before() {
 
 		if (initialized.compareAndSet(false, true)) {
+			session.execute("CREATE TYPE IF NOT EXISTS cql_template_user (testname text, happy boolean);");
+			session
+					.execute("CREATE TABLE IF NOT EXISTS cql_template_tests (id text PRIMARY KEY, thetest cql_template_user);");
 			session.execute("CREATE TABLE IF NOT EXISTS user (id text PRIMARY KEY, username text);");
 		}
 
 		session.execute("TRUNCATE user;");
+		session.execute("TRUNCATE cql_template_tests;");
 		session.execute("INSERT INTO user (id, username) VALUES ('WHITE', 'Walter');");
+		session.execute(
+				"INSERT INTO cql_template_tests (id, thetest) VALUES ('shouldApplyBeanPropertyRowMapper', {testname: 'shouldApplyBeanPropertyRowMapper', happy: true});");
 
 		template = new CqlTemplate();
 		template.setSession(getSession());
@@ -197,6 +205,38 @@ void selectByQueryWithNonExistingKeyspaceShouldThrowThatKeyspaceDoesNotExists()
 		assertThatThrownBy(() -> template.queryForObject("SELECT id FROM user;", String.class))
 				.isInstanceOf(CassandraInvalidQueryException.class)
 				.hasMessageContaining("Keyspace 'non_existing' does not exist");
+	}
+
+	@Test // DATACASS-810
+	void shouldApplyBeanPropertyRowMapper() {
+
+		CqlTemplateTest result = template.queryForObject("SELECT * FROM cql_template_tests",
+				new BeanPropertyRowMapper<>(CqlTemplateTest.class));
+
+		assertThat(result.getId()).isEqualTo("shouldApplyBeanPropertyRowMapper");
+		assertThat(result.getThetest().getFormattedContents()).contains("testname:'shouldApplyBeanPropertyRowMapper'")
+				.contains("happy:true");
+	}
+
+	static class CqlTemplateTest {
+
+		String id;
+		UdtValue thetest;
 
+		public String getId() {
+			return id;
+		}
+
+		public void setId(String id) {
+			this.id = id;
+		}
+
+		public UdtValue getThetest() {
+			return thetest;
+		}
+
+		public void setThetest(UdtValue thetest) {
+			this.thetest = thetest;
+		}
 	}
 }