<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JDOQLTypedQuery (JDO API 3.2.1)</title>
<link rel="stylesheet" type="text/css" href="../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="JDOQLTypedQuery (JDO API 3.2.1)";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":6,"i1":6,"i2":6,"i3":6,"i4":6,"i5":6,"i6":6,"i7":18,"i8":6,"i9":6,"i10":6,"i11":6,"i12":6,"i13":6,"i14":6,"i15":6,"i16":6,"i17":6,"i18":6,"i19":6,"i20":6,"i21":6,"i22":6,"i23":6,"i24":6,"i25":6,"i26":6,"i27":6,"i28":6,"i29":6,"i30":6,"i31":6,"i32":6,"i33":6,"i34":6,"i35":6,"i36":6,"i37":6,"i38":6,"i39":6,"i40":6,"i41":18,"i42":6,"i43":18,"i44":6,"i45":18,"i46":6,"i47":6,"i48":6,"i49":6,"i50":6,"i51":6,"i52":6,"i53":6,"i54":6,"i55":6,"i56":6,"i57":6,"i58":6,"i59":6,"i60":6,"i61":6,"i62":6,"i63":6,"i64":6,"i65":6};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance Methods"],4:["t3","Abstract Methods"],16:["t5","Default Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/JDOQLTypedQuery.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../index-all.html">Index</a></li>
<li><a href="../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../javax/jdo/JDOOptimisticVerificationException.html" title="class in javax.jdo"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../javax/jdo/JDOQLTypedSubquery.html" title="interface in javax.jdo"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../index.html?javax/jdo/JDOQLTypedQuery.html" target="_top">Frames</a></li>
<li><a href="JDOQLTypedQuery.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">javax.jdo</div>
<h2 title="Interface JDOQLTypedQuery" class="title">Interface JDOQLTypedQuery&lt;T&gt;</h2>
</div>
<div class="contentContainer">
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>T</code> - candidate type for this query</dd>
</dl>
<dl>
<dt>All Superinterfaces:</dt>
<dd><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/AutoCloseable.html?is-external=true" title="class or interface in java.lang">AutoCloseable</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/io/Closeable.html?is-external=true" title="class or interface in java.io">Closeable</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html?is-external=true" title="class or interface in java.io">Serializable</a></dd>
</dl>
<hr>
<br>
<pre>public interface <span class="typeNameLabel">JDOQLTypedQuery&lt;T&gt;</span>
extends <a href="https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html?is-external=true" title="class or interface in java.io">Serializable</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/io/Closeable.html?is-external=true" title="class or interface in java.io">Closeable</a></pre>
<div class="block">Interface for a type-safe refactorable JDOQL query, using a fluent API, based around expressions.
 Note that a JDOQLTypedQuery only supports named parameters, and the values of these parameters
 should be set using the relevant setter methods prior to execution, and that the values for the 
 parameters will only be retained until the subsequent query execution.</div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- =========== FIELD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Field Summary table, listing fields, and an explanation">
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Field and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#QUERY_CLASS_PREFIX">QUERY_CLASS_PREFIX</a></span></code>&nbsp;</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t3" class="tableTab"><span><a href="javascript:show(4);">Abstract Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t5" class="tableTab"><span><a href="javascript:show(16);">Default Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#cancel-java.lang.Thread-">cancel</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html?is-external=true" title="class or interface in java.lang">Thread</a>&nbsp;thread)</code>
<div class="block">Method to cancel an executing query in the specified thread.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#cancelAll--">cancelAll</a></span>()</code>
<div class="block">Method to cancel any executing queries.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/query/PersistableExpression.html" title="interface in javax.jdo.query">PersistableExpression</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#candidate--">candidate</a></span>()</code>
<div class="block">Method to return an expression for the candidate of the query.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/query/CharacterExpression.html" title="interface in javax.jdo.query">CharacterExpression</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#characterParameter-java.lang.String-">characterParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Method to return a character parameter for the query.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#close-java.lang.Object-">close</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;result)</code>
<div class="block">Method to close the specified query result.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#closeAll--">closeAll</a></span>()</code>
<div class="block">Method to close all query results from this query.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/query/CollectionExpression.html" title="interface in javax.jdo.query">CollectionExpression</a>&lt;?,?&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#collectionParameter-java.lang.String-">collectionParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Method to return a collection parameter for the query.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>default &lt;E&gt;&nbsp;<a href="../../javax/jdo/query/CollectionExpression.html" title="interface in javax.jdo.query">CollectionExpression</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;E&gt;,E&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#collectionParameter-java.lang.String-java.lang.Class-">collectionParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                   <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;E&gt;&nbsp;elementType)</code>
<div class="block">Method to return a collection parameter for the query.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#datastoreReadTimeoutMillis-java.lang.Integer-">datastoreReadTimeoutMillis</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true" title="class or interface in java.lang">Integer</a>&nbsp;interval)</code>
<div class="block">Set the datastore read timeout (millis).</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#datastoreWriteTimeoutMillis-java.lang.Integer-">datastoreWriteTimeoutMillis</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true" title="class or interface in java.lang">Integer</a>&nbsp;interval)</code>
<div class="block">Set the datastore write timeout (millis).</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/query/DateExpression.html" title="interface in javax.jdo.query">DateExpression</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#dateParameter-java.lang.String-">dateParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Method to return a date parameter for the query.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/query/DateTimeExpression.html" title="interface in javax.jdo.query">DateTimeExpression</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#datetimeParameter-java.lang.String-">datetimeParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Method to return a datetime parameter for the query.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code>long</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#deletePersistentAll--">deletePersistentAll</a></span>()</code>
<div class="block">Method to execute the query deleting the affected instances.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#excludeSubclasses--">excludeSubclasses</a></span>()</code>
<div class="block">Method to remove subclasses (of the candidate) from the query</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#executeList--">executeList</a></span>()</code>
<div class="block">Method to execute the query where there are (potentially) multiple rows and we are returning the candidate type.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#executeResultList--">executeResultList</a></span>()</code>
<div class="block">Method to execute the query where there are (potentially) multiple rows and we have a result defined but no result class.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;R&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#executeResultList-java.lang.Class-">executeResultList</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;R&gt;&nbsp;resultCls)</code>
<div class="block">Method to execute the query where there are (potentially) multiple rows and we are returning either the result type.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#executeResultUnique--">executeResultUnique</a></span>()</code>
<div class="block">Method to execute the query where there is a single row and we have a result defined but no result class.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;R</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#executeResultUnique-java.lang.Class-">executeResultUnique</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;R&gt;&nbsp;resultCls)</code>
<div class="block">Method to execute the query where there is a single row and we are returning either the result type.</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#executeUnique--">executeUnique</a></span>()</code>
<div class="block">Method to execute the query where there is a single row and we are returning the candidate type.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#extension-java.lang.String-java.lang.Object-">extension</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
         <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;value)</code>
<div class="block">Specify an extension for this query.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#extensions-java.util.Map-">extensions</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&nbsp;values)</code>
<div class="block">Specify a map of extensions for this query.</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#filter-javax.jdo.query.BooleanExpression-">filter</a></span>(<a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;expr)</code>
<div class="block">Method to set the filter of the query.</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true" title="class or interface in java.lang">Integer</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#getDatastoreReadTimeoutMillis--">getDatastoreReadTimeoutMillis</a></span>()</code>
<div class="block">Get the effective timeout setting for read operations.</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true" title="class or interface in java.lang">Integer</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#getDatastoreWriteTimeoutMillis--">getDatastoreWriteTimeoutMillis</a></span>()</code>
<div class="block">Get the effective timeout setting for write operations.</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/FetchPlan.html" title="interface in javax.jdo">FetchPlan</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#getFetchPlan--">getFetchPlan</a></span>()</code>
<div class="block">Accessor for the FetchPlan for this query</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#getIgnoreCache--">getIgnoreCache</a></span>()</code>
<div class="block">Get the ignoreCache option setting.</div>
</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/PersistenceManager.html" title="interface in javax.jdo">PersistenceManager</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#getPersistenceManager--">getPersistenceManager</a></span>()</code>
<div class="block">Accessor for the PersistenceManager for this query</div>
</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Boolean.html?is-external=true" title="class or interface in java.lang">Boolean</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#getSerializeRead--">getSerializeRead</a></span>()</code>
<div class="block">Return the current value of the serializeRead property.</div>
</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#groupBy-javax.jdo.query.Expression...-">groupBy</a></span>(<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;...&nbsp;exprs)</code>
<div class="block">Method to set the grouping(s) for the query.</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#having-javax.jdo.query.Expression-">having</a></span>(<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;&nbsp;expr)</code>
<div class="block">Method to set the having clause of the query.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#ifThen-javax.jdo.query.BooleanExpression-V-">ifThen</a></span>(<a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
      V&nbsp;thenValue)</code>
<div class="block">Method to return an "IF (...) ...</div>
</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#ifThen-java.lang.Class-javax.jdo.query.BooleanExpression-javax.jdo.query.Expression-">ifThen</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;V&gt;&nbsp;type,
      <a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
      <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;thenValueExpr)</code>
<div class="block">Method to return an "IF (...) ...</div>
</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#ifThenElse-javax.jdo.query.BooleanExpression-javax.jdo.query.Expression-V-">ifThenElse</a></span>(<a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
          <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;thenValueExpr,
          V&nbsp;elseValue)</code>
<div class="block">Method to return an "IF (...) ...</div>
</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#ifThenElse-javax.jdo.query.BooleanExpression-V-javax.jdo.query.Expression-">ifThenElse</a></span>(<a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
          V&nbsp;thenValue,
          <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;elseValueExpr)</code>
<div class="block">Method to return an "IF (...) ...</div>
</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#ifThenElse-javax.jdo.query.BooleanExpression-V-V-">ifThenElse</a></span>(<a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
          V&nbsp;thenValue,
          V&nbsp;elseValue)</code>
<div class="block">Method to return an "IF (...) ...</div>
</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#ifThenElse-java.lang.Class-javax.jdo.query.BooleanExpression-javax.jdo.query.Expression-javax.jdo.query.Expression-">ifThenElse</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;V&gt;&nbsp;type,
          <a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
          <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;thenValueExpr,
          <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;elseValueExpr)</code>
<div class="block">Method to return an "IF (...) ...</div>
</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#ignoreCache-boolean-">ignoreCache</a></span>(boolean&nbsp;flag)</code>
<div class="block">Set whether we to ignore the cache with this query.</div>
</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#includeSubclasses--">includeSubclasses</a></span>()</code>
<div class="block">Method to include subclasses (of the candidate) to the query</div>
</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code>boolean</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#isUnmodifiable--">isUnmodifiable</a></span>()</code>
<div class="block">The unmodifiable flag, when set, disallows further modification of the query, 
 except for specifying the range, result class, and ignoreCache option.</div>
</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/query/ListExpression.html" title="interface in javax.jdo.query">ListExpression</a>&lt;?,?&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#listParameter-java.lang.String-">listParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Method to return a list parameter for the query.</div>
</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code>default &lt;E&gt;&nbsp;<a href="../../javax/jdo/query/ListExpression.html" title="interface in javax.jdo.query">ListExpression</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;E&gt;,E&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#listParameter-java.lang.String-java.lang.Class-">listParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
             <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;E&gt;&nbsp;elementType)</code>
<div class="block">Method to return a list parameter for the query.</div>
</td>
</tr>
<tr id="i42" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/query/MapExpression.html" title="interface in javax.jdo.query">MapExpression</a>&lt;?,?,?&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#mapParameter-java.lang.String-">mapParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Method to return a map parameter for the query.</div>
</td>
</tr>
<tr id="i43" class="rowColor">
<td class="colFirst"><code>default &lt;K,V&gt;&nbsp;<a href="../../javax/jdo/query/MapExpression.html" title="interface in javax.jdo.query">MapExpression</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;K,V&gt;,K,V&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#mapParameter-java.lang.String-java.lang.Class-java.lang.Class-">mapParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
            <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;K&gt;&nbsp;keyType,
            <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;V&gt;&nbsp;valueType)</code>
<div class="block">Method to return a map parameter for the query.</div>
</td>
</tr>
<tr id="i44" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/query/NumericExpression.html" title="interface in javax.jdo.query">NumericExpression</a>&lt;?&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#numericParameter-java.lang.String-">numericParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Method to return a numeric parameter for the query.</div>
</td>
</tr>
<tr id="i45" class="rowColor">
<td class="colFirst"><code>default &lt;N&gt;&nbsp;<a href="../../javax/jdo/query/NumericExpression.html" title="interface in javax.jdo.query">NumericExpression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#numericParameter-java.lang.String-java.lang.Class-">numericParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;N&gt;&nbsp;type)</code>
<div class="block">Method to return a numeric parameter for the query.</div>
</td>
</tr>
<tr id="i46" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#orderBy-javax.jdo.query.OrderExpression...-">orderBy</a></span>(<a href="../../javax/jdo/query/OrderExpression.html" title="interface in javax.jdo.query">OrderExpression</a>&lt;?&gt;...&nbsp;orderExprs)</code>
<div class="block">Method to set the ordering of the query.</div>
</td>
</tr>
<tr id="i47" class="rowColor">
<td class="colFirst"><code>&lt;P&gt;&nbsp;<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;P&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#parameter-java.lang.String-java.lang.Class-">parameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
         <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;P&gt;&nbsp;type)</code>
<div class="block">Method to return a parameter for the query.</div>
</td>
</tr>
<tr id="i48" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#range-javax.jdo.query.Expression-javax.jdo.query.Expression-">range</a></span>(<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;&nbsp;paramLowerInclExpr,
     <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;&nbsp;paramUpperExclExpr)</code>
<div class="block">Method to set the range of any required results, using parameters (expressions).</div>
</td>
</tr>
<tr id="i49" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#range-long-long-">range</a></span>(long&nbsp;lowerIncl,
     long&nbsp;upperExcl)</code>
<div class="block">Method to set the range of any required results, using long values.</div>
</td>
</tr>
<tr id="i50" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#range-javax.jdo.query.NumericExpression-javax.jdo.query.NumericExpression-">range</a></span>(<a href="../../javax/jdo/query/NumericExpression.html" title="interface in javax.jdo.query">NumericExpression</a>&lt;?&gt;&nbsp;lowerInclExpr,
     <a href="../../javax/jdo/query/NumericExpression.html" title="interface in javax.jdo.query">NumericExpression</a>&lt;?&gt;&nbsp;upperExclExpr)</code>
<div class="block">Method to set the range of any required results, using expressions.</div>
</td>
</tr>
<tr id="i51" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#result-boolean-javax.jdo.query.Expression...-">result</a></span>(boolean&nbsp;distinct,
      <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;...&nbsp;exprs)</code>
<div class="block">Method to set the result of the query.</div>
</td>
</tr>
<tr id="i52" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#saveAsNamedQuery-java.lang.String-">saveAsNamedQuery</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Save the query, as it is currently defined, as a named query under the specified name.</div>
</td>
</tr>
<tr id="i53" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#serializeRead-java.lang.Boolean-">serializeRead</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Boolean.html?is-external=true" title="class or interface in java.lang">Boolean</a>&nbsp;serialize)</code>
<div class="block">Set whether we to lock all objects read by this query.</div>
</td>
</tr>
<tr id="i54" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#setCandidates-java.util.Collection-">setCandidates</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;candidates)</code>
<div class="block">Method to set the candidates to use over which we are querying.</div>
</td>
</tr>
<tr id="i55" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#setParameter-javax.jdo.query.Expression-java.lang.Object-">setParameter</a></span>(<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;&nbsp;paramExpr,
            <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;value)</code>
<div class="block">Method to set a parameter value for the specified (parameter) expression when executing the query.</div>
</td>
</tr>
<tr id="i56" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#setParameter-java.lang.String-java.lang.Object-">setParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;paramName,
            <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;value)</code>
<div class="block">Method to set the value for a named parameter for use when executing the query.</div>
</td>
</tr>
<tr id="i57" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#setParameters-java.util.Map-">setParameters</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,?&gt;&nbsp;namedParamMap)</code>
<div class="block">Method to set the named parameters on this query prior to execution.</div>
</td>
</tr>
<tr id="i58" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/query/StringExpression.html" title="interface in javax.jdo.query">StringExpression</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#stringParameter-java.lang.String-">stringParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Method to return a string parameter for the query.</div>
</td>
</tr>
<tr id="i59" class="rowColor">
<td class="colFirst"><code>&lt;S&gt;&nbsp;<a href="../../javax/jdo/JDOQLTypedSubquery.html" title="interface in javax.jdo">JDOQLTypedSubquery</a>&lt;S&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#subquery-java.lang.Class-java.lang.String-">subquery</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;S&gt;&nbsp;candidate,
        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;candidateAlias)</code>
<div class="block">Method to return a subquery for use in this query.</div>
</td>
</tr>
<tr id="i60" class="altColor">
<td class="colFirst"><code>&lt;E&gt;&nbsp;<a href="../../javax/jdo/JDOQLTypedSubquery.html" title="interface in javax.jdo">JDOQLTypedSubquery</a>&lt;E&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#subquery-javax.jdo.query.CollectionExpression-java.lang.Class-java.lang.String-">subquery</a></span>(<a href="../../javax/jdo/query/CollectionExpression.html" title="interface in javax.jdo.query">CollectionExpression</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;E&gt;,E&gt;&nbsp;candidateCollection,
        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;E&gt;&nbsp;candidate,
        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;candidateAlias)</code>
<div class="block">Method to return a correlated subquery for use in this query.</div>
</td>
</tr>
<tr id="i61" class="rowColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedSubquery.html" title="interface in javax.jdo">JDOQLTypedSubquery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#subquery-java.lang.String-">subquery</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;candidateAlias)</code>
<div class="block">Method to return a subquery for use in this query using the same candidate class as this query.</div>
</td>
</tr>
<tr id="i62" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/query/TimeExpression.html" title="interface in javax.jdo.query">TimeExpression</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#timeParameter-java.lang.String-">timeParameter</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>
<div class="block">Method to return a time parameter for the query.</div>
</td>
</tr>
<tr id="i63" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#toString--">toString</a></span>()</code>
<div class="block">Method to return the equivalent String form of this query (if applicable for the query language).</div>
</td>
</tr>
<tr id="i64" class="altColor">
<td class="colFirst"><code><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#unmodifiable--">unmodifiable</a></span>()</code>
<div class="block">Set to make this query unmodifiable hereafter.</div>
</td>
</tr>
<tr id="i65" class="rowColor">
<td class="colFirst"><code>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../javax/jdo/JDOQLTypedQuery.html#variable-java.lang.String-java.lang.Class-">variable</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
        <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;V&gt;&nbsp;type)</code>
<div class="block">Method to return a variable for this query.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.io.Closeable">
<!--   -->
</a>
<h3>Methods inherited from interface&nbsp;java.io.<a href="https://docs.oracle.com/javase/8/docs/api/java/io/Closeable.html?is-external=true" title="class or interface in java.io">Closeable</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/Closeable.html?is-external=true#close--" title="class or interface in java.io">close</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ FIELD DETAIL =========== -->
<ul class="blockList">
<li class="blockList"><a name="field.detail">
<!--   -->
</a>
<h3>Field Detail</h3>
<a name="QUERY_CLASS_PREFIX">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>QUERY_CLASS_PREFIX</h4>
<pre>static final&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a> QUERY_CLASS_PREFIX</pre>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../constant-values.html#javax.jdo.JDOQLTypedQuery.QUERY_CLASS_PREFIX">Constant Field Values</a></dd>
</dl>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="candidate--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>candidate</h4>
<pre><a href="../../javax/jdo/query/PersistableExpression.html" title="interface in javax.jdo.query">PersistableExpression</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;candidate()</pre>
<div class="block">Method to return an expression for the candidate of the query.
 Cast the returned expression to the candidate "Q" type to be able to call methods on it.
 This calls the method "Q{type}.candidate(null)"
 The preference is to use the "Q{type}.candidate()" method for real type-safe handling.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the candidate</dd>
</dl>
</li>
</ul>
<a name="parameter-java.lang.String-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>parameter</h4>
<pre>&lt;P&gt;&nbsp;<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;P&gt;&nbsp;parameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                            <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;P&gt;&nbsp;type)</pre>
<div class="block">Method to return a parameter for the query.
 Cast the returned parameter to the right type to be able to call methods on it.
 The preference is to use the "xxxParameter(String)" methods for real type-safe handling.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>P</code> - type for the parameter</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dd><code>type</code> - Java type of the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="stringParameter-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>stringParameter</h4>
<pre><a href="../../javax/jdo/query/StringExpression.html" title="interface in javax.jdo.query">StringExpression</a>&nbsp;stringParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Method to return a string parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>StringExpression for the parameter</dd>
</dl>
</li>
</ul>
<a name="characterParameter-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>characterParameter</h4>
<pre><a href="../../javax/jdo/query/CharacterExpression.html" title="interface in javax.jdo.query">CharacterExpression</a>&nbsp;characterParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Method to return a character parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="numericParameter-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>numericParameter</h4>
<pre><a href="../../javax/jdo/query/NumericExpression.html" title="interface in javax.jdo.query">NumericExpression</a>&lt;?&gt;&nbsp;numericParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Method to return a numeric parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>NumericExpression for the parameter</dd>
</dl>
</li>
</ul>
<a name="numericParameter-java.lang.String-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>numericParameter</h4>
<pre>default&nbsp;&lt;N&gt;&nbsp;<a href="../../javax/jdo/query/NumericExpression.html" title="interface in javax.jdo.query">NumericExpression</a>&lt;N&gt;&nbsp;numericParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                                                  <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;N&gt;&nbsp;type)</pre>
<div class="block">Method to return a numeric parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>N</code> - Type for the numeric parameter</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dd><code>type</code> - Type of the numeric parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>NumericExpression for the parameter</dd>
</dl>
</li>
</ul>
<a name="dateParameter-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>dateParameter</h4>
<pre><a href="../../javax/jdo/query/DateExpression.html" title="interface in javax.jdo.query">DateExpression</a>&nbsp;dateParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Method to return a date parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="timeParameter-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>timeParameter</h4>
<pre><a href="../../javax/jdo/query/TimeExpression.html" title="interface in javax.jdo.query">TimeExpression</a>&nbsp;timeParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Method to return a time parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="datetimeParameter-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>datetimeParameter</h4>
<pre><a href="../../javax/jdo/query/DateTimeExpression.html" title="interface in javax.jdo.query">DateTimeExpression</a>&nbsp;datetimeParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Method to return a datetime parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="collectionParameter-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>collectionParameter</h4>
<pre><a href="../../javax/jdo/query/CollectionExpression.html" title="interface in javax.jdo.query">CollectionExpression</a>&lt;?,?&gt;&nbsp;collectionParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Method to return a collection parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="collectionParameter-java.lang.String-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>collectionParameter</h4>
<pre>default&nbsp;&lt;E&gt;&nbsp;<a href="../../javax/jdo/query/CollectionExpression.html" title="interface in javax.jdo.query">CollectionExpression</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;E&gt;,E&gt;&nbsp;collectionParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                                                                      <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;E&gt;&nbsp;elementType)</pre>
<div class="block">Method to return a collection parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>E</code> - Element type for the collection parameter</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dd><code>elementType</code> - Element type of the collection parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="mapParameter-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>mapParameter</h4>
<pre><a href="../../javax/jdo/query/MapExpression.html" title="interface in javax.jdo.query">MapExpression</a>&lt;?,?,?&gt;&nbsp;mapParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Method to return a map parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="mapParameter-java.lang.String-java.lang.Class-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>mapParameter</h4>
<pre>default&nbsp;&lt;K,V&gt;&nbsp;<a href="../../javax/jdo/query/MapExpression.html" title="interface in javax.jdo.query">MapExpression</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;K,V&gt;,K,V&gt;&nbsp;mapParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;K&gt;&nbsp;keyType,
                                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;V&gt;&nbsp;valueType)</pre>
<div class="block">Method to return a map parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>K</code> - Key type for the map parameter</dd>
<dd><code>V</code> - Value type for the map parameter</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dd><code>keyType</code> - Key type of the map parameter</dd>
<dd><code>valueType</code> - Value type of the map parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="listParameter-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>listParameter</h4>
<pre><a href="../../javax/jdo/query/ListExpression.html" title="interface in javax.jdo.query">ListExpression</a>&lt;?,?&gt;&nbsp;listParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Method to return a list parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="listParameter-java.lang.String-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>listParameter</h4>
<pre>default&nbsp;&lt;E&gt;&nbsp;<a href="../../javax/jdo/query/ListExpression.html" title="interface in javax.jdo.query">ListExpression</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;E&gt;,E&gt;&nbsp;listParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;E&gt;&nbsp;elementType)</pre>
<div class="block">Method to return a list parameter for the query.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>E</code> - Element type for the list parameter</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the parameter</dd>
<dd><code>elementType</code> - Element type of the list parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the parameter</dd>
</dl>
</li>
</ul>
<a name="variable-java.lang.String-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>variable</h4>
<pre>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;variable(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name,
                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;V&gt;&nbsp;type)</pre>
<div class="block">Method to return a variable for this query.
 Cast the returned variable to the right type to be able to call methods on it.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>V</code> - type for the variable</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name of the variable</dd>
<dd><code>type</code> - Type of the variable</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression for the variable</dd>
</dl>
</li>
</ul>
<a name="setCandidates-java.util.Collection-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setCandidates</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;setCandidates(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;candidates)</pre>
<div class="block">Method to set the candidates to use over which we are querying.
 If no candidates are set then the query is performed on the datastore.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>candidates</code> - The candidates</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="excludeSubclasses--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>excludeSubclasses</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;excludeSubclasses()</pre>
<div class="block">Method to remove subclasses (of the candidate) from the query</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="includeSubclasses--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>includeSubclasses</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;includeSubclasses()</pre>
<div class="block">Method to include subclasses (of the candidate) to the query</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="filter-javax.jdo.query.BooleanExpression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>filter</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;filter(<a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;expr)</pre>
<div class="block">Method to set the filter of the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>expr</code> - Filter expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="ifThenElse-java.lang.Class-javax.jdo.query.BooleanExpression-javax.jdo.query.Expression-javax.jdo.query.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ifThenElse</h4>
<pre>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;&nbsp;ifThenElse(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;V&gt;&nbsp;type,
                                       <a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
                                       <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;thenValueExpr,
                                       <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;elseValueExpr)</pre>
<div class="block">Method to return an "IF (...) ... ELSE ..." expression for use in this query.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>V</code> - type for the IfThenElseExpression</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>type</code> - The type returned by the IfElse.</dd>
<dd><code>cond</code> - The if condition</dd>
<dd><code>thenValueExpr</code> - Expression for value to return when the if expression is met</dd>
<dd><code>elseValueExpr</code> - Expression for value to return when the if expression is not met</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The IfThenElse expression</dd>
</dl>
</li>
</ul>
<a name="ifThenElse-javax.jdo.query.BooleanExpression-java.lang.Object-javax.jdo.query.Expression-">
<!--   -->
</a><a name="ifThenElse-javax.jdo.query.BooleanExpression-V-javax.jdo.query.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ifThenElse</h4>
<pre>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;&nbsp;ifThenElse(<a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
                                       V&nbsp;thenValue,
                                       <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;elseValueExpr)</pre>
<div class="block">Method to return an "IF (...) ... ELSE ..." expression for use in this query.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>V</code> - type for the IfThenElseExpression</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>cond</code> - The if condition</dd>
<dd><code>thenValue</code> - Value to return when the if expression is met</dd>
<dd><code>elseValueExpr</code> - Expression to return when the if expression is not met</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The IfThenElse expression</dd>
</dl>
</li>
</ul>
<a name="ifThenElse-javax.jdo.query.BooleanExpression-javax.jdo.query.Expression-java.lang.Object-">
<!--   -->
</a><a name="ifThenElse-javax.jdo.query.BooleanExpression-javax.jdo.query.Expression-V-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ifThenElse</h4>
<pre>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;&nbsp;ifThenElse(<a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
                                       <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;thenValueExpr,
                                       V&nbsp;elseValue)</pre>
<div class="block">Method to return an "IF (...) ... ELSE ..." expression for use in this query.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>V</code> - type for the IfThenElseExpression</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>cond</code> - The if condition</dd>
<dd><code>thenValueExpr</code> - Expression to return when the if expression is met</dd>
<dd><code>elseValue</code> - Value to return when the if expression is not met</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The IfThenElse expression</dd>
</dl>
</li>
</ul>
<a name="ifThenElse-javax.jdo.query.BooleanExpression-java.lang.Object-java.lang.Object-">
<!--   -->
</a><a name="ifThenElse-javax.jdo.query.BooleanExpression-V-V-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ifThenElse</h4>
<pre>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;&nbsp;ifThenElse(<a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
                                       V&nbsp;thenValue,
                                       V&nbsp;elseValue)</pre>
<div class="block">Method to return an "IF (...) ... ELSE ..." expression for use in this query.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>V</code> - type for the IfThenElseExpression</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>cond</code> - The if condition</dd>
<dd><code>thenValue</code> - Value to return when the if expression is met</dd>
<dd><code>elseValue</code> - Value to return when the if expression is not met</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The IfThenElse expression</dd>
</dl>
</li>
</ul>
<a name="ifThen-java.lang.Class-javax.jdo.query.BooleanExpression-javax.jdo.query.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ifThen</h4>
<pre>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;&nbsp;ifThen(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;V&gt;&nbsp;type,
                                   <a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
                                   <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;V&gt;&nbsp;thenValueExpr)</pre>
<div class="block">Method to return an "IF (...) ... ELSE ..." expression for use in this query.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>V</code> - type for the IfThenElseExpression</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>type</code> - The type returned by the IfElse.</dd>
<dd><code>cond</code> - The if condition</dd>
<dd><code>thenValueExpr</code> - Expression for value to return when the if expression is met</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The IfThenElse expression</dd>
</dl>
</li>
</ul>
<a name="ifThen-javax.jdo.query.BooleanExpression-java.lang.Object-">
<!--   -->
</a><a name="ifThen-javax.jdo.query.BooleanExpression-V-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ifThen</h4>
<pre>&lt;V&gt;&nbsp;<a href="../../javax/jdo/query/IfThenElseExpression.html" title="interface in javax.jdo.query">IfThenElseExpression</a>&lt;V&gt;&nbsp;ifThen(<a href="../../javax/jdo/query/BooleanExpression.html" title="interface in javax.jdo.query">BooleanExpression</a>&nbsp;cond,
                                   V&nbsp;thenValue)</pre>
<div class="block">Method to return an "IF (...) ... ELSE ..." expression for use in this query.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>V</code> - type for the IfThenElseExpression</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>cond</code> - The if condition</dd>
<dd><code>thenValue</code> - Value to return when the if expression is met</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The IfThenElse expression</dd>
</dl>
</li>
</ul>
<a name="groupBy-javax.jdo.query.Expression...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>groupBy</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;groupBy(<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;...&nbsp;exprs)</pre>
<div class="block">Method to set the grouping(s) for the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>exprs</code> - Grouping expression(s)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="having-javax.jdo.query.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>having</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;having(<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;&nbsp;expr)</pre>
<div class="block">Method to set the having clause of the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>expr</code> - Having expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="orderBy-javax.jdo.query.OrderExpression...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>orderBy</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;orderBy(<a href="../../javax/jdo/query/OrderExpression.html" title="interface in javax.jdo.query">OrderExpression</a>&lt;?&gt;...&nbsp;orderExprs)</pre>
<div class="block">Method to set the ordering of the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>orderExprs</code> - Ordering expression(s)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="result-boolean-javax.jdo.query.Expression...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>result</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;result(boolean&nbsp;distinct,
                          <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;...&nbsp;exprs)</pre>
<div class="block">Method to set the result of the query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>distinct</code> - Whether results are distinct</dd>
<dd><code>exprs</code> - The result expressions</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="range-javax.jdo.query.NumericExpression-javax.jdo.query.NumericExpression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>range</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;range(<a href="../../javax/jdo/query/NumericExpression.html" title="interface in javax.jdo.query">NumericExpression</a>&lt;?&gt;&nbsp;lowerInclExpr,
                         <a href="../../javax/jdo/query/NumericExpression.html" title="interface in javax.jdo.query">NumericExpression</a>&lt;?&gt;&nbsp;upperExclExpr)</pre>
<div class="block">Method to set the range of any required results, using expressions.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>lowerInclExpr</code> - The position of the first result (inclusive)</dd>
<dd><code>upperExclExpr</code> - The position of the last result (exclusive)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="range-long-long-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>range</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;range(long&nbsp;lowerIncl,
                         long&nbsp;upperExcl)</pre>
<div class="block">Method to set the range of any required results, using long values.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>lowerIncl</code> - The position of the first result (inclusive)</dd>
<dd><code>upperExcl</code> - The position of the last result (exclusive)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="range-javax.jdo.query.Expression-javax.jdo.query.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>range</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;range(<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;&nbsp;paramLowerInclExpr,
                         <a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;&nbsp;paramUpperExclExpr)</pre>
<div class="block">Method to set the range of any required results, using parameters (expressions).</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>paramLowerInclExpr</code> - Expression for a parameter defining the position of the first result (inclusive)</dd>
<dd><code>paramUpperExclExpr</code> - Expression for a parameter defining the position of the last result (exclusive)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="subquery-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>subquery</h4>
<pre><a href="../../javax/jdo/JDOQLTypedSubquery.html" title="interface in javax.jdo">JDOQLTypedSubquery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;subquery(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;candidateAlias)</pre>
<div class="block">Method to return a subquery for use in this query using the same candidate class as this query.
 To obtain the expression for the subquery to link it back to this query, call "result(...)" on the subquery.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>candidateAlias</code> - Alias for the candidate</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The subquery</dd>
</dl>
</li>
</ul>
<a name="subquery-java.lang.Class-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>subquery</h4>
<pre>&lt;S&gt;&nbsp;<a href="../../javax/jdo/JDOQLTypedSubquery.html" title="interface in javax.jdo">JDOQLTypedSubquery</a>&lt;S&gt;&nbsp;subquery(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;S&gt;&nbsp;candidate,
                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;candidateAlias)</pre>
<div class="block">Method to return a subquery for use in this query.
 To obtain the expression for the subquery to link it back to this query, call "result(...)" on the subquery.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>S</code> - Candidate type for subquery</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>candidate</code> - Candidate for the subquery</dd>
<dd><code>candidateAlias</code> - Alias for the candidate</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The subquery</dd>
</dl>
</li>
</ul>
<a name="subquery-javax.jdo.query.CollectionExpression-java.lang.Class-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>subquery</h4>
<pre>&lt;E&gt;&nbsp;<a href="../../javax/jdo/JDOQLTypedSubquery.html" title="interface in javax.jdo">JDOQLTypedSubquery</a>&lt;E&gt;&nbsp;subquery(<a href="../../javax/jdo/query/CollectionExpression.html" title="interface in javax.jdo.query">CollectionExpression</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;E&gt;,E&gt;&nbsp;candidateCollection,
                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;E&gt;&nbsp;candidate,
                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;candidateAlias)</pre>
<div class="block">Method to return a correlated subquery for use in this query.
 The candidate collection of the subquery is defined using a collection relationship of the outer query.
 To obtain the expression for the subquery to link it back to this query, call "result(...)" on the subquery.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>E</code> - Candidate type for subquery</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>candidateCollection</code> - Expression defining the candidate collection for the subquery</dd>
<dd><code>candidate</code> - Candidate for the subquery</dd>
<dd><code>candidateAlias</code> - Alias for the candidate</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The subquery</dd>
</dl>
</li>
</ul>
<a name="setParameters-java.util.Map-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setParameters</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;setParameters(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,?&gt;&nbsp;namedParamMap)</pre>
<div class="block">Method to set the named parameters on this query prior to execution.
 All parameter values specified in this method will only be retained until the subsequent query execution.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>namedParamMap</code> - The map of parameter values keyed by their names.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>This query</dd>
</dl>
</li>
</ul>
<a name="setParameter-javax.jdo.query.Expression-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setParameter</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;setParameter(<a href="../../javax/jdo/query/Expression.html" title="interface in javax.jdo.query">Expression</a>&lt;?&gt;&nbsp;paramExpr,
                                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;value)</pre>
<div class="block">Method to set a parameter value for the specified (parameter) expression when executing the query.
 All parameter values specified in this method will only be retained until the subsequent query execution.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>paramExpr</code> - Expression defining the parameter</dd>
<dd><code>value</code> - The value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="setParameter-java.lang.String-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setParameter</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;setParameter(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;paramName,
                                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;value)</pre>
<div class="block">Method to set the value for a named parameter for use when executing the query.
 All parameter values specified in this method will only be retained until the subsequent query execution.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>paramName</code> - Parameter name</dd>
<dd><code>value</code> - The value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The query</dd>
</dl>
</li>
</ul>
<a name="executeList--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>executeList</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;executeList()</pre>
<div class="block">Method to execute the query where there are (potentially) multiple rows and we are returning the candidate type.
 Any parameters required should be set prior to calling this method, using one of the <cite>setParameter</cite> methods.
 <P>Calling this method with a result being specified will result in JDOUserException being thrown.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The results</dd>
</dl>
</li>
</ul>
<a name="executeUnique--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>executeUnique</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&nbsp;executeUnique()</pre>
<div class="block">Method to execute the query where there is a single row and we are returning the candidate type.
 Any parameters required should be set prior to calling this method, using one of the <cite>setParameter</cite> methods.
 <P>Calling this method with a result being specified will result in JDOUserException being thrown.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The result</dd>
</dl>
</li>
</ul>
<a name="executeResultList-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>executeResultList</h4>
<pre>&lt;R&gt;&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;R&gt;&nbsp;executeResultList(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;R&gt;&nbsp;resultCls)</pre>
<div class="block">Method to execute the query where there are (potentially) multiple rows and we are returning either the result type.
 Any parameters required should be set prior to calling this method, using one of the <cite>setParameters</cite> methods.
 <P>Calling this method with no result being specified will result in JDOUserException being thrown.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>R</code> - result type</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>resultCls</code> - Result class</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The results</dd>
</dl>
</li>
</ul>
<a name="executeResultUnique-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>executeResultUnique</h4>
<pre>&lt;R&gt;&nbsp;R&nbsp;executeResultUnique(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Class.html?is-external=true" title="class or interface in java.lang">Class</a>&lt;R&gt;&nbsp;resultCls)</pre>
<div class="block">Method to execute the query where there is a single row and we are returning either the result type.
 Any parameters required should be set prior to calling this method, using one of the <cite>setParameter</cite> methods.
 <P>Calling this method with no result being specified will result in JDOUserException being thrown.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>R</code> - result type</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>resultCls</code> - Result class</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The result</dd>
</dl>
</li>
</ul>
<a name="executeResultList--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>executeResultList</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&gt;&nbsp;executeResultList()</pre>
<div class="block">Method to execute the query where there are (potentially) multiple rows and we have a result defined but no result class.
 Any parameters required should be set prior to calling this method, using one of the <cite>setParameter</cite> methods.
 <P>Calling this method with no result being specified will result in JDOUserException being thrown.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The results</dd>
</dl>
</li>
</ul>
<a name="executeResultUnique--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>executeResultUnique</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;executeResultUnique()</pre>
<div class="block">Method to execute the query where there is a single row and we have a result defined but no result class.
 Any parameters required should be set prior to calling this method, using one of the <cite>setParameters</cite> methods.
 <P>Calling this method with no result being specified will result in JDOUserException being thrown.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The results</dd>
</dl>
</li>
</ul>
<a name="deletePersistentAll--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>deletePersistentAll</h4>
<pre>long&nbsp;deletePersistentAll()</pre>
<div class="block">Method to execute the query deleting the affected instances.
 Any parameters required should be set prior to calling this method, using one of the <cite>setParameter</cite> methods.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The number of objects deleted</dd>
</dl>
</li>
</ul>
<a name="getDatastoreReadTimeoutMillis--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getDatastoreReadTimeoutMillis</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true" title="class or interface in java.lang">Integer</a>&nbsp;getDatastoreReadTimeoutMillis()</pre>
<div class="block">Get the effective timeout setting for read operations.
 If the timeout has not been set on this query explicitly, the effective
 datastore read timeout value from the persistence manager is returned.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the effective timeout setting (milliseconds).</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../javax/jdo/PersistenceManager.html#setDatastoreReadTimeoutMillis-java.lang.Integer-"><code>PersistenceManager.setDatastoreReadTimeoutMillis(Integer)</code></a></dd>
</dl>
</li>
</ul>
<a name="datastoreReadTimeoutMillis-java.lang.Integer-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>datastoreReadTimeoutMillis</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;datastoreReadTimeoutMillis(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true" title="class or interface in java.lang">Integer</a>&nbsp;interval)</pre>
<div class="block">Set the datastore read timeout (millis).</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>interval</code> - The interval</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>This query</dd>
</dl>
</li>
</ul>
<a name="getDatastoreWriteTimeoutMillis--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getDatastoreWriteTimeoutMillis</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true" title="class or interface in java.lang">Integer</a>&nbsp;getDatastoreWriteTimeoutMillis()</pre>
<div class="block">Get the effective timeout setting for write operations. 
 If the timeout has not been set on this query explicitly, the effective
 datastore write timeout value from the persistence manager is returned.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the effective timeout setting (milliseconds).</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../javax/jdo/PersistenceManager.html#setDatastoreWriteTimeoutMillis-java.lang.Integer-"><code>PersistenceManager.setDatastoreWriteTimeoutMillis(Integer)</code></a></dd>
</dl>
</li>
</ul>
<a name="datastoreWriteTimeoutMillis-java.lang.Integer-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>datastoreWriteTimeoutMillis</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;datastoreWriteTimeoutMillis(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true" title="class or interface in java.lang">Integer</a>&nbsp;interval)</pre>
<div class="block">Set the datastore write timeout (millis).</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>interval</code> - The interval</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>This query</dd>
</dl>
</li>
</ul>
<a name="getSerializeRead--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getSerializeRead</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Boolean.html?is-external=true" title="class or interface in java.lang">Boolean</a>&nbsp;getSerializeRead()</pre>
<div class="block">Return the current value of the serializeRead property.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the value of the serializeRead property</dd>
</dl>
</li>
</ul>
<a name="serializeRead-java.lang.Boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>serializeRead</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;serializeRead(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Boolean.html?is-external=true" title="class or interface in java.lang">Boolean</a>&nbsp;serialize)</pre>
<div class="block">Set whether we to lock all objects read by this query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>serialize</code> - Whether to lock</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>This query</dd>
</dl>
</li>
</ul>
<a name="isUnmodifiable--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isUnmodifiable</h4>
<pre>boolean&nbsp;isUnmodifiable()</pre>
<div class="block">The unmodifiable flag, when set, disallows further modification of the query, 
 except for specifying the range, result class, and ignoreCache option.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the current setting of the flag</dd>
</dl>
</li>
</ul>
<a name="unmodifiable--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>unmodifiable</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;unmodifiable()</pre>
<div class="block">Set to make this query unmodifiable hereafter.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>This query</dd>
</dl>
</li>
</ul>
<a name="getIgnoreCache--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getIgnoreCache</h4>
<pre>boolean&nbsp;getIgnoreCache()</pre>
<div class="block">Get the ignoreCache option setting.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the ignoreCache option setting.</dd>
</dl>
</li>
</ul>
<a name="ignoreCache-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ignoreCache</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;ignoreCache(boolean&nbsp;flag)</pre>
<div class="block">Set whether we to ignore the cache with this query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>flag</code> - Whether to ignore the cache</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>This query</dd>
</dl>
</li>
</ul>
<a name="extension-java.lang.String-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>extension</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;extension(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;key,
                             <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;value)</pre>
<div class="block">Specify an extension for this query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>key</code> - The extension key</dd>
<dd><code>value</code> - The extension value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>This query</dd>
</dl>
</li>
</ul>
<a name="extensions-java.util.Map-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>extensions</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;extensions(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&nbsp;values)</pre>
<div class="block">Specify a map of extensions for this query.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>values</code> - The extension map of keys and values</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>This query</dd>
</dl>
</li>
</ul>
<a name="saveAsNamedQuery-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>saveAsNamedQuery</h4>
<pre><a href="../../javax/jdo/JDOQLTypedQuery.html" title="interface in javax.jdo">JDOQLTypedQuery</a>&lt;<a href="../../javax/jdo/JDOQLTypedQuery.html" title="type parameter in JDOQLTypedQuery">T</a>&gt;&nbsp;saveAsNamedQuery(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
<div class="block">Save the query, as it is currently defined, as a named query under the specified name.
 If a named query already exists under this name (either defined in metadata, or previously saved)
 then it will be overwritten.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - Name to save it under.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>This query</dd>
</dl>
</li>
</ul>
<a name="getPersistenceManager--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getPersistenceManager</h4>
<pre><a href="../../javax/jdo/PersistenceManager.html" title="interface in javax.jdo">PersistenceManager</a>&nbsp;getPersistenceManager()</pre>
<div class="block">Accessor for the PersistenceManager for this query</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The PersistenceManager</dd>
</dl>
</li>
</ul>
<a name="getFetchPlan--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFetchPlan</h4>
<pre><a href="../../javax/jdo/FetchPlan.html" title="interface in javax.jdo">FetchPlan</a>&nbsp;getFetchPlan()</pre>
<div class="block">Accessor for the FetchPlan for this query</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The FetchPlan</dd>
</dl>
</li>
</ul>
<a name="cancelAll--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cancelAll</h4>
<pre>void&nbsp;cancelAll()</pre>
<div class="block">Method to cancel any executing queries.
 If the underlying datastore doesn't support cancellation of queries this will throw JDOUnsupportedOptionException.
 If the cancellation fails (e.g in the underlying datastore) then this will throw a JDOException.</div>
</li>
</ul>
<a name="cancel-java.lang.Thread-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cancel</h4>
<pre>void&nbsp;cancel(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html?is-external=true" title="class or interface in java.lang">Thread</a>&nbsp;thread)</pre>
<div class="block">Method to cancel an executing query in the specified thread.
 If the underlying datastore doesn't support cancellation of queries this will throw JDOUnsupportedOptionException.
 If the cancellation fails (e.g in the underlying datastore) then this will throw a JDOException.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>thread</code> - The thread to cancel</dd>
</dl>
</li>
</ul>
<a name="close-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>close</h4>
<pre>void&nbsp;close(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;result)</pre>
<div class="block">Method to close the specified query result.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>result</code> - The result</dd>
</dl>
</li>
</ul>
<a name="closeAll--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>closeAll</h4>
<pre>void&nbsp;closeAll()</pre>
<div class="block">Method to close all query results from this query.</div>
</li>
</ul>
<a name="toString--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>toString</h4>
<pre><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;toString()</pre>
<div class="block">Method to return the equivalent String form of this query (if applicable for the query language).</div>
<dl>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#toString--" title="class or interface in java.lang">toString</a></code>&nbsp;in class&nbsp;<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The single-string form of this query</dd>
</dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/JDOQLTypedQuery.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../index-all.html">Index</a></li>
<li><a href="../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../javax/jdo/JDOOptimisticVerificationException.html" title="class in javax.jdo"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../javax/jdo/JDOQLTypedSubquery.html" title="interface in javax.jdo"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../index.html?javax/jdo/JDOQLTypedQuery.html" target="_top">Frames</a></li>
<li><a href="JDOQLTypedQuery.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &#169; 2005&#x2013;2022 <a href="http://www.apache.org">The Apache Software Foundation</a>. All rights reserved.</small></p>
</body>
</html>
