Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (c) 2010 Mysema Ltd.
   * All rights reserved.
   *
   */
  package com.mysema.query.jdoql.sql;
  
  import java.io.Closeable;
 import java.util.List;
 
 import  javax.annotation.Nullable;
 import  javax.jdo.PersistenceManager;
 import  javax.jdo.Query;
 
 
JDOSQLQuery is an SQLQuery implementation that uses JDO's SQL query functionality to execute queries

Author(s):
tiwe
 
 public final class JDOSQLQuery extends AbstractSQLQuery<JDOSQLQueryimplements SQLCommonQuery<JDOSQLQuery>, Closeable{
     
     private static final Logger logger = LoggerFactory.getLogger(JDOSQLQuery.class);
 
     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 SQLTemplates templates;
 
     public JDOSQLQuery(@Nullable PersistenceManager persistenceManagerSQLTemplates templates) {
         this(persistenceManagertemplatesnew DefaultQueryMetadata(), false);
     }
 
     public JDOSQLQuery(
             @Nullable PersistenceManager persistenceManager,
             SQLTemplates templates,
             QueryMetadata metadataboolean detach) {
         super(metadata);
         this. = templates;
         this. = persistenceManager;
         this. = detach;
     }
 
     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) {
         SQLSerializer serializer = new SQLSerializer();
         serializer.serialize(.getMetadata(), forCount);
 
         // create Query
         if (.isDebugEnabled()){
             .debug(serializer.toString());
         }
         Query query = .newQuery("javax.jdo.query.SQL",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());
            }
        }else{
            query.setResultClass(Long.class);
        }
        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 QueryMetadata getMetadata(){
        return .getMetadata();
    }
    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);
        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();
    }
    @Override
    public String toString(){
        if (!.getMetadata().getJoins().isEmpty()){
            SQLSerializer serializer = new SQLSerializer();
            serializer.serialize(.getMetadata(), false);
            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