Coverage Report - org.apache.camel.component.jpa.QueryBuilder
 
Classes in this File Line Coverage Branch Coverage Complexity
QueryBuilder
27% 
20% 
0
 
 1  
 /**
 2  
  * Licensed to the Apache Software Foundation (ASF) under one or more
 3  
  * contributor license agreements.  See the NOTICE file distributed with
 4  
  * this work for additional information regarding copyright ownership.
 5  
  * The ASF licenses this file to You under the Apache License, Version 2.0
 6  
  * (the "License"); you may not use this file except in compliance with
 7  
  * the License.  You may obtain a copy of the License at
 8  
  *
 9  
  *      http://www.apache.org/licenses/LICENSE-2.0
 10  
  *
 11  
  * Unless required by applicable law or agreed to in writing, software
 12  
  * distributed under the License is distributed on an "AS IS" BASIS,
 13  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 14  
  * See the License for the specific language governing permissions and
 15  
  * limitations under the License.
 16  
  */
 17  
 package org.apache.camel.component.jpa;
 18  
 
 19  
 import java.util.Arrays;
 20  
 import java.util.Collection;
 21  
 import java.util.Map;
 22  
 import java.util.Set;
 23  
 
 24  
 import javax.persistence.EntityManager;
 25  
 import javax.persistence.Query;
 26  
 
 27  
 /**
 28  
  * A builder of query expressions
 29  
  * 
 30  
  * @version $Revision: 563665 $
 31  
  */
 32  3
 public abstract class QueryBuilder implements QueryFactory {
 33  
     ParameterBuilder parameterBuilder;
 34  
 
 35  
     /**
 36  
      * Creates a query builder using the JPA query syntax
 37  
      * 
 38  
      * @param query JPA query language to create
 39  
      * @return a query builder
 40  
      */
 41  
     public static QueryBuilder query(final String query) {
 42  2
         return new QueryBuilder() {
 43  
             protected Query makeQueryObject(EntityManager entityManager) {
 44  2
                 return entityManager.createQuery(query);
 45  
             }
 46  
 
 47  
             @Override
 48  2
             public String toString() {
 49  0
                 return "Query: " + query + " params: " + getParameterDescription();
 50  
             }
 51  
         };
 52  
     }
 53  
 
 54  
     /**
 55  
      * Creates a named query
 56  
      */
 57  
     public static QueryBuilder namedQuery(final String namedQuery) {
 58  1
         return new QueryBuilder() {
 59  
             protected Query makeQueryObject(EntityManager entityManager) {
 60  3
                 return entityManager.createNamedQuery(namedQuery);
 61  
             }
 62  
 
 63  
             @Override
 64  1
             public String toString() {
 65  0
                 return "Named: " + namedQuery + getParameterDescription();
 66  
             }
 67  
         };
 68  
     }
 69  
 
 70  
     /**
 71  
      * Creates a native SQL query
 72  
      */
 73  
     public static QueryBuilder nativeQuery(final String nativeQuery) {
 74  0
         return new QueryBuilder() {
 75  
             protected Query makeQueryObject(EntityManager entityManager) {
 76  0
                 return entityManager.createNativeQuery(nativeQuery);
 77  
             }
 78  
 
 79  
             @Override
 80  0
             public String toString() {
 81  0
                 return "NativeQuery: " + nativeQuery + getParameterDescription();
 82  
             }
 83  
         };
 84  
     }
 85  
 
 86  
     /**
 87  
      * Specifies the parameters to the query
 88  
      * 
 89  
      * @param parameters the parameters to be configured on the query
 90  
      * @return this query builder
 91  
      */
 92  
     public QueryBuilder parameters(Object... parameters) {
 93  0
         return parameters(Arrays.asList(parameters));
 94  
     }
 95  
 
 96  
     /**
 97  
      * Specifies the parameters to the query as an ordered collection of
 98  
      * parameters
 99  
      * 
 100  
      * @param parameters the parameters to be configured on the query
 101  
      * @return this query builder
 102  
      */
 103  
     public QueryBuilder parameters(final Collection parameters) {
 104  0
         checkNoParametersConfigured();
 105  0
         parameterBuilder = new ParameterBuilder() {
 106  
             public void populateQuery(EntityManager entityManager, Query query) {
 107  0
                 int counter = 0;
 108  0
                 for (Object parameter : parameters) {
 109  0
                     query.setParameter(counter++, parameter);
 110  0
                 }
 111  0
             }
 112  
 
 113  
             @Override
 114  0
             public String toString() {
 115  0
                 return "Parameters: " + parameters;
 116  
             }
 117  
         };
 118  0
         return this;
 119  
     }
 120  
 
 121  
     /**
 122  
      * Specifies the parameters to the query as a Map of key/value pairs
 123  
      * 
 124  
      * @param parameterMap the parameters to be configured on the query
 125  
      * @return this query builder
 126  
      */
 127  
     public QueryBuilder parameters(final Map<String, Object> parameterMap) {
 128  0
         checkNoParametersConfigured();
 129  0
         parameterBuilder = new ParameterBuilder() {
 130  
             public void populateQuery(EntityManager entityManager, Query query) {
 131  0
                 Set<Map.Entry<String, Object>> entries = parameterMap.entrySet();
 132  0
                 for (Map.Entry<String, Object> entry : entries) {
 133  0
                     query.setParameter(entry.getKey(), entry.getValue());
 134  0
                 }
 135  0
             }
 136  
 
 137  
             @Override
 138  0
             public String toString() {
 139  0
                 return "Parameters: " + parameterMap;
 140  
             }
 141  
         };
 142  0
         return this;
 143  
     }
 144  
 
 145  
     protected void checkNoParametersConfigured() {
 146  0
         if (parameterBuilder != null) {
 147  0
             throw new IllegalArgumentException("Cannot add parameters to a QueryBuilder which already has parameters configured");
 148  
         }
 149  0
     }
 150  
 
 151  
     public Query createQuery(EntityManager entityManager) {
 152  5
         Query query = makeQueryObject(entityManager);
 153  5
         populateQuery(entityManager, query);
 154  5
         return query;
 155  
     }
 156  
 
 157  
     protected String getParameterDescription() {
 158  0
         if (parameterBuilder == null) {
 159  0
             return "";
 160  
         } else {
 161  0
             return " " + parameterBuilder.toString();
 162  
         }
 163  
     }
 164  
 
 165  
     protected void populateQuery(EntityManager entityManager, Query query) {
 166  5
         if (parameterBuilder != null) {
 167  0
             parameterBuilder.populateQuery(entityManager, query);
 168  
         }
 169  5
     }
 170  
 
 171  
     protected abstract Query makeQueryObject(EntityManager entityManager);
 172  
 
 173  
     /**
 174  
      * A plugin strategy to populate the query with parameters
 175  
      */
 176  0
     protected abstract static class ParameterBuilder {
 177  
         public abstract void populateQuery(EntityManager entityManager, Query query);
 178  
     }
 179  
 }