com.blazebit.persistence.impl.JoinOnBuilderImpl Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of blaze-persistence-core-impl-jar Show documentation
There is a newer version: 1.6.12
Show newest version
/*
 * Copyright 2014 - 2023 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.JoinOnOrBuilder;
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.ExpressionBuilder;
import com.blazebit.persistence.impl.builder.expression.ExpressionBuilderEndedListener;
import com.blazebit.persistence.impl.builder.predicate.JoinOnOrBuilderImpl;
import com.blazebit.persistence.impl.builder.predicate.PredicateBuilderEndedListener;
import com.blazebit.persistence.impl.builder.predicate.PredicateBuilderEndedListenerImpl;
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.Predicate;
import com.blazebit.persistence.parser.predicate.PredicateBuilder;

/**
 *
 * @author Moritz Becker
 * @since 1.0.0
 */
public class JoinOnBuilderImpl extends PredicateManager> implements JoinOnBuilder, PredicateBuilder, PredicateBuilderEndedListener, SubqueryBuilderListener, ExpressionBuilderEndedListener {

    private final T result;
    private final PredicateBuilderEndedListener listener;
    private final PredicateBuilderEndedListenerImpl predicateBuilderListener = new PredicateBuilderEndedListenerImpl();
    private final SubqueryBuilderListenerImpl subqueryBuilderListener = new SubqueryBuilderListenerImpl();

    public JoinOnBuilderImpl(T result, final PredicateBuilderEndedListener listener, ParameterManager parameterManager, ExpressionFactory expressionFactory, SubqueryInitiatorFactory subqueryInitFactory) {
        super(subqueryInitFactory.getQueryBuilder().queryGenerator, parameterManager, subqueryInitFactory, expressionFactory);
        this.result = result;
        this.listener = listener;
    }

    @Override
    public ClauseType getClauseType() {
        return ClauseType.JOIN;
    }

    @Override
    protected String getClauseName() {
        return "ON";
    }

    @Override
    public RestrictionBuilder> on(String expression) {
        Expression leftExpression = expressionFactory.createSimpleExpression(expression, false);
        return restrict((JoinOnBuilder) this, leftExpression);
    }

    @Override
    public CaseWhenStarterBuilder>> onCase() {
        return restrictCase((JoinOnBuilder) this);
    }

    @Override
    public SimpleCaseWhenStarterBuilder>> onSimpleCase(String expression) {
        return restrictSimpleCase((JoinOnBuilder) this, expressionFactory.createSimpleExpression(expression, false));
    }

    @Override
    public SubqueryInitiator> onExists() {
        return restrictExists((JoinOnBuilder) this);
    }

    @Override
    public SubqueryInitiator> onNotExists() {
        return restrictNotExists((JoinOnBuilder) this);
    }

    @Override
    public SubqueryBuilder> onExists(FullQueryBuilder criteriaBuilder) {
        return restrictExists((JoinOnBuilder) this, criteriaBuilder);
    }

    @Override
    public SubqueryBuilder> onNotExists(FullQueryBuilder criteriaBuilder) {
        return restrictNotExists((JoinOnBuilder) this, criteriaBuilder);
    }

    @Override
    public SubqueryInitiator>> onSubquery() {
        return restrict((JoinOnBuilder) this);
    }

    @Override
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public SubqueryInitiator>> onSubquery(String subqueryAlias, String expression) {
        return restrict((JoinOnBuilder) this, subqueryAlias, expression);
    }

    @Override
    public MultipleSubqueryInitiator>> onSubqueries(String expression) {
        return restrictSubqueries((JoinOnBuilder) this, expression);
    }

    @Override
    public SubqueryBuilder>> onSubquery(FullQueryBuilder criteriaBuilder) {
        return restrict((JoinOnBuilder) this, criteriaBuilder);
    }

    @Override
    public SubqueryBuilder>> onSubquery(String subqueryAlias, String expression, FullQueryBuilder criteriaBuilder) {
        return restrict((JoinOnBuilder) this, subqueryAlias, expression, criteriaBuilder);
    }

    @Override
    public JoinOnBuilder onExpression(String expression) {
        Predicate predicate = expressionFactory.createBooleanExpression(expression, false);
        restrictExpression(predicate);
        return this;
    }

    @Override
    public MultipleSubqueryInitiator> onExpressionSubqueries(String expression) {
        Predicate predicate = expressionFactory.createBooleanExpression(expression, false);
        return restrictExpressionSubqueries((JoinOnBuilder) this, predicate);
    }

    @Override
    public T setOnExpression(String expression) {
        Predicate predicate = expressionFactory.createBooleanExpression(expression, false);
        restrictSetExpression(predicate);
        listener.onBuilderEnded(this);
        return result;
    }

    @Override
    public MultipleSubqueryInitiator setOnExpressionSubqueries(String expression) {
        Predicate predicate = expressionFactory.createBooleanExpression(expression, false);
        return restrictSetExpressionSubqueries(result, predicate, this);
    }

    @Override
    public CompoundPredicate getPredicate() {
        return rootPredicate.getPredicate();
    }

    @Override
    public T end() {
        verifyEnded();
        listener.onBuilderEnded(this);
        return result;
    }

    @Override
    public void onBuilderEnded(ExpressionBuilder builder) {
        listener.onBuilderEnded(this);
    }

    @Override
    public void onBuilderEnded(PredicateBuilder builder) {
        predicateBuilderListener.onBuilderEnded(builder);
        rootPredicate.getPredicate().getChildren().add(builder.getPredicate());
    }

    @Override
    public JoinOnOrBuilder> onOr() {
        return rootPredicate.startBuilder(new JoinOnOrBuilderImpl>(this, rootPredicate, expressionFactory, parameterManager, subqueryInitFactory));
    }

    @Override
    public void onReplaceBuilder(SubqueryInternalBuilder oldBuilder, SubqueryInternalBuilder newBuilder) {
        subqueryBuilderListener.onReplaceBuilder(oldBuilder, newBuilder);
    }

    @Override
    public void onBuilderEnded(SubqueryInternalBuilder builder) {
        subqueryBuilderListener.onBuilderEnded(builder);
    }

    @Override
    public void onBuilderStarted(SubqueryInternalBuilder builder) {
        subqueryBuilderListener.onBuilderStarted(builder);
    }

    @Override
    public void onInitiatorStarted(SubqueryInitiator initiator) {
        subqueryBuilderListener.onInitiatorStarted(initiator);
    }

    protected void verifyBuilderEnded() {
        super.verifyBuilderEnded();
        predicateBuilderListener.verifyBuilderEnded();
        subqueryBuilderListener.verifySubqueryBuilderEnded();
    }

    protected  X startBuilder(X builder) {
        return predicateBuilderListener.startBuilder(builder);
    }
}