public QueryImpl(EntityManagerImpl em,
    RuntimeExceptionTranslator ret,
    Query query) 
{
              
        _em = em;
        _query = new DelegatingQuery(query, ret);
}

Constructor; supply factory and delegate.

 public OpenJPAQuery addAggregateListener(AggregateListener listener) 
{
        _em.assertNotCloseInvoked();
        _query.addAggregateListener(listener);
        return this;
}

 public OpenJPAQuery addFilterListener(FilterListener listener) 
{
        _em.assertNotCloseInvoked();
        _query.addFilterListener(listener);
        return this;
}

 public OpenJPAQuery closeAll() 
{
        _query.closeAll();
        return this;
}

 public OpenJPAQuery compile() 
{
        _em.assertNotCloseInvoked();
        _query.compile();
        return this;
}

 public boolean equals(Object other) 
{
        if (other == this)
            return true;
        if (!(other instanceof QueryImpl))
            return false;
        return _query.equals(((QueryImpl) other)._query);
}

 public int executeUpdate() 
{
        _em.assertNotCloseInvoked();
        if (_query.getOperation() == QueryOperations.OP_DELETE) {
            // handle which types of parameters we are using, if any
            if (_positional != null)
                return asInt(_query.deleteAll(_positional.toArray()));
            if (_named != null)
                return asInt(_query.deleteAll(_named));
            return asInt(_query.deleteAll());
        }
        if (_query.getOperation() == QueryOperations.OP_UPDATE) {
            // handle which types of parameters we are using, if any
            if (_positional != null)
                return asInt(_query.updateAll(_positional.toArray()));
            if (_named != null)
                return asInt(_query.updateAll(_named));
            return asInt(_query.updateAll());
        }
        throw new InvalidStateException(_loc.get("not-update-delete-query",
            _query.getQueryString()), null, null, false);
}

 public Collection getCandidateCollection() 
{
        return _query.getCandidateCollection();
}

 public String[] getDataStoreActions(Map params) 
{
        return _query.getDataStoreActions(params);
}

 public Query getDelegate() 
{
        return _query.getDelegate();
}

Delegate.

 public OpenJPAEntityManager getEntityManager() 
{
        return _em;
}

 public FetchPlan getFetchPlan() 
{
        _em.assertNotCloseInvoked();
        _query.assertNotSerialized();
        _query.lock();
        try {
            if (_fetch == null)
                _fetch = ((EntityManagerFactoryImpl) _em.
                    getEntityManagerFactory()).toFetchPlan(_query.getBroker(),
                    _query.getFetchConfiguration());
            return _fetch;
        } finally {
            _query.unlock();
        }
}

 public int getFirstResult() 
{
        return asInt(_query.getStartRange());
}

 public FlushModeType getFlushMode() 
{
        return EntityManagerImpl.fromFlushBeforeQueries(_query.
            getFetchConfiguration().getFlushBeforeQueries());
}

 public boolean getIgnoreChanges() 
{
        return _query.getIgnoreChanges();
}

 public String getLanguage() 
{
        return _query.getLanguage();
}

 public int getMaxResults() 
{
        return asInt(_query.getEndRange() - _query.getStartRange());
}

 public Map getNamedParameters() 
{
        _query.lock();
        try {
            return (_named == null) ? Collections.EMPTY_MAP
                : Collections.unmodifiableMap(_named);
        } finally {
            _query.unlock();
        }
}

 public QueryOperationType getOperation() 
{
        return QueryOperationType.fromKernelConstant(_query.getOperation());
}

 public Object[] getPositionalParameters() 
{
        _query.lock();
        try {
            return (_positional == null) ? EMPTY_ARRAY : _positional.toArray();
        } finally {
            _query.unlock();
        }
}

 public String getQueryString() 
{
        return _query.getQueryString();
}

 public Class getResultClass() 
{
        Class res = _query.getResultType();
        if (res != null)
            return res;
        return _query.getCandidateType();
}

 public List getResultList() 
{
        _em.assertNotCloseInvoked();
        Object ob = execute();
        if (ob instanceof List) {
            List ret = (List) ob;
            if (ret instanceof ResultList)
                return new DelegatingResultList((ResultList) ret,
                    PersistenceExceptions.getRollbackTranslator(_em));
            else
                return ret;
        }
        return Collections.singletonList(ob);
}

 public Object getSingleResult() 
{
        _em.assertNotCloseInvoked();
        // temporarily set query to unique so that a single result is validated
        // and returned; unset again in case the user executes query again
        // via getResultList
        _query.setUnique(true);
        try {
            return execute();
        } finally {
            _query.setUnique(false);
        }
}

Execute a query that returns a single result.

 public boolean hasPositionalParameters() 
{
        return _positional != null;
}

 public boolean hasSubclasses() 
{
        return _query.hasSubclasses();
}

 public int hashCode() 
{
        return _query.hashCode();
}

 public OpenJPAQuery removeAggregateListener(AggregateListener listener) 
{
        _em.assertNotCloseInvoked();
        _query.removeAggregateListener(listener);
        return this;
}

 public OpenJPAQuery removeFilterListener(FilterListener listener) 
{
        _em.assertNotCloseInvoked();
        _query.removeFilterListener(listener);
        return this;
}

 public OpenJPAQuery setCandidateCollection(Collection coll) 
{
        _em.assertNotCloseInvoked();
        _query.setCandidateCollection(coll);
        return this;
}

 public OpenJPAQuery setFirstResult(int startPosition) 
{
        _em.assertNotCloseInvoked();
        long end;
        if (_query.getEndRange() == Long.MAX_VALUE)
            end = Long.MAX_VALUE;
        else
            end = startPosition +
                (_query.getEndRange() - _query.getStartRange());
        _query.setRange(startPosition, end);
        return this;
}

 public OpenJPAQuery setFlushMode(FlushModeType flushMode) 
{
        _em.assertNotCloseInvoked();
        _query.getFetchConfiguration().setFlushBeforeQueries
            (EntityManagerImpl.toFlushBeforeQueries(flushMode));
        return this;
}

 public OpenJPAQuery setHint(String key,
    Object value) 
{
        _em.assertNotCloseInvoked();
        if (key == null || !key.startsWith("openjpa."))
            return this;
        String k = key.substring("openjpa.".length());
        try {
            if ("Subclasses".equals(k)) {
                if (value instanceof String)
                    value = Boolean.valueOf((String) value);
                setSubclasses(((Boolean) value).booleanValue());
            } else if ("FilterListener".equals(k))
                addFilterListener(Filters.hintToFilterListener(value,
                    _query.getBroker().getClassLoader()));
            else if ("FilterListeners".equals(k)) {
                FilterListener[] arr = Filters.hintToFilterListeners(value,
                    _query.getBroker().getClassLoader());
                for (int i = 0; i <  arr.length; i++)
                    addFilterListener(arr[i]);
            } else if ("AggregateListener".equals(k))
                addAggregateListener(Filters.hintToAggregateListener(value,
                    _query.getBroker().getClassLoader()));
            else if ("FilterListeners".equals(k)) {
                AggregateListener[] arr = Filters.hintToAggregateListeners
                    (value, _query.getBroker().getClassLoader());
                for (int i = 0; i <  arr.length; i++)
                    addAggregateListener(arr[i]);
            } else if (k.startsWith("FetchPlan.")) {
                k = k.substring("FetchPlan.".length());
                hintToSetter(getFetchPlan(), k, value);
            } else if (k.startsWith("hint.")) {
                if ("hint.OptimizeResultCount".equals(k)) {
                    if (value instanceof String) {
                        try {
                            value = new Integer((String) value);
                        } catch (NumberFormatException nfe) {
                        }
                    }
                    if (!(value instanceof Number) 
                        || ((Number) value).intValue() <  0)
                        throw new ArgumentException(_loc.get
                            ("bad-query-hint-value", key, value), null, null, 
                            false);
                }
                _query.getFetchConfiguration().setHint(key, value);
            }
            else
                throw new ArgumentException(_loc.get("bad-query-hint", key),
                    null, null, false);
            return this;
        } catch (Exception e) {
            throw PersistenceExceptions.toPersistenceException(e);
        }
}

 public OpenJPAQuery setIgnoreChanges(boolean ignore) 
{
        _em.assertNotCloseInvoked();
        _query.setIgnoreChanges(ignore);
        return this;
}

 public OpenJPAQuery setMaxResults(int max) 
{
        _em.assertNotCloseInvoked();
        long start = _query.getStartRange();
        if (max == Integer.MAX_VALUE)
            _query.setRange(start, Long.MAX_VALUE);
        else
            _query.setRange(start, start + max);
        return this;
}

 public OpenJPAQuery setParameter(int position,
    Object value) 
{
        _query.assertOpen();
        _em.assertNotCloseInvoked();
        _query.lock();
        try {
            // not allowed to mix positional and named parameters (EDR2 3.6.4)
            if (_named != null)
                throw new InvalidStateException(_loc.get
                    ("no-pos-named-params-mix", _query.getQueryString()),
                    null, null, false);
            if (position <  1)
                throw new InvalidStateException(_loc.get
                    ("illegal-index", position), null, null, false);
            if (_positional == null)
                _positional = new ArrayList();
            // make sure it is at least the requested size
            while (_positional.size() <  position)
                _positional.add(null);
            // note that we add it to position - 1, since setPosition
            // starts at 1, while List starts at 0
            _positional.set(position - 1, value);
            return this;
        } finally {
            _query.unlock();
        }
}

 public OpenJPAQuery setParameter(String name,
    Object value) 
{
        _query.assertOpen();
        _em.assertNotCloseInvoked();
        _query.lock();
        try {
            // not allowed to mix positional and named parameters (EDR2 3.6.4)
            if (_positional != null)
                throw new InvalidStateException(_loc.get
                    ("no-pos-named-params-mix", _query.getQueryString()),
                    null, null, false);
            if (_named == null)
                _named = new HashMap();
            _named.put(name, value);
            return this;
        } finally {
            _query.unlock();
        }
}

 public OpenJPAQuery setParameter(int position,
    Calendar value,
    TemporalType t) 
{
        return setParameter(position, value);
}

 public OpenJPAQuery setParameter(int position,
    Date value,
    TemporalType type) 
{
        return setParameter(position, value);
}

 public OpenJPAQuery setParameter(String name,
    Calendar value,
    TemporalType t) 
{
        return setParameter(name, value);
}

 public OpenJPAQuery setParameter(String name,
    Date value,
    TemporalType type) 
{
        return setParameter(name, value);
}

 public OpenJPAQuery setParameters(Object params) 
{
        _query.assertOpen();
        _em.assertNotCloseInvoked();
        _query.lock();
        try {
            _positional = null;
            _named = null;
            if (params != null)
                for (int i = 0; i <  params.length; i++)
                    setParameter(i + 1, params[i]);
            return this;
        } finally {
            _query.unlock();
        }
}

 public OpenJPAQuery setParameters(Map params) 
{
        _query.assertOpen();
        _em.assertNotCloseInvoked();
        _query.lock();
        try {
            _positional = null;
            _named = null;
            if (params != null)
                for (Map.Entry e : (Set< Map.Entry >) params.entrySet())
                    setParameter((String) e.getKey(), e.getValue());
            return this;
        } finally {
            _query.unlock();
        }
}

 public OpenJPAQuery setResultClass(Class cls) 
{
        _em.assertNotCloseInvoked();
        if (ImplHelper.isManagedType(_em.getConfiguration(), cls))
            _query.setCandidateType(cls, true);
        else
            _query.setResultType(cls);
        return this;
}

 public OpenJPAQuery setSubclasses(boolean subs) 
{
        _em.assertNotCloseInvoked();
        Class cls = _query.getCandidateType();
        _query.setCandidateExtent(_query.getBroker().newExtent(cls, subs));
        return this;
}