All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.dellroad.querystream.jpa.util.ForwardingCriteriaBuilder Maven / Gradle / Ivy

    
/*
 * Copyright (C) 2018 Archie L. Cobbs. All rights reserved.
 */

package org.dellroad.querystream.jpa.util;

import java.util.Collection;
import java.util.Map;
import java.util.Set;

import javax.persistence.Tuple;
import javax.persistence.criteria.CollectionJoin;
import javax.persistence.criteria.CompoundSelection;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaDelete;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.CriteriaUpdate;
import javax.persistence.criteria.Expression;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.ListJoin;
import javax.persistence.criteria.MapJoin;
import javax.persistence.criteria.Order;
import javax.persistence.criteria.ParameterExpression;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.persistence.criteria.Selection;
import javax.persistence.criteria.SetJoin;
import javax.persistence.criteria.Subquery;

/**
 * {@link CriteriaBuilder} that forwards all methods to a delegate {@linkplain #getCriteriaBuilder provided} by the subclass.
 *
 * 
    
 * Subclasses must override {@link #getCriteriaBuilder} to provide the delegate.
 *
 * 
    
 * This class also adds some "fail fast" error checking for null values so that errors occur immediately, instead of
 * later (and more mysteriously) during query execution.
 */
public abstract class ForwardingCriteriaBuilder implements CriteriaBuilder {

    /**
     * Get the delegate {@link CriteriaBuilder} to whom all methods should be forwarded.
     *
     * @return the underlying {@link CriteriaBuilder}
     */
    protected abstract CriteriaBuilder getCriteriaBuilder();

    @Override
    public CriteriaQuery createQuery() {
        return this.getCriteriaBuilder().createQuery();
    }

    @Override
    public  CriteriaQuery createQuery(Class resultClass) {
        this.nullCheck("resultClass", resultClass);
        return this.getCriteriaBuilder().createQuery(resultClass);
    }

    @Override
    public CriteriaQuery createTupleQuery() {
        return this.getCriteriaBuilder().createTupleQuery();
    }

    @Override
    public  CriteriaUpdate createCriteriaUpdate(Class targetEntity) {
        this.nullCheck("targetEntity", targetEntity);
        return this.getCriteriaBuilder().createCriteriaUpdate(targetEntity);
    }

    @Override
    public  CriteriaDelete createCriteriaDelete(Class targetEntity) {
        this.nullCheck("targetEntity", targetEntity);
        return this.getCriteriaBuilder().createCriteriaDelete(targetEntity);
    }

    @Override
    public  CompoundSelection construct(Class resultClass, Selection... selections) {
        this.nullCheck("resultClass", resultClass);
        this.nullCheck("selections", selections);
        return this.getCriteriaBuilder().construct(resultClass, selections);
    }

    @Override
    public CompoundSelection tuple(Selection... selections) {
        this.nullCheck("selections", selections);
        return this.getCriteriaBuilder().tuple(selections);
    }

    @Override
    public CompoundSelection array(Selection... selections) {
        this.nullCheck("selections", selections);
        return this.getCriteriaBuilder().array(selections);
    }

    @Override
    public Order asc(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().asc(expr);
    }

    @Override
    public Order desc(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().desc(expr);
    }

    @Override
    public  Expression avg(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().avg(expr);
    }

    @Override
    public  Expression sum(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().sum(expr);
    }

    @Override
    public Expression sumAsLong(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().sumAsLong(expr);
    }

    @Override
    public Expression sumAsDouble(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().sumAsDouble(expr);
    }

    @Override
    public  Expression max(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().max(expr);
    }

    @Override
    public  Expression min(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().min(expr);
    }

    @Override
    public > Expression greatest(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().greatest(expr);
    }

    @Override
    public > Expression least(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().least(expr);
    }

    @Override
    public Expression count(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().count(expr);
    }

    @Override
    public Expression countDistinct(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().countDistinct(expr);
    }

    @Override
    public Predicate exists(Subquery subquery) {
        this.nullCheck("subquery", subquery);
        return this.getCriteriaBuilder().exists(subquery);
    }

    @Override
    public  Expression all(Subquery subquery) {
        this.nullCheck("subquery", subquery);
        return this.getCriteriaBuilder().all(subquery);
    }

    @Override
    public  Expression some(Subquery subquery) {
        this.nullCheck("subquery", subquery);
        return this.getCriteriaBuilder().some(subquery);
    }

    @Override
    public  Expression any(Subquery subquery) {
        this.nullCheck("subquery", subquery);
        return this.getCriteriaBuilder().any(subquery);
    }

    @Override
    public Predicate and(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().and(x, y);
    }

    @Override
    public Predicate and(Predicate... preds) {
        this.nullCheck("preds", preds);
        return this.getCriteriaBuilder().and(preds);
    }

    @Override
    public Predicate or(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().or(x, y);
    }

    @Override
    public Predicate or(Predicate... preds) {
        this.nullCheck("preds", preds);
        return this.getCriteriaBuilder().or(preds);
    }

    @Override
    public Predicate not(Expression pred) {
        this.nullCheck("pred", pred);
        return this.getCriteriaBuilder().not(pred);
    }

    @Override
    public Predicate conjunction() {
        return this.getCriteriaBuilder().conjunction();
    }

    @Override
    public Predicate disjunction() {
        return this.getCriteriaBuilder().disjunction();
    }

    @Override
    public Predicate isTrue(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().isTrue(expr);
    }

    @Override
    public Predicate isFalse(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().isFalse(expr);
    }

    @Override
    public Predicate isNull(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().isNull(expr);
    }

    @Override
    public Predicate isNotNull(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().isNotNull(expr);
    }

    @Override
    public Predicate equal(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().equal(x, y);
    }

    @Override
    public Predicate equal(Expression x, Object y) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().equal(x, y);
    }

    @Override
    public Predicate notEqual(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().notEqual(x, y);
    }

    @Override
    public Predicate notEqual(Expression x, Object y) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().notEqual(x, y);
    }

    @Override
    public > Predicate greaterThan(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().greaterThan(x, y);
    }

    @Override
    public > Predicate greaterThan(Expression x, Y y) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().greaterThan(x, y);
    }

    @Override
    public > Predicate greaterThanOrEqualTo(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().greaterThanOrEqualTo(x, y);
    }

    @Override
    public > Predicate greaterThanOrEqualTo(Expression x, Y y) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().greaterThanOrEqualTo(x, y);
    }

    @Override
    public > Predicate lessThan(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().lessThan(x, y);
    }

    @Override
    public > Predicate lessThan(Expression x, Y y) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().lessThan(x, y);
    }

    @Override
    public > Predicate lessThanOrEqualTo(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().lessThanOrEqualTo(x, y);
    }

    @Override
    public > Predicate lessThanOrEqualTo(Expression x, Y y) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().lessThanOrEqualTo(x, y);
    }

    @Override
    public > Predicate between(Expression expr,
      Expression lo, Expression hi) {
        this.nullCheck("expr", expr);
        this.nullCheck("lo", lo);
        this.nullCheck("hi", hi);
        return this.getCriteriaBuilder().between(expr, lo, hi);
    }

    @Override
    public > Predicate between(Expression expr, Y lo, Y hi) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().between(expr, lo, hi);
    }

    @Override
    public Predicate gt(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().gt(x, y);
    }

    @Override
    public Predicate gt(Expression x, Number y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().gt(x, y);
    }

    @Override
    public Predicate ge(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().ge(x, y);
    }

    @Override
    public Predicate ge(Expression x, Number y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().ge(x, y);
    }

    @Override
    public Predicate lt(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().lt(x, y);
    }

    @Override
    public Predicate lt(Expression x, Number y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().lt(x, y);
    }

    @Override
    public Predicate le(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().le(x, y);
    }

    @Override
    public Predicate le(Expression x, Number y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().le(x, y);
    }

    @Override
    public  Expression neg(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().neg(expr);
    }

    @Override
    public  Expression abs(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().abs(expr);
    }

    @Override
    public  Expression sum(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().sum(x, y);
    }

    @Override
    public  Expression sum(Expression x, N y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().sum(x, y);
    }

    @Override
    public  Expression sum(N x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().sum(x, y);
    }

    @Override
    public  Expression prod(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().prod(x, y);
    }

    @Override
    public  Expression prod(Expression x, N y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().prod(x, y);
    }

    @Override
    public  Expression prod(N x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().prod(x, y);
    }

    @Override
    public  Expression diff(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().diff(x, y);
    }

    @Override
    public  Expression diff(Expression x, N y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().diff(x, y);
    }

    @Override
    public  Expression diff(N x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().diff(x, y);
    }

    @Override
    public Expression quot(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().quot(x, y);
    }

    @Override
    public Expression quot(Expression x, Number y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().quot(x, y);
    }

    @Override
    public Expression quot(Number x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().quot(x, y);
    }

    @Override
    public Expression mod(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().mod(x, y);
    }

    @Override
    public Expression mod(Expression x, Integer y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().mod(x, y);
    }

    @Override
    public Expression mod(Integer x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().mod(x, y);
    }

    @Override
    public Expression sqrt(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().sqrt(expr);
    }

    @Override
    public Expression toLong(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().toLong(expr);
    }

    @Override
    public Expression toInteger(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().toInteger(expr);
    }

    @Override
    public Expression toFloat(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().toFloat(expr);
    }

    @Override
    public Expression toDouble(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().toDouble(expr);
    }

    @Override
    public Expression toBigDecimal(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().toBigDecimal(expr);
    }

    @Override
    public Expression toBigInteger(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().toBigInteger(expr);
    }

    @Override
    public Expression toString(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().toString(expr);
    }

    @Override
    public  Expression literal(T expr) {
        return this.getCriteriaBuilder().literal(expr);
    }

    @Override
    public  Expression nullLiteral(Class type) {
        this.nullCheck("type", type);
        return this.getCriteriaBuilder().nullLiteral(type);
    }

    @Override
    public  ParameterExpression parameter(Class type) {
        this.nullCheck("type", type);
        return this.getCriteriaBuilder().parameter(type);
    }

    @Override
    public  ParameterExpression parameter(Class type, String name) {
        this.nullCheck("type", type);
        this.nullCheck("name", name);
        return this.getCriteriaBuilder().parameter(type, name);
    }

    @Override
    public > Predicate isEmpty(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().isEmpty(expr);
    }

    @Override
    public > Predicate isNotEmpty(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().isNotEmpty(expr);
    }

    @Override
    public > Expression size(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().size(expr);
    }

    @Override
    public > Expression size(C expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().size(expr);
    }

    @Override
    public > Predicate isMember(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().isMember(x, y);
    }

    @Override
    public > Predicate isMember(E x, Expression y) {
        //this.nullCheck("x", x); ???
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().isMember(x, y);
    }

    @Override
    public > Predicate isNotMember(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().isNotMember(x, y);
    }

    @Override
    public > Predicate isNotMember(E x, Expression y) {
        //this.nullCheck("x", x); ???
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().isNotMember(x, y);
    }

    @Override
    public > Expression> values(M map) {
        return this.getCriteriaBuilder().values(map);
    }

    @Override
    public > Expression> keys(M map) {
        return this.getCriteriaBuilder().keys(map);
    }

    @Override
    public Predicate like(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().like(x, y);
    }

    @Override
    public Predicate like(Expression x, String y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().like(x, y);
    }

    @Override
    public Predicate like(Expression x, Expression y, Expression esc) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        this.nullCheck("esc", esc);
        return this.getCriteriaBuilder().like(x, y, esc);
    }

    @Override
    public Predicate like(Expression x, Expression y, char esc) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().like(x, y, esc);
    }

    @Override
    public Predicate like(Expression x, String y, Expression esc) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        this.nullCheck("esc", esc);
        return this.getCriteriaBuilder().like(x, y, esc);
    }

    @Override
    public Predicate like(Expression x, String y, char esc) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().like(x, y, esc);
    }

    @Override
    public Predicate notLike(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().notLike(x, y);
    }

    @Override
    public Predicate notLike(Expression x, String y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().notLike(x, y);
    }

    @Override
    public Predicate notLike(Expression x, Expression y, Expression esc) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        this.nullCheck("esc", esc);
        return this.getCriteriaBuilder().notLike(x, y, esc);
    }

    @Override
    public Predicate notLike(Expression x, Expression y, char esc) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().notLike(x, y, esc);
    }

    @Override
    public Predicate notLike(Expression x, String y, Expression esc) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        this.nullCheck("esc", esc);
        return this.getCriteriaBuilder().notLike(x, y, esc);
    }

    @Override
    public Predicate notLike(Expression x, String y, char esc) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().notLike(x, y, esc);
    }

    @Override
    public Expression concat(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().concat(x, y);
    }

    @Override
    public Expression concat(Expression x, String y) {
        this.nullCheck("x", x);
        //this.nullCheck("y", y);  ???
        return this.getCriteriaBuilder().concat(x, y);
    }

    @Override
    public Expression concat(String x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().concat(x, y);
    }

    @Override
    public Expression substring(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().substring(x, y);
    }

    @Override
    public Expression substring(Expression x, int y) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().substring(x, y);
    }

    @Override
    public Expression substring(Expression x, Expression y, Expression z) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        this.nullCheck("z", z);
        return this.getCriteriaBuilder().substring(x, y, z);
    }

    @Override
    public Expression substring(Expression x, int y, int z) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().substring(x, y, z);
    }

    @Override
    public Expression trim(Expression x) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().trim(x);
    }

    @Override
    public Expression trim(CriteriaBuilder.Trimspec x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().trim(x, y);
    }

    @Override
    public Expression trim(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().trim(x, y);
    }

    @Override
    public Expression trim(CriteriaBuilder.Trimspec x, Expression y, Expression z) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        this.nullCheck("z", z);
        return this.getCriteriaBuilder().trim(x, y, z);
    }

    @Override
    public Expression trim(char x, Expression y) {
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().trim(x, y);
    }

    @Override
    public Expression trim(CriteriaBuilder.Trimspec x, char y, Expression z) {
        this.nullCheck("x", x);
        this.nullCheck("z", z);
        return this.getCriteriaBuilder().trim(x, y, z);
    }

    @Override
    public Expression lower(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().lower(expr);
    }

    @Override
    public Expression upper(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().upper(expr);
    }

    @Override
    public Expression length(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().length(expr);
    }

    @Override
    public Expression locate(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().locate(x, y);
    }

    @Override
    public Expression locate(Expression x, String y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().locate(x, y);
    }

    @Override
    public Expression locate(Expression x, Expression y, Expression z) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        this.nullCheck("z", z);
        return this.getCriteriaBuilder().locate(x, y, z);
    }

    @Override
    public Expression locate(Expression x, String y, int z) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().locate(x, y, z);
    }

    @Override
    public Expression currentDate() {
        return this.getCriteriaBuilder().currentDate();
    }

    @Override
    public Expression currentTimestamp() {
        return this.getCriteriaBuilder().currentTimestamp();
    }

    @Override
    public Expression currentTime() {
        return this.getCriteriaBuilder().currentTime();
    }

    @Override
    public  CriteriaBuilder.In in(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().in(expr);
    }

    @Override
    public  Expression coalesce(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().coalesce(x, y);
    }

    @Override
    public  Expression coalesce(Expression x, Y y) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().coalesce(x, y);
    }

    @Override
    public  Expression nullif(Expression x, Expression y) {
        this.nullCheck("x", x);
        this.nullCheck("y", y);
        return this.getCriteriaBuilder().nullif(x, y);
    }

    @Override
    public  Expression nullif(Expression x, Y y) {
        this.nullCheck("x", x);
        return this.getCriteriaBuilder().nullif(x, y);
    }

    @Override
    public  CriteriaBuilder.Coalesce coalesce() {
        return this.getCriteriaBuilder().coalesce();
    }

    @Override
    public  CriteriaBuilder.SimpleCase selectCase(Expression expr) {
        this.nullCheck("expr", expr);
        return this.getCriteriaBuilder().selectCase(expr);
    }

    @Override
    public  CriteriaBuilder.Case selectCase() {
        return this.getCriteriaBuilder().selectCase();
    }

    @Override
    public  Expression function(String name, Class type, Expression... exprs) {
        this.nullCheck("name", name);
        this.nullCheck("type", type);
        this.nullCheck("exprs", exprs);
        return this.getCriteriaBuilder().function(name, type, exprs);
    }

    @Override
    public  Join treat(Join join, Class type) {
        this.nullCheck("join", join);
        this.nullCheck("type", type);
        return this.getCriteriaBuilder().treat(join, type);
    }

    @Override
    public  CollectionJoin treat(CollectionJoin join, Class type) {
        this.nullCheck("join", join);
        this.nullCheck("type", type);
        return this.getCriteriaBuilder().treat(join, type);
    }

    @Override
    public  SetJoin treat(SetJoin join, Class type) {
        this.nullCheck("join", join);
        this.nullCheck("type", type);
        return this.getCriteriaBuilder().treat(join, type);
    }

    @Override
    public  ListJoin treat(ListJoin join, Class type) {
        this.nullCheck("join", join);
        this.nullCheck("type", type);
        return this.getCriteriaBuilder().treat(join, type);
    }

    @Override
    public  MapJoin treat(MapJoin join, Class type) {
        this.nullCheck("join", join);
        this.nullCheck("type", type);
        return this.getCriteriaBuilder().treat(join, type);
    }

    @Override
    public  Path treat(Path path, Class type) {
        this.nullCheck("path", path);
        this.nullCheck("type", type);
        return this.getCriteriaBuilder().treat(path, type);
    }

    @Override
    public  Root treat(Root root, Class type) {
        this.nullCheck("root", root);
        this.nullCheck("type", type);
        return this.getCriteriaBuilder().treat(root, type);
    }

    private void nullCheck(String name, Object value) {
        if (value == null)
            throw new IllegalArgumentException("null " + name);
    }

    private void nullCheck(String name, Object[] values) {
        this.nullCheck(name, (Object)values);
        int index = 0;
        for (Object value : values)
            this.nullCheck(name + " #" + index++, value);
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy