modules/spring-data-2.2-ext/src/main/java/org/apache/ignite/springdata22/repository/query/QueryUtils.java - ignite-extensions - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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 org.apache.ignite.springdata22.repository.query;

 import java.util.HashSet;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import org.jetbrains.annotations.Nullable;
 import org.springframework.data.util.Streamable;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;

 import static java.util.regex.Pattern.CASE_INSENSITIVE;
 import static java.util.regex.Pattern.DOTALL;
 import static java.util.regex.Pattern.compile;

 /**
  * Simple utility class to create queries.
  *
  * @author Oliver Gierke
  * @author Kevin Raymond
  * @author Thomas Darimont
  * @author Komi Innocent
  * @author Christoph Strobl
  * @author Mark Paluch
  * @author Sébastien Péralta
  * @author Jens Schauder
  * @author Nils Borrmann
  * @author Reda.Housni -Alaoui
  */
 public abstract class QueryUtils {
     /**
      * The constant COUNT_QUERY_STRING.
      */
     public static final String COUNT_QUERY_STRING = "select count(%s) from %s x";

     /**
      * The constant DELETE_ALL_QUERY_STRING.
      */
     public static final String DELETE_ALL_QUERY_STRING = "delete from %s x";

     /**
      * Used Regex/Unicode categories (see http://www.unicode.org/reports/tr18/#General_Category_Property): Z Separator
      * Cc Control Cf Format P Punctuation
      */
     private static final String IDENTIFIER = "[._[\\P{Z}&&\\P{Cc}&&\\P{Cf}&&\\P{P}]]+";

     /**
      * The Colon no double colon.
      */
     static final String COLON_NO_DOUBLE_COLON = "(?<![:\\\\]):";

     /**
      * The Identifier group.
      */
     static final String IDENTIFIER_GROUP = String.format("(%s)", IDENTIFIER);

     /** */
     private static final String COUNT_REPLACEMENT_TEMPLATE = "select count(%s) $5$6$7";

     /** */
     private static final String SIMPLE_COUNT_VALUE = "$2";

     /** */
     private static final String COMPLEX_COUNT_VALUE = "$3$6";

     /** */
     private static final String ORDER_BY_PART = "(?iu)\\s+order\\s+by\\s+.*$";

     /** */
     private static final Pattern ALIAS_MATCH;

     /** */
     private static final Pattern COUNT_MATCH;

     /** */
     private static final Pattern PROJECTION_CLAUSE = Pattern
         .compile("select\\s+(.+)\\s+from", Pattern.CASE_INSENSITIVE);

     /** */
     private static final String JOIN = "join\\s+(fetch\\s+)?" + IDENTIFIER + "\\s+(as\\s+)?" + IDENTIFIER_GROUP;

     /** */
     private static final Pattern JOIN_PATTERN = Pattern.compile(JOIN, Pattern.CASE_INSENSITIVE);

     /** */
     private static final String EQUALS_CONDITION_STRING = "%s.%s = :%s";

     /** */
     private static final Pattern NAMED_PARAMETER = Pattern.compile(
         COLON_NO_DOUBLE_COLON + IDENTIFIER + "|\\#" + IDENTIFIER, CASE_INSENSITIVE);

     /** */
     private static final Pattern CONSTRUCTOR_EXPRESSION;

     /** */
     private static final int QUERY_JOIN_ALIAS_GROUP_INDEX = 3;

     /** */
     private static final int VARIABLE_NAME_GROUP_INDEX = 4;

     /** */
     private static final Pattern FUNCTION_PATTERN;

     static {
         StringBuilder builder = new StringBuilder();
         builder.append("(?<=from)"); // from as starting delimiter
         builder.append("(?:\\s)+"); // at least one space separating
         builder.append(IDENTIFIER_GROUP); // Entity name, can be qualified (any
         builder.append("(?:\\sas)*"); // exclude possible "as" keyword
         builder.append("(?:\\s)+"); // at least one space separating
         builder.append("(?!(?:where))(\\w+)"); // the actual alias

         ALIAS_MATCH = compile(builder.toString(), CASE_INSENSITIVE);

         builder = new StringBuilder();
         builder.append("(select\\s+((distinct )?(.+?)?)\\s+)?(from\\s+");
         builder.append(IDENTIFIER);
         builder.append("(?:\\s+as)?\\s+)");
         builder.append(IDENTIFIER_GROUP);
         builder.append("(.*)");

         COUNT_MATCH = compile(builder.toString(), CASE_INSENSITIVE);

         builder = new StringBuilder();
         builder.append("select");
         builder.append("\\s+"); // at least one space separating
         builder.append("(.*\\s+)?"); // anything in between (e.g. distinct) at least one space separating
         builder.append("new");
         builder.append("\\s+"); // at least one space separating
         builder.append(IDENTIFIER);
         builder.append("\\s*"); // zero to unlimited space separating
         builder.append("\\(");
         builder.append(".*");
         builder.append("\\)");

         CONSTRUCTOR_EXPRESSION = compile(builder.toString(), CASE_INSENSITIVE + DOTALL);

         builder = new StringBuilder();
         // any function call including parameters within the brackets
         builder.append("\\w+\\s*\\([\\w\\.,\\s'=]+\\)");
         // the potential alias
         builder.append("\\s+[as|AS]+\\s+(([\\w\\.]+))");

         FUNCTION_PATTERN = compile(builder.toString());
     }

     /**
      * Private constructor to prevent instantiation.
      */
     private QueryUtils() {
         // No-op.
     }

     /**
      * Returns the query string to execute an exists query for the given id attributes.
      *
      * @param entityName        the name of the entity to create the query for, must not be {@literal null}.
      * @param cntQryPlaceHolder the placeholder for the count clause, must not be {@literal null}.
      * @param idAttrs           the id attributes for the entity, must not be {@literal null}.
      * @return the exists query string
      */
     public static String getExistsQueryString(String entityName,
         String cntQryPlaceHolder,
         Iterable<String> idAttrs) {
         String whereClause = Streamable.of(idAttrs).stream() //
             .map(idAttribute -> String.format(EQUALS_CONDITION_STRING, "x", idAttribute,
                 idAttribute)) //
             .collect(Collectors.joining(" AND ", " WHERE ", ""));

         return String.format(COUNT_QUERY_STRING, cntQryPlaceHolder, entityName) + whereClause;
     }

     /**
      * Returns the query string for the given class name.
      *
      * @param template   must not be {@literal null}.
      * @param entityName must not be {@literal null}.
      * @return the template with placeholders replaced by the {@literal entityName}. Guaranteed to be not {@literal
      *     null}.
      */
     public static String getQueryString(String template, String entityName) {
         Assert.hasText(entityName, "Entity name must not be null or empty!");

         return String.format(template, entityName);
     }

     /**
      * Returns the aliases used for {@code left (outer) join}s.
      *
      * @param qry a query string to extract the aliases of joins from. Must not be {@literal null}.
      * @return a {@literal Set} of aliases used in the query. Guaranteed to be not {@literal null}.
      */
     static Set<String> getOuterJoinAliases(String qry) {
         Set<String> result = new HashSet<>();
         Matcher matcher = JOIN_PATTERN.matcher(qry);

         while (matcher.find()) {
             String alias = matcher.group(QUERY_JOIN_ALIAS_GROUP_INDEX);
             if (StringUtils.hasText(alias))
                 result.add(alias);
         }

         return result;
     }

     /**
      * Returns the aliases used for aggregate functions like {@code SUM, COUNT, ...}.
      *
      * @param qry a {@literal String} containing a query. Must not be {@literal null}.
      * @return a {@literal Set} containing all found aliases. Guaranteed to be not {@literal null}.
      */
     static Set<String> getFunctionAliases(String qry) {
         Set<String> result = new HashSet<>();
         Matcher matcher = FUNCTION_PATTERN.matcher(qry);

         while (matcher.find()) {
             String alias = matcher.group(1);

             if (StringUtils.hasText(alias))
                 result.add(alias);
         }

         return result;
     }

     /**
      * Resolves the alias for the entity to be retrieved from the given JPA query.
      *
      * @param qry must not be {@literal null}.
      * @return Might return {@literal null}.
      */
     @Nullable
     static String detectAlias(String qry) {
         Matcher matcher = ALIAS_MATCH.matcher(qry);

         return matcher.find() ? matcher.group(2) : null;
     }

     /**
      * Creates a count projected query from the given original query.
      *
      * @param originalQry   must not be {@literal null}.
      * @param cntProjection may be {@literal null}.
      * @return a query String to be used a count query for pagination. Guaranteed to be not {@literal null}.
      */
     static String createCountQueryFor(String originalQry, @Nullable String cntProjection) {
         Assert.hasText(originalQry, "OriginalQuery must not be null or empty!");

         Matcher matcher = COUNT_MATCH.matcher(originalQry);
         String countQuery;

         if (cntProjection == null) {
             String variable = matcher.matches() ? matcher.group(VARIABLE_NAME_GROUP_INDEX) : null;
             boolean useVariable = variable != null && StringUtils.hasText(variable) && !variable.startsWith("new")
                 && !variable.startsWith("count(") && !variable.contains(",");

             String replacement = useVariable ? SIMPLE_COUNT_VALUE : COMPLEX_COUNT_VALUE;
             countQuery = matcher.replaceFirst(String.format(COUNT_REPLACEMENT_TEMPLATE, replacement));
         }
         else
             countQuery = matcher.replaceFirst(String.format(COUNT_REPLACEMENT_TEMPLATE, cntProjection));

         return countQuery.replaceFirst(ORDER_BY_PART, "");
     }

     /**
      * Returns whether the given JPQL query contains a constructor expression.
      *
      * @param qry must not be {@literal null} or empty.
      * @return boolean
      */
     public static boolean hasConstructorExpression(String qry) {
         Assert.hasText(qry, "Query must not be null or empty!");

         return CONSTRUCTOR_EXPRESSION.matcher(qry).find();
     }

     /**
      * Returns the projection part of the query, i.e. everything between {@code select} and {@code from}.
      *
      * @param qry must not be {@literal null} or empty.
      * @return projection
      */
     public static String getProjection(String qry) {
         Assert.hasText(qry, "Query must not be null or empty!");

         Matcher matcher = PROJECTION_CLAUSE.matcher(qry);
         String projection = matcher.find() ? matcher.group(1) : "";
         return projection.trim();
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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 org.apache.ignite.springdata22.repository.query;

	import java.util.HashSet;
	import java.util.Set;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;
	import java.util.stream.Collectors;
	import org.jetbrains.annotations.Nullable;
	import org.springframework.data.util.Streamable;
	import org.springframework.util.Assert;
	import org.springframework.util.StringUtils;

	import static java.util.regex.Pattern.CASE_INSENSITIVE;
	import static java.util.regex.Pattern.DOTALL;
	import static java.util.regex.Pattern.compile;

	/**
	* Simple utility class to create queries.
	*
	* @author Oliver Gierke
	* @author Kevin Raymond
	* @author Thomas Darimont
	* @author Komi Innocent
	* @author Christoph Strobl
	* @author Mark Paluch
	* @author Sébastien Péralta
	* @author Jens Schauder
	* @author Nils Borrmann
	* @author Reda.Housni -Alaoui
	*/
	public abstract class QueryUtils {
	/**
	* The constant COUNT_QUERY_STRING.
	*/
	public static final String COUNT_QUERY_STRING = "select count(%s) from %s x";

	/**
	* The constant DELETE_ALL_QUERY_STRING.
	*/
	public static final String DELETE_ALL_QUERY_STRING = "delete from %s x";

	/**
	* Used Regex/Unicode categories (see http://www.unicode.org/reports/tr18/#General_Category_Property): Z Separator
	* Cc Control Cf Format P Punctuation
	*/
	private static final String IDENTIFIER = "[._[\\P{Z}&&\\P{Cc}&&\\P{Cf}&&\\P{P}]]+";

	/**
	* The Colon no double colon.
	*/
	static final String COLON_NO_DOUBLE_COLON = "(?<![:\\\\]):";

	/**
	* The Identifier group.
	*/
	static final String IDENTIFIER_GROUP = String.format("(%s)", IDENTIFIER);

	/** */
	private static final String COUNT_REPLACEMENT_TEMPLATE = "select count(%s) $5$6$7";

	/** */
	private static final String SIMPLE_COUNT_VALUE = "$2";

	/** */
	private static final String COMPLEX_COUNT_VALUE = "$3$6";

	/** */
	private static final String ORDER_BY_PART = "(?iu)\\s+order\\s+by\\s+.*$";

	/** */
	private static final Pattern ALIAS_MATCH;

	/** */
	private static final Pattern COUNT_MATCH;

	/** */
	private static final Pattern PROJECTION_CLAUSE = Pattern
	.compile("select\\s+(.+)\\s+from", Pattern.CASE_INSENSITIVE);

	/** */
	private static final String JOIN = "join\\s+(fetch\\s+)?" + IDENTIFIER + "\\s+(as\\s+)?" + IDENTIFIER_GROUP;

	/** */
	private static final Pattern JOIN_PATTERN = Pattern.compile(JOIN, Pattern.CASE_INSENSITIVE);

	/** */
	private static final String EQUALS_CONDITION_STRING = "%s.%s = :%s";

	/** */
	private static final Pattern NAMED_PARAMETER = Pattern.compile(
	COLON_NO_DOUBLE_COLON + IDENTIFIER + "\|\\#" + IDENTIFIER, CASE_INSENSITIVE);

	/** */
	private static final Pattern CONSTRUCTOR_EXPRESSION;

	/** */
	private static final int QUERY_JOIN_ALIAS_GROUP_INDEX = 3;

	/** */
	private static final int VARIABLE_NAME_GROUP_INDEX = 4;

	/** */
	private static final Pattern FUNCTION_PATTERN;

	static {
	StringBuilder builder = new StringBuilder();
	builder.append("(?<=from)"); // from as starting delimiter
	builder.append("(?:\\s)+"); // at least one space separating
	builder.append(IDENTIFIER_GROUP); // Entity name, can be qualified (any
	builder.append("(?:\\sas)*"); // exclude possible "as" keyword
	builder.append("(?:\\s)+"); // at least one space separating
	builder.append("(?!(?:where))(\\w+)"); // the actual alias

	ALIAS_MATCH = compile(builder.toString(), CASE_INSENSITIVE);

	builder = new StringBuilder();
	builder.append("(select\\s+((distinct )?(.+?)?)\\s+)?(from\\s+");
	builder.append(IDENTIFIER);
	builder.append("(?:\\s+as)?\\s+)");
	builder.append(IDENTIFIER_GROUP);
	builder.append("(.*)");

	COUNT_MATCH = compile(builder.toString(), CASE_INSENSITIVE);

	builder = new StringBuilder();
	builder.append("select");
	builder.append("\\s+"); // at least one space separating
	builder.append("(.*\\s+)?"); // anything in between (e.g. distinct) at least one space separating
	builder.append("new");
	builder.append("\\s+"); // at least one space separating
	builder.append(IDENTIFIER);
	builder.append("\\s*"); // zero to unlimited space separating
	builder.append("\\(");
	builder.append(".*");
	builder.append("\\)");

	CONSTRUCTOR_EXPRESSION = compile(builder.toString(), CASE_INSENSITIVE + DOTALL);

	builder = new StringBuilder();
	// any function call including parameters within the brackets
	builder.append("\\w+\\s*\\([\\w\\.,\\s'=]+\\)");
	// the potential alias
	builder.append("\\s+[as\|AS]+\\s+(([\\w\\.]+))");

	FUNCTION_PATTERN = compile(builder.toString());
	}

	/**
	* Private constructor to prevent instantiation.
	*/
	private QueryUtils() {
	// No-op.
	}

	/**
	* Returns the query string to execute an exists query for the given id attributes.
	*
	* @param entityName the name of the entity to create the query for, must not be {@literal null}.
	* @param cntQryPlaceHolder the placeholder for the count clause, must not be {@literal null}.
	* @param idAttrs the id attributes for the entity, must not be {@literal null}.
	* @return the exists query string
	*/
	public static String getExistsQueryString(String entityName,
	String cntQryPlaceHolder,
	Iterable<String> idAttrs) {
	String whereClause = Streamable.of(idAttrs).stream() //
	.map(idAttribute -> String.format(EQUALS_CONDITION_STRING, "x", idAttribute,
	idAttribute)) //
	.collect(Collectors.joining(" AND ", " WHERE ", ""));

	return String.format(COUNT_QUERY_STRING, cntQryPlaceHolder, entityName) + whereClause;
	}

	/**
	* Returns the query string for the given class name.
	*
	* @param template must not be {@literal null}.
	* @param entityName must not be {@literal null}.
	* @return the template with placeholders replaced by the {@literal entityName}. Guaranteed to be not {@literal
	* null}.
	*/
	public static String getQueryString(String template, String entityName) {
	Assert.hasText(entityName, "Entity name must not be null or empty!");

	return String.format(template, entityName);
	}

	/**
	* Returns the aliases used for {@code left (outer) join}s.
	*
	* @param qry a query string to extract the aliases of joins from. Must not be {@literal null}.
	* @return a {@literal Set} of aliases used in the query. Guaranteed to be not {@literal null}.
	*/
	static Set<String> getOuterJoinAliases(String qry) {
	Set<String> result = new HashSet<>();
	Matcher matcher = JOIN_PATTERN.matcher(qry);

	while (matcher.find()) {
	String alias = matcher.group(QUERY_JOIN_ALIAS_GROUP_INDEX);
	if (StringUtils.hasText(alias))
	result.add(alias);
	}

	return result;
	}

	/**
	* Returns the aliases used for aggregate functions like {@code SUM, COUNT, ...}.
	*
	* @param qry a {@literal String} containing a query. Must not be {@literal null}.
	* @return a {@literal Set} containing all found aliases. Guaranteed to be not {@literal null}.
	*/
	static Set<String> getFunctionAliases(String qry) {
	Set<String> result = new HashSet<>();
	Matcher matcher = FUNCTION_PATTERN.matcher(qry);

	while (matcher.find()) {
	String alias = matcher.group(1);

	if (StringUtils.hasText(alias))
	result.add(alias);
	}

	return result;
	}

	/**
	* Resolves the alias for the entity to be retrieved from the given JPA query.
	*
	* @param qry must not be {@literal null}.
	* @return Might return {@literal null}.
	*/
	@Nullable
	static String detectAlias(String qry) {
	Matcher matcher = ALIAS_MATCH.matcher(qry);

	return matcher.find() ? matcher.group(2) : null;
	}

	/**
	* Creates a count projected query from the given original query.
	*
	* @param originalQry must not be {@literal null}.
	* @param cntProjection may be {@literal null}.
	* @return a query String to be used a count query for pagination. Guaranteed to be not {@literal null}.
	*/
	static String createCountQueryFor(String originalQry, @Nullable String cntProjection) {
	Assert.hasText(originalQry, "OriginalQuery must not be null or empty!");

	Matcher matcher = COUNT_MATCH.matcher(originalQry);
	String countQuery;

	if (cntProjection == null) {
	String variable = matcher.matches() ? matcher.group(VARIABLE_NAME_GROUP_INDEX) : null;
	boolean useVariable = variable != null && StringUtils.hasText(variable) && !variable.startsWith("new")
	&& !variable.startsWith("count(") && !variable.contains(",");

	String replacement = useVariable ? SIMPLE_COUNT_VALUE : COMPLEX_COUNT_VALUE;
	countQuery = matcher.replaceFirst(String.format(COUNT_REPLACEMENT_TEMPLATE, replacement));
	}
	else
	countQuery = matcher.replaceFirst(String.format(COUNT_REPLACEMENT_TEMPLATE, cntProjection));

	return countQuery.replaceFirst(ORDER_BY_PART, "");
	}

	/**
	* Returns whether the given JPQL query contains a constructor expression.
	*
	* @param qry must not be {@literal null} or empty.
	* @return boolean
	*/
	public static boolean hasConstructorExpression(String qry) {
	Assert.hasText(qry, "Query must not be null or empty!");

	return CONSTRUCTOR_EXPRESSION.matcher(qry).find();
	}

	/**
	* Returns the projection part of the query, i.e. everything between {@code select} and {@code from}.
	*
	* @param qry must not be {@literal null} or empty.
	* @return projection
	*/
	public static String getProjection(String qry) {
	Assert.hasText(qry, "Query must not be null or empty!");

	Matcher matcher = PROJECTION_CLAUSE.matcher(qry);
	String projection = matcher.find() ? matcher.group(1) : "";
	return projection.trim();
	}
	}