<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<title>CriteriaBuilder</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="CriteriaBuilder";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":6,"i1":6,"i2":6,"i3":6,"i4":6,"i5":6,"i6":6,"i7":6,"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":6,"i42":6,"i43":6,"i44":6,"i45":6,"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,"i66":6,"i67":6,"i68":6,"i69":6,"i70":6,"i71":6,"i72":6,"i73":6,"i74":6,"i75":6,"i76":6,"i77":6,"i78":6,"i79":6,"i80":6,"i81":6,"i82":6,"i83":6,"i84":6,"i85":6,"i86":6,"i87":6,"i88":6,"i89":6,"i90":6,"i91":6,"i92":6,"i93":6,"i94":6,"i95":6,"i96":6,"i97":6,"i98":6,"i99":6,"i100":6,"i101":6,"i102":6,"i103":6,"i104":6,"i105":6,"i106":6,"i107":6,"i108":6,"i109":6,"i110":6,"i111":6,"i112":6,"i113":6,"i114":6,"i115":6,"i116":6,"i117":6,"i118":6,"i119":6,"i120":6,"i121":6,"i122":6,"i123":6,"i124":6,"i125":6,"i126":6,"i127":6,"i128":6,"i129":6,"i130":6,"i131":6,"i132":6,"i133":6,"i134":6,"i135":6,"i136":6,"i137":6,"i138":6,"i139":6,"i140":6,"i141":6,"i142":6,"i143":6,"i144":6,"i145":6,"i146":6};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance Methods"],4:["t3","Abstract 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="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/persistence/criteria/CompoundSelection.html" title="interface in javax.persistence.criteria"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../javax/persistence/criteria/CriteriaBuilder.Case.html" title="interface in javax.persistence.criteria"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?javax/persistence/criteria/CriteriaBuilder.html" target="_top">Frames</a></li>
<li><a href="CriteriaBuilder.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><a href="#nested.class.summary">Nested</a>&nbsp;|&nbsp;</li>
<li>Field&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>Field&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.persistence.criteria</div>
<h2 title="Interface CriteriaBuilder" class="title">Interface CriteriaBuilder</h2>
</div>
<div class="contentContainer">
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public interface <span class="typeNameLabel">CriteriaBuilder</span></pre>
<div class="block">Used to construct criteria queries, compound selections, 
 expressions, predicates, orderings.

 <p> Note that <code>Predicate</code> is used instead of <code>Expression&#060;Boolean&#062;</code> 
 in this API in order to work around the fact that Java 
 generics are not compatible with varags.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Java Persistence 2.0</dd>
</dl>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="nested.class.summary">
<!--   -->
</a>
<h3>Nested Class Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Nested Class Summary table, listing nested classes, and an explanation">
<caption><span>Nested Classes</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Interface and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static interface&nbsp;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.Case.html" title="interface in javax.persistence.criteria">CriteriaBuilder.Case</a>&lt;<a href="../../../javax/persistence/criteria/CriteriaBuilder.Case.html" title="type parameter in CriteriaBuilder.Case">R</a>&gt;</span></code>
<div class="block">Interface used to build general case expressions.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static interface&nbsp;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.Coalesce.html" title="interface in javax.persistence.criteria">CriteriaBuilder.Coalesce</a>&lt;<a href="../../../javax/persistence/criteria/CriteriaBuilder.Coalesce.html" title="type parameter in CriteriaBuilder.Coalesce">T</a>&gt;</span></code>
<div class="block">Interface used to build coalesce expressions.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static interface&nbsp;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.In.html" title="interface in javax.persistence.criteria">CriteriaBuilder.In</a>&lt;<a href="../../../javax/persistence/criteria/CriteriaBuilder.In.html" title="type parameter in CriteriaBuilder.In">T</a>&gt;</span></code>
<div class="block">Interface used to build in predicates.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static interface&nbsp;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.SimpleCase.html" title="interface in javax.persistence.criteria">CriteriaBuilder.SimpleCase</a>&lt;<a href="../../../javax/persistence/criteria/CriteriaBuilder.SimpleCase.html" title="type parameter in CriteriaBuilder.SimpleCase">C</a>,<a href="../../../javax/persistence/criteria/CriteriaBuilder.SimpleCase.html" title="type parameter in CriteriaBuilder.SimpleCase">R</a>&gt;</span></code>
<div class="block">Interface used to build simple case expressions.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static class&nbsp;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.Trimspec.html" title="enum in javax.persistence.criteria">CriteriaBuilder.Trimspec</a></span></code>
<div class="block">Used to specify how strings are trimmed.</div>
</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></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>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#abs-javax.persistence.criteria.Expression-">abs</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</code>
<div class="block">Create an expression that returns the absolute value
 of its argument.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#all-javax.persistence.criteria.Subquery-">all</a></span>(<a href="../../../javax/persistence/criteria/Subquery.html" title="interface in javax.persistence.criteria">Subquery</a>&lt;Y&gt;&nbsp;subquery)</code>
<div class="block">Create an all expression over the subquery results.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#and-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">and</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;x,
   <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;y)</code>
<div class="block">Create a conjunction of the given boolean expressions.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#and-javax.persistence.criteria.Predicate...-">and</a></span>(<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>...&nbsp;restrictions)</code>
<div class="block">Create a conjunction of the given restriction predicates.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#any-javax.persistence.criteria.Subquery-">any</a></span>(<a href="../../../javax/persistence/criteria/Subquery.html" title="interface in javax.persistence.criteria">Subquery</a>&lt;Y&gt;&nbsp;subquery)</code>
<div class="block">Create an any expression over the subquery results.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/CompoundSelection.html" title="interface in javax.persistence.criteria">CompoundSelection</a>&lt;java.lang.Object[]&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#array-javax.persistence.criteria.Selection...-">array</a></span>(<a href="../../../javax/persistence/criteria/Selection.html" title="interface in javax.persistence.criteria">Selection</a>&lt;?&gt;...&nbsp;selections)</code>
<div class="block">Create an array-valued selection item.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Order.html" title="interface in javax.persistence.criteria">Order</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#asc-javax.persistence.criteria.Expression-">asc</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</code>
<div class="block">Create an ordering by the ascending value of the expression.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Double&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#avg-javax.persistence.criteria.Expression-">avg</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</code>
<div class="block">Create an aggregate expression applying the avg operation.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#between-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">between</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;v,
       <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
       <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 between the second and third arguments in value.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#between-javax.persistence.criteria.Expression-Y-Y-">between</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;v,
       Y&nbsp;x,
       Y&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 between the second and third arguments in value.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaBuilder.Coalesce.html" title="interface in javax.persistence.criteria">CriteriaBuilder.Coalesce</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#coalesce--">coalesce</a></span>()</code>
<div class="block">Create a coalesce expression.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#coalesce-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">coalesce</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
        <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns null if all its arguments
 evaluate to null, and the value of the first non-null argument
 otherwise.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#coalesce-javax.persistence.criteria.Expression-Y-">coalesce</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
        Y&nbsp;y)</code>
<div class="block">Create an expression that returns null if all its arguments
 evaluate to null, and the value of the first non-null argument
 otherwise.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#concat-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">concat</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
      <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;y)</code>
<div class="block">Create an expression for string concatenation.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#concat-javax.persistence.criteria.Expression-java.lang.String-">concat</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
      java.lang.String&nbsp;y)</code>
<div class="block">Create an expression for string concatenation.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#concat-java.lang.String-javax.persistence.criteria.Expression-">concat</a></span>(java.lang.String&nbsp;x,
      <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;y)</code>
<div class="block">Create an expression for string concatenation.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#conjunction--">conjunction</a></span>()</code>
<div class="block">Create a conjunction (with zero conjuncts).</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/CompoundSelection.html" title="interface in javax.persistence.criteria">CompoundSelection</a>&lt;Y&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#construct-java.lang.Class-javax.persistence.criteria.Selection...-">construct</a></span>(java.lang.Class&lt;Y&gt;&nbsp;resultClass,
         <a href="../../../javax/persistence/criteria/Selection.html" title="interface in javax.persistence.criteria">Selection</a>&lt;?&gt;...&nbsp;selections)</code>
<div class="block">Create a selection item corresponding to a constructor.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Long&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#count-javax.persistence.criteria.Expression-">count</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</code>
<div class="block">Create an aggregate expression applying the count operation.</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Long&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#countDistinct-javax.persistence.criteria.Expression-">countDistinct</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</code>
<div class="block">Create an aggregate expression applying the count distinct 
 operation.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaDelete.html" title="interface in javax.persistence.criteria">CriteriaDelete</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#createCriteriaDelete-java.lang.Class-">createCriteriaDelete</a></span>(java.lang.Class&lt;T&gt;&nbsp;targetEntity)</code>
<div class="block">Create a <code>CriteriaDelete</code> query object to perform a bulk delete operation.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaUpdate.html" title="interface in javax.persistence.criteria">CriteriaUpdate</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#createCriteriaUpdate-java.lang.Class-">createCriteriaUpdate</a></span>(java.lang.Class&lt;T&gt;&nbsp;targetEntity)</code>
<div class="block">Create a <code>CriteriaUpdate</code> query object to perform a bulk update operation.</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/CriteriaQuery.html" title="interface in javax.persistence.criteria">CriteriaQuery</a>&lt;java.lang.Object&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#createQuery--">createQuery</a></span>()</code>
<div class="block">Create a <code>CriteriaQuery</code> object.</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaQuery.html" title="interface in javax.persistence.criteria">CriteriaQuery</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#createQuery-java.lang.Class-">createQuery</a></span>(java.lang.Class&lt;T&gt;&nbsp;resultClass)</code>
<div class="block">Create a <code>CriteriaQuery</code> object with the specified result 
  type.</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/CriteriaQuery.html" title="interface in javax.persistence.criteria">CriteriaQuery</a>&lt;<a href="../../../javax/persistence/Tuple.html" title="interface in javax.persistence">Tuple</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#createTupleQuery--">createTupleQuery</a></span>()</code>
<div class="block">Create a <code>CriteriaQuery</code> object that returns a tuple of 
  objects as its result.</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.sql.Date&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#currentDate--">currentDate</a></span>()</code>
<div class="block">Create expression to return current date.</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.sql.Time&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#currentTime--">currentTime</a></span>()</code>
<div class="block">Create expression to return current time.</div>
</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.sql.Timestamp&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#currentTimestamp--">currentTimestamp</a></span>()</code>
<div class="block">Create expression to return current timestamp.</div>
</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Order.html" title="interface in javax.persistence.criteria">Order</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#desc-javax.persistence.criteria.Expression-">desc</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</code>
<div class="block">Create an ordering by the descending value of the expression.</div>
</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#diff-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">diff</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns the difference
 between its arguments.</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#diff-javax.persistence.criteria.Expression-N-">diff</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
    N&nbsp;y)</code>
<div class="block">Create an expression that returns the difference
 between its arguments.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#diff-N-javax.persistence.criteria.Expression-">diff</a></span>(N&nbsp;x,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns the difference
 between its arguments.</div>
</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#disjunction--">disjunction</a></span>()</code>
<div class="block">Create a disjunction (with zero disjuncts).</div>
</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#equal-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">equal</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x,
     <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing the arguments for equality.</div>
</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#equal-javax.persistence.criteria.Expression-java.lang.Object-">equal</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x,
     java.lang.Object&nbsp;y)</code>
<div class="block">Create a predicate for testing the arguments for equality.</div>
</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#exists-javax.persistence.criteria.Subquery-">exists</a></span>(<a href="../../../javax/persistence/criteria/Subquery.html" title="interface in javax.persistence.criteria">Subquery</a>&lt;?&gt;&nbsp;subquery)</code>
<div class="block">Create a predicate testing the existence of a subquery result.</div>
</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#function-java.lang.String-java.lang.Class-javax.persistence.criteria.Expression...-">function</a></span>(java.lang.String&nbsp;name,
        java.lang.Class&lt;T&gt;&nbsp;type,
        <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;...&nbsp;args)</code>
<div class="block">Create an expression for the execution of a database
 function.</div>
</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#ge-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">ge</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than or equal to the second.</div>
</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#ge-javax.persistence.criteria.Expression-java.lang.Number-">ge</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
  java.lang.Number&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than or equal to the second.</div>
</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#greaterThan-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">greaterThan</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
           <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than the second.</div>
</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#greaterThan-javax.persistence.criteria.Expression-Y-">greaterThan</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
           Y&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than the second.</div>
</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#greaterThanOrEqualTo-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">greaterThanOrEqualTo</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than or equal to the second.</div>
</td>
</tr>
<tr id="i42" class="altColor">
<td class="colFirst"><code>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#greaterThanOrEqualTo-javax.persistence.criteria.Expression-Y-">greaterThanOrEqualTo</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                    Y&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than or equal to the second.</div>
</td>
</tr>
<tr id="i43" class="rowColor">
<td class="colFirst"><code>&lt;X extends java.lang.Comparable&lt;? super X&gt;&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;X&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#greatest-javax.persistence.criteria.Expression-">greatest</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;X&gt;&nbsp;x)</code>
<div class="block">Create an aggregate expression for finding the greatest of
 the values (strings, dates, etc).</div>
</td>
</tr>
<tr id="i44" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#gt-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">gt</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than the second.</div>
</td>
</tr>
<tr id="i45" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#gt-javax.persistence.criteria.Expression-java.lang.Number-">gt</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
  java.lang.Number&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than the second.</div>
</td>
</tr>
<tr id="i46" class="altColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaBuilder.In.html" title="interface in javax.persistence.criteria">CriteriaBuilder.In</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#in-javax.persistence.criteria.Expression-">in</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends T&gt;&nbsp;expression)</code>
<div class="block">Create predicate to test whether given expression
  is contained in a list of values.</div>
</td>
</tr>
<tr id="i47" class="rowColor">
<td class="colFirst"><code>&lt;C extends java.util.Collection&lt;?&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#isEmpty-javax.persistence.criteria.Expression-">isEmpty</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</code>
<div class="block">Create a predicate that tests whether a collection is empty.</div>
</td>
</tr>
<tr id="i48" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#isFalse-javax.persistence.criteria.Expression-">isFalse</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;x)</code>
<div class="block">Create a predicate testing for a false value.</div>
</td>
</tr>
<tr id="i49" class="rowColor">
<td class="colFirst"><code>&lt;E,C extends java.util.Collection&lt;E&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#isMember-E-javax.persistence.criteria.Expression-">isMember</a></span>(E&nbsp;elem,
        <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</code>
<div class="block">Create a predicate that tests whether an element is
  a member of a collection.</div>
</td>
</tr>
<tr id="i50" class="altColor">
<td class="colFirst"><code>&lt;E,C extends java.util.Collection&lt;E&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#isMember-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">isMember</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;E&gt;&nbsp;elem,
        <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</code>
<div class="block">Create a predicate that tests whether an element is
  a member of a collection.</div>
</td>
</tr>
<tr id="i51" class="rowColor">
<td class="colFirst"><code>&lt;C extends java.util.Collection&lt;?&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#isNotEmpty-javax.persistence.criteria.Expression-">isNotEmpty</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</code>
<div class="block">Create a predicate that tests whether a collection is
  not empty.</div>
</td>
</tr>
<tr id="i52" class="altColor">
<td class="colFirst"><code>&lt;E,C extends java.util.Collection&lt;E&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#isNotMember-E-javax.persistence.criteria.Expression-">isNotMember</a></span>(E&nbsp;elem,
           <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</code>
<div class="block">Create a predicate that tests whether an element is
  not a member of a collection.</div>
</td>
</tr>
<tr id="i53" class="rowColor">
<td class="colFirst"><code>&lt;E,C extends java.util.Collection&lt;E&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#isNotMember-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">isNotMember</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;E&gt;&nbsp;elem,
           <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</code>
<div class="block">Create a predicate that tests whether an element is
  not a member of a collection.</div>
</td>
</tr>
<tr id="i54" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#isNotNull-javax.persistence.criteria.Expression-">isNotNull</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</code>
<div class="block">Create a predicate to test whether the expression is not null.</div>
</td>
</tr>
<tr id="i55" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#isNull-javax.persistence.criteria.Expression-">isNull</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</code>
<div class="block">Create a predicate to test whether the expression is null.</div>
</td>
</tr>
<tr id="i56" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#isTrue-javax.persistence.criteria.Expression-">isTrue</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;x)</code>
<div class="block">Create a predicate testing for a true value.</div>
</td>
</tr>
<tr id="i57" class="rowColor">
<td class="colFirst"><code>&lt;K,M extends java.util.Map&lt;K,?&gt;&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.util.Set&lt;K&gt;&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#keys-M-">keys</a></span>(M&nbsp;map)</code>
<div class="block">Create an expression that returns the keys of a map.</div>
</td>
</tr>
<tr id="i58" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#le-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">le</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 less than or equal to the second.</div>
</td>
</tr>
<tr id="i59" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#le-javax.persistence.criteria.Expression-java.lang.Number-">le</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
  java.lang.Number&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 less than or equal to the second.</div>
</td>
</tr>
<tr id="i60" class="altColor">
<td class="colFirst"><code>&lt;X extends java.lang.Comparable&lt;? super X&gt;&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;X&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#least-javax.persistence.criteria.Expression-">least</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;X&gt;&nbsp;x)</code>
<div class="block">Create an aggregate expression for finding the least of
 the values (strings, dates, etc).</div>
</td>
</tr>
<tr id="i61" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#length-javax.persistence.criteria.Expression-">length</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</code>
<div class="block">Create expression to return length of a string.</div>
</td>
</tr>
<tr id="i62" class="altColor">
<td class="colFirst"><code>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#lessThan-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">lessThan</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
        <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 less than the second.</div>
</td>
</tr>
<tr id="i63" class="rowColor">
<td class="colFirst"><code>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#lessThan-javax.persistence.criteria.Expression-Y-">lessThan</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
        Y&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 less than the second.</div>
</td>
</tr>
<tr id="i64" class="altColor">
<td class="colFirst"><code>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#lessThanOrEqualTo-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">lessThanOrEqualTo</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                 <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 less than or equal to the second.</div>
</td>
</tr>
<tr id="i65" class="rowColor">
<td class="colFirst"><code>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;<br><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#lessThanOrEqualTo-javax.persistence.criteria.Expression-Y-">lessThanOrEqualTo</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                 Y&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 less than or equal to the second.</div>
</td>
</tr>
<tr id="i66" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#like-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">like</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern)</code>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
</td>
</tr>
<tr id="i67" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#like-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-char-">like</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern,
    char&nbsp;escapeChar)</code>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
</td>
</tr>
<tr id="i68" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#like-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">like</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;escapeChar)</code>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
</td>
</tr>
<tr id="i69" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#like-javax.persistence.criteria.Expression-java.lang.String-">like</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
    java.lang.String&nbsp;pattern)</code>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
</td>
</tr>
<tr id="i70" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#like-javax.persistence.criteria.Expression-java.lang.String-char-">like</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
    java.lang.String&nbsp;pattern,
    char&nbsp;escapeChar)</code>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
</td>
</tr>
<tr id="i71" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#like-javax.persistence.criteria.Expression-java.lang.String-javax.persistence.criteria.Expression-">like</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
    java.lang.String&nbsp;pattern,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;escapeChar)</code>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
</td>
</tr>
<tr id="i72" class="altColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#literal-T-">literal</a></span>(T&nbsp;value)</code>
<div class="block">Create an expression for a literal.</div>
</td>
</tr>
<tr id="i73" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#locate-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">locate</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
      <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern)</code>
<div class="block">Create expression to locate the position of one string
 within another, returning position of first character
 if found.</div>
</td>
</tr>
<tr id="i74" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#locate-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">locate</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
      <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern,
      <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;from)</code>
<div class="block">Create expression to locate the position of one string
 within another, returning position of first character
 if found.</div>
</td>
</tr>
<tr id="i75" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#locate-javax.persistence.criteria.Expression-java.lang.String-">locate</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
      java.lang.String&nbsp;pattern)</code>
<div class="block">Create expression to locate the position of one string
 within another, returning position of first character
 if found.</div>
</td>
</tr>
<tr id="i76" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#locate-javax.persistence.criteria.Expression-java.lang.String-int-">locate</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
      java.lang.String&nbsp;pattern,
      int&nbsp;from)</code>
<div class="block">Create expression to locate the position of one string
 within another, returning position of first character
 if found.</div>
</td>
</tr>
<tr id="i77" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#lower-javax.persistence.criteria.Expression-">lower</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</code>
<div class="block">Create expression for converting a string to lowercase.</div>
</td>
</tr>
<tr id="i78" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#lt-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">lt</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 less than the second.</div>
</td>
</tr>
<tr id="i79" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#lt-javax.persistence.criteria.Expression-java.lang.Number-">lt</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
  java.lang.Number&nbsp;y)</code>
<div class="block">Create a predicate for testing whether the first argument is 
 less than the second.</div>
</td>
</tr>
<tr id="i80" class="altColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#max-javax.persistence.criteria.Expression-">max</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</code>
<div class="block">Create an aggregate expression applying the numerical max 
 operation.</div>
</td>
</tr>
<tr id="i81" class="rowColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#min-javax.persistence.criteria.Expression-">min</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</code>
<div class="block">Create an aggregate expression applying the numerical min 
 operation.</div>
</td>
</tr>
<tr id="i82" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#mod-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">mod</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;x,
   <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns the modulus
 of its arguments.</div>
</td>
</tr>
<tr id="i83" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#mod-javax.persistence.criteria.Expression-java.lang.Integer-">mod</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;x,
   java.lang.Integer&nbsp;y)</code>
<div class="block">Create an expression that returns the modulus
 of its arguments.</div>
</td>
</tr>
<tr id="i84" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#mod-java.lang.Integer-javax.persistence.criteria.Expression-">mod</a></span>(java.lang.Integer&nbsp;x,
   <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns the modulus
 of its arguments.</div>
</td>
</tr>
<tr id="i85" class="rowColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#neg-javax.persistence.criteria.Expression-">neg</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</code>
<div class="block">Create an expression that returns the arithmetic negation
 of its argument.</div>
</td>
</tr>
<tr id="i86" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#not-javax.persistence.criteria.Expression-">not</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;restriction)</code>
<div class="block">Create a negation of the given restriction.</div>
</td>
</tr>
<tr id="i87" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#notEqual-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">notEqual</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x,
        <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;y)</code>
<div class="block">Create a predicate for testing the arguments for inequality.</div>
</td>
</tr>
<tr id="i88" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#notEqual-javax.persistence.criteria.Expression-java.lang.Object-">notEqual</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x,
        java.lang.Object&nbsp;y)</code>
<div class="block">Create a predicate for testing the arguments for inequality.</div>
</td>
</tr>
<tr id="i89" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#notLike-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">notLike</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
       <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern)</code>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
</td>
</tr>
<tr id="i90" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#notLike-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-char-">notLike</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
       <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern,
       char&nbsp;escapeChar)</code>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
</td>
</tr>
<tr id="i91" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#notLike-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">notLike</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
       <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern,
       <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;escapeChar)</code>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
</td>
</tr>
<tr id="i92" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#notLike-javax.persistence.criteria.Expression-java.lang.String-">notLike</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
       java.lang.String&nbsp;pattern)</code>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
</td>
</tr>
<tr id="i93" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#notLike-javax.persistence.criteria.Expression-java.lang.String-char-">notLike</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
       java.lang.String&nbsp;pattern,
       char&nbsp;escapeChar)</code>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
</td>
</tr>
<tr id="i94" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#notLike-javax.persistence.criteria.Expression-java.lang.String-javax.persistence.criteria.Expression-">notLike</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
       java.lang.String&nbsp;pattern,
       <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;escapeChar)</code>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
</td>
</tr>
<tr id="i95" class="rowColor">
<td class="colFirst"><code>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#nullif-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">nullif</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;x,
      <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;y)</code>
<div class="block">Create an expression that tests whether its argument are
 equal, returning null if they are and the value of the
 first expression if they are not.</div>
</td>
</tr>
<tr id="i96" class="altColor">
<td class="colFirst"><code>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#nullif-javax.persistence.criteria.Expression-Y-">nullif</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;x,
      Y&nbsp;y)</code>
<div class="block">Create an expression that tests whether its argument are
 equal, returning null if they are and the value of the
 first expression if they are not.</div>
</td>
</tr>
<tr id="i97" class="rowColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#nullLiteral-java.lang.Class-">nullLiteral</a></span>(java.lang.Class&lt;T&gt;&nbsp;resultClass)</code>
<div class="block">Create an expression for a null literal with the given type.</div>
</td>
</tr>
<tr id="i98" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#or-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">or</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;x,
  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;y)</code>
<div class="block">Create a disjunction of the given boolean expressions.</div>
</td>
</tr>
<tr id="i99" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#or-javax.persistence.criteria.Predicate...-">or</a></span>(<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>...&nbsp;restrictions)</code>
<div class="block">Create a disjunction of the given restriction predicates.</div>
</td>
</tr>
<tr id="i100" class="altColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/ParameterExpression.html" title="interface in javax.persistence.criteria">ParameterExpression</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#parameter-java.lang.Class-">parameter</a></span>(java.lang.Class&lt;T&gt;&nbsp;paramClass)</code>
<div class="block">Create a parameter expression.</div>
</td>
</tr>
<tr id="i101" class="rowColor">
<td class="colFirst"><code>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/ParameterExpression.html" title="interface in javax.persistence.criteria">ParameterExpression</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#parameter-java.lang.Class-java.lang.String-">parameter</a></span>(java.lang.Class&lt;T&gt;&nbsp;paramClass,
         java.lang.String&nbsp;name)</code>
<div class="block">Create a parameter expression with the given name.</div>
</td>
</tr>
<tr id="i102" class="altColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#prod-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">prod</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns the product
 of its arguments.</div>
</td>
</tr>
<tr id="i103" class="rowColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#prod-javax.persistence.criteria.Expression-N-">prod</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
    N&nbsp;y)</code>
<div class="block">Create an expression that returns the product
 of its arguments.</div>
</td>
</tr>
<tr id="i104" class="altColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#prod-N-javax.persistence.criteria.Expression-">prod</a></span>(N&nbsp;x,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns the product
 of its arguments.</div>
</td>
</tr>
<tr id="i105" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Number&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#quot-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">quot</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns the quotient
 of its arguments.</div>
</td>
</tr>
<tr id="i106" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Number&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#quot-javax.persistence.criteria.Expression-java.lang.Number-">quot</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
    java.lang.Number&nbsp;y)</code>
<div class="block">Create an expression that returns the quotient
 of its arguments.</div>
</td>
</tr>
<tr id="i107" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Number&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#quot-java.lang.Number-javax.persistence.criteria.Expression-">quot</a></span>(java.lang.Number&nbsp;x,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns the quotient
 of its arguments.</div>
</td>
</tr>
<tr id="i108" class="altColor">
<td class="colFirst"><code>&lt;R&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaBuilder.Case.html" title="interface in javax.persistence.criteria">CriteriaBuilder.Case</a>&lt;R&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#selectCase--">selectCase</a></span>()</code>
<div class="block">Create a general case expression.</div>
</td>
</tr>
<tr id="i109" class="rowColor">
<td class="colFirst"><code>&lt;C,R&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaBuilder.SimpleCase.html" title="interface in javax.persistence.criteria">CriteriaBuilder.SimpleCase</a>&lt;C,R&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#selectCase-javax.persistence.criteria.Expression-">selectCase</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends C&gt;&nbsp;expression)</code>
<div class="block">Create a simple case expression.</div>
</td>
</tr>
<tr id="i110" class="altColor">
<td class="colFirst"><code>&lt;C extends java.util.Collection&lt;?&gt;&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#size-C-">size</a></span>(C&nbsp;collection)</code>
<div class="block">Create an expression that tests the size of a collection.</div>
</td>
</tr>
<tr id="i111" class="rowColor">
<td class="colFirst"><code>&lt;C extends java.util.Collection&lt;?&gt;&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#size-javax.persistence.criteria.Expression-">size</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</code>
<div class="block">Create an expression that tests the size of a collection.</div>
</td>
</tr>
<tr id="i112" class="altColor">
<td class="colFirst"><code>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#some-javax.persistence.criteria.Subquery-">some</a></span>(<a href="../../../javax/persistence/criteria/Subquery.html" title="interface in javax.persistence.criteria">Subquery</a>&lt;Y&gt;&nbsp;subquery)</code>
<div class="block">Create a some expression over the subquery results.</div>
</td>
</tr>
<tr id="i113" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Double&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#sqrt-javax.persistence.criteria.Expression-">sqrt</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x)</code>
<div class="block">Create an expression that returns the square root
 of its argument.</div>
</td>
</tr>
<tr id="i114" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#substring-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">substring</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
         <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;from)</code>
<div class="block">Create an expression for substring extraction.</div>
</td>
</tr>
<tr id="i115" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#substring-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">substring</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
         <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;from,
         <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;len)</code>
<div class="block">Create an expression for substring extraction.</div>
</td>
</tr>
<tr id="i116" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#substring-javax.persistence.criteria.Expression-int-">substring</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
         int&nbsp;from)</code>
<div class="block">Create an expression for substring extraction.</div>
</td>
</tr>
<tr id="i117" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#substring-javax.persistence.criteria.Expression-int-int-">substring</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
         int&nbsp;from,
         int&nbsp;len)</code>
<div class="block">Create an expression for substring extraction.</div>
</td>
</tr>
<tr id="i118" class="altColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#sum-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">sum</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
   <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns the sum
 of its arguments.</div>
</td>
</tr>
<tr id="i119" class="rowColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#sum-javax.persistence.criteria.Expression-N-">sum</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
   N&nbsp;y)</code>
<div class="block">Create an expression that returns the sum
 of its arguments.</div>
</td>
</tr>
<tr id="i120" class="altColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#sum-javax.persistence.criteria.Expression-">sum</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</code>
<div class="block">Create an aggregate expression applying the sum operation.</div>
</td>
</tr>
<tr id="i121" class="rowColor">
<td class="colFirst"><code>&lt;N extends java.lang.Number&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#sum-N-javax.persistence.criteria.Expression-">sum</a></span>(N&nbsp;x,
   <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</code>
<div class="block">Create an expression that returns the sum
 of its arguments.</div>
</td>
</tr>
<tr id="i122" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Double&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#sumAsDouble-javax.persistence.criteria.Expression-">sumAsDouble</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Float&gt;&nbsp;x)</code>
<div class="block">Create an aggregate expression applying the sum operation to a
 Float-valued expression, returning a Double result.</div>
</td>
</tr>
<tr id="i123" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Long&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#sumAsLong-javax.persistence.criteria.Expression-">sumAsLong</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;x)</code>
<div class="block">Create an aggregate expression applying the sum operation to an
 Integer-valued expression, returning a Long result.</div>
</td>
</tr>
<tr id="i124" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.math.BigDecimal&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#toBigDecimal-javax.persistence.criteria.Expression-">toBigDecimal</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</code>
<div class="block">Typecast.</div>
</td>
</tr>
<tr id="i125" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.math.BigInteger&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#toBigInteger-javax.persistence.criteria.Expression-">toBigInteger</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</code>
<div class="block">Typecast.</div>
</td>
</tr>
<tr id="i126" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Double&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#toDouble-javax.persistence.criteria.Expression-">toDouble</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</code>
<div class="block">Typecast.</div>
</td>
</tr>
<tr id="i127" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Float&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#toFloat-javax.persistence.criteria.Expression-">toFloat</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</code>
<div class="block">Typecast.</div>
</td>
</tr>
<tr id="i128" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#toInteger-javax.persistence.criteria.Expression-">toInteger</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</code>
<div class="block">Typecast.</div>
</td>
</tr>
<tr id="i129" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Long&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#toLong-javax.persistence.criteria.Expression-">toLong</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</code>
<div class="block">Typecast.</div>
</td>
</tr>
<tr id="i130" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#toString-javax.persistence.criteria.Expression-">toString</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;character)</code>
<div class="block">Typecast.</div>
</td>
</tr>
<tr id="i131" class="rowColor">
<td class="colFirst"><code>&lt;X,T,E extends T&gt;<br><a href="../../../javax/persistence/criteria/CollectionJoin.html" title="interface in javax.persistence.criteria">CollectionJoin</a>&lt;X,E&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#treat-javax.persistence.criteria.CollectionJoin-java.lang.Class-">treat</a></span>(<a href="../../../javax/persistence/criteria/CollectionJoin.html" title="interface in javax.persistence.criteria">CollectionJoin</a>&lt;X,T&gt;&nbsp;join,
     java.lang.Class&lt;E&gt;&nbsp;type)</code>
<div class="block">Downcast CollectionJoin object to the specified type.</div>
</td>
</tr>
<tr id="i132" class="altColor">
<td class="colFirst"><code>&lt;X,T,V extends T&gt;<br><a href="../../../javax/persistence/criteria/Join.html" title="interface in javax.persistence.criteria">Join</a>&lt;X,V&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#treat-javax.persistence.criteria.Join-java.lang.Class-">treat</a></span>(<a href="../../../javax/persistence/criteria/Join.html" title="interface in javax.persistence.criteria">Join</a>&lt;X,T&gt;&nbsp;join,
     java.lang.Class&lt;V&gt;&nbsp;type)</code>
<div class="block">Downcast Join object to the specified type.</div>
</td>
</tr>
<tr id="i133" class="rowColor">
<td class="colFirst"><code>&lt;X,T,E extends T&gt;<br><a href="../../../javax/persistence/criteria/ListJoin.html" title="interface in javax.persistence.criteria">ListJoin</a>&lt;X,E&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#treat-javax.persistence.criteria.ListJoin-java.lang.Class-">treat</a></span>(<a href="../../../javax/persistence/criteria/ListJoin.html" title="interface in javax.persistence.criteria">ListJoin</a>&lt;X,T&gt;&nbsp;join,
     java.lang.Class&lt;E&gt;&nbsp;type)</code>
<div class="block">Downcast ListJoin object to the specified type.</div>
</td>
</tr>
<tr id="i134" class="altColor">
<td class="colFirst"><code>&lt;X,K,T,V extends T&gt;<br><a href="../../../javax/persistence/criteria/MapJoin.html" title="interface in javax.persistence.criteria">MapJoin</a>&lt;X,K,V&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#treat-javax.persistence.criteria.MapJoin-java.lang.Class-">treat</a></span>(<a href="../../../javax/persistence/criteria/MapJoin.html" title="interface in javax.persistence.criteria">MapJoin</a>&lt;X,K,T&gt;&nbsp;join,
     java.lang.Class&lt;V&gt;&nbsp;type)</code>
<div class="block">Downcast MapJoin object to the specified type.</div>
</td>
</tr>
<tr id="i135" class="rowColor">
<td class="colFirst"><code>&lt;X,T extends X&gt;<br><a href="../../../javax/persistence/criteria/Path.html" title="interface in javax.persistence.criteria">Path</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#treat-javax.persistence.criteria.Path-java.lang.Class-">treat</a></span>(<a href="../../../javax/persistence/criteria/Path.html" title="interface in javax.persistence.criteria">Path</a>&lt;X&gt;&nbsp;path,
     java.lang.Class&lt;T&gt;&nbsp;type)</code>
<div class="block">Downcast Path object to the specified type.</div>
</td>
</tr>
<tr id="i136" class="altColor">
<td class="colFirst"><code>&lt;X,T extends X&gt;<br><a href="../../../javax/persistence/criteria/Root.html" title="interface in javax.persistence.criteria">Root</a>&lt;T&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#treat-javax.persistence.criteria.Root-java.lang.Class-">treat</a></span>(<a href="../../../javax/persistence/criteria/Root.html" title="interface in javax.persistence.criteria">Root</a>&lt;X&gt;&nbsp;root,
     java.lang.Class&lt;T&gt;&nbsp;type)</code>
<div class="block">Downcast Root object to the specified type.</div>
</td>
</tr>
<tr id="i137" class="rowColor">
<td class="colFirst"><code>&lt;X,T,E extends T&gt;<br><a href="../../../javax/persistence/criteria/SetJoin.html" title="interface in javax.persistence.criteria">SetJoin</a>&lt;X,E&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#treat-javax.persistence.criteria.SetJoin-java.lang.Class-">treat</a></span>(<a href="../../../javax/persistence/criteria/SetJoin.html" title="interface in javax.persistence.criteria">SetJoin</a>&lt;X,T&gt;&nbsp;join,
     java.lang.Class&lt;E&gt;&nbsp;type)</code>
<div class="block">Downcast SetJoin object to the specified type.</div>
</td>
</tr>
<tr id="i138" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#trim-char-javax.persistence.criteria.Expression-">trim</a></span>(char&nbsp;t,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</code>
<div class="block">Create expression to trim character from both ends of
 a string.</div>
</td>
</tr>
<tr id="i139" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#trim-javax.persistence.criteria.CriteriaBuilder.Trimspec-char-javax.persistence.criteria.Expression-">trim</a></span>(<a href="../../../javax/persistence/criteria/CriteriaBuilder.Trimspec.html" title="enum in javax.persistence.criteria">CriteriaBuilder.Trimspec</a>&nbsp;ts,
    char&nbsp;t,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</code>
<div class="block">Create expression to trim character from a string.</div>
</td>
</tr>
<tr id="i140" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#trim-javax.persistence.criteria.CriteriaBuilder.Trimspec-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">trim</a></span>(<a href="../../../javax/persistence/criteria/CriteriaBuilder.Trimspec.html" title="enum in javax.persistence.criteria">CriteriaBuilder.Trimspec</a>&nbsp;ts,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;t,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</code>
<div class="block">Create expression to trim character from a string.</div>
</td>
</tr>
<tr id="i141" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#trim-javax.persistence.criteria.CriteriaBuilder.Trimspec-javax.persistence.criteria.Expression-">trim</a></span>(<a href="../../../javax/persistence/criteria/CriteriaBuilder.Trimspec.html" title="enum in javax.persistence.criteria">CriteriaBuilder.Trimspec</a>&nbsp;ts,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</code>
<div class="block">Create expression to trim blanks from a string.</div>
</td>
</tr>
<tr id="i142" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#trim-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">trim</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;t,
    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</code>
<div class="block">Create expression to trim character from both ends of
 a string.</div>
</td>
</tr>
<tr id="i143" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#trim-javax.persistence.criteria.Expression-">trim</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</code>
<div class="block">Create expression to trim blanks from both ends of
 a string.</div>
</td>
</tr>
<tr id="i144" class="altColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/CompoundSelection.html" title="interface in javax.persistence.criteria">CompoundSelection</a>&lt;<a href="../../../javax/persistence/Tuple.html" title="interface in javax.persistence">Tuple</a>&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#tuple-javax.persistence.criteria.Selection...-">tuple</a></span>(<a href="../../../javax/persistence/criteria/Selection.html" title="interface in javax.persistence.criteria">Selection</a>&lt;?&gt;...&nbsp;selections)</code>
<div class="block">Create a tuple-valued selection item.</div>
</td>
</tr>
<tr id="i145" class="rowColor">
<td class="colFirst"><code><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#upper-javax.persistence.criteria.Expression-">upper</a></span>(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</code>
<div class="block">Create expression for converting a string to uppercase.</div>
</td>
</tr>
<tr id="i146" class="altColor">
<td class="colFirst"><code>&lt;V,M extends java.util.Map&lt;?,V&gt;&gt;<br><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.util.Collection&lt;V&gt;&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../javax/persistence/criteria/CriteriaBuilder.html#values-M-">values</a></span>(M&nbsp;map)</code>
<div class="block">Create an expression that returns the values of a map.</div>
</td>
</tr>
</table>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="createQuery--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createQuery</h4>
<pre><a href="../../../javax/persistence/criteria/CriteriaQuery.html" title="interface in javax.persistence.criteria">CriteriaQuery</a>&lt;java.lang.Object&gt;&nbsp;createQuery()</pre>
<div class="block">Create a <code>CriteriaQuery</code> object.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>criteria query object</dd>
</dl>
</li>
</ul>
<a name="createQuery-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createQuery</h4>
<pre>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaQuery.html" title="interface in javax.persistence.criteria">CriteriaQuery</a>&lt;T&gt;&nbsp;createQuery(java.lang.Class&lt;T&gt;&nbsp;resultClass)</pre>
<div class="block">Create a <code>CriteriaQuery</code> object with the specified result 
  type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>resultClass</code> - type of the query result</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>criteria query object</dd>
</dl>
</li>
</ul>
<a name="createTupleQuery--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createTupleQuery</h4>
<pre><a href="../../../javax/persistence/criteria/CriteriaQuery.html" title="interface in javax.persistence.criteria">CriteriaQuery</a>&lt;<a href="../../../javax/persistence/Tuple.html" title="interface in javax.persistence">Tuple</a>&gt;&nbsp;createTupleQuery()</pre>
<div class="block">Create a <code>CriteriaQuery</code> object that returns a tuple of 
  objects as its result.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>criteria query object</dd>
</dl>
</li>
</ul>
<a name="createCriteriaUpdate-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCriteriaUpdate</h4>
<pre>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaUpdate.html" title="interface in javax.persistence.criteria">CriteriaUpdate</a>&lt;T&gt;&nbsp;createCriteriaUpdate(java.lang.Class&lt;T&gt;&nbsp;targetEntity)</pre>
<div class="block">Create a <code>CriteriaUpdate</code> query object to perform a bulk update operation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>targetEntity</code> - target type for update operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the query object</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Java Persistence 2.1</dd>
</dl>
</li>
</ul>
<a name="createCriteriaDelete-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createCriteriaDelete</h4>
<pre>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaDelete.html" title="interface in javax.persistence.criteria">CriteriaDelete</a>&lt;T&gt;&nbsp;createCriteriaDelete(java.lang.Class&lt;T&gt;&nbsp;targetEntity)</pre>
<div class="block">Create a <code>CriteriaDelete</code> query object to perform a bulk delete operation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>targetEntity</code> - target type for delete operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the query object</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Java Persistence 2.1</dd>
</dl>
</li>
</ul>
<a name="construct-java.lang.Class-javax.persistence.criteria.Selection...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>construct</h4>
<pre>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/CompoundSelection.html" title="interface in javax.persistence.criteria">CompoundSelection</a>&lt;Y&gt;&nbsp;construct(java.lang.Class&lt;Y&gt;&nbsp;resultClass,
                                   <a href="../../../javax/persistence/criteria/Selection.html" title="interface in javax.persistence.criteria">Selection</a>&lt;?&gt;...&nbsp;selections)</pre>
<div class="block">Create a selection item corresponding to a constructor.
 This method is used to specify a constructor that will be
 applied to the results of the query execution. If the
 constructor is for an entity class, the resulting entities
 will be in the new state after the query is executed.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>resultClass</code> - class whose instance is to be constructed</dd>
<dd><code>selections</code> - arguments to the constructor</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>compound selection item</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>java.lang.IllegalArgumentException</code> - if an argument is a 
         tuple- or array-valued selection item</dd>
</dl>
</li>
</ul>
<a name="tuple-javax.persistence.criteria.Selection...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>tuple</h4>
<pre><a href="../../../javax/persistence/criteria/CompoundSelection.html" title="interface in javax.persistence.criteria">CompoundSelection</a>&lt;<a href="../../../javax/persistence/Tuple.html" title="interface in javax.persistence">Tuple</a>&gt;&nbsp;tuple(<a href="../../../javax/persistence/criteria/Selection.html" title="interface in javax.persistence.criteria">Selection</a>&lt;?&gt;...&nbsp;selections)</pre>
<div class="block">Create a tuple-valued selection item.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selections</code> - selection items</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>tuple-valued compound selection</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>java.lang.IllegalArgumentException</code> - if an argument is a 
         tuple- or array-valued selection item</dd>
</dl>
</li>
</ul>
<a name="array-javax.persistence.criteria.Selection...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>array</h4>
<pre><a href="../../../javax/persistence/criteria/CompoundSelection.html" title="interface in javax.persistence.criteria">CompoundSelection</a>&lt;java.lang.Object[]&gt;&nbsp;array(<a href="../../../javax/persistence/criteria/Selection.html" title="interface in javax.persistence.criteria">Selection</a>&lt;?&gt;...&nbsp;selections)</pre>
<div class="block">Create an array-valued selection item.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>selections</code> - selection items</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>array-valued compound selection</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>java.lang.IllegalArgumentException</code> - if an argument is a 
         tuple- or array-valued selection item</dd>
</dl>
</li>
</ul>
<a name="asc-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>asc</h4>
<pre><a href="../../../javax/persistence/criteria/Order.html" title="interface in javax.persistence.criteria">Order</a>&nbsp;asc(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</pre>
<div class="block">Create an ordering by the ascending value of the expression.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression used to define the ordering</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>ascending ordering corresponding to the expression</dd>
</dl>
</li>
</ul>
<a name="desc-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>desc</h4>
<pre><a href="../../../javax/persistence/criteria/Order.html" title="interface in javax.persistence.criteria">Order</a>&nbsp;desc(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</pre>
<div class="block">Create an ordering by the descending value of the expression.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression used to define the ordering</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>descending ordering corresponding to the expression</dd>
</dl>
</li>
</ul>
<a name="avg-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>avg</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Double&gt;&nbsp;avg(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</pre>
<div class="block">Create an aggregate expression applying the avg operation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression representing input value to avg operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>avg expression</dd>
</dl>
</li>
</ul>
<a name="sum-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sum</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;sum(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</pre>
<div class="block">Create an aggregate expression applying the sum operation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression representing input value to sum operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>sum expression</dd>
</dl>
</li>
</ul>
<a name="sumAsLong-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sumAsLong</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Long&gt;&nbsp;sumAsLong(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;x)</pre>
<div class="block">Create an aggregate expression applying the sum operation to an
 Integer-valued expression, returning a Long result.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression representing input value to sum operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>sum expression</dd>
</dl>
</li>
</ul>
<a name="sumAsDouble-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sumAsDouble</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Double&gt;&nbsp;sumAsDouble(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Float&gt;&nbsp;x)</pre>
<div class="block">Create an aggregate expression applying the sum operation to a
 Float-valued expression, returning a Double result.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression representing input value to sum operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>sum expression</dd>
</dl>
</li>
</ul>
<a name="max-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>max</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;max(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</pre>
<div class="block">Create an aggregate expression applying the numerical max 
 operation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression representing input value to max operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>max expression</dd>
</dl>
</li>
</ul>
<a name="min-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>min</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;min(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</pre>
<div class="block">Create an aggregate expression applying the numerical min 
 operation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression representing input value to min operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>min expression</dd>
</dl>
</li>
</ul>
<a name="greatest-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>greatest</h4>
<pre>&lt;X extends java.lang.Comparable&lt;? super X&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;X&gt;&nbsp;greatest(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;X&gt;&nbsp;x)</pre>
<div class="block">Create an aggregate expression for finding the greatest of
 the values (strings, dates, etc).</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression representing input value to greatest
           operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>greatest expression</dd>
</dl>
</li>
</ul>
<a name="least-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>least</h4>
<pre>&lt;X extends java.lang.Comparable&lt;? super X&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;X&gt;&nbsp;least(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;X&gt;&nbsp;x)</pre>
<div class="block">Create an aggregate expression for finding the least of
 the values (strings, dates, etc).</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression representing input value to least
           operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>least expression</dd>
</dl>
</li>
</ul>
<a name="count-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>count</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Long&gt;&nbsp;count(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</pre>
<div class="block">Create an aggregate expression applying the count operation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression representing input value to count 
           operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>count expression</dd>
</dl>
</li>
</ul>
<a name="countDistinct-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>countDistinct</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Long&gt;&nbsp;countDistinct(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</pre>
<div class="block">Create an aggregate expression applying the count distinct 
 operation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression representing input value to 
        count distinct operation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>count distinct expression</dd>
</dl>
</li>
</ul>
<a name="exists-javax.persistence.criteria.Subquery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>exists</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;exists(<a href="../../../javax/persistence/criteria/Subquery.html" title="interface in javax.persistence.criteria">Subquery</a>&lt;?&gt;&nbsp;subquery)</pre>
<div class="block">Create a predicate testing the existence of a subquery result.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>subquery</code> - subquery whose result is to be tested</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>exists predicate</dd>
</dl>
</li>
</ul>
<a name="all-javax.persistence.criteria.Subquery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>all</h4>
<pre>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;all(<a href="../../../javax/persistence/criteria/Subquery.html" title="interface in javax.persistence.criteria">Subquery</a>&lt;Y&gt;&nbsp;subquery)</pre>
<div class="block">Create an all expression over the subquery results.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>subquery</code> - subquery</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>all expression</dd>
</dl>
</li>
</ul>
<a name="some-javax.persistence.criteria.Subquery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>some</h4>
<pre>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;some(<a href="../../../javax/persistence/criteria/Subquery.html" title="interface in javax.persistence.criteria">Subquery</a>&lt;Y&gt;&nbsp;subquery)</pre>
<div class="block">Create a some expression over the subquery results.
 This expression is equivalent to an <code>any</code> expression.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>subquery</code> - subquery</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>some expression</dd>
</dl>
</li>
</ul>
<a name="any-javax.persistence.criteria.Subquery-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>any</h4>
<pre>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;any(<a href="../../../javax/persistence/criteria/Subquery.html" title="interface in javax.persistence.criteria">Subquery</a>&lt;Y&gt;&nbsp;subquery)</pre>
<div class="block">Create an any expression over the subquery results. 
 This expression is equivalent to a <code>some</code> expression.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>subquery</code> - subquery</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>any expression</dd>
</dl>
</li>
</ul>
<a name="and-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>and</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;and(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;x,
              <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;y)</pre>
<div class="block">Create a conjunction of the given boolean expressions.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - boolean expression</dd>
<dd><code>y</code> - boolean expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>and predicate</dd>
</dl>
</li>
</ul>
<a name="and-javax.persistence.criteria.Predicate...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>and</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;and(<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>...&nbsp;restrictions)</pre>
<div class="block">Create a conjunction of the given restriction predicates.
 A conjunction of zero predicates is true.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>restrictions</code> - zero or more restriction predicates</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>and predicate</dd>
</dl>
</li>
</ul>
<a name="or-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>or</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;or(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;x,
             <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;y)</pre>
<div class="block">Create a disjunction of the given boolean expressions.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - boolean expression</dd>
<dd><code>y</code> - boolean expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>or predicate</dd>
</dl>
</li>
</ul>
<a name="or-javax.persistence.criteria.Predicate...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>or</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;or(<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>...&nbsp;restrictions)</pre>
<div class="block">Create a disjunction of the given restriction predicates.
 A disjunction of zero predicates is false.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>restrictions</code> - zero or more restriction predicates</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>or predicate</dd>
</dl>
</li>
</ul>
<a name="not-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>not</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;not(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;restriction)</pre>
<div class="block">Create a negation of the given restriction.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>restriction</code> - restriction expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>not predicate</dd>
</dl>
</li>
</ul>
<a name="conjunction--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>conjunction</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;conjunction()</pre>
<div class="block">Create a conjunction (with zero conjuncts).
 A conjunction with zero conjuncts is true.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>and predicate</dd>
</dl>
</li>
</ul>
<a name="disjunction--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>disjunction</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;disjunction()</pre>
<div class="block">Create a disjunction (with zero disjuncts).
 A disjunction with zero disjuncts is false.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>or predicate</dd>
</dl>
</li>
</ul>
<a name="isTrue-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isTrue</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;isTrue(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;x)</pre>
<div class="block">Create a predicate testing for a true value.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression to be tested</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>predicate</dd>
</dl>
</li>
</ul>
<a name="isFalse-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isFalse</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;isFalse(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Boolean&gt;&nbsp;x)</pre>
<div class="block">Create a predicate testing for a false value.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression to be tested</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>predicate</dd>
</dl>
</li>
</ul>
<a name="isNull-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isNull</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;isNull(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</pre>
<div class="block">Create a predicate to test whether the expression is null.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>is-null predicate</dd>
</dl>
</li>
</ul>
<a name="isNotNull-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isNotNull</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;isNotNull(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x)</pre>
<div class="block">Create a predicate to test whether the expression is not null.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>is-not-null predicate</dd>
</dl>
</li>
</ul>
<a name="equal-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>equal</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;equal(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x,
                <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing the arguments for equality.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>equality predicate</dd>
</dl>
</li>
</ul>
<a name="equal-javax.persistence.criteria.Expression-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>equal</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;equal(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x,
                java.lang.Object&nbsp;y)</pre>
<div class="block">Create a predicate for testing the arguments for equality.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - object</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>equality predicate</dd>
</dl>
</li>
</ul>
<a name="notEqual-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>notEqual</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;notEqual(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x,
                   <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing the arguments for inequality.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>inequality predicate</dd>
</dl>
</li>
</ul>
<a name="notEqual-javax.persistence.criteria.Expression-java.lang.Object-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>notEqual</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;notEqual(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;x,
                   java.lang.Object&nbsp;y)</pre>
<div class="block">Create a predicate for testing the arguments for inequality.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - object</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>inequality predicate</dd>
</dl>
</li>
</ul>
<a name="greaterThan-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>greaterThan</h4>
<pre>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;greaterThan(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                                                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>greater-than predicate</dd>
</dl>
</li>
</ul>
<a name="greaterThan-javax.persistence.criteria.Expression-java.lang.Comparable-">
<!--   -->
</a><a name="greaterThan-javax.persistence.criteria.Expression-Y-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>greaterThan</h4>
<pre>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;greaterThan(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                                                                  Y&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>greater-than predicate</dd>
</dl>
</li>
</ul>
<a name="greaterThanOrEqualTo-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>greaterThanOrEqualTo</h4>
<pre>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;greaterThanOrEqualTo(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                                                                           <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than or equal to the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>greater-than-or-equal predicate</dd>
</dl>
</li>
</ul>
<a name="greaterThanOrEqualTo-javax.persistence.criteria.Expression-java.lang.Comparable-">
<!--   -->
</a><a name="greaterThanOrEqualTo-javax.persistence.criteria.Expression-Y-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>greaterThanOrEqualTo</h4>
<pre>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;greaterThanOrEqualTo(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                                                                           Y&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than or equal to the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>greater-than-or-equal predicate</dd>
</dl>
</li>
</ul>
<a name="lessThan-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>lessThan</h4>
<pre>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;lessThan(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                                                               <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 less than the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>less-than predicate</dd>
</dl>
</li>
</ul>
<a name="lessThan-javax.persistence.criteria.Expression-java.lang.Comparable-">
<!--   -->
</a><a name="lessThan-javax.persistence.criteria.Expression-Y-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>lessThan</h4>
<pre>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;lessThan(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                                                               Y&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 less than the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>less-than predicate</dd>
</dl>
</li>
</ul>
<a name="lessThanOrEqualTo-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>lessThanOrEqualTo</h4>
<pre>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;lessThanOrEqualTo(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                                                                        <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 less than or equal to the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>less-than-or-equal predicate</dd>
</dl>
</li>
</ul>
<a name="lessThanOrEqualTo-javax.persistence.criteria.Expression-java.lang.Comparable-">
<!--   -->
</a><a name="lessThanOrEqualTo-javax.persistence.criteria.Expression-Y-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>lessThanOrEqualTo</h4>
<pre>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;lessThanOrEqualTo(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                                                                        Y&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 less than or equal to the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>less-than-or-equal predicate</dd>
</dl>
</li>
</ul>
<a name="between-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>between</h4>
<pre>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;between(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;v,
                                                              <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                                                              <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 between the second and third arguments in value.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>v</code> - expression</dd>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>between predicate</dd>
</dl>
</li>
</ul>
<a name="between-javax.persistence.criteria.Expression-java.lang.Comparable-java.lang.Comparable-">
<!--   -->
</a><a name="between-javax.persistence.criteria.Expression-Y-Y-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>between</h4>
<pre>&lt;Y extends java.lang.Comparable&lt;? super Y&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;between(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;v,
                                                              Y&nbsp;x,
                                                              Y&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 between the second and third arguments in value.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>v</code> - expression</dd>
<dd><code>x</code> - value</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>between predicate</dd>
</dl>
</li>
</ul>
<a name="gt-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>gt</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;gt(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
             <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>greater-than predicate</dd>
</dl>
</li>
</ul>
<a name="gt-javax.persistence.criteria.Expression-java.lang.Number-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>gt</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;gt(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
             java.lang.Number&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>greater-than predicate</dd>
</dl>
</li>
</ul>
<a name="ge-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ge</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;ge(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
             <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than or equal to the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>greater-than-or-equal predicate</dd>
</dl>
</li>
</ul>
<a name="ge-javax.persistence.criteria.Expression-java.lang.Number-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ge</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;ge(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
             java.lang.Number&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 greater than or equal to the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>greater-than-or-equal predicate</dd>
</dl>
</li>
</ul>
<a name="lt-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>lt</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;lt(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
             <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 less than the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>less-than predicate</dd>
</dl>
</li>
</ul>
<a name="lt-javax.persistence.criteria.Expression-java.lang.Number-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>lt</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;lt(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
             java.lang.Number&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 less than the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>less-than predicate</dd>
</dl>
</li>
</ul>
<a name="le-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>le</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;le(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
             <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 less than or equal to the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>less-than-or-equal predicate</dd>
</dl>
</li>
</ul>
<a name="le-javax.persistence.criteria.Expression-java.lang.Number-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>le</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;le(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
             java.lang.Number&nbsp;y)</pre>
<div class="block">Create a predicate for testing whether the first argument is 
 less than or equal to the second.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>less-than-or-equal predicate</dd>
</dl>
</li>
</ul>
<a name="neg-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>neg</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;neg(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</pre>
<div class="block">Create an expression that returns the arithmetic negation
 of its argument.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>arithmetic negation</dd>
</dl>
</li>
</ul>
<a name="abs-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>abs</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;abs(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;x)</pre>
<div class="block">Create an expression that returns the absolute value
 of its argument.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>absolute value</dd>
</dl>
</li>
</ul>
<a name="sum-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sum</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;sum(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
                                               <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns the sum
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>sum</dd>
</dl>
</li>
</ul>
<a name="sum-javax.persistence.criteria.Expression-java.lang.Number-">
<!--   -->
</a><a name="sum-javax.persistence.criteria.Expression-N-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sum</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;sum(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
                                               N&nbsp;y)</pre>
<div class="block">Create an expression that returns the sum
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>sum</dd>
</dl>
</li>
</ul>
<a name="sum-java.lang.Number-javax.persistence.criteria.Expression-">
<!--   -->
</a><a name="sum-N-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sum</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;sum(N&nbsp;x,
                                               <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns the sum
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - value</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>sum</dd>
</dl>
</li>
</ul>
<a name="prod-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>prod</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;prod(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
                                                <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns the product
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>product</dd>
</dl>
</li>
</ul>
<a name="prod-javax.persistence.criteria.Expression-java.lang.Number-">
<!--   -->
</a><a name="prod-javax.persistence.criteria.Expression-N-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>prod</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;prod(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
                                                N&nbsp;y)</pre>
<div class="block">Create an expression that returns the product
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>product</dd>
</dl>
</li>
</ul>
<a name="prod-java.lang.Number-javax.persistence.criteria.Expression-">
<!--   -->
</a><a name="prod-N-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>prod</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;prod(N&nbsp;x,
                                                <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns the product
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - value</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>product</dd>
</dl>
</li>
</ul>
<a name="diff-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>diff</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;diff(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
                                                <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns the difference
 between its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>difference</dd>
</dl>
</li>
</ul>
<a name="diff-javax.persistence.criteria.Expression-java.lang.Number-">
<!--   -->
</a><a name="diff-javax.persistence.criteria.Expression-N-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>diff</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;diff(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;x,
                                                N&nbsp;y)</pre>
<div class="block">Create an expression that returns the difference
 between its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>difference</dd>
</dl>
</li>
</ul>
<a name="diff-java.lang.Number-javax.persistence.criteria.Expression-">
<!--   -->
</a><a name="diff-N-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>diff</h4>
<pre>&lt;N extends java.lang.Number&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;N&gt;&nbsp;diff(N&nbsp;x,
                                                <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends N&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns the difference
 between its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - value</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>difference</dd>
</dl>
</li>
</ul>
<a name="quot-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>quot</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Number&gt;&nbsp;quot(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns the quotient
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>quotient</dd>
</dl>
</li>
</ul>
<a name="quot-javax.persistence.criteria.Expression-java.lang.Number-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>quot</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Number&gt;&nbsp;quot(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x,
                                  java.lang.Number&nbsp;y)</pre>
<div class="block">Create an expression that returns the quotient
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>quotient</dd>
</dl>
</li>
</ul>
<a name="quot-java.lang.Number-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>quot</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Number&gt;&nbsp;quot(java.lang.Number&nbsp;x,
                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns the quotient
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - value</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>quotient</dd>
</dl>
</li>
</ul>
<a name="mod-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>mod</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;mod(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;x,
                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns the modulus
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>modulus</dd>
</dl>
</li>
</ul>
<a name="mod-javax.persistence.criteria.Expression-java.lang.Integer-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>mod</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;mod(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;x,
                                  java.lang.Integer&nbsp;y)</pre>
<div class="block">Create an expression that returns the modulus
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>modulus</dd>
</dl>
</li>
</ul>
<a name="mod-java.lang.Integer-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>mod</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;mod(java.lang.Integer&nbsp;x,
                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns the modulus
 of its arguments.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - value</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>modulus</dd>
</dl>
</li>
</ul>
<a name="sqrt-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sqrt</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Double&gt;&nbsp;sqrt(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;x)</pre>
<div class="block">Create an expression that returns the square root
 of its argument.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>square root</dd>
</dl>
</li>
</ul>
<a name="toLong-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toLong</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Long&gt;&nbsp;toLong(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</pre>
<div class="block">Typecast.  Returns same expression object.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>number</code> - numeric expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression&#060;Long&#062;</dd>
</dl>
</li>
</ul>
<a name="toInteger-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toInteger</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;toInteger(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</pre>
<div class="block">Typecast.  Returns same expression object.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>number</code> - numeric expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression&#060;Integer&#062;</dd>
</dl>
</li>
</ul>
<a name="toFloat-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toFloat</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Float&gt;&nbsp;toFloat(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</pre>
<div class="block">Typecast. Returns same expression object.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>number</code> - numeric expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression&#060;Float&#062;</dd>
</dl>
</li>
</ul>
<a name="toDouble-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toDouble</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Double&gt;&nbsp;toDouble(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</pre>
<div class="block">Typecast.  Returns same expression object.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>number</code> - numeric expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression&#060;Double&#062;</dd>
</dl>
</li>
</ul>
<a name="toBigDecimal-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toBigDecimal</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.math.BigDecimal&gt;&nbsp;toBigDecimal(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</pre>
<div class="block">Typecast.  Returns same expression object.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>number</code> - numeric expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression&#060;BigDecimal&#062;</dd>
</dl>
</li>
</ul>
<a name="toBigInteger-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toBigInteger</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.math.BigInteger&gt;&nbsp;toBigInteger(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends java.lang.Number&gt;&nbsp;number)</pre>
<div class="block">Typecast.  Returns same expression object.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>number</code> - numeric expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression&#060;BigInteger&#062;</dd>
</dl>
</li>
</ul>
<a name="toString-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toString</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;toString(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;character)</pre>
<div class="block">Typecast.  Returns same expression object.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>character</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Expression&#060;String&#062;</dd>
</dl>
</li>
</ul>
<a name="literal-java.lang.Object-">
<!--   -->
</a><a name="literal-T-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>literal</h4>
<pre>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;T&gt;&nbsp;literal(T&nbsp;value)</pre>
<div class="block">Create an expression for a literal.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>value</code> - value represented by the expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression literal</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>java.lang.IllegalArgumentException</code> - if value is null</dd>
</dl>
</li>
</ul>
<a name="nullLiteral-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>nullLiteral</h4>
<pre>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;T&gt;&nbsp;nullLiteral(java.lang.Class&lt;T&gt;&nbsp;resultClass)</pre>
<div class="block">Create an expression for a null literal with the given type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>resultClass</code> - type of the null literal</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>null expression literal</dd>
</dl>
</li>
</ul>
<a name="parameter-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>parameter</h4>
<pre>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/ParameterExpression.html" title="interface in javax.persistence.criteria">ParameterExpression</a>&lt;T&gt;&nbsp;parameter(java.lang.Class&lt;T&gt;&nbsp;paramClass)</pre>
<div class="block">Create a parameter expression.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>paramClass</code> - parameter class</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>parameter expression</dd>
</dl>
</li>
</ul>
<a name="parameter-java.lang.Class-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>parameter</h4>
<pre>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/ParameterExpression.html" title="interface in javax.persistence.criteria">ParameterExpression</a>&lt;T&gt;&nbsp;parameter(java.lang.Class&lt;T&gt;&nbsp;paramClass,
                                     java.lang.String&nbsp;name)</pre>
<div class="block">Create a parameter expression with the given name.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>paramClass</code> - parameter class</dd>
<dd><code>name</code> - name that can be used to refer to 
              the parameter</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>parameter expression</dd>
</dl>
</li>
</ul>
<a name="isEmpty-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isEmpty</h4>
<pre>&lt;C extends java.util.Collection&lt;?&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;isEmpty(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</pre>
<div class="block">Create a predicate that tests whether a collection is empty.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>collection</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>is-empty predicate</dd>
</dl>
</li>
</ul>
<a name="isNotEmpty-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isNotEmpty</h4>
<pre>&lt;C extends java.util.Collection&lt;?&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;isNotEmpty(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</pre>
<div class="block">Create a predicate that tests whether a collection is
  not empty.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>collection</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>is-not-empty predicate</dd>
</dl>
</li>
</ul>
<a name="size-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>size</h4>
<pre>&lt;C extends java.util.Collection&lt;?&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;size(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</pre>
<div class="block">Create an expression that tests the size of a collection.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>collection</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>size expression</dd>
</dl>
</li>
</ul>
<a name="size-java.util.Collection-">
<!--   -->
</a><a name="size-C-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>size</h4>
<pre>&lt;C extends java.util.Collection&lt;?&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;size(C&nbsp;collection)</pre>
<div class="block">Create an expression that tests the size of a collection.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>collection</code> - collection</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>size expression</dd>
</dl>
</li>
</ul>
<a name="isMember-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isMember</h4>
<pre>&lt;E,C extends java.util.Collection&lt;E&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;isMember(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;E&gt;&nbsp;elem,
                                                         <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</pre>
<div class="block">Create a predicate that tests whether an element is
  a member of a collection.
  If the collection is empty, the predicate will be false.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>elem</code> - element expression</dd>
<dd><code>collection</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>is-member predicate</dd>
</dl>
</li>
</ul>
<a name="isMember-java.lang.Object-javax.persistence.criteria.Expression-">
<!--   -->
</a><a name="isMember-E-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isMember</h4>
<pre>&lt;E,C extends java.util.Collection&lt;E&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;isMember(E&nbsp;elem,
                                                         <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</pre>
<div class="block">Create a predicate that tests whether an element is
  a member of a collection.
  If the collection is empty, the predicate will be false.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>elem</code> - element</dd>
<dd><code>collection</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>is-member predicate</dd>
</dl>
</li>
</ul>
<a name="isNotMember-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isNotMember</h4>
<pre>&lt;E,C extends java.util.Collection&lt;E&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;isNotMember(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;E&gt;&nbsp;elem,
                                                            <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</pre>
<div class="block">Create a predicate that tests whether an element is
  not a member of a collection.
  If the collection is empty, the predicate will be true.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>elem</code> - element expression</dd>
<dd><code>collection</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>is-not-member predicate</dd>
</dl>
</li>
</ul>
<a name="isNotMember-java.lang.Object-javax.persistence.criteria.Expression-">
<!--   -->
</a><a name="isNotMember-E-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isNotMember</h4>
<pre>&lt;E,C extends java.util.Collection&lt;E&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;isNotMember(E&nbsp;elem,
                                                            <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;C&gt;&nbsp;collection)</pre>
<div class="block">Create a predicate that tests whether an element is
  not a member of a collection.
  If the collection is empty, the predicate will be true.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>elem</code> - element</dd>
<dd><code>collection</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>is-not-member predicate</dd>
</dl>
</li>
</ul>
<a name="values-java.util.Map-">
<!--   -->
</a><a name="values-M-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>values</h4>
<pre>&lt;V,M extends java.util.Map&lt;?,V&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.util.Collection&lt;V&gt;&gt;&nbsp;values(M&nbsp;map)</pre>
<div class="block">Create an expression that returns the values of a map.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>map</code> - map</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>collection expression</dd>
</dl>
</li>
</ul>
<a name="keys-java.util.Map-">
<!--   -->
</a><a name="keys-M-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>keys</h4>
<pre>&lt;K,M extends java.util.Map&lt;K,?&gt;&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.util.Set&lt;K&gt;&gt;&nbsp;keys(M&nbsp;map)</pre>
<div class="block">Create an expression that returns the keys of a map.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>map</code> - map</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>set expression</dd>
</dl>
</li>
</ul>
<a name="like-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>like</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;like(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
               <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern)</pre>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>like predicate</dd>
</dl>
</li>
</ul>
<a name="like-javax.persistence.criteria.Expression-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>like</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;like(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
               java.lang.String&nbsp;pattern)</pre>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>like predicate</dd>
</dl>
</li>
</ul>
<a name="like-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>like</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;like(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
               <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern,
               <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;escapeChar)</pre>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string expression</dd>
<dd><code>escapeChar</code> - escape character expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>like predicate</dd>
</dl>
</li>
</ul>
<a name="like-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-char-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>like</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;like(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
               <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern,
               char&nbsp;escapeChar)</pre>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string expression</dd>
<dd><code>escapeChar</code> - escape character</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>like predicate</dd>
</dl>
</li>
</ul>
<a name="like-javax.persistence.criteria.Expression-java.lang.String-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>like</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;like(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
               java.lang.String&nbsp;pattern,
               <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;escapeChar)</pre>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string</dd>
<dd><code>escapeChar</code> - escape character expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>like predicate</dd>
</dl>
</li>
</ul>
<a name="like-javax.persistence.criteria.Expression-java.lang.String-char-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>like</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;like(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
               java.lang.String&nbsp;pattern,
               char&nbsp;escapeChar)</pre>
<div class="block">Create a predicate for testing whether the expression
 satisfies the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string</dd>
<dd><code>escapeChar</code> - escape character</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>like predicate</dd>
</dl>
</li>
</ul>
<a name="notLike-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>notLike</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;notLike(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern)</pre>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>not-like predicate</dd>
</dl>
</li>
</ul>
<a name="notLike-javax.persistence.criteria.Expression-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>notLike</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;notLike(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                  java.lang.String&nbsp;pattern)</pre>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>not-like predicate</dd>
</dl>
</li>
</ul>
<a name="notLike-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>notLike</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;notLike(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern,
                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;escapeChar)</pre>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string expression</dd>
<dd><code>escapeChar</code> - escape character expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>not-like predicate</dd>
</dl>
</li>
</ul>
<a name="notLike-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-char-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>notLike</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;notLike(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern,
                  char&nbsp;escapeChar)</pre>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string expression</dd>
<dd><code>escapeChar</code> - escape character</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>not-like predicate</dd>
</dl>
</li>
</ul>
<a name="notLike-javax.persistence.criteria.Expression-java.lang.String-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>notLike</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;notLike(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                  java.lang.String&nbsp;pattern,
                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;escapeChar)</pre>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string</dd>
<dd><code>escapeChar</code> - escape character expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>not-like predicate</dd>
</dl>
</li>
</ul>
<a name="notLike-javax.persistence.criteria.Expression-java.lang.String-char-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>notLike</h4>
<pre><a href="../../../javax/persistence/criteria/Predicate.html" title="interface in javax.persistence.criteria">Predicate</a>&nbsp;notLike(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                  java.lang.String&nbsp;pattern,
                  char&nbsp;escapeChar)</pre>
<div class="block">Create a predicate for testing whether the expression
 does not satisfy the given pattern.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>pattern</code> - string</dd>
<dd><code>escapeChar</code> - escape character</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>not-like predicate</dd>
</dl>
</li>
</ul>
<a name="concat-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>concat</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;concat(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                                    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;y)</pre>
<div class="block">Create an expression for string concatenation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>y</code> - string expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to concatenation</dd>
</dl>
</li>
</ul>
<a name="concat-javax.persistence.criteria.Expression-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>concat</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;concat(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                                    java.lang.String&nbsp;y)</pre>
<div class="block">Create an expression for string concatenation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>y</code> - string</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to concatenation</dd>
</dl>
</li>
</ul>
<a name="concat-java.lang.String-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>concat</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;concat(java.lang.String&nbsp;x,
                                    <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;y)</pre>
<div class="block">Create an expression for string concatenation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string</dd>
<dd><code>y</code> - string expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to concatenation</dd>
</dl>
</li>
</ul>
<a name="substring-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>substring</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;substring(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                                       <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;from)</pre>
<div class="block">Create an expression for substring extraction.
  Extracts a substring starting at the specified position
  through to end of the string.
  First position is 1.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>from</code> - start position expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to substring extraction</dd>
</dl>
</li>
</ul>
<a name="substring-javax.persistence.criteria.Expression-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>substring</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;substring(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                                       int&nbsp;from)</pre>
<div class="block">Create an expression for substring extraction.
  Extracts a substring starting at the specified position
  through to end of the string.
  First position is 1.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>from</code> - start position</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to substring extraction</dd>
</dl>
</li>
</ul>
<a name="substring-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>substring</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;substring(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                                       <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;from,
                                       <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;len)</pre>
<div class="block">Create an expression for substring extraction.
  Extracts a substring of given length starting at the
  specified position.
  First position is 1.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>from</code> - start position expression</dd>
<dd><code>len</code> - length expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to substring extraction</dd>
</dl>
</li>
</ul>
<a name="substring-javax.persistence.criteria.Expression-int-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>substring</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;substring(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                                       int&nbsp;from,
                                       int&nbsp;len)</pre>
<div class="block">Create an expression for substring extraction.
  Extracts a substring of given length starting at the
  specified position.
  First position is 1.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dd><code>from</code> - start position</dd>
<dd><code>len</code> - length</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to substring extraction</dd>
</dl>
</li>
</ul>
<a name="trim-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>trim</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;trim(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</pre>
<div class="block">Create expression to trim blanks from both ends of
 a string.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression for string to trim</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>trim expression</dd>
</dl>
</li>
</ul>
<a name="trim-javax.persistence.criteria.CriteriaBuilder.Trimspec-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>trim</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;trim(<a href="../../../javax/persistence/criteria/CriteriaBuilder.Trimspec.html" title="enum in javax.persistence.criteria">CriteriaBuilder.Trimspec</a>&nbsp;ts,
                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</pre>
<div class="block">Create expression to trim blanks from a string.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>ts</code> - trim specification</dd>
<dd><code>x</code> - expression for string to trim</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>trim expression</dd>
</dl>
</li>
</ul>
<a name="trim-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>trim</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;trim(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;t,
                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</pre>
<div class="block">Create expression to trim character from both ends of
 a string.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>t</code> - expression for character to be trimmed</dd>
<dd><code>x</code> - expression for string to trim</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>trim expression</dd>
</dl>
</li>
</ul>
<a name="trim-javax.persistence.criteria.CriteriaBuilder.Trimspec-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>trim</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;trim(<a href="../../../javax/persistence/criteria/CriteriaBuilder.Trimspec.html" title="enum in javax.persistence.criteria">CriteriaBuilder.Trimspec</a>&nbsp;ts,
                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Character&gt;&nbsp;t,
                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</pre>
<div class="block">Create expression to trim character from a string.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>ts</code> - trim specification</dd>
<dd><code>t</code> - expression for character to be trimmed</dd>
<dd><code>x</code> - expression for string to trim</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>trim expression</dd>
</dl>
</li>
</ul>
<a name="trim-char-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>trim</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;trim(char&nbsp;t,
                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</pre>
<div class="block">Create expression to trim character from both ends of
 a string.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>t</code> - character to be trimmed</dd>
<dd><code>x</code> - expression for string to trim</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>trim expression</dd>
</dl>
</li>
</ul>
<a name="trim-javax.persistence.criteria.CriteriaBuilder.Trimspec-char-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>trim</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;trim(<a href="../../../javax/persistence/criteria/CriteriaBuilder.Trimspec.html" title="enum in javax.persistence.criteria">CriteriaBuilder.Trimspec</a>&nbsp;ts,
                                  char&nbsp;t,
                                  <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</pre>
<div class="block">Create expression to trim character from a string.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>ts</code> - trim specification</dd>
<dd><code>t</code> - character to be trimmed</dd>
<dd><code>x</code> - expression for string to trim</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>trim expression</dd>
</dl>
</li>
</ul>
<a name="lower-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>lower</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;lower(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</pre>
<div class="block">Create expression for converting a string to lowercase.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression to convert to lowercase</dd>
</dl>
</li>
</ul>
<a name="upper-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>upper</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;upper(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</pre>
<div class="block">Create expression for converting a string to uppercase.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression to convert to uppercase</dd>
</dl>
</li>
</ul>
<a name="length-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>length</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;length(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x)</pre>
<div class="block">Create expression to return length of a string.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - string expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>length expression</dd>
</dl>
</li>
</ul>
<a name="locate-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>locate</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;locate(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                                     <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern)</pre>
<div class="block">Create expression to locate the position of one string
 within another, returning position of first character
 if found.
 The first position in a string is denoted by 1.  If the
 string to be located is not found, 0 is returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression for string to be searched</dd>
<dd><code>pattern</code> - expression for string to be located</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to position</dd>
</dl>
</li>
</ul>
<a name="locate-javax.persistence.criteria.Expression-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>locate</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;locate(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                                     java.lang.String&nbsp;pattern)</pre>
<div class="block">Create expression to locate the position of one string
 within another, returning position of first character
 if found.
 The first position in a string is denoted by 1.  If the
 string to be located is not found, 0 is returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression for string to be searched</dd>
<dd><code>pattern</code> - string to be located</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to position</dd>
</dl>
</li>
</ul>
<a name="locate-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>locate</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;locate(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                                     <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;pattern,
                                     <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;from)</pre>
<div class="block">Create expression to locate the position of one string
 within another, returning position of first character
 if found.
 The first position in a string is denoted by 1.  If the
 string to be located is not found, 0 is returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression for string to be searched</dd>
<dd><code>pattern</code> - expression for string to be located</dd>
<dd><code>from</code> - expression for position at which to start search</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to position</dd>
</dl>
</li>
</ul>
<a name="locate-javax.persistence.criteria.Expression-java.lang.String-int-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>locate</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.Integer&gt;&nbsp;locate(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.lang.String&gt;&nbsp;x,
                                     java.lang.String&nbsp;pattern,
                                     int&nbsp;from)</pre>
<div class="block">Create expression to locate the position of one string
 within another, returning position of first character
 if found.
 The first position in a string is denoted by 1.  If the
 string to be located is not found, 0 is returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression for string to be searched</dd>
<dd><code>pattern</code> - string to be located</dd>
<dd><code>from</code> - position at which to start search</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression corresponding to position</dd>
</dl>
</li>
</ul>
<a name="currentDate--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>currentDate</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.sql.Date&gt;&nbsp;currentDate()</pre>
<div class="block">Create expression to return current date.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression for current date</dd>
</dl>
</li>
</ul>
<a name="currentTimestamp--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>currentTimestamp</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.sql.Timestamp&gt;&nbsp;currentTimestamp()</pre>
<div class="block">Create expression to return current timestamp.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression for current timestamp</dd>
</dl>
</li>
</ul>
<a name="currentTime--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>currentTime</h4>
<pre><a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;java.sql.Time&gt;&nbsp;currentTime()</pre>
<div class="block">Create expression to return current time.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression for current time</dd>
</dl>
</li>
</ul>
<a name="in-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>in</h4>
<pre>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaBuilder.In.html" title="interface in javax.persistence.criteria">CriteriaBuilder.In</a>&lt;T&gt;&nbsp;in(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends T&gt;&nbsp;expression)</pre>
<div class="block">Create predicate to test whether given expression
  is contained in a list of values.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>expression</code> - to be tested against list of values</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>in predicate</dd>
</dl>
</li>
</ul>
<a name="coalesce-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>coalesce</h4>
<pre>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;coalesce(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                           <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;y)</pre>
<div class="block">Create an expression that returns null if all its arguments
 evaluate to null, and the value of the first non-null argument
 otherwise.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>coalesce expression</dd>
</dl>
</li>
</ul>
<a name="coalesce-javax.persistence.criteria.Expression-java.lang.Object-">
<!--   -->
</a><a name="coalesce-javax.persistence.criteria.Expression-Y-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>coalesce</h4>
<pre>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;coalesce(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends Y&gt;&nbsp;x,
                           Y&nbsp;y)</pre>
<div class="block">Create an expression that returns null if all its arguments
 evaluate to null, and the value of the first non-null argument
 otherwise.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>coalesce expression</dd>
</dl>
</li>
</ul>
<a name="nullif-javax.persistence.criteria.Expression-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>nullif</h4>
<pre>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;nullif(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;x,
                         <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;&nbsp;y)</pre>
<div class="block">Create an expression that tests whether its argument are
 equal, returning null if they are and the value of the
 first expression if they are not.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - expression</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>nullif expression</dd>
</dl>
</li>
</ul>
<a name="nullif-javax.persistence.criteria.Expression-java.lang.Object-">
<!--   -->
</a><a name="nullif-javax.persistence.criteria.Expression-Y-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>nullif</h4>
<pre>&lt;Y&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;nullif(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;Y&gt;&nbsp;x,
                         Y&nbsp;y)</pre>
<div class="block">Create an expression that tests whether its argument are
 equal, returning null if they are and the value of the
 first expression if they are not.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>x</code> - expression</dd>
<dd><code>y</code> - value</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>nullif expression</dd>
</dl>
</li>
</ul>
<a name="coalesce--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>coalesce</h4>
<pre>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaBuilder.Coalesce.html" title="interface in javax.persistence.criteria">CriteriaBuilder.Coalesce</a>&lt;T&gt;&nbsp;coalesce()</pre>
<div class="block">Create a coalesce expression.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>coalesce expression</dd>
</dl>
</li>
</ul>
<a name="selectCase-javax.persistence.criteria.Expression-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>selectCase</h4>
<pre>&lt;C,R&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaBuilder.SimpleCase.html" title="interface in javax.persistence.criteria">CriteriaBuilder.SimpleCase</a>&lt;C,R&gt;&nbsp;selectCase(<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;? extends C&gt;&nbsp;expression)</pre>
<div class="block">Create a simple case expression.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>expression</code> - to be tested against the case conditions</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>simple case expression</dd>
</dl>
</li>
</ul>
<a name="selectCase--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>selectCase</h4>
<pre>&lt;R&gt;&nbsp;<a href="../../../javax/persistence/criteria/CriteriaBuilder.Case.html" title="interface in javax.persistence.criteria">CriteriaBuilder.Case</a>&lt;R&gt;&nbsp;selectCase()</pre>
<div class="block">Create a general case expression.</div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>general case expression</dd>
</dl>
</li>
</ul>
<a name="function-java.lang.String-java.lang.Class-javax.persistence.criteria.Expression...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>function</h4>
<pre>&lt;T&gt;&nbsp;<a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;T&gt;&nbsp;function(java.lang.String&nbsp;name,
                           java.lang.Class&lt;T&gt;&nbsp;type,
                           <a href="../../../javax/persistence/criteria/Expression.html" title="interface in javax.persistence.criteria">Expression</a>&lt;?&gt;...&nbsp;args)</pre>
<div class="block">Create an expression for the execution of a database
 function.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>name</code> - function name</dd>
<dd><code>type</code> - expected result type</dd>
<dd><code>args</code> - function arguments</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>expression</dd>
</dl>
</li>
</ul>
<a name="treat-javax.persistence.criteria.Join-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>treat</h4>
<pre>&lt;X,T,V extends T&gt;&nbsp;<a href="../../../javax/persistence/criteria/Join.html" title="interface in javax.persistence.criteria">Join</a>&lt;X,V&gt;&nbsp;treat(<a href="../../../javax/persistence/criteria/Join.html" title="interface in javax.persistence.criteria">Join</a>&lt;X,T&gt;&nbsp;join,
                                  java.lang.Class&lt;V&gt;&nbsp;type)</pre>
<div class="block">Downcast Join object to the specified type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>join</code> - Join object</dd>
<dd><code>type</code> - type to be downcast to</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Join object of the specified type</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Java Persistence 2.1</dd>
</dl>
</li>
</ul>
<a name="treat-javax.persistence.criteria.CollectionJoin-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>treat</h4>
<pre>&lt;X,T,E extends T&gt;&nbsp;<a href="../../../javax/persistence/criteria/CollectionJoin.html" title="interface in javax.persistence.criteria">CollectionJoin</a>&lt;X,E&gt;&nbsp;treat(<a href="../../../javax/persistence/criteria/CollectionJoin.html" title="interface in javax.persistence.criteria">CollectionJoin</a>&lt;X,T&gt;&nbsp;join,
                                            java.lang.Class&lt;E&gt;&nbsp;type)</pre>
<div class="block">Downcast CollectionJoin object to the specified type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>join</code> - CollectionJoin object</dd>
<dd><code>type</code> - type to be downcast to</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>CollectionJoin object of the specified type</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Java Persistence 2.1</dd>
</dl>
</li>
</ul>
<a name="treat-javax.persistence.criteria.SetJoin-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>treat</h4>
<pre>&lt;X,T,E extends T&gt;&nbsp;<a href="../../../javax/persistence/criteria/SetJoin.html" title="interface in javax.persistence.criteria">SetJoin</a>&lt;X,E&gt;&nbsp;treat(<a href="../../../javax/persistence/criteria/SetJoin.html" title="interface in javax.persistence.criteria">SetJoin</a>&lt;X,T&gt;&nbsp;join,
                                     java.lang.Class&lt;E&gt;&nbsp;type)</pre>
<div class="block">Downcast SetJoin object to the specified type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>join</code> - SetJoin object</dd>
<dd><code>type</code> - type to be downcast to</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>SetJoin object of the specified type</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Java Persistence 2.1</dd>
</dl>
</li>
</ul>
<a name="treat-javax.persistence.criteria.ListJoin-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>treat</h4>
<pre>&lt;X,T,E extends T&gt;&nbsp;<a href="../../../javax/persistence/criteria/ListJoin.html" title="interface in javax.persistence.criteria">ListJoin</a>&lt;X,E&gt;&nbsp;treat(<a href="../../../javax/persistence/criteria/ListJoin.html" title="interface in javax.persistence.criteria">ListJoin</a>&lt;X,T&gt;&nbsp;join,
                                      java.lang.Class&lt;E&gt;&nbsp;type)</pre>
<div class="block">Downcast ListJoin object to the specified type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>join</code> - ListJoin object</dd>
<dd><code>type</code> - type to be downcast to</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>ListJoin object of the specified type</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Java Persistence 2.1</dd>
</dl>
</li>
</ul>
<a name="treat-javax.persistence.criteria.MapJoin-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>treat</h4>
<pre>&lt;X,K,T,V extends T&gt;&nbsp;<a href="../../../javax/persistence/criteria/MapJoin.html" title="interface in javax.persistence.criteria">MapJoin</a>&lt;X,K,V&gt;&nbsp;treat(<a href="../../../javax/persistence/criteria/MapJoin.html" title="interface in javax.persistence.criteria">MapJoin</a>&lt;X,K,T&gt;&nbsp;join,
                                         java.lang.Class&lt;V&gt;&nbsp;type)</pre>
<div class="block">Downcast MapJoin object to the specified type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>join</code> - MapJoin object</dd>
<dd><code>type</code> - type to be downcast to</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>MapJoin object of the specified type</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Java Persistence 2.1</dd>
</dl>
</li>
</ul>
<a name="treat-javax.persistence.criteria.Path-java.lang.Class-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>treat</h4>
<pre>&lt;X,T extends X&gt;&nbsp;<a href="../../../javax/persistence/criteria/Path.html" title="interface in javax.persistence.criteria">Path</a>&lt;T&gt;&nbsp;treat(<a href="../../../javax/persistence/criteria/Path.html" title="interface in javax.persistence.criteria">Path</a>&lt;X&gt;&nbsp;path,
                              java.lang.Class&lt;T&gt;&nbsp;type)</pre>
<div class="block">Downcast Path object to the specified type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>path</code> - path</dd>
<dd><code>type</code> - type to be downcast to</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Path object of the specified type</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Java Persistence 2.1</dd>
</dl>
</li>
</ul>
<a name="treat-javax.persistence.criteria.Root-java.lang.Class-">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>treat</h4>
<pre>&lt;X,T extends X&gt;&nbsp;<a href="../../../javax/persistence/criteria/Root.html" title="interface in javax.persistence.criteria">Root</a>&lt;T&gt;&nbsp;treat(<a href="../../../javax/persistence/criteria/Root.html" title="interface in javax.persistence.criteria">Root</a>&lt;X&gt;&nbsp;root,
                              java.lang.Class&lt;T&gt;&nbsp;type)</pre>
<div class="block">Downcast Root object to the specified type.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>root</code> - root</dd>
<dd><code>type</code> - type to be downcast to</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Root object of the specified type</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>Java Persistence 2.1</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="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/persistence/criteria/CompoundSelection.html" title="interface in javax.persistence.criteria"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../javax/persistence/criteria/CriteriaBuilder.Case.html" title="interface in javax.persistence.criteria"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../index.html?javax/persistence/criteria/CriteriaBuilder.html" target="_top">Frames</a></li>
<li><a href="CriteriaBuilder.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><a href="#nested.class.summary">Nested</a>&nbsp;|&nbsp;</li>
<li>Field&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>Field&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 ======= -->
</body>
</html>
