private final void compileIfNeeded() {
//
// Check: if is alread compiled, there is no need to compile it again
if (_compiled) {
return;
}
//
// Check: if we have no filters, we can set the status right away
if (filters.isEmpty()) {
_sqlWhereClause = isDefaultAccept() ? DEFAULT_SQL_TRUE : DEFAULT_SQL_FALSE;
_sqlFilters = Collections.emptyList();
_nonSqlFilters = null;
_compiled = true;
return;
}
final List<ISqlQueryFilter> resultSqlFilters = new ArrayList<ISqlQueryFilter>();
final StringBuilder resultSqlWhereClause = new StringBuilder();
final List<IQueryFilter<T>> resultNonSqlFilters = new ArrayList<IQueryFilter<T>>();
final List<IQueryFilter<T>> resultAllFiltersSoFar =
new ArrayList<IQueryFilter<T>>(filters.size());
boolean allowSqlFilters = true; // do we allow SQL filter?
for (final IQueryFilter<T> filter : filters) {
final List<ISqlQueryFilter> sqlFilters;
final List<IQueryFilter<T>> nonSqlFilters;
//
// Case: we are not accepting SQL filters
// => no point to check forward but treat this filter as a nonSQL filter
if (!allowSqlFilters) {
sqlFilters = null;
nonSqlFilters = Collections.singletonList(filter);
}
//
// Case: Composite Filter (SQL and non-SQL)
else if (filter instanceof ICompositeQueryFilter) {
final ICompositeQueryFilter<T> compositeFilter = (ICompositeQueryFilter<T>) filter;
// Case: our composite is a pure SQL filter
if (compositeFilter.isPureSql()) {
final ISqlQueryFilter sqlFilter = compositeFilter.asSqlQueryFilter();
sqlFilters = Collections.singletonList(sqlFilter);
nonSqlFilters = null;
}
// Case: our composite is not a pure SQL filter but it's join method is AND
// => we can mix this kind of filters
else if (compositeFilter.isJoinAnd() == this.isJoinAnd() == true) {
sqlFilters = compositeFilter.getSqlFilters();
nonSqlFilters = compositeFilter.getNonSqlFilters();
}
// Case: our composite is not a pure SQL filter and it's join method is not AND
// => we cannot mix SQL and nonSQL in this way so we consider the whole compositeFilter as
// non-sql
else {
sqlFilters = null;
nonSqlFilters = Collections.<IQueryFilter<T>>singletonList(compositeFilter);
}
}
//
// Case: Pure SQL Filter
else if (filter instanceof ISqlQueryFilter) {
final ISqlQueryFilter sqlFilter = (ISqlQueryFilter) filter;
sqlFilters = Collections.singletonList(sqlFilter);
nonSqlFilters = null;
}
//
// Case: non-SQL filter:
else {
sqlFilters = null;
nonSqlFilters = Collections.singletonList(filter);
}
//
// Append the SQL Part (if any)
appendSqlWhereClause(resultSqlWhereClause, resultSqlFilters, sqlFilters);
//
// Append Non-SQL part (if any)
if (nonSqlFilters != null && !nonSqlFilters.isEmpty()) {
resultNonSqlFilters.addAll(nonSqlFilters);
}
//
// Update our all filters so far list
resultAllFiltersSoFar.add(filter);
//
// Case: Until now we allowed SQL filters but our join method is not AND
// ... and we already have SQL Filters and nonSQL filters accumulated
//
// => make all filters as nonSQL
// => clear "resultNonSqlFilters" and "resultSqlWhereClause" because we will not use them from
// now on
// => don't allow SQL filters from now on
if (allowSqlFilters
&& !this.isJoinAnd()
&& !resultSqlFilters.isEmpty()
&& !resultNonSqlFilters.isEmpty()) {
resultNonSqlFilters.clear();
resultNonSqlFilters.addAll(resultAllFiltersSoFar);
resultSqlFilters.clear();
resultSqlWhereClause.setLength(0);
// we are not allowing mixing filters anymore
// => we allow only nonSQL filters; all SQL filters will be considered nonSQL from now on
allowSqlFilters = false;
}
}
this._sqlFilters = Collections.unmodifiableList(resultSqlFilters);
this._nonSqlFilters = Collections.unmodifiableList(resultNonSqlFilters);
this._sqlWhereClause = resultSqlWhereClause.toString();
this._compiled = true;
}
