Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
com.blazebit.persistence.impl.PredicateManager Maven / Gradle / Ivy
/*
* Copyright 2014 - 2019 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 com.blazebit.persistence.CaseWhenStarterBuilder;
import com.blazebit.persistence.FullQueryBuilder;
import com.blazebit.persistence.JoinOnBuilder;
import com.blazebit.persistence.MultipleSubqueryInitiator;
import com.blazebit.persistence.RestrictionBuilder;
import com.blazebit.persistence.SimpleCaseWhenStarterBuilder;
import com.blazebit.persistence.SubqueryBuilder;
import com.blazebit.persistence.SubqueryInitiator;
import com.blazebit.persistence.impl.builder.expression.CaseWhenBuilderImpl;
import com.blazebit.persistence.impl.builder.expression.ExpressionBuilder;
import com.blazebit.persistence.impl.builder.expression.ExpressionBuilderEndedListener;
import com.blazebit.persistence.impl.builder.expression.SimpleCaseWhenBuilderImpl;
import com.blazebit.persistence.impl.builder.predicate.CaseExpressionBuilderListener;
import com.blazebit.persistence.impl.builder.predicate.JoinOnBuilderImpl;
import com.blazebit.persistence.impl.builder.predicate.LeftHandsideSubqueryPredicateBuilderListener;
import com.blazebit.persistence.impl.builder.predicate.RestrictionBuilderImpl;
import com.blazebit.persistence.impl.builder.predicate.RightHandsideSubqueryPredicateBuilder;
import com.blazebit.persistence.impl.builder.predicate.RootPredicate;
import com.blazebit.persistence.impl.builder.predicate.SuperExpressionLeftHandsideSubqueryPredicateBuilder;
import com.blazebit.persistence.parser.SimpleQueryGenerator;
import com.blazebit.persistence.parser.expression.Expression;
import com.blazebit.persistence.parser.expression.ExpressionFactory;
import com.blazebit.persistence.parser.expression.modifier.ExpressionModifier;
import com.blazebit.persistence.parser.predicate.ExistsPredicate;
import com.blazebit.persistence.parser.predicate.Predicate;
import com.blazebit.persistence.impl.transform.ExpressionModifierVisitor;
import java.util.Collections;
import java.util.List;
/**
*
* @author Moritz Becker
* @since 1.0.0
*/
public abstract class PredicateManager extends AbstractManager {
protected final ExpressionFactory expressionFactory;
protected final RootPredicate rootPredicate;
@SuppressWarnings({ "unchecked", "rawtypes" })
private final SubqueryBuilderListenerImpl> leftSubqueryPredicateBuilderListener = new LeftHandsideSubqueryPredicateBuilderListener();
private SubqueryBuilderListenerImpl rightSubqueryPredicateBuilderListener;
private SubqueryBuilderListenerImpl> superExprLeftSubqueryPredicateBuilderListener;
private CaseExpressionBuilderListener caseExpressionBuilderListener;
private MultipleSubqueryInitiator currentMultipleSubqueryInitiator;
PredicateManager(ResolvingQueryGenerator queryGenerator, ParameterManager parameterManager, SubqueryInitiatorFactory subqueryInitFactory, ExpressionFactory expressionFactory) {
super(queryGenerator, parameterManager, subqueryInitFactory);
this.rootPredicate = new RootPredicate(parameterManager, getClauseType(), subqueryInitFactory.getQueryBuilder());
this.expressionFactory = expressionFactory;
}
void applyFrom(PredicateManager predicateManager) {
rootPredicate.getPredicate().getChildren().addAll(subqueryInitFactory.reattachSubqueries(predicateManager.rootPredicate.getPredicate().clone(true), getClauseType()).getChildren());
}
@SuppressWarnings("unchecked")
RestrictionBuilder restrict(T builder, Expression expr) {
return rootPredicate.startBuilder(new RestrictionBuilderImpl(builder, rootPredicate, expr, subqueryInitFactory, expressionFactory, parameterManager, getClauseType()));
}
CaseWhenStarterBuilder> restrictCase(T builder) {
@SuppressWarnings("unchecked")
RestrictionBuilder restrictionBuilder = rootPredicate.startBuilder(new RestrictionBuilderImpl(builder, rootPredicate, subqueryInitFactory, expressionFactory, parameterManager, getClauseType()));
caseExpressionBuilderListener = new CaseExpressionBuilderListener((RestrictionBuilderImpl) restrictionBuilder);
return caseExpressionBuilderListener.startBuilder(new CaseWhenBuilderImpl>(restrictionBuilder, caseExpressionBuilderListener, subqueryInitFactory, expressionFactory, parameterManager, getClauseType()));
}
void restrictExpression(Predicate predicate) {
rootPredicate.verifyBuilderEnded();
parameterManager.collectParameterRegistrations(predicate, getClauseType(), subqueryInitFactory.getQueryBuilder());
rootPredicate.getPredicate().getChildren().add(predicate);
}
void restrictSetExpression(Predicate predicate) {
rootPredicate.verifyBuilderEnded();
parameterManager.collectParameterRegistrations(predicate, getClauseType(), subqueryInitFactory.getQueryBuilder());
List children = rootPredicate.getPredicate().getChildren();
children.clear();
children.add(predicate);
}
SimpleCaseWhenStarterBuilder> restrictSimpleCase(T builder, Expression caseOperand) {
@SuppressWarnings("unchecked")
RestrictionBuilder restrictionBuilder = rootPredicate.startBuilder(new RestrictionBuilderImpl(builder, rootPredicate, subqueryInitFactory, expressionFactory, parameterManager, getClauseType()));
caseExpressionBuilderListener = new CaseExpressionBuilderListener((RestrictionBuilderImpl) restrictionBuilder);
return caseExpressionBuilderListener.startBuilder(new SimpleCaseWhenBuilderImpl>(restrictionBuilder, caseExpressionBuilderListener, expressionFactory, caseOperand, subqueryInitFactory, parameterManager, getClauseType()));
}
SubqueryInitiator> restrict(T builder) {
@SuppressWarnings("unchecked")
RestrictionBuilder restrictionBuilder = (RestrictionBuilder) rootPredicate.startBuilder(new RestrictionBuilderImpl(builder, rootPredicate, subqueryInitFactory, expressionFactory, parameterManager, getClauseType()));
return subqueryInitFactory.createSubqueryInitiator(restrictionBuilder, leftSubqueryPredicateBuilderListener, false, getClauseType());
}
SubqueryBuilder> restrict(T builder, FullQueryBuilder criteriaBuilder) {
@SuppressWarnings("unchecked")
RestrictionBuilder restrictionBuilder = (RestrictionBuilder) rootPredicate.startBuilder(new RestrictionBuilderImpl(builder, rootPredicate, subqueryInitFactory, expressionFactory, parameterManager, getClauseType()));
return subqueryInitFactory.createSubqueryBuilder(restrictionBuilder, leftSubqueryPredicateBuilderListener, false, criteriaBuilder, getClauseType());
}
MultipleSubqueryInitiator> restrictSubqueries(T builder, String expression) {
Expression expr = expressionFactory.createSimpleExpression(expression, true);
@SuppressWarnings("unchecked")
RestrictionBuilderImpl restrictionBuilder = rootPredicate.startBuilder(new RestrictionBuilderImpl(builder, rootPredicate, subqueryInitFactory, expressionFactory, parameterManager, getClauseType()));
// We don't need a listener or marker here, because the resulting restriction builder can only be ended, when the initiator is ended
MultipleSubqueryInitiator> initiator = new MultipleSubqueryInitiatorImpl>(restrictionBuilder, expr, new RestrictionBuilderExpressionBuilderListener(restrictionBuilder), subqueryInitFactory, getClauseType());
return initiator;
}
MultipleSubqueryInitiator restrictExpressionSubqueries(X builder, Predicate predicate) {
rootPredicate.verifyBuilderEnded();
parameterManager.collectParameterRegistrations(predicate, getClauseType(), subqueryInitFactory.getQueryBuilder());
MultipleSubqueryInitiator initiator = new MultipleSubqueryInitiatorImpl(builder, predicate, new ExpressionBuilderEndedListener() {
@Override
public void onBuilderEnded(ExpressionBuilder builder) {
rootPredicate.getPredicate().getChildren().add((Predicate) builder.getExpression());
currentMultipleSubqueryInitiator = null;
}
}, subqueryInitFactory, getClauseType());
currentMultipleSubqueryInitiator = initiator;
return initiator;
}
MultipleSubqueryInitiator restrictSetExpressionSubqueries(X builder, Predicate predicate) {
rootPredicate.verifyBuilderEnded();
parameterManager.collectParameterRegistrations(predicate, getClauseType(), subqueryInitFactory.getQueryBuilder());
MultipleSubqueryInitiator initiator = new MultipleSubqueryInitiatorImpl(builder, predicate, new ExpressionBuilderEndedListener() {
@Override
public void onBuilderEnded(ExpressionBuilder builder) {
List children = rootPredicate.getPredicate().getChildren();
children.clear();
children.add((Predicate) builder.getExpression());
currentMultipleSubqueryInitiator = null;
}
}, subqueryInitFactory, getClauseType());
currentMultipleSubqueryInitiator = initiator;
return initiator;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
SubqueryInitiator> restrict(T builder, String subqueryAlias, String expression) {
Expression expr = expressionFactory.createSimpleExpression(expression, true);
superExprLeftSubqueryPredicateBuilderListener = new SuperExpressionLeftHandsideSubqueryPredicateBuilder(subqueryAlias, expr);
RestrictionBuilder restrictionBuilder = (RestrictionBuilder) rootPredicate.startBuilder(new RestrictionBuilderImpl(builder, rootPredicate, subqueryInitFactory, expressionFactory, parameterManager, getClauseType()));
return subqueryInitFactory.createSubqueryInitiator(restrictionBuilder, superExprLeftSubqueryPredicateBuilderListener, false, getClauseType());
}
@SuppressWarnings({ "rawtypes", "unchecked" })
SubqueryBuilder> restrict(T builder, String subqueryAlias, String expression, FullQueryBuilder criteriaBuilder) {
Expression expr = expressionFactory.createSimpleExpression(expression, true);
superExprLeftSubqueryPredicateBuilderListener = new SuperExpressionLeftHandsideSubqueryPredicateBuilder(subqueryAlias, expr);
RestrictionBuilder restrictionBuilder = (RestrictionBuilder) rootPredicate.startBuilder(new RestrictionBuilderImpl(builder, rootPredicate, subqueryInitFactory, expressionFactory, parameterManager, getClauseType()));
return subqueryInitFactory.createSubqueryBuilder(restrictionBuilder, superExprLeftSubqueryPredicateBuilderListener, false, criteriaBuilder, getClauseType());
}
SubqueryInitiator restrictExists(T result) {
rightSubqueryPredicateBuilderListener = rootPredicate.startBuilder(new RightHandsideSubqueryPredicateBuilder(rootPredicate, new ExistsPredicate()));
return subqueryInitFactory.createSubqueryInitiator(result, rightSubqueryPredicateBuilderListener, true, getClauseType());
}
SubqueryInitiator restrictNotExists(T result) {
rightSubqueryPredicateBuilderListener = rootPredicate.startBuilder(new RightHandsideSubqueryPredicateBuilder(rootPredicate, new ExistsPredicate(true)));
return subqueryInitFactory.createSubqueryInitiator(result, rightSubqueryPredicateBuilderListener, true, getClauseType());
}
SubqueryBuilder restrictExists(T result, FullQueryBuilder criteriaBuilder) {
rightSubqueryPredicateBuilderListener = rootPredicate.startBuilder(new RightHandsideSubqueryPredicateBuilder(rootPredicate, new ExistsPredicate()));
return subqueryInitFactory.createSubqueryBuilder(result, rightSubqueryPredicateBuilderListener, true, criteriaBuilder, getClauseType());
}
SubqueryBuilder restrictNotExists(T result, FullQueryBuilder criteriaBuilder) {
rightSubqueryPredicateBuilderListener = rootPredicate.startBuilder(new RightHandsideSubqueryPredicateBuilder(rootPredicate, new ExistsPredicate(true)));
return subqueryInitFactory.createSubqueryBuilder(result, rightSubqueryPredicateBuilderListener, true, criteriaBuilder, getClauseType());
}
@Override
public void apply(ExpressionModifierVisitor visitor) {
visitor.visit(rootPredicate, getClauseType());
}
void verifyBuilderEnded() {
rootPredicate.verifyBuilderEnded();
leftSubqueryPredicateBuilderListener.verifySubqueryBuilderEnded();
if (rightSubqueryPredicateBuilderListener != null) {
rightSubqueryPredicateBuilderListener.verifySubqueryBuilderEnded();
}
if (superExprLeftSubqueryPredicateBuilderListener != null) {
superExprLeftSubqueryPredicateBuilderListener.verifySubqueryBuilderEnded();
}
if (caseExpressionBuilderListener != null) {
caseExpressionBuilderListener.verifyBuilderEnded();
}
if (currentMultipleSubqueryInitiator != null) {
throw new BuilderChainingException("A builder was not ended properly.");
}
}
void acceptVisitor(Expression.Visitor v) {
rootPredicate.getPredicate().accept(v);
}
X acceptVisitor(Expression.ResultVisitor v) {
return rootPredicate.getPredicate().accept(v);
}
boolean hasPredicates() {
return rootPredicate.getPredicate().getChildren().size() > 0;
}
void buildClause(StringBuilder sb) {
buildClause(sb, Collections.emptyList(), Collections.emptyList(), null);
}
void buildClause(StringBuilder sb, List additionalConjuncts, List optionalConjuncts, List endConjuncts) {
if (!hasPredicates() && additionalConjuncts.isEmpty()) {
return;
}
int initialLength = sb.length();
sb.append(' ').append(getClauseName()).append(' ');
int oldLength = sb.length();
buildClausePredicate(sb, additionalConjuncts, optionalConjuncts, endConjuncts);
if (sb.length() == oldLength) {
sb.setLength(initialLength);
}
}
void buildClausePredicate(StringBuilder sb, List additionalConjuncts, List optionalConjuncts, List endConjuncts) {
int size = additionalConjuncts.size();
boolean hasPredicates = size > 0;
for (int i = 0; i < size; i++) {
sb.append(additionalConjuncts.get(i));
sb.append(" AND ");
}
queryGenerator.setClauseType(getClauseType());
queryGenerator.setQueryBuffer(sb);
int oldLength = sb.length();
applyPredicate(queryGenerator);
queryGenerator.setClauseType(null);
if (sb.length() == oldLength) {
if (size > 0) {
sb.setLength(sb.length() - " AND ".length());
}
} else {
hasPredicates = true;
}
if (endConjuncts != null && !endConjuncts.isEmpty()) {
for (int i = 0; i < optionalConjuncts.size(); i++) {
sb.append(" AND ");
sb.append(optionalConjuncts.get(i));
}
for (int i = 0; i < endConjuncts.size(); i++) {
sb.append(" AND ");
sb.append(endConjuncts.get(i));
}
} else if (hasPredicates) {
for (int i = 0; i < optionalConjuncts.size(); i++) {
sb.append(" AND ");
sb.append(optionalConjuncts.get(i));
}
}
}
protected abstract String getClauseName();
void applyPredicate(ResolvingQueryGenerator queryGenerator) {
SimpleQueryGenerator.BooleanLiteralRenderingContext oldBooleanLiteralRenderingContext = queryGenerator.setBooleanLiteralRenderingContext(SimpleQueryGenerator.BooleanLiteralRenderingContext.PREDICATE);
queryGenerator.generate(rootPredicate.getPredicate());
queryGenerator.setBooleanLiteralRenderingContext(oldBooleanLiteralRenderingContext);
}
public JoinOnBuilder startOnBuilder(AbstractCommonQueryBuilder builder) {
return rootPredicate.startBuilder(new JoinOnBuilderImpl(builder, rootPredicate, parameterManager, expressionFactory, subqueryInitFactory));
}
// TODO: needs equals-hashCode implementation
}