com.blazebit.persistence.impl.AbstractModificationCriteriaBuilder Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2015 Blazebit.
*
* 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
*
* http://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 com.blazebit.persistence.impl;
import java.util.*;
import javax.persistence.Query;
import javax.persistence.Tuple;
import javax.persistence.TypedQuery;
import javax.persistence.metamodel.Attribute;
import javax.persistence.metamodel.EntityType;
import com.blazebit.persistence.BaseModificationCriteriaBuilder;
import com.blazebit.persistence.CommonQueryBuilder;
import com.blazebit.persistence.FullSelectCTECriteriaBuilder;
import com.blazebit.persistence.ReturningBuilder;
import com.blazebit.persistence.ReturningModificationCriteriaBuilderFactory;
import com.blazebit.persistence.ReturningObjectBuilder;
import com.blazebit.persistence.ReturningResult;
import com.blazebit.persistence.SelectRecursiveCTECriteriaBuilder;
import com.blazebit.persistence.impl.builder.object.ReturningTupleObjectBuilder;
import com.blazebit.persistence.impl.dialect.DB2DbmsDialect;
import com.blazebit.persistence.impl.query.*;
import com.blazebit.persistence.spi.DbmsModificationState;
import com.blazebit.persistence.spi.DbmsStatementType;
/**
*
* @param The entity type of this modification builder
* @author Christian Beikov
* @since 1.1.0
*/
public abstract class AbstractModificationCriteriaBuilder, Y> extends AbstractCommonQueryBuilder, AbstractCommonQueryBuilder, BaseFinalSetOperationBuilderImpl> implements BaseModificationCriteriaBuilder, CTEInfoBuilder {
protected final EntityType entityType;
protected final String entityAlias;
protected final EntityType cteType;
protected final String cteName;
protected final Y result;
protected final CTEBuilderListener listener;
protected final boolean isReturningEntityAliasAllowed;
protected final Map returningAttributeBindingMap;
@SuppressWarnings("unchecked")
public AbstractModificationCriteriaBuilder(MainQuery mainQuery, boolean isMainQuery, DbmsStatementType statementType, Class clazz, String alias, String cteName, Class cteClass, Y result, CTEBuilderListener listener) {
// NOTE: using tuple here because this class is used for the join manager and tuple is definitively not an entity
// but in case of the insert criteria, the appropriate return type which is convenient because update and delete don't have a return type
super(mainQuery, isMainQuery, statementType, (Class) Tuple.class, null);
// set defaults
if (alias == null) {
alias = clazz.getSimpleName().toLowerCase();
} else {
// If the user supplies an alias, the intention is clear
fromClassExplicitelySet = true;
}
this.entityType = em.getMetamodel().entity(clazz);
this.entityAlias = joinManager.addRoot(entityType, alias);
this.result = result;
this.listener = listener;
if (cteClass == null) {
this.cteType = null;
this.cteName = null;
this.isReturningEntityAliasAllowed = false;
this.returningAttributeBindingMap = new LinkedHashMap(0);
} else {
this.cteType = em.getMetamodel().entity(cteClass);
this.cteName = cteName;
// Returning the "entity" is only allowed in CTEs
this.isReturningEntityAliasAllowed = true;
this.returningAttributeBindingMap = new LinkedHashMap(cteType.getAttributes().size());
}
}
@Override
public FullSelectCTECriteriaBuilder with(Class cteClass) {
if (!dbmsDialect.supportsWithClauseInModificationQuery()) {
throw new UnsupportedOperationException("The database does not support a with clause in modification queries!");
}
return super.with(cteClass);
}
@Override
public SelectRecursiveCTECriteriaBuilder withRecursive(Class cteClass) {
if (!dbmsDialect.supportsWithClauseInModificationQuery()) {
throw new UnsupportedOperationException("The database does not support a with clause in modification queries!");
}
return super.withRecursive(cteClass);
}
@Override
public ReturningModificationCriteriaBuilderFactory withReturning(Class cteClass) {
if (!dbmsDialect.supportsWithClauseInModificationQuery()) {
throw new UnsupportedOperationException("The database does not support a with clause in modification queries!");
}
return super.withReturning(cteClass);
}
protected void applyJpaReturning(StringBuilder sbSelectFrom) {
sbSelectFrom.append(" RETURNING ");
boolean first = true;
for (String attribute : returningAttributeBindingMap.values()) {
if (first) {
first = false;
} else {
sbSelectFrom.append(", ");
}
sbSelectFrom.append(attribute);
}
}
@Override
public Query getQuery() {
return getQuery(null);
}
@Override
protected Query getQuery(Map includedModificationStates) {
Query query;
// We use this to make these features only available to Hibernate as it is the only provider that supports sql replace yet
if (statementType == DbmsStatementType.INSERT
|| (hasLimit() || mainQuery.cteManager.hasCtes() || returningAttributeBindingMap.size() > 0)) {
// We need to change the underlying sql when doing a limit with hibernate since it does not support limiting insert ... select statements
// For CTEs we will also need to change the underlying sql
query = em.createQuery(getBaseQueryStringWithCheck());
Set parameterListNames = parameterManager.getParameterListNames(query);
boolean isEmbedded = this instanceof ReturningBuilder;
String[] returningColumns = getReturningColumns();
boolean shouldRenderCteNodes = renderCteNodes(isEmbedded);
List ctes = shouldRenderCteNodes ? getCteNodes(query, isEmbedded) : Collections.EMPTY_LIST;
QuerySpecification querySpecification = new ModificationQuerySpecification(
this,
query,
getCountExampleQuery(),
parameterListNames,
mainQuery.cteManager.isRecursive(),
ctes,
shouldRenderCteNodes,
isEmbedded,
returningColumns,
includedModificationStates,
returningAttributeBindingMap
);
query = new CustomSQLQuery(
querySpecification,
query,
(CommonQueryBuilder) this,
cbf.getExtendedQuerySupport(),
parameterManager.getValuesParameters(),
parameterManager.getValuesBinders()
);
} else {
query = em.createQuery(getBaseQueryStringWithCheck());
}
parameterManager.parameterizeQuery(query);
// Don't set the values for UPDATE or DELETE statements, otherwise Datanucleus will pass through the values to the JDBC statement
if (statementType == DbmsStatementType.INSERT) {
query.setFirstResult(firstResult);
query.setMaxResults(maxResults);
}
return query;
}
public int executeUpdate() {
return getQuery().executeUpdate();
}
@Override
protected Map getModificationStates(Map, Map> explicitVersionEntities) {
Map versionEntities = explicitVersionEntities.get(entityType.getJavaType());
if (versionEntities == null) {
return null;
}
Map includedModificationStates = new HashMap();
// TODO: this needs to include the modification states based on what the dbms uses as default
boolean defaultOld = !(dbmsDialect instanceof DB2DbmsDialect);
if (defaultOld) {
for (Map.Entry entry : versionEntities.entrySet()) {
if (entry.getValue() == DbmsModificationState.NEW) {
includedModificationStates.put(DbmsModificationState.NEW, entityType.getName() + "_new");
break;
}
}
} else {
for (Map.Entry entry : versionEntities.entrySet()) {
if (entry.getValue() == DbmsModificationState.OLD) {
includedModificationStates.put(DbmsModificationState.OLD, entityType.getName() + "_old");
break;
}
}
}
return includedModificationStates;
}
protected Map getModificationStateRelatedTableNameRemappings(Map, Map> explicitVersionEntities) {
Map versionEntities = explicitVersionEntities.get(entityType.getJavaType());
if (versionEntities == null) {
return null;
}
Map tableNameRemappings = new HashMap();
// TODO: this needs to include the modification states based on what the dbms uses as default, so use a DbmsDialect method
boolean defaultOld = !(dbmsDialect instanceof DB2DbmsDialect);
if (defaultOld) {
for (Map.Entry entry : versionEntities.entrySet()) {
if (entry.getValue() == DbmsModificationState.NEW) {
tableNameRemappings.put(entry.getKey(), entityType.getName() + "_new");
}
}
} else {
for (Map.Entry entry : versionEntities.entrySet()) {
if (entry.getValue() == DbmsModificationState.OLD) {
tableNameRemappings.put(entry.getKey(), entityType.getName() + "_old");
}
}
}
return tableNameRemappings;
}
public ReturningResult executeWithReturning(String... attributes) {
return getWithReturningQuery(attributes).getSingleResult();
}
public TypedQuery> getWithReturningQuery(String... attributes) {
if (attributes == null) {
throw new NullPointerException("attributes");
}
if (attributes.length == 0) {
throw new IllegalArgumentException("Invalid empty attributes");
}
Query baseQuery = em.createQuery(getBaseQueryStringWithCheck());
List>> attributeList = getAndCheckAttributes(attributes);
TypedQuery exampleQuery = getExampleQuery(attributeList);
String[] returningColumns = getReturningColumns(attributeList);
return getExecuteWithReturningQuery(exampleQuery, baseQuery, returningColumns, new ReturningTupleObjectBuilder());
}
public ReturningResult executeWithReturning(String attribute, Class type) {
return getWithReturningQuery(attribute, type).getSingleResult();
}
@SuppressWarnings("unchecked")
public TypedQuery> getWithReturningQuery(String attribute, Class type) {
if (attribute == null) {
throw new NullPointerException("attribute");
}
if (type == null) {
throw new NullPointerException("type");
}
if (attribute.isEmpty()) {
throw new IllegalArgumentException("Invalid empty attribute");
}
AttributePath attrPath = JpaUtils.getBasicAttributePath(getMetamodel(), entityType, attribute);
if (!type.isAssignableFrom(attrPath.getAttributeClass())) {
throw new IllegalArgumentException("The given expected field type is not of the expected type: " + attrPath.getAttributeClass().getName());
}
List>> attributes = new ArrayList>>();
attributes.add(attrPath.getAttributes());
Query baseQuery = em.createQuery(getBaseQueryStringWithCheck());
TypedQuery exampleQuery = getExampleQuery(attributes);
String[] returningColumns = getReturningColumns(attributes);
return getExecuteWithReturningQuery(exampleQuery, baseQuery, returningColumns, null);
}
public ReturningResult executeWithReturning(ReturningObjectBuilder objectBuilder) {
return getWithReturningQuery(objectBuilder).getSingleResult();
}
@SuppressWarnings({ "unchecked", "rawtypes" })
public TypedQuery> getWithReturningQuery(ReturningObjectBuilder objectBuilder) {
// TODO: this is not really nice, we should abstract that somehow
objectBuilder.applyReturning((ReturningBuilder) this);
List>> attributes = getAndCheckReturningAttributes();
returningAttributeBindingMap.clear();
Query baseQuery = em.createQuery(getBaseQueryStringWithCheck());
TypedQuery exampleQuery = getExampleQuery(attributes);
String[] returningColumns = getReturningColumns(attributes);
return getExecuteWithReturningQuery(exampleQuery, baseQuery, returningColumns, objectBuilder);
}
private TypedQuery> getExecuteWithReturningQuery(TypedQuery exampleQuery, Query baseQuery, String[] returningColumns, ReturningObjectBuilder objectBuilder) {
Set parameterListNames = parameterManager.getParameterListNames(baseQuery);
boolean shouldRenderCteNodes = renderCteNodes(false);
List ctes = shouldRenderCteNodes ? getCteNodes(baseQuery, false) : Collections.EMPTY_LIST;
QuerySpecification querySpecification = new ReturningModificationQuerySpecification(
this, baseQuery, exampleQuery, parameterListNames, mainQuery.cteManager.isRecursive(), ctes, shouldRenderCteNodes, returningColumns, objectBuilder
);
CustomReturningSQLTypedQuery query = new CustomReturningSQLTypedQuery(
querySpecification,
exampleQuery,
(CommonQueryBuilder) this,
cbf.getExtendedQuerySupport(),
parameterManager.getValuesParameters(),
parameterManager.getValuesBinders()
);
query.setFirstResult(firstResult);
query.setMaxResults(maxResults);
parameterManager.parameterizeQuery(query);
return query;
}
private List>> getAndCheckReturningAttributes() {
validateReturningAttributes();
return getAndCheckAttributes(returningAttributeBindingMap.keySet().toArray(new String[returningAttributeBindingMap.size()]));
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private void validateReturningAttributes() {
int attributeCount = returningAttributeBindingMap.size();
if (attributeCount == 0) {
throw new IllegalArgumentException("Invalid empty attributes");
}
Set> availableAttributes;
if (cteType == null || (availableAttributes = ((EntityType) cteType).getAttributes()).size() == returningAttributeBindingMap.size()) {
return;
}
Set attributeNames = new TreeSet();
for (Attribute attr : availableAttributes) {
String attributeName = attr.getName();
if (!returningAttributeBindingMap.containsKey(attributeName)) {
attributeNames.add(attributeName);
}
}
throw new IllegalArgumentException("The following required CTE attributes are not bound: " + attributeNames);
}
@SuppressWarnings("unchecked")
public X returning(String cteAttribute, String modificationQueryAttribute) {
if (cteAttribute == null) {
throw new NullPointerException("cteAttribute");
}
if (modificationQueryAttribute == null) {
throw new NullPointerException("modificationQueryAttribute");
}
if (cteAttribute.isEmpty()) {
throw new IllegalArgumentException("Invalid empty cteAttribute");
}
if (modificationQueryAttribute.isEmpty()) {
throw new IllegalArgumentException("Invalid empty modificationQueryAttribute");
}
Attribute cteAttr = JpaUtils.getAttribute(cteType, cteAttribute);
if (cteAttr == null) {
throw new IllegalArgumentException("The cte attribute [" + cteAttribute + "] does not exist!");
}
Class queryAttrType;
if (isReturningEntityAliasAllowed && modificationQueryAttribute.equals(entityAlias)) {
// Our little special case, since there would be no other way to refer to the id as the object type
queryAttrType = entityType.getJavaType();
Attribute idAttribute = JpaUtils.getIdAttribute(entityType);
modificationQueryAttribute = idAttribute.getName();
} else {
AttributePath queryAttributePath = JpaUtils.getBasicAttributePath(getMetamodel(), entityType, modificationQueryAttribute);
queryAttrType = queryAttributePath.getAttributeClass();
}
// NOTE: Actually we would check if the dbms supports returning this kind of attribute,
// but if it already supports the returning clause, it can only also support returning all columns
if (!cteAttr.getJavaType().isAssignableFrom(queryAttrType)) {
throw new IllegalArgumentException("The given cte attribute '" + cteAttribute + "' with the type '" + cteAttr.getJavaType().getName() + "'"
+ " can not be assigned with a value of the type '" + queryAttrType.getName() + "' of the query attribute '" + modificationQueryAttribute + "'!");
}
String bindingEntry = returningAttributeBindingMap.get(cteAttribute);
if (bindingEntry != null) {
throw new IllegalArgumentException("The cte attribute [" + cteAttribute + "] has already been bound!");
}
returningAttributeBindingMap.put(cteAttribute, modificationQueryAttribute);
return (X) this;
}
public Y end() {
validateReturningAttributes();
listener.onBuilderEnded(this);
return result;
}
public CTEInfo createCTEInfo() {
List attributes = prepareAndGetAttributes();
CTEInfo info = new CTEInfo(cteName, cteType, attributes, false, false, this, null);
return info;
}
private List>> getAndCheckAttributes(String[] attributes) {
List>> attrs = new ArrayList>>(attributes.length);
for (int i = 0; i < attributes.length; i++) {
if (attributes[i] == null) {
throw new NullPointerException("attribute at position " + i);
}
if (attributes[i].isEmpty()) {
throw new IllegalArgumentException("empty attribute at position " + i);
}
attrs.add(JpaUtils.getBasicAttributePath(getMetamodel(), entityType, attributes[i]).getAttributes());
}
return attrs;
}
private String[] getReturningColumns(List>> attributes) {
List columns = new ArrayList(attributes.size());
StringBuilder sb = new StringBuilder();
for (List> returningAttribute : attributes) {
sb.append(returningAttribute.get(0).getName());
for(int i = 1; i < returningAttribute.size(); i++){
sb.append('.').append(returningAttribute.get(i).getName());
}
for (String column : cbf.getExtendedQuerySupport().getColumnNames(em, entityType, sb.toString())) {
columns.add(column);
}
sb.setLength(0);
}
return columns.toArray(new String[columns.size()]);
}
private String[] getReturningColumns() {
if (returningAttributeBindingMap.isEmpty()) {
return null;
}
Collection returningAttributeNames = returningAttributeBindingMap.values();
List columns = new ArrayList(returningAttributeNames.size());
for (String returningAttributeName : returningAttributeBindingMap.values()) {
for (String column : cbf.getExtendedQuerySupport().getColumnNames(em, entityType, returningAttributeName)) {
columns.add(column);
}
}
return columns.toArray(new String[columns.size()]);
}
private Query getCountExampleQuery() {
StringBuilder sb = new StringBuilder();
sb.append("SELECT COUNT(e) FROM ");
sb.append(entityType.getName());
sb.append(" e");
String exampleQueryString = sb.toString();
return em.createQuery(exampleQueryString);
}
private TypedQuery getExampleQuery(List>> attributes) {
StringBuilder sb = new StringBuilder();
sb.append("SELECT ");
boolean first = true;
for (List> attrPath : attributes) {
Attribute lastPathElem = attrPath.get(attrPath.size() - 1);
if (first) {
first = false;
} else {
sb.append(",");
}
// TODO: actually we should also check if the attribute is a @GeneratedValue
if (!dbmsDialect.supportsReturningColumns() && !JpaUtils.getIdAttribute(entityType).equals(lastPathElem)) {
throw new IllegalArgumentException("Returning the query attribute [" + lastPathElem.getName() + "] is not supported by the dbms, only generated keys can be returned!");
}
if (JpaUtils.isJoinable(lastPathElem)) {
// We have to map *-to-one relationships to their ids
EntityType type = em.getMetamodel().entity(JpaUtils.resolveFieldClass(entityType.getJavaType(), lastPathElem));
Attribute idAttribute = JpaUtils.getIdAttribute(type);
// NOTE: Since we are talking about *-to-ones, the expression can only be a path to an object
// so it is safe to just append the id to the path
sb.append(lastPathElem.getName()).append('.').append(idAttribute.getName());
} else {
sb.append(attrPath.get(0).getName());
for(int i = 1; i < attrPath.size(); i++){
sb.append('.').append(attrPath.get(i).getName());
}
}
}
sb.append(" FROM ");
sb.append(entityType.getName());
String exampleQueryString = sb.toString();
return em.createQuery(exampleQueryString, Object[].class);
}
protected List prepareAndGetAttributes() {
return new ArrayList(returningAttributeBindingMap.keySet());
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy