public DelegatingQuery(Query query) 
{
        this(query, null);
}

Constructor; supply delegate.

 public DelegatingQuery(Query query,
    RuntimeExceptionTranslator trans) 
{
        _query = query;
        if (query instanceof DelegatingQuery)
            _del = (DelegatingQuery) query;
        else
            _del = null;
        _trans = trans;
}

Constructor; supply delegate and exception translator.

 public  void addAggregateListener(AggregateListener listener) 
{
        try {
            _query.addAggregateListener(listener);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void addFilterListener(FilterListener listener) 
{
        try {
            _query.addFilterListener(listener);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void assertNotReadOnly() 
{
        try {
            _query.assertNotReadOnly();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void assertNotSerialized() 
{
        try {
            _query.assertNotSerialized();
        } catch (RuntimeException re) {
            throw translate(re);
		}
}

 public  void assertOpen() 
{
        try {
            _query.assertOpen();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Class classForName(String name,
    String[] imports) 
{
        try {
            return _query.classForName(name, imports);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void closeAll() 
{
        try {
            _query.closeAll();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void closeResources() 
{
        try {
            _query.closeResources();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void compile() 
{
        try {
            _query.compile();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void declareParameters(String params) 
{
        try {
            _query.declareParameters(params);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public long deleteAll() 
{
        try {
            return _query.deleteAll();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public long deleteAll(Object[] parameters) 
{
        try {
            return _query.deleteAll(parameters);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public long deleteAll(Map parameterMap) 
{
        try {
            return _query.deleteAll(parameterMap);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Number deleteInMemory(StoreQuery q,
    StoreQuery.Executor ex,
    Object[] params) 
{
        try {
            return _query.deleteInMemory(q, ex, params);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public boolean equals(Object other) 
{
        if (other == this)
            return true;
        if (other instanceof DelegatingQuery)
            other = ((DelegatingQuery) other).getInnermostDelegate();
        return getInnermostDelegate().equals(other);
}

 public Object execute() 
{
        try {
            return _query.execute();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Object execute(Map params) 
{
        try {
            return _query.execute(params);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Object execute(Object[] params) 
{
        try {
            return _query.execute(params);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public ClassMetaData[] getAccessPathMetaDatas() 
{
        try {
            return _query.getAccessPathMetaDatas();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public AggregateListener getAggregateListener(String tag) 
{
        try {
            return _query.getAggregateListener(tag);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Collection getAggregateListeners() 
{
        try {
            return _query.getAggregateListeners();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public String getAlias() 
{
        try {
            return _query.getAlias();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Broker getBroker() 
{
        try {
            return _query.getBroker();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Collection getCandidateCollection() 
{
        try {
            return _query.getCandidateCollection();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Extent getCandidateExtent() 
{
        try {
            return _query.getCandidateExtent();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Class getCandidateType() 
{
        try {
            return _query.getCandidateType();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Object getCompilation() 
{
        try {
            return _query.getCompilation();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public String[] getDataStoreActions(Map params) 
{
        try {
            return _query.getDataStoreActions(params);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Query getDelegate() 
{
        return _query;
}

Return the direct delegate.

 public long getEndRange() 
{
        try {
            return _query.getEndRange();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public FetchConfiguration getFetchConfiguration() 
{
        try {
            return _query.getFetchConfiguration();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public FilterListener getFilterListener(String tag) 
{
        try {
            return _query.getFilterListener(tag);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Collection getFilterListeners() 
{
        try {
            return _query.getFilterListeners();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public boolean getIgnoreChanges() 
{
        try {
            return _query.getIgnoreChanges();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Query getInnermostDelegate() 
{
        return (_del == null) ? _query : _del.getInnermostDelegate();
}

Return the native delegate.

 public String getLanguage() 
{
        try {
            return _query.getLanguage();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public int getOperation() 
{
        try {
            return _query.getOperation();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public String getParameterDeclaration() 
{
        try {
            return _query.getParameterDeclaration();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public LinkedMap getParameterTypes() 
{
        try {
            return _query.getParameterTypes();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public String[] getProjectionAliases() 
{
        try {
            return _query.getProjectionAliases();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Class[] getProjectionTypes() 
{
        try {
            return _query.getProjectionTypes();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Query getQuery() 
{
        return this;
}

 public String getQueryString() 
{
        try {
            return _query.getQueryString();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public String getResultMappingName() 
{
        try {
            return _query.getResultMappingName();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Class getResultMappingScope() 
{
        try {
            return _query.getResultMappingScope();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Class getResultType() 
{
        try {
            return _query.getResultType();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public long getStartRange() 
{
        try {
            return _query.getStartRange();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public StoreContext getStoreContext() 
{
        try {
            return _query.getStoreContext();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Map getUpdates() 
{
        try {
            return _query.getUpdates();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public boolean hasGrouping() 
{
        try {
            return _query.hasGrouping();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public boolean hasSubclasses() 
{
        try {
            return _query.hasSubclasses();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

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

 public boolean isAggregate() 
{
        try {
            return _query.isAggregate();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public boolean isReadOnly() 
{
        try {
            return _query.isReadOnly();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public boolean isUnique() 
{
        try {
            return _query.isUnique();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void lock() 
{
        try {
            _query.lock();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void removeAggregateListener(AggregateListener listener) 
{
        try {
            _query.removeAggregateListener(listener);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void removeFilterListener(FilterListener listener) 
{
        try {
            _query.removeFilterListener(listener);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void setCandidateCollection(Collection coll) 
{
        try {
            _query.setCandidateCollection(coll);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void setCandidateExtent(Extent extent) 
{
        try {
            _query.setCandidateExtent(extent);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void setCandidateType(Class cls,
    boolean subs) 
{
        try {
            _query.setCandidateType(cls, subs);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void setIgnoreChanges(boolean ignore) 
{
        try {
            _query.setIgnoreChanges(ignore);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public boolean setQuery(Object query) 
{
        try {
            return _query.setQuery(query);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void setRange(long start,
    long end) 
{
        try {
            _query.setRange(start, end);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void setReadOnly(boolean readOnly) 
{
        try {
            _query.setReadOnly(readOnly);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void setResultMapping(Class scope,
    String name) 
{
        try {
            _query.setResultMapping(scope, name);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void setResultType(Class cls) 
{
        try {
            _query.setResultType(cls);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public  void setUnique(boolean unique) 
{
        try {
            _query.setUnique(unique);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 protected RuntimeException translate(RuntimeException re) 
{
        return (_trans == null) ? re : _trans.translate(re);
}

Translate the OpenJPA exception.

 public  void unlock() 
{
        try {
            _query.unlock();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public long updateAll() 
{
        try {
            return _query.updateAll();
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public long updateAll(Object[] parameters) 
{
        try {
            return _query.updateAll(parameters);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public long updateAll(Map parameterMap) 
{
        try {
            return _query.updateAll(parameterMap);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public Number updateInMemory(StoreQuery q,
    StoreQuery.Executor ex,
    Object[] params) 
{
        try {
            return _query.updateInMemory(q, ex, params);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}