Nested Hibernate Filters

Nested Hibernate Filters

Hibernate added a feature that is not part of the JPA, and this is filters.
When you want to load information from the database but want to filter the data, you can use HQL, @Where or filters.
HQL is good if your filter is limited to the query that you need. If you always want to filter the class you can add to the class the @Where. In the cases that you sometimes want to filter and sometimes not, or you need to parameterize the filtering then you use the @Filters.
It feels like all the features of filtering were an afterthought by hibernate. The reason is that hibernate does not use the field names for the filtering or @Where but uses the database field name. The reason they do this, is that it is easy to add to the sql statement the where statement, and they do not have to parse the class objects.
Another oversight on the filter issue is nested filters. Hibernate does not care how many times you enable the filter, one disable will disable it in any case. Also if you change the parameter of a filter that is already open hibernate has no problem and will update the fiter.

Take the following case:

Enable filter, date: 1/1/2000
Load data
Enable filter, date: 1/1/1999
Load data
                Disable filter
Load data
Disable filter
 
In this scenario we have two problems. Once the disable filter is called there is no open filter so the third load data will run with no filter at all. Even if the filter was not closed we would still have the problem that the date of the filter is incorrect, since it is set for 1999 and not 2000.
To solve this issue we need to implement a stack of filters per filter name and store them on the local thread (so that our genericdao is thread safe).

FilterInfo Class

The first class will hold the parameters of the filter and what is the nested count (how many times has the enable been called for the same filter with the same parameters):
public class FilterInfo {
       private int nestedCount;
       private Map<String, Object> parameters = new HashMap<String, Object>();
      
             
       public FilterInfo(Map<String, Object> parameters) {
              super();
              this.parameters = parameters;
       }
 
      
       public boolean areParametersTheSame(Map<String, Object> currentParameters) {
              if (parameters.size() > 0) {
                     // check old parameters, see if changed
                     for (String paramName : parameters.keySet()) {
                           for (String currentparamName : currentParameters.keySet()) {
                                  if (paramName.equals(currentparamName)) {
                                         Object newValue = parameters.get(paramName);
                                         Object oldValue = currentParameters.get(paramName);
                                         if (!newValue.equals(oldValue)) {
                                                return false;
                                         }
                                  }
                           }
                     }
              }
              return true;
       }
 
       public int decNestedCount() {
              nestedCount--;
              return nestedCount;
       }
 
       public int incNestedCount() {
              nestedCount++;
              return nestedCount;
       }
 
       public Map<String, Object> getParameters() {
              return parameters;
       }
 
       public int getNestedCount() {
              return nestedCount;
       }
 
}
 

FilterStack Class

This class will store a stack of the parameters per filter so that we can re enable the filter with the correct parameters once a nested filter is disabled.
public class FilterStack {
       private String filterName;
       private Stack<FilterInfo> filterStack = new Stack<FilterInfo>();
 
       public FilterStack(String filterName) {
              this.filterName = filterName;
       }
 
       public FilterInfo setParameters(Map<String, Object> parameters) {
              boolean areParametersTheSame = false;
              FilterInfo filterInfo = null;
              if (filterStack.size() > 0) {
                     filterInfo = filterStack.peek();
                     areParametersTheSame = filterInfo.areParametersTheSame(parameters);
              }
              if (!areParametersTheSame) {
                     // add a new stack
                     filterInfo = new FilterInfo(parameters);
                     filterStack.push(filterInfo);
              }
              filterInfo.incNestedCount();
              return filterInfo;
       }
 
       public FilterInfo disableFilter() {
              if (filterStack.size()==0) {
                     throw new InfraException("you are closing a filter that is not open: " + filterName);
              }
              FilterInfo peek = filterStack.peek();
              if (peek != null) {
                     int decNestedCount = peek.decNestedCount();
                     if (decNestedCount <= 0) {
                           filterStack.pop();
                           return filterStack.size()>0 ?  filterStack.peek() : null;
                     }
              }
              return peek;
       }
 
}
 

NestedFilterInfo Class

The last class will be stored on the local thread, and will hold all the information for all the open filters.
public class NestedFilterInfo {
       private Map<String, FilterStack> filtersByName = new HashMap<String, FilterStack>();
 
       public FilterInfo enableFilter(String filterName, Map<String, Object> parameters) {
              // get current filter information
              FilterStack filterStack = filtersByName.get(filterName);
              if (filterStack == null) {
                     filterStack = new FilterStack(filterName);
                     filtersByName.put(filterName, filterStack);
              }
 
              // check if filter parameters have changed.
              return filterStack.setParameters(parameters);
       }
 
       public FilterInfo disableFilter(String filterName) {
              FilterStack filterStack = filtersByName.get(filterName);
              return filterStack.disableFilter();
       }
      
       public Set<String> getFilterNames() {
              return filtersByName.keySet();
       }
 
       public void clear() {
              filtersByName.clear();           
       }
}
 
 

GenericDao class

In the generic dao class that actually opens and closes the filter will use these classes to manage all open filters. The function to enable a filter will call:
public void enableFilter(String filterName, Map<String, Object> mapParameters) {
NestedFilterInfo filterStack = getFilterStack();
       FilterInfo enableFilter = filterStack.enableFilter(filterName, mapParameters);
       sessionEnableFilter(filterName, enableFilter.getParameters());
}
 
private void sessionEnableFilter(String filterName, Map<String, Object> mapParameters) {
       Filter filter = session().enableFilter(filterName);
       Object value;
       if (mapParameters != null) {
              for (Map.Entry<String, Object> entryParameters : mapParameters.entrySet()) {
                     value = entryParameters.getValue();
                     filter.setParameter(entryParameters.getKey(), value);
              }
       }
}
 
The enabling filter is the easy part. For every enable filter if no parameters have changed we will increment the counter on the FilterInfo class. If the parameters have changed we will create a new FIlterInfo and add it to the stack in the FilterStack.
The magic is done in the disable filter:
public void disableFilter(String filterName) {
       NestedFilterInfo filterStack = getFilterStack();
       FilterInfo filterInfo = filterStack.disableFilter(filterName);
       if (filterInfo == null || filterInfo.getNestedCount() <= 0) {
              session().disableFilter(filterName);
       } else {
              sessionEnableFilter(filterName, filterInfo.getParameters());
       }
}
 
Here we call the disable and get a FilterInfo class. If the nested count is down to zero then we have finished the stack and called the disable the same amount as the enable so we will close the filter on the session. If not then either the stack count went down by one, or we got the previous filter that was open. In either case we update the session filter with the parameters, and this way we have reverted the filter to the previous one.
This solution support both nested filters with the same parameters (only after the last disable with the filter really be closed) and nested filters with different parameters (with the new parameters the session will be updated, and on the disable filter the previous parameters will be returned to the session).
 
 
 
 
 
 


 
Backend/Data Architect

Backend Group
Thank you for your interest!

We will contact you as soon as possible.

Send us a message

Oops, something went wrong
Please try again or contact us by email at info@tikalk.com