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.builder.predicate.LikeBuilderImpl 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.CaseWhenAndThenBuilder;
import com.blazebit.persistence.CaseWhenBuilder;
import com.blazebit.persistence.CaseWhenOrThenBuilder;
import com.blazebit.persistence.CaseWhenThenBuilder;
import com.blazebit.persistence.EscapeBuilder;
import com.blazebit.persistence.FullQueryBuilder;
import com.blazebit.persistence.LikeBuilder;
import com.blazebit.persistence.MultipleSubqueryInitiator;
import com.blazebit.persistence.RestrictionBuilder;
import com.blazebit.persistence.SimpleCaseWhenBuilder;
import com.blazebit.persistence.SubqueryBuilder;
import com.blazebit.persistence.SubqueryInitiator;
import com.blazebit.persistence.impl.ClauseType;
import com.blazebit.persistence.impl.MultipleSubqueryInitiatorImpl;
import com.blazebit.persistence.impl.ParameterManager;
import com.blazebit.persistence.impl.SubqueryAndExpressionBuilderListener;
import com.blazebit.persistence.impl.SubqueryInitiatorFactory;
import com.blazebit.persistence.impl.builder.expression.CaseWhenBuilderImpl;
import com.blazebit.persistence.impl.builder.expression.EscapeBuilderImpl;
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.LikePredicate;
import com.blazebit.persistence.parser.predicate.PredicateBuilder;
import com.blazebit.persistence.parser.util.TypeUtils;
/**
*
* @author Moritz Becker
* @since 1.0.0
*/
public class LikeBuilderImpl extends SubqueryAndExpressionBuilderListener implements LikeBuilder, PredicateBuilder {
private final Expression leftExpression;
private final ExpressionFactory expressionFactory;
private final ParameterManager parameterManager;
private final ClauseType clauseType;
private final SubqueryInitiatorFactory subqueryInitFactory;
private final T result;
private final PredicateBuilderEndedListener listener;
private final EscapeBuilderImpl.EscapeBuilderImplEndedListener escapeBuilderEndedListener = new EscapeBuilderImpl.EscapeBuilderImplEndedListener() {
@Override
public void onBuilderEnded(EscapeBuilderImpl builder) {
super.onBuilderEnded(builder);
likePredicate = new LikePredicate(leftExpression, patternExpression, caseSensitive, builder.getEscapeCharacter(), negated);
listener.onBuilderEnded(LikeBuilderImpl.this);
}
};
private boolean negated;
private boolean caseSensitive;
private LikePredicate likePredicate;
private Expression patternExpression;
public LikeBuilderImpl(T result, PredicateBuilderEndedListener listener, Expression leftExpression, ExpressionFactory expressionFactory, ParameterManager parameterManager, SubqueryInitiatorFactory subqueryInitFactory, ClauseType clauseType, boolean negated, boolean caseSensitive) {
this.result = result;
this.listener = listener;
this.leftExpression = leftExpression;
this.expressionFactory = expressionFactory;
this.parameterManager = parameterManager;
this.clauseType = clauseType;
this.subqueryInitFactory = subqueryInitFactory;
this.negated = negated;
this.caseSensitive = caseSensitive;
}
@Override
public EscapeBuilder value(Object value) {
if (value == null) {
throw new NullPointerException("value");
}
patternExpression = parameterManager.addParameterExpression(value, clauseType, subqueryInitFactory.getQueryBuilder());
return escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
}
@Override
public EscapeBuilder literal(Object value) {
if (value == null) {
throw new NullPointerException("value");
}
String literal = TypeUtils.asLiteral(value, subqueryInitFactory.getQueryBuilder().getMetamodel().getEnumTypes().keySet());
if (literal == null) {
return value(value);
}
patternExpression = expressionFactory.createInItemExpression(literal);
return escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
}
@Override
public EscapeBuilder expression(String expression) {
if (expression == null) {
throw new NullPointerException("expression");
}
patternExpression = expressionFactory.createSimpleExpression(expression);
return escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
}
@Override
public MultipleSubqueryInitiator> subqueries(String expression) {
Expression expr = expressionFactory.createSimpleExpression(expression);
ExpressionToEscapeBuilderEndedListener listener = new ExpressionToEscapeBuilderEndedListener();
return new MultipleSubqueryInitiatorImpl>(new EscapeBuilderImpl(listener, result), expr, listener, subqueryInitFactory, clauseType);
}
/**
* @author Christian Beikov
* @since 1.0.0
*/
private class ExpressionToEscapeBuilderEndedListener extends EscapeBuilderImpl.EscapeBuilderImplEndedListener implements ExpressionBuilderEndedListener {
private Expression patternExpression;
@Override
public void onBuilderEnded(ExpressionBuilder builder) {
patternExpression = builder.getExpression();
}
@Override
public void onBuilderEnded(EscapeBuilderImpl builder) {
super.onBuilderEnded(builder);
likePredicate = new LikePredicate(leftExpression, patternExpression, caseSensitive, builder.getEscapeCharacter(), negated);
listener.onBuilderEnded(LikeBuilderImpl.this);
}
}
@Override
public RestrictionBuilder>>> caseWhen(String expression) {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).when(expression);
}
@Override
public SubqueryInitiator>>>> caseWhenSubquery() {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenSubquery();
}
@Override
public SubqueryInitiator>>>> caseWhenSubquery(String subqueryAlias, String expression) {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenSubquery(subqueryAlias, expression);
}
@Override
public MultipleSubqueryInitiator>>>> caseWhenSubqueries(String expression) {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenSubqueries(expression);
}
@Override
public SubqueryBuilder>>>> caseWhenSubquery(FullQueryBuilder criteriaBuilder) {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenSubquery(criteriaBuilder);
}
@Override
public SubqueryBuilder>>>> caseWhenSubquery(String subqueryAlias, String expression, FullQueryBuilder criteriaBuilder) {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenSubquery(subqueryAlias, expression, criteriaBuilder);
}
@Override
public SubqueryInitiator>>> caseWhenExists() {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenExists();
}
@Override
public SubqueryInitiator>>> caseWhenNotExists() {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenNotExists();
}
@Override
public SubqueryBuilder>>> caseWhenExists(FullQueryBuilder criteriaBuilder) {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenExists(criteriaBuilder);
}
@Override
public SubqueryBuilder>>> caseWhenNotExists(FullQueryBuilder criteriaBuilder) {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenNotExists(criteriaBuilder);
}
@Override
public CaseWhenAndThenBuilder>> caseWhenAnd() {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenAnd();
}
@Override
public CaseWhenOrThenBuilder>> caseWhenOr() {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new CaseWhenBuilderImpl>(escapeBuilder, this, subqueryInitFactory, expressionFactory, parameterManager, clauseType)).whenOr();
}
@Override
public SimpleCaseWhenBuilder> simpleCase(String caseOperand) {
EscapeBuilder escapeBuilder = escapeBuilderEndedListener.startBuilder(new EscapeBuilderImpl(escapeBuilderEndedListener, result));
return startBuilder(new SimpleCaseWhenBuilderImpl>(escapeBuilder, this, expressionFactory, expressionFactory.createSimpleExpression(caseOperand, false), subqueryInitFactory, parameterManager, clauseType));
}
@Override
public LikePredicate getPredicate() {
return likePredicate;
}
@Override
protected void verifyBuilderEnded() {
super.verifyBuilderEnded();
escapeBuilderEndedListener.verifyBuilderEnded();
}
}