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.WindowBuilderImpl 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.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.WhereBuilder;
import com.blazebit.persistence.WhereOrBuilder;
import com.blazebit.persistence.WindowBuilder;
import com.blazebit.persistence.WindowFrameBetweenBuilder;
import com.blazebit.persistence.WindowFrameBuilder;
import com.blazebit.persistence.WindowFrameExclusionBuilder;
import com.blazebit.persistence.impl.builder.predicate.WhereOrBuilderImpl;
import com.blazebit.persistence.parser.expression.Expression;
import com.blazebit.persistence.parser.expression.ExpressionFactory;
import com.blazebit.persistence.parser.expression.OrderByItem;
import com.blazebit.persistence.parser.expression.WindowDefinition;
import com.blazebit.persistence.parser.expression.WindowFrameExclusionType;
import com.blazebit.persistence.parser.expression.WindowFrameMode;
import com.blazebit.persistence.parser.expression.WindowFramePositionType;
import com.blazebit.persistence.parser.predicate.Predicate;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author Christian Beikov
* @since 1.4.0
*/
public class WindowBuilderImpl extends PredicateManager> implements WindowBuilder, WhereBuilder>, WindowFrameBuilder, WindowFrameExclusionBuilder, WindowFrameBetweenBuilder {
private final WindowManager windowManager;
private final T result;
private final String name;
private final List partitionExpressions = new ArrayList<>();
private final List orderByExpressions = new ArrayList<>();
private String baseWindowName;
private WindowFrameMode frameMode;
private WindowFramePositionType frameStartType;
private Expression frameStartExpression;
private WindowFramePositionType frameEndType;
private Expression frameEndExpression;
private WindowFrameExclusionType frameExclusionType;
public WindowBuilderImpl(ResolvingQueryGenerator queryGenerator, ParameterManager parameterManager, SubqueryInitiatorFactory subqueryInitFactory, ExpressionFactory expressionFactory, WindowManager windowManager, T result, String name) {
super(queryGenerator, parameterManager, subqueryInitFactory, expressionFactory);
this.windowManager = windowManager;
this.result = result;
this.name = name;
}
@Override
public ClauseType getClauseType() {
return ClauseType.WINDOW;
}
@Override
protected String getClauseName() {
return "WINDOW";
}
@Override
public & WindowBuilder> X filter() {
return (X) this;
}
@Override
public WindowBuilder partitionBy(String... partitionExpressions) {
for (String partitionExpression : partitionExpressions) {
this.partitionExpressions.add(expressionFactory.createSimpleExpression(partitionExpression, false));
}
return this;
}
@Override
public WindowBuilder partitionBy(String partitionExpression) {
partitionExpressions.add(expressionFactory.createSimpleExpression(partitionExpression, false));
return this;
}
@Override
public WindowFrameBuilder rows() {
this.frameMode = WindowFrameMode.ROWS;
return this;
}
@Override
public WindowFrameBuilder range() {
this.frameMode = WindowFrameMode.RANGE;
return this;
}
@Override
public WindowFrameBuilder groups() {
this.frameMode = WindowFrameMode.GROUPS;
return this;
}
public WindowBuilder orderBy(String expression, boolean ascending) {
return orderBy(expression, ascending, false);
}
@Override
public WindowBuilder orderBy(String expression, boolean ascending, boolean nullFirst) {
Expression expr = expressionFactory.createSimpleExpression(expression, false);
orderByExpressions.add(new OrderByItem(ascending, nullFirst, expr));
return this;
}
@Override
public WindowBuilder orderByAsc(String expression) {
return orderBy(expression, true, false);
}
@Override
public WindowBuilder orderByAsc(String expression, boolean nullFirst) {
return orderBy(expression, true, nullFirst);
}
@Override
public WindowBuilder orderByDesc(String expression) {
return orderBy(expression, false, false);
}
@Override
public WindowBuilder orderByDesc(String expression, boolean nullFirst) {
return orderBy(expression, false, nullFirst);
}
@Override
public WindowFrameBetweenBuilder betweenUnboundedPreceding() {
this.frameStartType = WindowFramePositionType.UNBOUNDED_PRECEDING;
return this;
}
@Override
public WindowFrameBetweenBuilder betweenPreceding(String expression) {
this.frameStartExpression = expressionFactory.createSimpleExpression(expression, false);
this.frameStartType = WindowFramePositionType.BOUNDED_PRECEDING;
return this;
}
@Override
public WindowFrameBetweenBuilder betweenFollowing(String expression) {
this.frameStartExpression = expressionFactory.createSimpleExpression(expression, false);
this.frameStartType = WindowFramePositionType.BOUNDED_FOLLOWING;
return this;
}
@Override
public WindowFrameBetweenBuilder betweenCurrentRow() {
this.frameStartType = WindowFramePositionType.CURRENT_ROW;
return this;
}
@Override
public WindowFrameExclusionBuilder unboundedPreceding() {
this.frameStartType = WindowFramePositionType.UNBOUNDED_PRECEDING;
return this;
}
@Override
public WindowFrameExclusionBuilder preceding(String expression) {
this.frameStartExpression = expressionFactory.createSimpleExpression(expression, false);
this.frameStartType = WindowFramePositionType.BOUNDED_PRECEDING;
return this;
}
@Override
public WindowFrameExclusionBuilder currentRow() {
this.frameStartType = WindowFramePositionType.CURRENT_ROW;
return this;
}
@Override
public WindowFrameExclusionBuilder andUnboundedFollowing() {
this.frameEndType = WindowFramePositionType.UNBOUNDED_FOLLOWING;
return this;
}
@Override
public WindowFrameExclusionBuilder andPreceding(String expression) {
this.frameEndExpression = expressionFactory.createSimpleExpression(expression, false);
this.frameEndType = WindowFramePositionType.BOUNDED_PRECEDING;
return this;
}
@Override
public WindowFrameExclusionBuilder andFollowing(String expression) {
this.frameEndExpression = expressionFactory.createSimpleExpression(expression, false);
this.frameEndType = WindowFramePositionType.BOUNDED_FOLLOWING;
return this;
}
@Override
public WindowFrameExclusionBuilder andCurrentRow() {
this.frameEndType = WindowFramePositionType.CURRENT_ROW;
return this;
}
@Override
public T excludeNoOthers() {
// The default
return end();
}
@Override
public T excludeCurrentRow() {
this.frameExclusionType = WindowFrameExclusionType.EXCLUDE_CURRENT_ROW;
return end();
}
@Override
public T excludeGroup() {
this.frameExclusionType = WindowFrameExclusionType.EXCLUDE_GROUP;
return end();
}
@Override
public T excludeTies() {
this.frameExclusionType = WindowFrameExclusionType.EXCLUDE_TIES;
return end();
}
@Override
public T end() {
WindowFrameMode frameMode = this.frameMode;
WindowFramePositionType frameStartType = this.frameStartType;
WindowFramePositionType frameEndType = this.frameEndType;
// The default
if (frameMode == WindowFrameMode.RANGE && frameEndExpression == null && frameEndType == WindowFramePositionType.CURRENT_ROW) {
frameEndType = null;
}
// The default
if (frameMode == WindowFrameMode.RANGE && frameEndType == null && frameStartExpression == null && frameStartType == WindowFramePositionType.UNBOUNDED_PRECEDING) {
frameStartType = null;
}
// The default
if (frameMode == WindowFrameMode.RANGE && frameStartType == null && frameEndType == null) {
frameMode = null;
}
windowManager.onBuilderEnded(name, new WindowDefinition(
baseWindowName,
partitionExpressions,
orderByExpressions,
rootPredicate.getPredicate(),
frameMode,
frameStartType,
frameStartExpression,
frameEndType,
frameEndExpression,
frameExclusionType
));
return result;
}
/*
* Where methods
*/
public RestrictionBuilder> where(String expression) {
Expression expr = expressionFactory.createSimpleExpression(expression, false);
return restrict(this, expr);
}
public CaseWhenStarterBuilder>> whereCase() {
return restrictCase(this);
}
public SimpleCaseWhenStarterBuilder>> whereSimpleCase(String expression) {
return restrictSimpleCase(this, expressionFactory.createSimpleExpression(expression, false));
}
public WhereOrBuilder> whereOr() {
return rootPredicate.startBuilder(new WhereOrBuilderImpl>(this, rootPredicate, subqueryInitFactory, expressionFactory, parameterManager));
}
@SuppressWarnings("unchecked")
public SubqueryInitiator> whereExists() {
return restrictExists(this);
}
@SuppressWarnings("unchecked")
public SubqueryInitiator> whereNotExists() {
return restrictNotExists(this);
}
@SuppressWarnings("unchecked")
public SubqueryBuilder> whereExists(FullQueryBuilder criteriaBuilder) {
return restrictExists(this, criteriaBuilder);
}
@SuppressWarnings("unchecked")
public SubqueryBuilder> whereNotExists(FullQueryBuilder criteriaBuilder) {
return restrictNotExists(this, criteriaBuilder);
}
public SubqueryInitiator>> whereSubquery() {
return restrict(this);
}
public SubqueryInitiator>> whereSubquery(String subqueryAlias, String expression) {
return restrict(this, subqueryAlias, expression);
}
public MultipleSubqueryInitiator>> whereSubqueries(String expression) {
return restrictSubqueries(this, expression);
}
public SubqueryBuilder>> whereSubquery(FullQueryBuilder criteriaBuilder) {
return restrict(this, criteriaBuilder);
}
public SubqueryBuilder>> whereSubquery(String subqueryAlias, String expression, FullQueryBuilder criteriaBuilder) {
return restrict(this, subqueryAlias, expression, criteriaBuilder);
}
@SuppressWarnings("unchecked")
public WindowBuilderImpl whereExpression(String expression) {
Predicate predicate = expressionFactory.createBooleanExpression(expression, false);
restrictExpression(predicate);
return this;
}
@SuppressWarnings("unchecked")
public MultipleSubqueryInitiator> whereExpressionSubqueries(String expression) {
Predicate predicate = expressionFactory.createBooleanExpression(expression, true);
return restrictExpressionSubqueries(this, predicate);
}
@SuppressWarnings("unchecked")
public WindowBuilderImpl setWhereExpression(String expression) {
Predicate predicate = expressionFactory.createBooleanExpression(expression, false);
restrictSetExpression(predicate);
return this;
}
@SuppressWarnings("unchecked")
public MultipleSubqueryInitiator> setWhereExpressionSubqueries(String expression) {
Predicate predicate = expressionFactory.createBooleanExpression(expression, true);
return restrictSetExpressionSubqueries(this, predicate);
}
}