HHH-19498 - improve upserts on MySQL and Maria

hibernate-core/src/main/java/org/hibernate/dialect/MariaDBDialect.java

@@ -35,13 +35,16 @@
 import org.hibernate.exception.spi.SQLExceptionConversionDelegate;
 import org.hibernate.exception.spi.TemplatedViolatedConstraintNameExtractor;
 import org.hibernate.exception.spi.ViolatedConstraintNameExtractor;
+import org.hibernate.persister.entity.mutation.EntityMutationTarget;
 import org.hibernate.query.sqm.CastType;
 import org.hibernate.service.ServiceRegistry;
 import org.hibernate.sql.ast.SqlAstTranslator;
 import org.hibernate.sql.ast.SqlAstTranslatorFactory;
 import org.hibernate.sql.ast.spi.StandardSqlAstTranslatorFactory;
 import org.hibernate.sql.ast.tree.Statement;
 import org.hibernate.sql.exec.spi.JdbcOperation;
+import org.hibernate.sql.model.MutationOperation;
+import org.hibernate.sql.model.internal.OptionalTableUpdate;
 import org.hibernate.tool.schema.extract.internal.SequenceInformationExtractorMariaDBDatabaseImpl;
 import org.hibernate.tool.schema.extract.spi.SequenceInformationExtractor;
 import org.hibernate.type.SqlTypes;
@@ -421,4 +424,10 @@ public boolean supportsWithClauseInSubquery() {
 		return false;
 	}
 
+	@Override
+	public MutationOperation createOptionalTableUpdateOperation(EntityMutationTarget mutationTarget, OptionalTableUpdate optionalTableUpdate, SessionFactoryImplementor factory) {
+		final MariaDBSqlAstTranslator<?> translator = new MariaDBSqlAstTranslator<>( factory, optionalTableUpdate, MariaDBDialect.this );
+		return translator.createMergeOperation( optionalTableUpdate );
+	}
+
 }

hibernate-core/src/main/java/org/hibernate/dialect/MySQLDeleteOrUpsertOperation.java

@@ -0,0 +1,64 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.dialect;
+
+
+import org.hibernate.StaleStateException;
+import org.hibernate.engine.jdbc.mutation.JdbcValueBindings;
+import org.hibernate.engine.spi.SharedSessionContractImplementor;
+import org.hibernate.jdbc.Expectation;
+import org.hibernate.persister.entity.mutation.EntityMutationTarget;
+import org.hibernate.persister.entity.mutation.EntityTableMapping;
+import org.hibernate.sql.model.ValuesAnalysis;
+import org.hibernate.sql.model.internal.OptionalTableUpdate;
+import org.hibernate.sql.model.jdbc.DeleteOrUpsertOperation;
+import org.hibernate.sql.model.jdbc.UpsertOperation;
+
+import java.sql.PreparedStatement;
+
+
+/**
+ * @author Jan Schatteman
+ */
+public class MySQLDeleteOrUpsertOperation extends DeleteOrUpsertOperation {
+
+	private Expectation customExpectation;
+
+	public MySQLDeleteOrUpsertOperation(EntityMutationTarget mutationTarget, EntityTableMapping tableMapping, UpsertOperation upsertOperation, OptionalTableUpdate optionalTableUpdate) {
+		super( mutationTarget, tableMapping, upsertOperation, optionalTableUpdate );
+	}
+
+	@Override
+	public void performMutation(JdbcValueBindings jdbcValueBindings, ValuesAnalysis valuesAnalysis, SharedSessionContractImplementor session) {
+		customExpectation = new MySQLRowCountExpectation();
+		super.performMutation( jdbcValueBindings, valuesAnalysis, session );
+	}
+
+	@Override
+	protected Expectation getExpectation() {
+		return customExpectation;
+	}
+
+	private class MySQLRowCountExpectation implements Expectation {
+		@Override
+		public final void verifyOutcome(int rowCount, PreparedStatement statement, int batchPosition, String sql) {
+			if ( getOptionalTableUpdate().getNumberOfOptimisticLockBindings() > 0 && rowCount == 0) {
+				throw new StaleStateException(
+						"Unexpected row count"
+						+ " (for a versioned entity the expected row count should != 0)"
+						+ " [" + sql + "]"
+				);
+			}
+			if ( rowCount > 2 ) {
+				throw new StaleStateException(
+						"Unexpected row count"
+						+ " (the expected row count for an ON DUPLICATE KEY UPDATE statement should be either 0, 1 or 2 )"
+						+ " [" + sql + "]"
+				);
+			}
+		}
+	}
+
+}

hibernate-core/src/main/java/org/hibernate/dialect/MySQLDialect.java

@@ -45,6 +45,7 @@
 import org.hibernate.mapping.CheckConstraint;
 import org.hibernate.metamodel.mapping.EntityMappingType;
 import org.hibernate.metamodel.spi.RuntimeModelCreationContext;
+import org.hibernate.persister.entity.mutation.EntityMutationTarget;
 import org.hibernate.query.common.TemporalUnit;
 import org.hibernate.query.sqm.CastType;
 import org.hibernate.query.sqm.IntervalType;
@@ -63,6 +64,8 @@
 import org.hibernate.sql.ast.spi.StandardSqlAstTranslatorFactory;
 import org.hibernate.sql.ast.tree.Statement;
 import org.hibernate.sql.exec.spi.JdbcOperation;
+import org.hibernate.sql.model.MutationOperation;
+import org.hibernate.sql.model.internal.OptionalTableUpdate;
 import org.hibernate.type.BasicTypeRegistry;
 import org.hibernate.type.NullType;
 import org.hibernate.type.SqlTypes;
@@ -1668,4 +1671,10 @@ public boolean supportsRowValueConstructorSyntaxInQuantifiedPredicates() {
 		return false;
 	}
 
+	@Override
+	public MutationOperation createOptionalTableUpdateOperation(EntityMutationTarget mutationTarget, OptionalTableUpdate optionalTableUpdate, SessionFactoryImplementor factory) {
+		final MySQLSqlAstTranslator<?> translator = new MySQLSqlAstTranslator<>( factory, optionalTableUpdate, MySQLDialect.this );
+		return translator.createMergeOperation( optionalTableUpdate );
+	}
+
 }

hibernate-core/src/main/java/org/hibernate/dialect/sql/ast/MariaDBSqlAstTranslator.java

@@ -14,7 +14,6 @@
 import org.hibernate.metamodel.mapping.JdbcMappingContainer;
 import org.hibernate.query.sqm.ComparisonOperator;
 import org.hibernate.sql.ast.Clause;
-import org.hibernate.sql.ast.spi.AbstractSqlAstTranslator;
 import org.hibernate.sql.ast.tree.Statement;
 import org.hibernate.sql.ast.tree.delete.DeleteStatement;
 import org.hibernate.sql.ast.tree.expression.BinaryArithmeticExpression;
@@ -44,7 +43,7 @@
  *
  * @author Christian Beikov
  */
-public class MariaDBSqlAstTranslator<T extends JdbcOperation> extends AbstractSqlAstTranslator<T> {
+public class MariaDBSqlAstTranslator<T extends JdbcOperation> extends SqlAstTranslatorWithOnDuplicateKeyUpdate<T> {
 
 	private final MariaDBDialect dialect;
 

hibernate-core/src/main/java/org/hibernate/dialect/sql/ast/MySQLSqlAstTranslator.java

@@ -12,7 +12,6 @@
 import org.hibernate.internal.util.collections.Stack;
 import org.hibernate.query.sqm.ComparisonOperator;
 import org.hibernate.sql.ast.Clause;
-import org.hibernate.sql.ast.spi.AbstractSqlAstTranslator;
 import org.hibernate.sql.ast.tree.Statement;
 import org.hibernate.sql.ast.tree.delete.DeleteStatement;
 import org.hibernate.sql.ast.tree.expression.BinaryArithmeticExpression;
@@ -46,7 +45,7 @@
  *
  * @author Christian Beikov
  */
-public class MySQLSqlAstTranslator<T extends JdbcOperation> extends AbstractSqlAstTranslator<T> {
+public class MySQLSqlAstTranslator<T extends JdbcOperation> extends SqlAstTranslatorWithOnDuplicateKeyUpdate<T> {
 
 	/**
 	 * On MySQL, 1GB or {@code 2^30 - 1} is the maximum size that a char value can be casted.

hibernate-core/src/main/java/org/hibernate/dialect/sql/ast/SqlAstTranslatorWithOnDuplicateKeyUpdate.java

@@ -0,0 +1,164 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ * Copyright Red Hat Inc. and Hibernate Authors
+ */
+package org.hibernate.dialect.sql.ast;
+
+
+import org.hibernate.dialect.MySQLDeleteOrUpsertOperation;
+import org.hibernate.engine.spi.SessionFactoryImplementor;
+import org.hibernate.persister.entity.mutation.EntityTableMapping;
+import org.hibernate.sql.ast.spi.SqlAstTranslatorWithUpsert;
+import org.hibernate.sql.ast.tree.Statement;
+import org.hibernate.sql.exec.spi.JdbcOperation;
+import org.hibernate.sql.model.MutationOperation;
+import org.hibernate.sql.model.ast.ColumnValueBinding;
+import org.hibernate.sql.model.internal.OptionalTableUpdate;
+import org.hibernate.sql.model.jdbc.UpsertOperation;
+
+import java.util.List;
+
+/**
+ * @author Jan Schatteman
+ */
+public class SqlAstTranslatorWithOnDuplicateKeyUpdate<T extends JdbcOperation> extends SqlAstTranslatorWithUpsert<T> {
+
+	public SqlAstTranslatorWithOnDuplicateKeyUpdate(SessionFactoryImplementor sessionFactory, Statement statement) {
+		super( sessionFactory, statement );
+	}
+
+	@Override
+	public MutationOperation createMergeOperation(OptionalTableUpdate optionalTableUpdate) {
+		renderUpsertStatement( optionalTableUpdate );
+
+		final UpsertOperation upsertOperation = new UpsertOperation(
+				optionalTableUpdate.getMutatingTable().getTableMapping(),
+				optionalTableUpdate.getMutationTarget(),
+				getSql(),
+				getParameterBinders()
+		);
+
+		return new MySQLDeleteOrUpsertOperation(
+				optionalTableUpdate.getMutationTarget(),
+				(EntityTableMapping) optionalTableUpdate.getMutatingTable().getTableMapping(),
+				upsertOperation,
+				optionalTableUpdate
+		);
+	}
+
+	@Override
+	protected void renderUpsertStatement(OptionalTableUpdate optionalTableUpdate) {
+/*
+		Template: (for an entity with @Version, and without using values() - but this might require changes in parameter binding)
+			INSERT INTO employees (id, name, salary, version)
+				VALUES (?, ?, ?, ?) AS t
+			ON DUPLICATE KEY UPDATE
+				name = IF(employees.version=?,t.name,employees.name),
+				salary = IF(employees.version=?,t.salary,employees.salary),
+				version = IF(employees.version=?,t.version,employees.version),
+
+		So, initially we'll have:
+			INSERT INTO employees (id, name, salary, version)
+				VALUES (?, ?, ?, ?)
+			ON DUPLICATE KEY UPDATE
+				name = IF(version=@oldversion:=?,VALUES(name), employees.name),
+				salary = IF(version=@oldversion?,VALUES(salary),employees.salary),
+				version = IF(version=@oldversion?,VALUES(version),employees.version),
+*/
+		renderInsertInto( optionalTableUpdate );
+		appendSql( " " );
+		renderOnDuplicateKeyUpdate( optionalTableUpdate );
+	}
+
+	protected void renderInsertInto(OptionalTableUpdate optionalTableUpdate) {
+		appendSql( "insert into " );
+		appendSql( optionalTableUpdate.getMutatingTable().getTableName() );
+		appendSql( " (" );
+
+		final List<ColumnValueBinding> keyBindings = optionalTableUpdate.getKeyBindings();
+		for ( ColumnValueBinding keyBinding : keyBindings ) {
+			appendSql( keyBinding.getColumnReference().getColumnExpression() );
+			appendSql( ',' );
+		}
+
+		optionalTableUpdate.forEachValueBinding( (columnPosition, columnValueBinding) -> {
+				appendSql( columnValueBinding.getColumnReference().getColumnExpression() );
+			if ( columnPosition != optionalTableUpdate.getValueBindings().size() - 1  ) {
+				appendSql( ',' );
+			}
+		} );
+
+		appendSql( ") values (" );
+
+		for ( ColumnValueBinding keyBinding : keyBindings ) {
+			keyBinding.getValueExpression().accept( this );
+			appendSql( ',' );
+		}
+
+		optionalTableUpdate.forEachValueBinding( (columnPosition, columnValueBinding) -> {
+			if ( columnPosition > 0 ) {
+				appendSql( ',' );
+			}
+			columnValueBinding.getValueExpression().accept( this );
+		} );
+		appendSql( ")" );
+	}
+
+	protected void renderOnDuplicateKeyUpdate(OptionalTableUpdate optionalTableUpdate) {
+		appendSql( "on duplicate key update " );
+		optionalTableUpdate.forEachValueBinding( (columnPosition, columnValueBinding) -> {
+			final String columnName = columnValueBinding.getColumnReference().getColumnExpression();
+			if ( columnPosition > 0 ) {
+				appendSql( ',' );
+			}
+			appendSql( columnName );
+			append( " = " );
+
+			if ( optionalTableUpdate.getNumberOfOptimisticLockBindings() > 0 ) {
+				renderVersionedUpdate( optionalTableUpdate, columnPosition, columnValueBinding );
+			}
+			else {
+				renderNonVersionedUpdate( columnValueBinding );
+			}
+		} );
+	}
+
+	private void renderVersionedUpdate(OptionalTableUpdate optionalTableUpdate, Integer columnPosition, ColumnValueBinding columnValueBinding) {
+		final String tableName = optionalTableUpdate.getMutatingTable().getTableName();
+		appendSql( "if(" );
+		renderVersionRestriction( tableName, optionalTableUpdate.getOptimisticLockBindings(), columnPosition );
+		appendSql( "," );
+		appendSql( "values(" );
+		appendSql( columnValueBinding.getColumnReference().getColumnExpression() );
+		appendSql( ")" );
+		appendSql( "," );
+		columnValueBinding.getColumnReference().appendColumnForWrite( this, tableName );
+		appendSql( ")" );
+	}
+
+	private void renderNonVersionedUpdate(ColumnValueBinding columnValueBinding) {
+		appendSql( "values(" );
+		appendSql( columnValueBinding.getColumnReference().getColumnExpression() );
+		appendSql( ")" );
+	}
+
+	private void renderVersionRestriction(String tableName, List<ColumnValueBinding> optimisticLockBindings, int index) {
+		final String operator = index == 0 ? ":=" : "";
+		final String versionVariable = "@oldversion" + operator;
+		for (int i = 0; i < optimisticLockBindings.size(); i++) {
+//			if ( i>0 ) {
+//				appendSql(" and ");
+//			}
+			final ColumnValueBinding binding = optimisticLockBindings.get( i );
+			binding.getColumnReference().appendColumnForWrite( this, tableName );
+			appendSql( "=" );
+			appendSql( versionVariable );
+//			if ( i == 0 ) {
+				if ( index == 0) {
+					binding.getValueExpression().accept( this );
+				}
+//			}
+		}
+	}
+
+}

hibernate-core/src/main/java/org/hibernate/sql/model/jdbc/DeleteOrUpsertOperation.java

@@ -41,7 +41,7 @@ public class DeleteOrUpsertOperation implements SelfExecutingUpdateOperation {
 
 	private final OptionalTableUpdate optionalTableUpdate;
 
-	private final Expectation expectation = new Expectation.RowCount();
+	private final Expectation expectation = getExpectation();
 
 	public DeleteOrUpsertOperation(
 			EntityMutationTarget mutationTarget,
@@ -127,7 +127,7 @@ private void performDelete(JdbcValueBindings jdbcValueBindings, SharedSessionCon
 					.executeUpdate( upsertDeleteStatement, statementDetails.getSqlString() );
 			MODEL_MUTATION_LOGGER.tracef( "`%s` rows upsert-deleted from `%s`", rowCount, tableMapping.getTableName() );
 			try {
-				expectation.verifyOutcome( rowCount, upsertDeleteStatement, -1, statementDetails.getSqlString() );
+				getExpectation().verifyOutcome( rowCount, upsertDeleteStatement, -1, statementDetails.getSqlString() );
 			}
 			catch (SQLException e) {
 				throw jdbcServices.getSqlExceptionHelper().convert(
@@ -203,7 +203,7 @@ private void performUpsert(JdbcValueBindings jdbcValueBindings, SharedSessionCon
 							.executeUpdate( updateStatement, statementDetails.getSqlString() );
 			MODEL_MUTATION_LOGGER.tracef( "`%s` rows upserted into `%s`", rowCount, tableMapping.getTableName() );
 			try {
-				expectation.verifyOutcome( rowCount, updateStatement, -1, statementDetails.getSqlString() );
+				getExpectation().verifyOutcome( rowCount, updateStatement, -1, statementDetails.getSqlString() );
 			}
 			catch (SQLException e) {
 				throw jdbcServices.getSqlExceptionHelper().convert(
@@ -231,4 +231,8 @@ public UpsertOperation getUpsertOperation() {
 	public OptionalTableUpdate getOptionalTableUpdate() {
 		return optionalTableUpdate;
 	}
+
+	protected Expectation getExpectation() {
+		return new Expectation.RowCount();
+	}
 }