<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
   "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping >

<!--
create table testdata (id bigint not null, name varchar(200), level varchar(200));
create unique index nameidx on testdata (name);

create table hibernate_unique_key (next_hi INTEGER);
insert into hibernate_unique_key values (1);
-->

   <class name="rg.test.TestBean" table="testdata">
       <id name="id" type="long" column="id"  unsaved-value="0">
           <generator class="hilo"/>
       </id>
       <property name="name"   column="name"/>
       <property name="level"  column="level"/>
   </class>

   <filter-def name="levelFilter">
    <filter-param name="currentLevel" type="string"/>
   </filter-def>

</hibernate-mapping>

package rg.test;

public class TestBean {

   public TestBean(String name, String level) {
      this.name = name;
      this.level = level;
   }

   private long id;
   private String name;
   private String level;

   public String getLevel() {
      return level;
   }

   public String getName() {
      return name;
   }

   public void setId(long id) {
      this.id = id;
   }

   public void setLevel(String level) {
      this.level = level;
   }

   public void setName(String name) {
      this.name = name;
   }

   public long getId() {
      return id;
   }

   public TestBean() {}
}

package rg.test;

import org.hibernate.cfg.Configuration;
import org.hibernate.SessionFactory;
import org.hibernate.Session;
import java.util.Properties;
import org.hibernate.cfg.Environment;
import org.hibernate.Transaction;
import java.util.List;
import java.util.Iterator;
import org.hibernate.Query;

public class FilterTest {
   
   public static void main(String[] arg) {
      FilterTest ft = new FilterTest();
      ft.executeTest();
   }

   public FilterTest() {
   }

   public void executeTest() {
      initHibernate();
     
      createTestData();
     
      runTestWithoutFilter();
     
      runTestWithFilter();
     
      closeHibernate();
   }



   SessionFactory sessions;
   long NUM_QUERIES = 1000;

   private void initHibernate() {
      Properties properties = new Properties ();
      properties.setProperty (Environment.DRIVER, "org.gjt.mm.mysql.Driver" );
      properties.setProperty (Environment.URL, "jdbc:mysql://localhost/rgtest");
      properties.setProperty (Environment.USER, "root");
      properties.setProperty (Environment.PASS, "");
      properties.setProperty (Environment.DIALECT, "org.hibernate.dialect.MySQLDialect");

      Configuration cfg = new Configuration();
      cfg.addProperties(properties);
      cfg.addClass(TestBean.class);
      sessions = cfg.buildSessionFactory();
   }

   private void closeHibernate() {
      sessions.close();
   }
   
   private void createTestData(){
      Session session = sessions.openSession();
      Transaction tx = session.beginTransaction();
      Iterator iter  = session.createQuery("from TestBean").iterate();
      while (iter.hasNext()) {
         session.delete(iter.next());
      }
      tx.commit();
     
      tx = session.beginTransaction();
      for (int i=0; i < NUM_QUERIES;  i++) {
         TestBean t = new TestBean("Name " + i, "Level-" + (i / 10));
         session.persist(t);
      }
      tx.commit();
      session.close();
   }

   private void runTestWithoutFilter() {
      long st = System.currentTimeMillis();
      for (int i=0; i < NUM_QUERIES;  i++) {
         Session session = sessions.openSession();
         Query q = session.createQuery("from TestBean where name = ?");
         String name = "Name " + i;
         q.setParameter(0, name);
         List l = q.list();
         TestBean tb = (TestBean)l.get(0);
         session.close();
      }

      System.out.println("Time no filter = " + (System.currentTimeMillis() - st));
   }

   private void runTestWithFilter(){
      long st = System.currentTimeMillis();
      for (int i=0; i < NUM_QUERIES;  i++) {
         Session session = sessions.openSession();

         session.enableFilter("levelFilter").setParameter("currentLevel", "Level-" + (i / 10));       
         Query q = session.createQuery("from TestBean where name = ?");
         String name = "Name " + i;
         q.setParameter(0, name);
         List l = q.list();
         TestBean tb = (TestBean)l.get(0);
         session.close();
      }

      System.out.println("Time with filter = " + (System.currentTimeMillis() - st));
   }

}

public QueryTranslator[] getQuery(String queryString, boolean shallow, Map enabledFilters)

   public QueryTranslator[] getQuery(String queryString, boolean shallow, Map enabledFilters)
   throws QueryException, MappingException {

      // if there are no enabled filters, consider cached query compilations,
      // otherwise generate/compile a new set of query translators
      Object cacheKey = null;
      QueryTranslator[] queries = null;

      if ( enabledFilters == null || enabledFilters.isEmpty() ) {
         cacheKey = QUERY_KEY_FACTORY.newInstance(queryString, shallow);
         queries = (QueryTranslator[]) get(cacheKey);
      } else {
         // Include the filters in the cacheKey, this allows for different versions of the queries
         // to be cached if the filters are enabled or not, and also is based on the specific filters
         // that are enabled.
         String filtersKey = "";
         Iterator iter = enabledFilters.keySet().iterator();
         while (iter.hasNext()) {
            filtersKey += ((String)iter.next());
         }
         // Create the cache key with the filter names enabled.
         cacheKey = QUERY_KEY_FACTORY.newInstance(queryString+"|"+filtersKey, shallow);
         queries = (QueryTranslator[]) get(cacheKey);
         if (queries != null) {
            for (int i=0; i<queries.length; i++ ) {
               // Replace the filters to ensure that the current values are used.
               queries[i].getEnabledFilters().putAll(enabledFilters);
            }
         }
      }

      // have to be careful to ensure that if the JVM does out-of-order execution
      // then another threacd can't get an uncompiled QueryTranslator from the cache
      // we also have to be very careful to ensure that other threads can perform
      // compiled queries while another query is being compiled

      if ( queries==null ) {
         // a query that names an interface or unmapped class in the from clause
         // is actually executed as multiple queries
         String[] concreteQueryStrings = QuerySplitter.concreteQueries(queryString, this);
         queries = createQueryTranslators(concreteQueryStrings, cacheKey, enabledFilters);
      }
      for ( int i=0; i<queries.length; i++) {
//         queries[i].compile(this, settings.getQuerySubstitutions(), shallow, enabledFilters);
         queries[i].compile( settings.getQuerySubstitutions(), shallow );
      }
      // see comment above. note that QueryTranslator.compile() is synchronized
      return queries;
   }