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.CTEManager 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.FullSelectCTECriteriaBuilder;
import com.blazebit.persistence.LeafOngoingFinalSetOperationCTECriteriaBuilder;
import com.blazebit.persistence.ReturningModificationCriteriaBuilderFactory;
import com.blazebit.persistence.SelectRecursiveCTECriteriaBuilder;
import com.blazebit.persistence.StartOngoingSetOperationCTECriteriaBuilder;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
/**
*
* @author Christian Beikov
* @author Moritz Becker
* @since 1.1.0
*/
public class CTEManager extends CTEBuilderListenerImpl {
private final MainQuery mainQuery;
private final Map, CTEInfo> ctes;
private QueryContext queryContext;
private boolean recursive = false;
CTEManager(MainQuery mainQuery) {
this.mainQuery = mainQuery;
this.ctes = new LinkedHashMap<>();
}
void init(AbstractCommonQueryBuilder queryBuilder) {
if (queryContext == null) {
this.queryContext = new QueryContext(queryBuilder, ClauseType.CTE);
}
}
void applyFrom(CTEManager cteManager) {
if (cteManager.recursive) {
recursive = true;
}
for (Map.Entry, CTEInfo> entry : cteManager.ctes.entrySet()) {
CTEInfo cteInfo = entry.getValue().copy(this);
mainQuery.parameterManager.collectParameterRegistrations(cteInfo.nonRecursiveCriteriaBuilder, ClauseType.CTE);
if (cteInfo.recursive) {
mainQuery.parameterManager.collectParameterRegistrations(cteInfo.recursiveCriteriaBuilder, ClauseType.CTE);
}
ctes.put(entry.getKey(), cteInfo);
}
}
QueryContext getQueryContext() {
return queryContext;
}
Collection getCtes() {
return ctes.values();
}
public boolean hasCte(Class cte) {
return ctes.containsKey(cte);
}
public CTEInfo getCte(Class cteType) {
return ctes.get(cteType);
}
public boolean hasCtes() {
return ctes.size() > 0;
}
boolean isRecursive() {
return recursive;
}
void buildClause(StringBuilder sb) {
if (ctes.isEmpty()) {
return;
}
sb.append("WITH ");
if (recursive) {
sb.append("RECURSIVE ");
}
boolean first = true;
for (CTEInfo cte : ctes.values()) {
if (first) {
first = false;
} else {
sb.append(", ");
}
sb.append(cte.name);
sb.append('(');
final List attributes = cte.attributes;
sb.append(attributes.get(0));
for (int i = 1; i < attributes.size(); i++) {
sb.append(", ");
sb.append(attributes.get(i));
}
sb.append(')');
sb.append(" AS(\n");
sb.append(cte.nonRecursiveCriteriaBuilder.getQueryString());
if (cte.recursive) {
sb.append(cte.unionAll ? "\nUNION ALL\n" : "\nUNION\n");
sb.append(cte.recursiveCriteriaBuilder.getQueryString());
}
sb.append("\n)");
}
sb.append("\n");
}
@SuppressWarnings("unchecked")
StartOngoingSetOperationCTECriteriaBuilder> withStartSet(Class cteClass, Y result) {
mainQuery.assertSupportsAdvancedSql("Illegal use of WITH clause!");
String cteName = cteClass.getSimpleName();
FinalSetOperationCTECriteriaBuilderImpl parentFinalSetOperationBuilder = new FinalSetOperationCTECriteriaBuilderImpl(mainQuery, queryContext, (Class) cteClass, result, null, false, this, null);
OngoingFinalSetOperationCTECriteriaBuilderImpl subFinalSetOperationBuilder = new OngoingFinalSetOperationCTECriteriaBuilderImpl(mainQuery, queryContext, (Class) cteClass, null, null, true, parentFinalSetOperationBuilder.getSubListener(), null);
this.onBuilderStarted(parentFinalSetOperationBuilder);
LeafOngoingSetOperationCTECriteriaBuilderImpl leafCb = new LeafOngoingSetOperationCTECriteriaBuilderImpl(mainQuery, queryContext, cteName, (Class) cteClass, result, parentFinalSetOperationBuilder.getSubListener(), (FinalSetOperationCTECriteriaBuilderImpl) parentFinalSetOperationBuilder);
StartOngoingSetOperationCTECriteriaBuilderImpl> cb = new StartOngoingSetOperationCTECriteriaBuilderImpl>(
mainQuery, queryContext, cteName, (Class) cteClass, result, subFinalSetOperationBuilder.getSubListener(), (OngoingFinalSetOperationCTECriteriaBuilderImpl) subFinalSetOperationBuilder, leafCb
);
subFinalSetOperationBuilder.setOperationManager.setStartQueryBuilder(cb);
parentFinalSetOperationBuilder.setOperationManager.setStartQueryBuilder(subFinalSetOperationBuilder);
subFinalSetOperationBuilder.getSubListener().onBuilderStarted(cb);
parentFinalSetOperationBuilder.getSubListener().onBuilderStarted(leafCb);
// Generics hell..
return (StartOngoingSetOperationCTECriteriaBuilder) cb;
}
@SuppressWarnings("unchecked")
FullSelectCTECriteriaBuilder with(Class cteClass, Y result) {
mainQuery.assertSupportsAdvancedSql("Illegal use of WITH clause!");
String cteName = cteClass.getSimpleName();
FullSelectCTECriteriaBuilderImpl cteBuilder = new FullSelectCTECriteriaBuilderImpl(mainQuery, queryContext, cteName, (Class) cteClass, result, this);
this.onBuilderStarted(cteBuilder);
return cteBuilder;
}
@SuppressWarnings("unchecked")
SelectRecursiveCTECriteriaBuilder withRecursive(Class cteClass, Y result) {
mainQuery.assertSupportsAdvancedSql("Illegal use of WITH clause!");
String cteName = cteClass.getSimpleName();
recursive = true;
RecursiveCTECriteriaBuilderImpl cteBuilder = new RecursiveCTECriteriaBuilderImpl(mainQuery, queryContext, cteName, (Class) cteClass, result, this);
this.onBuilderStarted(cteBuilder);
return cteBuilder;
}
ReturningModificationCriteriaBuilderFactory withReturning(Class cteClass, Y result) {
mainQuery.assertSupportsAdvancedSql("Illegal use of WITH clause!");
String cteName = cteClass.getSimpleName();
ReturningModificationCriteraBuilderFactoryImpl factory = new ReturningModificationCriteraBuilderFactoryImpl(mainQuery, cteName, cteClass, result, this);
return factory;
}
@Override
public void onBuilderEnded(CTEInfoBuilder builder) {
super.onBuilderEnded(builder);
CTEInfo cteInfo = builder.createCTEInfo();
mainQuery.parameterManager.collectParameterRegistrations(cteInfo.nonRecursiveCriteriaBuilder, ClauseType.CTE);
if (cteInfo.recursive) {
mainQuery.parameterManager.collectParameterRegistrations(cteInfo.recursiveCriteriaBuilder, ClauseType.CTE);
}
ctes.put(cteInfo.cteType.getJavaType(), cteInfo);
}
}