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.builder.predicate.WhereOrBuilderImpl Maven / Gradle / Ivy
/*
* Copyright 2014 - 2020 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.builder.predicate;
import com.blazebit.persistence.CaseWhenStarterBuilder;
import com.blazebit.persistence.FullQueryBuilder;
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.WhereAndBuilder;
import com.blazebit.persistence.WhereOrBuilder;
import com.blazebit.persistence.impl.BuilderChainingException;
import com.blazebit.persistence.impl.ClauseType;
import com.blazebit.persistence.impl.MultipleSubqueryInitiatorImpl;
import com.blazebit.persistence.impl.ParameterManager;
import com.blazebit.persistence.impl.PredicateAndSubqueryBuilderEndedListener;
import com.blazebit.persistence.impl.RestrictionBuilderExpressionBuilderListener;
import com.blazebit.persistence.impl.SubqueryBuilderListenerImpl;
import com.blazebit.persistence.impl.SubqueryInitiatorFactory;
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.parser.expression.Expression;
import com.blazebit.persistence.parser.expression.ExpressionFactory;
import com.blazebit.persistence.parser.predicate.CompoundPredicate;
import com.blazebit.persistence.parser.predicate.ExistsPredicate;
import com.blazebit.persistence.parser.predicate.Predicate;
import com.blazebit.persistence.parser.predicate.PredicateBuilder;
/**
*
* @author Christian Beikov
* @author Moritz Becker
* @since 1.0.0
*/
public class WhereOrBuilderImpl extends PredicateAndSubqueryBuilderEndedListener implements WhereOrBuilder, PredicateBuilder {
private final T result;
private final PredicateBuilderEndedListener listener;
private final CompoundPredicate predicate;
private final SubqueryInitiatorFactory subqueryInitFactory;
private final ExpressionFactory expressionFactory;
private final ParameterManager parameterManager;
@SuppressWarnings({ "unchecked", "rawtypes" })
private final SubqueryBuilderListenerImpl>> leftSubqueryPredicateBuilderListener = new LeftHandsideSubqueryPredicateBuilderListener();
private SubqueryBuilderListenerImpl> rightSubqueryPredicateBuilderListener;
private SubqueryBuilderListenerImpl>> superExprLeftSubqueryPredicateBuilderListener;
private CaseExpressionBuilderListener caseExpressionBuilderListener;
private MultipleSubqueryInitiator currentMultipleSubqueryInitiator;
public WhereOrBuilderImpl(T result, PredicateBuilderEndedListener listener, SubqueryInitiatorFactory subqueryInitFactory, ExpressionFactory expressionFactory, ParameterManager parameterManager) {
this.result = result;
this.listener = listener;
this.predicate = new CompoundPredicate(CompoundPredicate.BooleanOperator.OR);
this.subqueryInitFactory = subqueryInitFactory;
this.expressionFactory = expressionFactory;
this.parameterManager = parameterManager;
}
@Override
public T endOr() {
verifyBuilderEnded();
listener.onBuilderEnded(this);
return result;
}
@Override
public CompoundPredicate getPredicate() {
return predicate;
}
@Override
public void onBuilderEnded(PredicateBuilder builder) {
super.onBuilderEnded(builder);
predicate.getChildren().add(builder.getPredicate());
}
@Override
public WhereAndBuilder> whereAnd() {
return startBuilder(new WhereAndBuilderImpl>(this, this, subqueryInitFactory, expressionFactory, parameterManager));
}
@Override
public RestrictionBuilder> where(String expression) {
Expression exp = expressionFactory.createSimpleExpression(expression, false);
return startBuilder(new RestrictionBuilderImpl>(this, this, exp, subqueryInitFactory, expressionFactory, parameterManager, ClauseType.WHERE));
}
@Override
public CaseWhenStarterBuilder>> whereCase() {
RestrictionBuilderImpl> restrictionBuilder = startBuilder(new RestrictionBuilderImpl>(this, this, subqueryInitFactory, expressionFactory, parameterManager, ClauseType.WHERE));
caseExpressionBuilderListener = new CaseExpressionBuilderListener(restrictionBuilder);
return caseExpressionBuilderListener.startBuilder(new CaseWhenBuilderImpl>>(restrictionBuilder, caseExpressionBuilderListener, subqueryInitFactory, expressionFactory, parameterManager, ClauseType.WHERE));
}
@Override
public SimpleCaseWhenStarterBuilder>> whereSimpleCase(String expression) {
RestrictionBuilderImpl> restrictionBuilder = startBuilder(new RestrictionBuilderImpl>(this, this, subqueryInitFactory, expressionFactory, parameterManager, ClauseType.WHERE));
caseExpressionBuilderListener = new CaseExpressionBuilderListener(restrictionBuilder);
return caseExpressionBuilderListener.startBuilder(new SimpleCaseWhenBuilderImpl>>(restrictionBuilder, caseExpressionBuilderListener, expressionFactory, expressionFactory.createSimpleExpression(expression, false), subqueryInitFactory, parameterManager, ClauseType.WHERE));
}
@Override
public SubqueryInitiator> whereExists() {
rightSubqueryPredicateBuilderListener = startBuilder(new RightHandsideSubqueryPredicateBuilder>(this, new ExistsPredicate()));
return subqueryInitFactory.createSubqueryInitiator((WhereOrBuilder) this, rightSubqueryPredicateBuilderListener, true, ClauseType.WHERE);
}
@Override
public SubqueryInitiator> whereNotExists() {
rightSubqueryPredicateBuilderListener = startBuilder(new RightHandsideSubqueryPredicateBuilder>(this, new ExistsPredicate(true)));
return subqueryInitFactory.createSubqueryInitiator((WhereOrBuilder) this, rightSubqueryPredicateBuilderListener, true, ClauseType.WHERE);
}
@Override
public SubqueryBuilder> whereExists(FullQueryBuilder criteriaBuilder) {
rightSubqueryPredicateBuilderListener = startBuilder(new RightHandsideSubqueryPredicateBuilder>(this, new ExistsPredicate()));
return subqueryInitFactory.createSubqueryBuilder((WhereOrBuilder) this, rightSubqueryPredicateBuilderListener, true, criteriaBuilder, ClauseType.WHERE);
}
@Override
public SubqueryBuilder> whereNotExists(FullQueryBuilder criteriaBuilder) {
rightSubqueryPredicateBuilderListener = startBuilder(new RightHandsideSubqueryPredicateBuilder>(this, new ExistsPredicate(true)));
return subqueryInitFactory.createSubqueryBuilder((WhereOrBuilder) this, rightSubqueryPredicateBuilderListener, true, criteriaBuilder, ClauseType.WHERE);
}
@Override
public SubqueryInitiator>> whereSubquery() {
RestrictionBuilder> restrictionBuilder = startBuilder(new RestrictionBuilderImpl>(this, this, subqueryInitFactory, expressionFactory, parameterManager, ClauseType.WHERE));
return subqueryInitFactory.createSubqueryInitiator(restrictionBuilder, leftSubqueryPredicateBuilderListener, false, ClauseType.WHERE);
}
@Override
@SuppressWarnings({ "rawtypes", "unchecked" })
public SubqueryInitiator>> whereSubquery(String subqueryAlias, String expression) {
superExprLeftSubqueryPredicateBuilderListener = new SuperExpressionLeftHandsideSubqueryPredicateBuilder(subqueryAlias, expressionFactory.createSimpleExpression(expression, true));
RestrictionBuilder> restrictionBuilder = startBuilder(new RestrictionBuilderImpl>(this, this, subqueryInitFactory, expressionFactory, parameterManager, ClauseType.WHERE));
return subqueryInitFactory.createSubqueryInitiator(restrictionBuilder, superExprLeftSubqueryPredicateBuilderListener, false, ClauseType.WHERE);
}
@Override
public MultipleSubqueryInitiator>> whereSubqueries(String expression) {
Expression expr = expressionFactory.createSimpleExpression(expression, true);
RestrictionBuilderImpl> restrictionBuilder = startBuilder(new RestrictionBuilderImpl>(this, this, subqueryInitFactory, expressionFactory, parameterManager, ClauseType.WHERE));
// 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, ClauseType.WHERE);
return initiator;
}
@Override
public SubqueryBuilder>> whereSubquery(FullQueryBuilder criteriaBuilder) {
RestrictionBuilder> restrictionBuilder = startBuilder(new RestrictionBuilderImpl>(this, this, subqueryInitFactory, expressionFactory, parameterManager, ClauseType.WHERE));
return subqueryInitFactory.createSubqueryBuilder(restrictionBuilder, leftSubqueryPredicateBuilderListener, false, criteriaBuilder, ClauseType.WHERE);
}
@Override
public SubqueryBuilder>> whereSubquery(String subqueryAlias, String expression, FullQueryBuilder criteriaBuilder) {
superExprLeftSubqueryPredicateBuilderListener = new SuperExpressionLeftHandsideSubqueryPredicateBuilder(subqueryAlias, expressionFactory.createSimpleExpression(expression, true));
RestrictionBuilder> restrictionBuilder = startBuilder(new RestrictionBuilderImpl>(this, this, subqueryInitFactory, expressionFactory, parameterManager, ClauseType.WHERE));
return subqueryInitFactory.createSubqueryBuilder(restrictionBuilder, superExprLeftSubqueryPredicateBuilderListener, false, criteriaBuilder, ClauseType.WHERE);
}
@Override
public WhereOrBuilder whereExpression(String expression) {
Predicate predicate = expressionFactory.createBooleanExpression(expression, false);
this.predicate.getChildren().add(predicate);
return this;
}
@Override
public MultipleSubqueryInitiator> whereExpressionSubqueries(String expression) {
Predicate predicate = expressionFactory.createBooleanExpression(expression, true);
// 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>(this, predicate, new ExpressionBuilderEndedListener() {
@Override
public void onBuilderEnded(ExpressionBuilder builder) {
WhereOrBuilderImpl.this.predicate.getChildren().add((Predicate) builder.getExpression());
currentMultipleSubqueryInitiator = null;
}
}, subqueryInitFactory, ClauseType.WHERE);
currentMultipleSubqueryInitiator = initiator;
return initiator;
}
@Override
protected void verifyBuilderEnded() {
super.verifyBuilderEnded();
if (currentMultipleSubqueryInitiator != null) {
throw new BuilderChainingException("A builder was not ended properly.");
}
leftSubqueryPredicateBuilderListener.verifySubqueryBuilderEnded();
if (rightSubqueryPredicateBuilderListener != null) {
rightSubqueryPredicateBuilderListener.verifySubqueryBuilderEnded();
}
if (superExprLeftSubqueryPredicateBuilderListener != null) {
superExprLeftSubqueryPredicateBuilderListener.verifySubqueryBuilderEnded();
}
if (caseExpressionBuilderListener != null) {
caseExpressionBuilderListener.verifyBuilderEnded();
}
}
}
