Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2009 Mysema Ltd.
   * All rights reserved.
   * 
   */
  package com.mysema.query.jdoql;
  
 import java.util.List;
 
 import  javax.jdo.PersistenceManager;
 import  javax.jdo.Query;
 
 
Abstract base class for custom implementations of the JDOQLQuery interface.

Parameters:
<SubType>
Author(s):
tiwe
 
 public abstract class AbstractJDOQLQuery<SubType extends AbstractJDOQLQuery<SubType>> extends QueryBaseWithProjection<Object, SubType> implements Projectable {
 
     private static final Logger logger = LoggerFactory.getLogger(JDOQLQueryImpl.class);
 
     private List<Objectconstants;
 
     private List<Query> queries = new ArrayList<Query>(2);
     
     private List<PEntity<?>> sources = new ArrayList<PEntity<?>>();
 
     private String filter;
 
     private final JDOQLPatterns patterns;
 
     private final PersistenceManager pm;
     
     public AbstractJDOQLQuery(PersistenceManager pm) {
         this(pm.);
     }
 
     public AbstractJDOQLQuery(PersistenceManager pmJDOQLPatterns patterns) {
         this. = patterns;
         this. = pm;
     }
 
     @Override
     protected SubType addToProjection(Expr<?>... o) {
         for (Expr<?> expr : o) {
             if (expr instanceof EConstructor) {
                 EConstructor<?> constructor = (EConstructor<?>) expr;
                 for (Expr<?> arg : constructor.getArgs()) {
                     super.addToProjection(arg);
                 }
             } else {
                 super.addToProjection(expr);
             }
         }
         return ;
     }
 
     public SubType from(PEntity<?>... o) {
         for (PEntity<?> expr : o) {
             .add(expr);
         }
         return ;
     }
 
     private String buildFilterString(boolean forCountRow) {
         if (getMetadata().getWhere() == null) {
             return null;
         }
         JDOQLSerializer serializer = new JDOQLSerializer(.get(0));
         serializer.handle(getMetadata().getWhere());
          = serializer.getConstants();
         ..println("SERIALIZED : " + serializer.toString());
         return serializer.toString();
     }
 
     @Override
     protected void clear() {
         super.clear();
          = null;
     }
    public long count() {
        String filterString = getFilterString();
        .debug("query : {}"filterString);
        Query query = createQuery(filterStringnulltrue);
        query.setUnique(true);
        if (getMetadata().isDistinct()){
            query.setResult("distinct count(this)");
        }else{
            query.setResult("count(this)");    
        }        
        return (Longexecute(query);
    }
    private Query createQuery(String filterStringQueryModifiers modifiersboolean forCount) {        
        Query query = .newQuery(.get(0).getType());        
        .add(query);
        if (filterString != null) {
            query.setFilter(filterString);
        }
        // variables
        if (.size() > 1) {
            StringBuffer buffer = new StringBuffer();
            for (int i = 1; i < .size(); i++) {
                if (buffer.length() > 0) {
                    buffer.append(", ");
                }
                PEntity<?> source = .get(i);
                buffer.append(source.getType().getName()).append(" ").append(
                        source.toString());
            }
        }
        // explicit parameters
        if ( != null) {
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < .size(); i++) {
                if (builder.length() > 0) {
                    builder.append(", ");
                }
                Object val = .get(i);
                builder.append(val.getClass().getName()).append(" ").append(
                        "a" + (i + 1));
            }
            query.declareParameters(builder.toString());
        }
        
        if (!getMetadata().getGroupBy().isEmpty()){
            List<? extends Expr<?>> groupBy = getMetadata().getGroupBy();
            JDOQLSerializer serializer = new JDOQLSerializer(.get(0));
            serializer.handle(", "groupBy);
            if (getMetadata().getHaving() != null){
                EBoolean having = getMetadata().getHaving();
                serializer.append(" having ").handle(having);
            }
            query.setGrouping(serializer.toString());
        }
        // range (not for count)
        if (modifiers != null && modifiers.isRestricting() && !forCount) {
            long fromIncl = 0;
            long toExcl = .;
            if (modifiers.getOffset() != null) {
                fromIncl = modifiers.getOffset().longValue();
            }
            if (modifiers.getLimit() != null) {
                toExcl = fromIncl + modifiers.getLimit().longValue();
            }
            query.setRange(fromIncltoExcl);
        }
        // projection (not for count)
        if (!getMetadata().getProjection().isEmpty() && !forCount) {
            List<? extends Expr<?>> projection = getMetadata().getProjection();
            if (projection.size() > 1 || !projection.get(0).equals(.get(0))) {
                JDOQLSerializer serializer = new JDOQLSerializer(.get(0));      
                if (getMetadata().isDistinct()){
                    serializer.append("distinct ");
                }
                serializer.handle(", "projection);
                query.setResult(serializer.toString());
            }else if (getMetadata().isDistinct()){
                query.setResult("distinct this");
            }
        }
        
        // TODO : distinct results
        // order (not for count)
        if (!getMetadata().getOrderBy().isEmpty() && !forCount) {
            List<OrderSpecifier<?>> order = getMetadata().getOrderBy();
            JDOQLSerializer serializer = new JDOQLSerializer(.get(0));
            boolean first = true;
            for (OrderSpecifier<?> os : order) {
                if (!first) {
                    serializer.append(", ");
                }
                serializer.handle(os.getTarget());
                serializer.append(os.getOrder() == . ? " ascending" : "descending");
                first = false;
            }
            query.setOrdering(serializer.toString());
        }
        return query;
    }
    protected List<ObjectgetConstants() {
        return ;
    }
    public Iterator<Object[]> iterate(Expr<?> e1Expr<?> e2Expr<?>... rest) {
        // TODO : optimize
        return list(e1e2rest).iterator();
    }
    public <RT> Iterator<RT> iterate(Expr<RT> projection) {
        // TODO : optimize
        return list(projection).iterator();
    }
    @SuppressWarnings("unchecked")
    public List<Object[]> list(Expr<?> expr1Expr<?> expr2Expr<?>... rest) {
        addToProjection(expr1expr2);
        addToProjection(rest);
        String filterString = getFilterString();
        return (List<Object[]>) execute(createQuery(filterStringgetMetadata().getModifiers(), false));
    }
    private Object execute(Query query) {
        Object rv;
        if ( != null) {
            rv = query.executeWithArray(.toArray());
        } else {
            rv = query.execute();
        }
        // query.closeAll();
        return rv;
    }
    @SuppressWarnings("unchecked")
    public <RT> List<RT> list(Expr<RT> expr) {
        addToProjection(expr);
        String filterString = getFilterString();
        .debug("query : {}"filterString);
        return (List<RT>) execute(createQuery(filterStringgetMetadata().getModifiers(), false));
    }
    @SuppressWarnings("unchecked")
    public <RT> SearchResults<RT> listResults(Expr<RT> expr) {
        addToProjection(expr);
        Query countQuery = createQuery(getFilterString(), nulltrue);
        countQuery.setUnique(true);
        countQuery.setResult("count(this)");
        long total = (Longexecute(countQuery);
        if (total > 0) {
            QueryModifiers modifiers = getMetadata().getModifiers();
            String filterString = getFilterString();
            .debug("query : {}"filterString);
            Query query = createQuery(filterStringmodifiersfalse);
            return new SearchResults<RT>((List<RT>) execute(query), modifiers,
                    total);
        } else {
            return SearchResults.emptyResults();
        }
    }
    private String getFilterString() {
        if ( == null) {
             = buildFilterString(false);
        }
        return ;
    }
    @SuppressWarnings("unchecked")
    public <RT> RT uniqueResult(Expr<RT> expr) {
        addToProjection(expr);
        String filterString = getFilterString();
        .debug("query : {}"filterString);
        Query query = createQuery(filterString, QueryModifiers.limit(1), false);
        query.setUnique(true);
        return (RT) execute(query);
    }
    public void close() throws IOException {
        for (Query query : ){
            query.closeAll();
        }        
    }
New to GrepCode? Check out our FAQ X