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.io.Closeable;
 import java.util.List;
 import java.util.Set;
 
 import  javax.annotation.Nullable;
 import  javax.jdo.PersistenceManager;
 import  javax.jdo.Query;
 
Abstract base class for custom implementations of the JDOQLQuery interface.

Parameters:
<Q>
Author(s):
tiwe
 
 public abstract class AbstractJDOQLQuery<Q extends AbstractJDOQLQuery<Q>> extends ProjectableQuery<Q> implements Closeable{
 
     private final boolean detach;
 
     private List<ObjectorderedConstants = new ArrayList<Object>();
 
     @Nullable
     private final PersistenceManager persistenceManager;
 
     private List<Query> queries = new ArrayList<Query>(2);
 
     private final JDOQLTemplates templates;
     
     private Set<StringfetchGroups = new HashSet<String>();
     
     @Nullable
     private Integer maxFetchDepth;
 
     public AbstractJDOQLQuery(@Nullable PersistenceManager persistenceManager) {
         this(persistenceManager.new DefaultQueryMetadata(), false);
     }
 
     @SuppressWarnings("unchecked")
     public AbstractJDOQLQuery(
             @Nullable PersistenceManager persistenceManager,
             JDOQLTemplates templates,
             QueryMetadata metadataboolean detach) {
         super(new QueryMixin<Q>(metadata));
         this..setSelf((Q) this);
         this. = templates;
         this. = persistenceManager;
         this. = detach;
     }
 
     @SuppressWarnings("unchecked")
     public Q addFetchGroup(String fetchGroupName) {
         .add(fetchGroupName);
         return (Q)this;
     }
 
     public void close() throws IOException {
         for (Query query : ){
             query.closeAll();
         }
     }
 
     public long count() {
         Query query = createQuery(true);
         query.setUnique(true);
         reset();
         Long rv = (Longexecute(query);
         if (rv != null){
             return rv.longValue();
         }else{
             throw new QueryException("Query returned null");
         }
     }
 
    private Query createQuery(boolean forCount) {
        Expr<?> source = .getMetadata().getJoins().get(0).getTarget();
        // serialize
        JDOQLSerializer serializer = new JDOQLSerializer(getTemplates(), source);
        serializer.serialize(.getMetadata(), forCountfalse);
        // create Query
        Query query = .newQuery(serializer.toString());
         = serializer.getConstants();
        .add(query);
        if (!forCount){
            List<? extends Expr<?>> projection = .getMetadata().getProjection();
            Class<?> exprType = projection.get(0).getClass();
            if (exprType.equals(QTuple.class)){
                query.setResultClass(JDOTuple.class);
            } else if (exprType.equals(EConstructor.class)){
                query.setResultClass(projection.get(0).getType());
            }
            
            if (!.isEmpty()){
                query.getFetchPlan().setGroups();
            }
            if ( != null){
                query.getFetchPlan().setMaxFetchDepth();
            }
        }
        return query;
    }
    @SuppressWarnings("unchecked")
    private <T> T detach(T results){
        if (results instanceof Collection){
            return (T) .detachCopyAll(results);
        }else{
            return .detachCopy(results);
        }
    }
    private Object execute(Query query) {
        Object rv;
        if (!.isEmpty()) {
            rv = query.executeWithArray(.toArray());
        } else {
            rv = query.execute();
        }
        if (isDetach()){
            rv = detach(rv);
        }
        return rv;
    }
    public Q from(PEntity<?>... args) {
        return .from(args);
    }
    public QueryMetadata getMetadata(){
        return .getMetadata();
    }
    public JDOQLTemplates getTemplates() {
        return ;
    }
    public boolean isDetach() {
        return ;
    }
    public CloseableIterator<Object[]> iterate(Expr<?>[] args) {
        return new ResultIterator<Object[]>(list(args).iterator(), this);
    }
    public <RT> CloseableIterator<RT> iterate(Expr<RT> projection) {
        return new ResultIterator<RT>(list(projection).iterator(), this);
    }
    @SuppressWarnings("unchecked")
    public List<Object[]> list(Expr<?>[] args) {
        .addToProjection(args);
        Object rv = execute(createQuery(false));
        reset();
        return (rv instanceof List) ? ((List<Object[]>)rv) : Collections.singletonList((Object[])rv);
    }
    @SuppressWarnings("unchecked")
    public <RT> List<RT> list(Expr<RT> expr) {
        .addToProjection(expr);
        Object rv = execute(createQuery(false));
        reset();
        return rv instanceof List ? (List<RT>)rv : Collections.singletonList((RT)rv);
    }
    @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);
            reset();
            return new SearchResults<RT>((List<RT>) execute(query), modifierstotal);
        } else {
            reset();
            return SearchResults.emptyResults();
        }
    }
    private void reset(){
        .getMetadata().reset();
    }
    @SuppressWarnings("unchecked")
    public Q setMaxFetchDepth(int depth) {
         = depth;
        return (Q)this;
    }
    
    @Override
    public String toString(){
        if (!.getMetadata().getJoins().isEmpty()){
            Expr<?> source = .getMetadata().getJoins().get(0).getTarget();
            JDOQLSerializer serializer = new JDOQLSerializer(getTemplates(), source);
            serializer.serialize(.getMetadata(), falsefalse);
            return serializer.toString().trim();
        }else{
            return super.toString();
        }
    }
    @SuppressWarnings("unchecked")
    public <RT> RT uniqueResult(Expr<RT> expr) {
        .addToProjection(expr);
        Query query = createQuery(false);
        query.setUnique(true);
        reset();
        return (RT) execute(query);
    }
New to GrepCode? Check out our FAQ X