src/persistence/org/codehaus/groovy/grails/orm/hibernate/metaclass/FindByPersistentMethod.java

   1 /* Copyright 2004-2005 the original author or authors.
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at
   6  *
   7  *      http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 package org.codehaus.groovy.grails.orm.hibernate.metaclass;
  16
  17 import org.codehaus.groovy.grails.commons.GrailsApplication;
  18 import org.codehaus.groovy.grails.orm.hibernate.cfg.GrailsHibernateUtil;
  19 import org.hibernate.Criteria;
  20 import org.hibernate.HibernateException;
  21 import org.hibernate.Session;
  22 import org.hibernate.SessionFactory;
  23 import org.hibernate.criterion.Restrictions;
  24 import org.hibernate.criterion.Disjunction;
  25 import org.springframework.orm.hibernate3.HibernateCallback;
  26
  27 import java.sql.SQLException;
  28 import java.util.Iterator;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.regex.Pattern;
  32
  33 /**
  34  * The "findBy*" static persistent method. This method allows querying for
  35  * instances of grails domain classes based on their properties. This method returns the first result of the query
  36  *
  37  * eg.
  38  * Account.findByHolder("Joe Blogs"); // Where class "Account" has a property called "holder"
  39  * Account.findByHolderAndBranch("Joe Blogs", "London" ); // Where class "Account" has a properties called "holder" and "branch"
  40  *
  41  * @author Graeme Rocher
  42  * @since 31-Aug-2005
  43  *
  44  */
  45 public class FindByPersistentMethod extends AbstractClausedStaticPersistentMethod {
  46
  47         private static final String OPERATOR_OR = "Or";
  48         private static final String OPERATOR_AND = "And";
  49
  50         private static final String METHOD_PATTERN = "(findBy)(\\w+)";
  51         private static final String[] OPERATORS = new String[]{ OPERATOR_AND, OPERATOR_OR };
  52
  53         public FindByPersistentMethod(GrailsApplication application,SessionFactory sessionFactory, ClassLoader classLoader) {
  54                 super(application,sessionFactory, classLoader, Pattern.compile( METHOD_PATTERN ),OPERATORS);
  55         }
  56
  57         protected Object doInvokeInternalWithExpressions(final Class clazz, String methodName, final Object[] arguments, final List expressions, String operatorInUse) {
  58
  59         final String operator = OPERATOR_OR.equals(operatorInUse) ? OPERATOR_OR : OPERATOR_AND;
  60         return super.getHibernateTemplate().execute( new HibernateCallback() {
  61
  62                         public Object doInHibernate(Session session) throws HibernateException, SQLException {
  63
  64
  65                                 Criteria crit = session.createCriteria(clazz);
  66                                 if(arguments.length > 0) {
  67                                         if(arguments[0] instanceof Map) {
  68                                                 Map argMap = (Map)arguments[0];
  69                                                 GrailsHibernateUtil.populateArgumentsForCriteria(crit,argMap);
  70                                         }
  71                                 }
  72                 if(operator.equals(OPERATOR_OR)) {
  73                     Disjunction dis = Restrictions.disjunction();
  74                     for (Iterator i = expressions.iterator(); i.hasNext();) {
  75                         GrailsMethodExpression current = (GrailsMethodExpression) i.next();
  76                         dis.add( current.getCriterion() );
  77                     }
  78                     crit.add(dis);
  79                 }
  80                 else {
  81                     for (Iterator i = expressions.iterator(); i.hasNext();) {
  82                         GrailsMethodExpression current = (GrailsMethodExpression) i.next();
  83                         crit.add( current.getCriterion() );
  84
  85                     }
  86                 }
  87                 crit.setMaxResults(1);
  88                 return crit.uniqueResult();
  89                         }
  90                 });
  91         }
  92
  93 }