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.annotation.Nullable;
 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 QueryBaseWithProjectionAndDetach<SubType> implements Projectable {
     
     private List<ObjectorderedConstants = new ArrayList<Object>();
 
     private List<Query> queries = new ArrayList<Query>(2);
     
     private final JDOQLPatterns patterns;
 
     @Nullable
     private final PersistenceManager pm;
     
     public AbstractJDOQLQuery(){
         this. = .;
         this. = null;
     }
     
     public AbstractJDOQLQuery(PersistenceManager pm) {
         this(pm.);
     }
 
     public AbstractJDOQLQuery(PersistenceManager pmJDOQLPatterns patterns) {
         this. = patterns;
         this. = pm;
     }
 
     @SuppressWarnings("unchecked")
     @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) {
         super.from(o);
         return ;
     }
 
     public <P> SubType from(PEntityCollection<P> targetPEntity<P> alias){
         super.from(createAlias(targetalias));
         return ;
     }
     
     private <D> Expr<D> createAlias(EEntity<?> targetPEntity<D> alias){
         return OSimple.create(alias.getType(), .targetalias);
     }
     
 //    @Override
 //    protected void clear() {
 //        super.clear();
 //    }
 
     public long count() {
         Query query = createQuery(true);
         query.setUnique(true);
         return (Longexecute(query);
    }
    private Query createQuery(boolean forCount) {        
        Expr<?> source = this.getMetadata().getJoins().get(0).getTarget();
        
        // serialize
        JDOQLSerializer serializer = new JDOQLSerializer(source);
        serializer.serialize(getMetadata(), forCountfalse);
        
        // create Query 
        Query query = .newQuery(serializer.toString());
         = serializer.getConstants();
        .add(query);               
        return query;
    }
    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);
        return (List<Object[]>) execute(createQuery(false));
    }
    private Object execute(Query query) {
        Object rv;
        if (!.isEmpty()) {
            rv = query.executeWithArray(.toArray());
        } else {
            rv = query.execute();
        }
        // query.closeAll();
        return rv;
    }
    @SuppressWarnings("unchecked")
    public <RT> List<RT> list(Expr<RT> expr) {
        addToProjection(expr);
        return (List<RT>) execute(createQuery(false));
    }
    @SuppressWarnings("unchecked")
    public <RT> SearchResults<RT> listResults(Expr<RT> expr) {
        addToProjection(expr);
        Query countQuery = createQuery(true);
        countQuery.setUnique(true);
        countQuery.setResult("count(this)");
        long total = (Longexecute(countQuery);
        if (total > 0) {
            QueryModifiers modifiers = getMetadata().getModifiers();
            Query query = createQuery(false);
            return new SearchResults<RT>((List<RT>) execute(query), modifiers,
                    total);
        } else {
            return SearchResults.emptyResults();
        }
    }
    @SuppressWarnings("unchecked")
    public <RT> RT uniqueResult(Expr<RT> expr) {
        addToProjection(expr);
        Query query = createQuery(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