/** * Return a filter that negates the given filter. */ protected Filter negate(Filter filter) { return Filter.not(addExplicitNullChecks(filter)); }
/** * 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; }
/** * Internal method for generating where clause for given search. Uses filter * options from search. */ protected String generateWhereClause(SearchContext ctx, List<Filter> filters, boolean isDisjunction) { String content = null; if (filters == null || filters.size() == 0) { return ""; } else if (filters.size() == 1) { content = filterToQL(ctx, filters.get(0)); } else { Filter junction = new Filter(null, filters, isDisjunction ? Filter.OP_OR : Filter.OP_AND); content = filterToQL(ctx, junction); } return (content == null) ? "" : " where " + content; }
/** * Internal method for generating from clause. This method should be called * after generating other clauses because it relies on the aliases they * create. This method takes every path that is called for in the other * clauses and makes it available as an alias using left joins. It also adds * join fetching for properties specified by <code>fetches</code> if * <code>doEagerFetching</code> is <code>true</code>. <b>NOTE:</b> When * using eager fetching, <code>applyFetches()</code> must be executed first. */ protected String generateFromClause(SearchContext ctx, boolean doEagerFetching) { StringBuilder sb = new StringBuilder(" from "); sb.append(getMetadataUtil().get(ctx.rootClass).getEntityName()); sb.append(" "); sb.append(ctx.getRootAlias()); sb.append(generateJoins(ctx, doEagerFetching)); return sb.toString(); }
value = prepareValue(ctx.rootClass, property, value, true); } else if (filter.isTakesSingleValue()) { value = prepareValue(ctx.rootClass, property, value, false); return getPathRef(ctx, property) + " is null"; case Filter.OP_NOT_NULL: return getPathRef(ctx, property) + " is not null"; case Filter.OP_IN: return getPathRef(ctx, property) + " in (" + param(ctx, value) + ")"; case Filter.OP_NOT_IN: return getPathRef(ctx, property) + " not in (" + param(ctx, value) + ")"; case Filter.OP_EQUAL: return getPathRef(ctx, property) + " = " + param(ctx, value); case Filter.OP_NOT_EQUAL: return getPathRef(ctx, property) + " != " + param(ctx, value); case Filter.OP_GREATER_THAN: return getPathRef(ctx, property) + " > " + param(ctx, value); case Filter.OP_LESS_THAN: return getPathRef(ctx, property) + " < " + param(ctx, value); case Filter.OP_GREATER_OR_EQUAL: return getPathRef(ctx, property) + " >= " + param(ctx, value); case Filter.OP_LESS_OR_EQUAL: return getPathRef(ctx, property) + " <= " + param(ctx, value); case Filter.OP_LIKE: return getPathRef(ctx, property) + " like " + param(ctx, value.toString()); case Filter.OP_ILIKE: return "lower(" + getPathRef(ctx, property) + ") like lower(" + param(ctx, value.toString()) + ")"; case Filter.OP_AND: case Filter.OP_OR:
String where = generateWhereClause(ctx, checkAndCleanFilters(search.getFilters()), search.isDisjunction()); String from = generateFromClause(ctx, false); sb.append(ctx.getRootAlias()); } else { sb.append(getPathRef(ctx, prop));
String where = generateWhereClause(ctx2, filters, false); String joins = generateJoins(ctx2, false); ctx.nextAliasNum = ctx2.nextAliasNum; ctx.nextSubqueryNum = ctx2.nextSubqueryNum; sb.append(getPathRef(ctx, property)); sb.append(" "); sb.append(ctx2.getRootAlias());
sb.append("null"); } else { appendCustomExpression(sb, ctx, field.getProperty()); prop = ctx.getRootAlias(); } else { AliasNode aliasNodeForProperty = getAliasForPathIfItExists(ctx, field.getProperty()); if (aliasNodeForProperty != null) { prop = aliasNodeForProperty.alias; } else { prop = getPathRef(ctx, field.getProperty());
appendCustomExpression(sb, ctx, sort.getProperty()); } else if (sort.isIgnoreCase() && metadataUtil.get(ctx.rootClass, sort.getProperty()).isString()) { sb.append("lower("); sb.append(getPathRef(ctx, sort.getProperty())); sb.append(")"); } else { sb.append(getPathRef(ctx, sort.getProperty()));