• Home
• com.introproventures
• graphql-jpa-query-schema
• 1.2.11
• source code
• JpaPredicateBuilder.java

×

Project download

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.introproventures.graphql.jpa.query.schema.impl.JpaPredicateBuilder Maven / Gradle / Ivy

/*
 * Copyright 2017 IntroPro Ventures Inc. and/or its affiliates.
 *
 * 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.introproventures.graphql.jpa.query.schema.impl;

import com.introproventures.graphql.jpa.query.schema.impl.PredicateFilter.Criteria;
import graphql.language.NullValue;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.Expression;
import jakarta.persistence.criteria.From;
import jakarta.persistence.criteria.Path;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.metamodel.Attribute;
import jakarta.persistence.metamodel.EntityType;
import jakarta.persistence.metamodel.PluralAttribute;
import java.lang.reflect.Constructor;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

/**
 * Supported types to build predicates for
 *
 * 

 * 
 Boolean 
 * 
 Byte 
 * 
 Short 
 * 
 Character 
 * 
 Integer 
 * 
 Long 
 * 
 Float 
 * 
 Double 
 * 
 java.math.BigInteger 
 * 
 java.math.BigDecimal 
 * 
 java.lang.String 
 * 
 java.util.Date 
 * 
 java.time.LocalDate 
 * 
 java.time.LocalDateTime 
 * 
 java.time.OffsetDateTime 
 * 
 java.time.ZonedDateTime 
 * 
 java.time.Instant 
 * 
 java.time.LocalTime 
 * 
 java.util.Calendar 
 * 
 java.sql.Date 
 * 
 java.sql.Time 
 * 
 java.sql.Timestamp 
 * 
 java.util.UUID 
 * 
 *
 */
class JpaPredicateBuilder {

    public static final Map, Class> WRAPPERS_TO_PRIMITIVES = new HashMap, Class>();
    public static final Map, Class> PRIMITIVES_TO_WRAPPERS = new HashMap, Class>();
    public static final Set> JAVA_SCALARS = new LinkedHashSet<>();

    static {
        PRIMITIVES_TO_WRAPPERS.put(boolean.class, Boolean.class);
        PRIMITIVES_TO_WRAPPERS.put(byte.class, Byte.class);
        PRIMITIVES_TO_WRAPPERS.put(char.class, Character.class);
        PRIMITIVES_TO_WRAPPERS.put(double.class, Double.class);
        PRIMITIVES_TO_WRAPPERS.put(float.class, Float.class);
        PRIMITIVES_TO_WRAPPERS.put(int.class, Integer.class);
        PRIMITIVES_TO_WRAPPERS.put(long.class, Long.class);
        PRIMITIVES_TO_WRAPPERS.put(short.class, Short.class);
        PRIMITIVES_TO_WRAPPERS.put(void.class, Void.class);

        WRAPPERS_TO_PRIMITIVES.put(Boolean.class, boolean.class);
        WRAPPERS_TO_PRIMITIVES.put(Byte.class, byte.class);
        WRAPPERS_TO_PRIMITIVES.put(Character.class, char.class);
        WRAPPERS_TO_PRIMITIVES.put(Double.class, double.class);
        WRAPPERS_TO_PRIMITIVES.put(Float.class, float.class);
        WRAPPERS_TO_PRIMITIVES.put(Integer.class, int.class);
        WRAPPERS_TO_PRIMITIVES.put(Long.class, long.class);
        WRAPPERS_TO_PRIMITIVES.put(Short.class, short.class);
        WRAPPERS_TO_PRIMITIVES.put(Void.class, void.class);

        JAVA_SCALARS.addAll(
            Arrays.asList(
                Boolean.class,
                Byte.class,
                Character.class,
                Double.class,
                Float.class,
                Integer.class,
                Long.class,
                Short.class,
                BigInteger.class,
                BigDecimal.class,
                String.class,
                Date.class,
                LocalDate.class,
                LocalDateTime.class,
                ZonedDateTime.class,
                Instant.class,
                LocalTime.class,
                Calendar.class,
                OffsetDateTime.class,
                java.sql.Date.class,
                java.sql.Time.class,
                java.sql.Timestamp.class,
                UUID.class
            )
        );
    }

    private final CriteriaBuilder cb;

    /**
     * JpaPredicateBuilder constructor
     *
     * @param cb
     */
    public JpaPredicateBuilder(CriteriaBuilder cb) {
        this.cb = cb;
    }

    protected Predicate addOrNull(Path root, Predicate p) {
        Predicate pr = cb.isNull(root);
        return cb.or(p, pr);
    }

    /**
     *
     * @param root
     * @param filter
     * @return
     */
    protected Predicate getStringPredicate(Path root, PredicateFilter filter) {
        // list or arrays only for in and not in, between and not between
        Predicate arrayValuePredicate = mayBeArrayValuePredicate(root, filter);

        if (arrayValuePredicate == null) {
            String compareValue = filter.getValue().toString();
            Expression fieldValue = root;

            if (
                filter.anyMatch(
                    Criteria.EQ_,
                    Criteria.NE_,
                    Criteria.LIKE_,
                    Criteria.STARTS_,
                    Criteria.ENDS_,
                    Criteria.LOWER
                )
            ) {
                compareValue = compareValue.toLowerCase();
                fieldValue = cb.lower(fieldValue);
            }
            if (filter.getCriterias().contains(Criteria.IN)) {
                CriteriaBuilder.In