#220 - Add Fluent API for EntityOperations.

Author: mp911de

Diff for: src/main/java/org/springframework/data/r2dbc/core/FluentR2dbcOperations.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2018-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.r2dbc.core;
+
+/**
+ * Stripped down interface providing access to a fluent API that specifies a basic set of reactive R2DBC operations.
+ *
+ * @author Mark Paluch
+ * @since 1.1
+ * @see R2dbcEntityOperations
+ */
+public interface FluentR2dbcOperations
+		extends ReactiveSelectOperation, ReactiveInsertOperation, ReactiveUpdateOperation, ReactiveDeleteOperation {}

Diff for: src/main/java/org/springframework/data/r2dbc/core/ReactiveDeleteOperation.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2018-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.r2dbc.core;
+
+import reactor.core.publisher.Mono;
+
+import org.springframework.data.r2dbc.query.Query;
+
+/**
+ * The {@link ReactiveDeleteOperation} interface allows creation and execution of {@code DELETE} operations in a fluent
+ * API style.
+ * <p>
+ * The starting {@literal domainType} is used for mapping the {@link Query} provided via {@code matching}. By default,
+ * the table to operate on is derived from the initial {@literal domainType} and can be defined there via
+ * {@link org.springframework.data.relational.core.mapping.Table} annotation. Using {@code inTable} allows to override
+ * the table name for the execution.
+ *
+ * <pre>
+ *     <code>
+ *         delete(Jedi.class)
+ *             .from("star_wars")
+ *             .matching(query(where("firstname").is("luke")))
+ *             .all();
+ *     </code>
+ * </pre>
+ *
+ * @author Mark Paluch
+ * @since 1.1
+ */
+public interface ReactiveDeleteOperation {
+
+	/**
+	 * Begin creating a {@code DELETE} operation for the given {@link Class domainType}.
+	 *
+	 * @param domainType {@link Class type} of domain object to delete; must not be {@literal null}.
+	 * @return new instance of {@link ReactiveDelete}.
+	 * @throws IllegalArgumentException if {@link Class domainType} is {@literal null}.
+	 * @see ReactiveDelete
+	 */
+	ReactiveDelete delete(Class<?> domainType);
+
+	/**
+	 * Table override (optional).
+	 */
+	interface DeleteWithTable {
+
+		/**
+		 * Explicitly set the {@link String name} of the table on which to perform the delete.
+		 * <p>
+		 * Skip this step to use the default table derived from the {@link Class domain type}.
+		 *
+		 * @param table {@link String name} of the table; must not be {@literal null} or empty.
+		 * @return new instance of {@link DeleteWithQuery}.
+		 * @throws IllegalArgumentException if {@link String table} is {@literal null} or empty.
+		 * @see DeleteWithQuery
+		 */
+		DeleteWithQuery from(String table);
+	}
+
+	/**
+	 * Required {@link Query filter}.
+	 */
+	interface DeleteWithQuery {
+
+		/**
+		 * Define the {@link Query} used to filter elements in the delete.
+		 *
+		 * @param query {@link Query} used as the filter in the delete; must not be {@literal null}.
+		 * @return new instance of {@link TerminatingDelete}.
+		 * @throws IllegalArgumentException if {@link Query} is {@literal null}.
+		 * @see TerminatingDelete
+		 * @see Query
+		 */
+		TerminatingDelete matching(Query query);
+	}
+
+	/**
+	 * Trigger {@code DELETE} operation by calling one of the terminating methods.
+	 */
+	interface TerminatingDelete {
+
+		/**
+		 * Remove all matching rows.
+		 *
+		 * @return the number of affected rows; never {@literal null}.
+		 * @see Mono
+		 */
+		Mono<Integer> all();
+	}
+
+	/**
+	 * The {@link ReactiveDelete} interface provides methods for constructing {@code DELETE} operations in a fluent way.
+	 */
+	interface ReactiveDelete extends DeleteWithTable, DeleteWithQuery {}
+
+}

Diff for: src/main/java/org/springframework/data/r2dbc/core/ReactiveDeleteOperationSupport.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2018-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.r2dbc.core;
+
+import reactor.core.publisher.Mono;
+
+import org.springframework.data.r2dbc.query.Query;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+/**
+ * Implementation of {@link ReactiveDeleteOperation}.
+ *
+ * @author Mark Paluch
+ * @since 1.1
+ */
+class ReactiveDeleteOperationSupport implements ReactiveDeleteOperation {
+
+	private final R2dbcEntityTemplate template;
+
+	ReactiveDeleteOperationSupport(R2dbcEntityTemplate template) {
+		this.template = template;
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.r2dbc.core.ReactiveDeleteOperation#delete(java.lang.Class)
+	 */
+	@Override
+	public ReactiveDelete delete(Class<?> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null");
+
+		return new ReactiveDeleteSupport(this.template, domainType, Query.empty(), null);
+	}
+
+	static class ReactiveDeleteSupport implements ReactiveDelete, TerminatingDelete {
+
+		private final R2dbcEntityTemplate template;
+
+		private final Class<?> domainType;
+
+		private final Query query;
+
+		private final @Nullable String tableName;
+
+		ReactiveDeleteSupport(R2dbcEntityTemplate template, Class<?> domainType, Query query, @Nullable String tableName) {
+			this.template = template;
+			this.domainType = domainType;
+			this.query = query;
+			this.tableName = tableName;
+		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.data.r2dbc.core.ReactiveDeleteOperation.DeleteWithTable#from(java.lang.String)
+		 */
+		@Override
+		public DeleteWithQuery from(String tableName) {
+
+			Assert.hasText(tableName, "Table name must not be null or empty");
+
+			return new ReactiveDeleteSupport(this.template, this.domainType, this.query, tableName);
+		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.data.r2dbc.core.ReactiveDeleteOperation.DeleteWithQuery#matching(org.springframework.data.r2dbc.query.Query)
+		 */
+		@Override
+		public TerminatingDelete matching(Query query) {
+
+			Assert.notNull(query, "Query must not be null");
+
+			return new ReactiveDeleteSupport(this.template, this.domainType, query, this.tableName);
+		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.data.r2dbc.core.ReactiveDeleteOperation.TerminatingDelete#all()
+		 */
+		public Mono<Integer> all() {
+			return this.template.doDelete(this.query, this.domainType, getTableName());
+		}
+
+		private String getTableName() {
+			return this.tableName != null ? this.tableName : this.template.getTableName(this.domainType);
+		}
+	}
+}

Diff for: src/main/java/org/springframework/data/r2dbc/core/ReactiveInsertOperation.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2018-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.r2dbc.core;
+
+import reactor.core.publisher.Mono;
+
+/**
+ * The {@link ReactiveInsertOperation} interface allows creation and execution of {@code INSERT} operations in a fluent
+ * API style.
+ * <p>
+ * By default,the table to operate on is derived from the initial {@link Class domainType} and can be defined there via
+ * {@link org.springframework.data.relational.core.mapping.Table} annotation. Using {@code inTable} allows to override
+ * the table name for the execution.
+ *
+ * <pre>
+ *     <code>
+ *         insert(Jedi.class)
+ *             .into("star_wars")
+ *             .using(luke);
+ *     </code>
+ * </pre>
+ *
+ * @author Mark Paluch
+ * @since 1.1
+ */
+public interface ReactiveInsertOperation {
+
+	/**
+	 * Begin creating an {@code INSERT} operation for given {@link Class domainType}.
+	 *
+	 * @param <T> {@link Class type} of the application domain object.
+	 * @param domainType {@link Class type} of the domain object to insert; must not be {@literal null}.
+	 * @return new instance of {@link ReactiveInsert}.
+	 * @throws IllegalArgumentException if {@link Class domainType} is {@literal null}.
+	 * @see ReactiveInsert
+	 */
+	<T> ReactiveInsert<T> insert(Class<T> domainType);
+
+	/**
+	 * Table override (optional).
+	 */
+	interface InsertWithTable<T> extends TerminatingInsert<T> {
+
+		/**
+		 * Explicitly set the {@link String name} of the table.
+		 * <p>
+		 * Skip this step to use the default table derived from the {@link Class domain type}.
+		 *
+		 * @param table {@link String name} of the table; must not be {@literal null} or empty.
+		 * @return new instance of {@link TerminatingInsert}.
+		 * @throws IllegalArgumentException if {@link String table} is {@literal null} or empty.
+		 */
+		TerminatingInsert<T> into(String table);
+	}
+
+	/**
+	 * Trigger {@code INSERT} execution by calling one of the terminating methods.
+	 */
+	interface TerminatingInsert<T> {
+
+		/**
+		 * Insert exactly one {@link Object}.
+		 *
+		 * @param object {@link Object} to insert; must not be {@literal null}.
+		 * @return the write result for this operation.
+		 * @throws IllegalArgumentException if {@link Object} is {@literal null}.
+		 * @see Mono
+		 */
+		Mono<T> using(T object);
+	}
+
+	/**
+	 * The {@link ReactiveInsert} interface provides methods for constructing {@code INSERT} operations in a fluent way.
+	 */
+	interface ReactiveInsert<T> extends InsertWithTable<T> {}
+
+}