ERP CRM SCM 等系统开发框架

/* Copyright 2013 David Wolverton * * 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.googlecode.genericdao.search; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * This class provides two methods for generating query language to fulfill an * <code>ISearch</code>. * <ol> * <li><code>generateQL()</code> - is used for getting the actual search * results.</li> * <li><code>generateRowCountQL()</code> - is used for getting just the number * of results.</li> * </ol> * Both methods return a query language sting and a list of values for filling * named parameters. For example the following query and parameter list might be * returned: * * <pre> * select _it from com.example.Cat _it * where _it.age &gt; :p1 and _it.name != :p2 * * parameter list: [3, 'Mittens'] * </pre> * * This is an abstract class. A subclass must be used to implement individual * query languages. Currently only HQL query language is supported ( * <code>com.googlecode.genericdao.dao.hibernate.HibernateSearchToQLProcessor</code>). The that * implementation could be used for EQL query language as well with no or minor * modifications. */ public abstract class BaseSearchProcessor { private static Logger logger = LoggerFactory.getLogger(BaseSearchProcessor.class); protected static int QLTYPE_HQL = 0; protected static int QLTYPE_EQL = 1; protected int qlType; protected MetadataUtil metadataUtil; protected String rootAlias = "_it"; protected static final String ROOT_PATH = ""; protected BaseSearchProcessor(int qlType, MetadataUtil metadataUtil) { if (metadataUtil == null) { throw new IllegalArgumentException("A SearchProcessor cannot be initialized with a null MetadataUtil."); } this.qlType = qlType; this.metadataUtil = metadataUtil; } /** * The MetadataUtil used by this search processor. This can only be set in * the constructor. */ public MetadataUtil getMetadataUtil() { return metadataUtil; } /** * This is the string used to represent the root entity of the search within * the query. The default value is <code>"_it"</code>. It may be necessary * to use a different alias if there are entities in the data model with the * name or property "_it". */ public void setRootAlias(String alias) { this.rootAlias = alias; } /** * Generate the QL string for a given search. Fill paramList with the values * to be used for the query. All parameters within the query string are * specified as named parameters ":pX", where X is the index of the * parameter value in paramList. */ public String generateQL(Class<?> entityClass, ISearch search, List<Object> paramList) { if (entityClass == null) throw new NullPointerException("The entity class for a search cannot be null"); SearchContext ctx = new SearchContext(entityClass, rootAlias, paramList); List<Field> fields = checkAndCleanFields(search.getFields()); applyFetches(ctx, checkAndCleanFetches(search.getFetches()), fields); String select = generateSelectClause(ctx, fields, search.isDistinct()); String where = generateWhereClause(ctx, checkAndCleanFilters(search.getFilters()), search.isDisjunction()); String orderBy = generateOrderByClause(ctx, checkAndCleanSorts(search.getSorts())); String from = generateFromClause(ctx, true); StringBuilder sb = new StringBuilder(); sb.append(select); sb.append(from); sb.append(where); sb.append(orderBy); String query = sb.toString(); if (logger.isDebugEnabled()) logger.debug("generateQL:\n " + query); return query; } /** * Generate the QL string that will query the total number of results from a * given search (paging is ignored). Fill paramList with the values to be * used for the query. All parameters within the query string are specified * as named parameters ":pX", where X is the index of the parameter value in * paramList. * * <b>NOTE:</b> Returns null if column operators are used in the search. * Such a search will always return 1 row. */ public String generateRowCountQL(Class<?> entityClass, ISearch search, List<Object> paramList) { if (entityClass == null) throw new NullPointerException("The entity class for a search cannot be null"); SearchContext ctx = new SearchContext(entityClass, rootAlias, paramList); String where = generateWhereClause(ctx, checkAndCleanFilters(search.getFilters()), search.isDisjunction()); String from = generateFromClause(ctx, false); boolean useOperator = false, notUseOperator = false; List<Field> fields = search.getFields(); if (fields != null) { for (Field field : fields) { switch (field.getOperator()) { case Field.OP_AVG: case Field.OP_COUNT: case Field.OP_COUNT_DISTINCT: case Field.OP_MAX: case Field.OP_MIN: case Field.OP_SUM: useOperator = true; break; default: notUseOperator = true; break; } } } if (useOperator && notUseOperator) { throw new Error("A search can not have a mix of fields with operators and fields without operators."); } else if (useOperator) { return null; // if we're using column operators, the query will // always return 1 result. } StringBuilder sb = new StringBuilder(); if (!search.isDistinct()) { sb.append("select count(").append(rootAlias).append(")"); } else if (fields.size() == 0) { sb.append("select count(distinct "); sb.append(rootAlias).append(")"); } else if (fields.size() == 1) { sb.append("select count(distinct "); String prop = fields.get(0).getProperty(); if (prop == null || "".equals(prop)) { sb.append(ctx.getRootAlias()); } else { sb.append(getPathRef(ctx, prop)); } sb.append(")"); } else { throw new IllegalArgumentException("Unfortunately, Hibernate Generic DAO does not currently support " + "the count operation on a search that has distinct set with multiple fields."); } sb.append(from); sb.append(where); String query = sb.toString(); if (logger.isDebugEnabled()) logger.debug("generateRowCountQL:\n " + query); return query; } /** * Internal method for generating the select clause based on the fields of * the given search. */ protected String generateSelectClause(SearchContext ctx, List<Field> fields, boolean distinct) { StringBuilder sb = null; boolean useOperator = false, notUseOperator = false; boolean first = true; if (fields != null) { for (Field field : fields) { if (first) { sb = new StringBuilder("select "); if (distinct) sb.append("distinct "); first = false; } else { sb.append(", "); } if (field.getOperator() == Field.OP_CUSTOM) { // Special case for custom operator. if (field.getProperty() == null) { sb.append("null"); } else { appendCustomExpression(sb, ctx, field.getProperty()); } } else { String prop; if (field.getProperty() == null || "".equals(field.getProperty())) { prop = ctx.getRootAlias(); } else { AliasNode aliasNodeForProperty = getAliasForPathIfItExists(ctx, field.getProperty()); if (aliasNodeForProperty != null) { prop = aliasNodeForProperty.alias; } else { prop = getPathRef(ctx, field.getProperty()); } } switch (field.getOperator()) { case Field.OP_AVG: sb.append("avg("); useOperator = tru