Added: 
websites/staging/olingo/trunk/content/doc/odata4/tutorials/Olingo_Tutorial_AdvancedReadWrite_Batch.html
==============================================================================
--- 
websites/staging/olingo/trunk/content/doc/odata4/tutorials/Olingo_Tutorial_AdvancedReadWrite_Batch.html
 (added)
+++ 
websites/staging/olingo/trunk/content/doc/odata4/tutorials/Olingo_Tutorial_AdvancedReadWrite_Batch.html
 Tue Sep 16 12:34:18 2014
@@ -0,0 +1,221 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<html lang="en">
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="description" content="Apache Olingo provides libraries which 
enable developers to implement OData producers and OData consumers. The 
available OData Java library implements OData version 2.0. In future on goal is 
to provide an OData 4.0 compliant library once the OData standard is published 
at OASIS. The focus within the community is currently on the Java technology 
but it is up to the community to discuss if other environments find interest.">
+    <meta name="author" content="">
+    <link rel="icon" href="/favicon.ico">
+    <title>
+      Apache Olingo
+    </title><!-- Bootstrap core CSS -->
+    <link href="/css/bootstrap.css" rel="stylesheet" type="text/css"><!-- 
Custom styles for this template -->
+    <link href="/css/navbar.css" rel="stylesheet" type="text/css"><!-- Just 
for debugging purposes. Don't actually copy these 2 lines! -->
+    <link href="/css/offcanvas.css" rel="stylesheet" type="text/css"><!-- 
Custom styles for this template -->
+    <link rel="stylesheet" href="/css/main.css">
+    <!--[if lt IE 9]><script 
src="/js/ie8-responsive-file-warning.js"></script><![endif]-->
+
+    <script src="/js/ie-emulation-modes-warning.js" type="text/javascript">
+</script><!-- IE10 viewport hack for Surface/desktop Windows 8 bug -->
+
+    <script src="/js/ie10-viewport-bug-workaround.js" type="text/javascript">
+</script><!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and 
media queries -->
+    <!--[if lt IE 9]>
+      <script src="/js/html5shiv.min.js"></script>
+      <script src="/js/respond.min.js"></script>
+    <![endif]-->
+  </head>
+
+  <body>
+    <div class="container">
+      <!-- Static navbar -->
+      <div class="navbar navbar-default" role="navigation">
+        <div class="container-fluid">
+          <div class="navbar-header">
+            <button type="button" class="navbar-toggle" data-toggle="collapse" 
data-target=".navbar-collapse">
+              <span class="sr-only">Toggle navigation</span>
+             <span class="icon-bar"></span>
+             <span class="icon-bar"></span>
+             <span class="icon-bar"></span>
+            </button>
+              <img class="navbar-brand" src="/img/OlingoOrangeTM.png" 
style="width:62px;" >
+              <a class="navbar-brand" href="#">Apache Olingo™</a>
+          </div>
+          <div class="navbar-collapse collapse">
+            <ul class="nav navbar-nav">
+
+              <li><a href="/">Home</a></li>
+              <li class="dropdown">
+                  <a href="#" class="dropdown-toggle" 
data-toggle="dropdown">ASF <b class="caret"></b></a>
+                  <ul class="dropdown-menu">
+                      <li><a href="http://www.apache.org/foundation/";>ASF 
Home</a></li>
+                      <li><a 
href="http://projects.apache.org/";>Projects</a></li>
+                      <li><a href="http://people.apache.org/";>People</a></li>
+                      <li><a 
href="http://www.apache.org/foundation/getinvolved.html";>Get Involved</a></li>
+                      <li><a 
href="http://www.apache.org/dyn/closer.cgi";>Download</a></li>
+                      <li><a 
href="http://www.apache.org/security/";>Security</a></li>
+                      <li><a 
href="http://www.apache.org/foundation/sponsorship.html";>Support Apache</a></li>
+                  </ul>
+              </li>
+
+              <li><a href="http://www.apache.org/licenses/";>License</a></li>
+
+              <li class="dropdown">
+                  <a href="#" class="dropdown-toggle" 
data-toggle="dropdown">Download <b class="caret"></b></a>
+                  <ul class="dropdown-menu">
+                      <li><a href="/doc/odata2/download.html">Download OData 
2.0 Java</a></li>
+                      <li><a href="/doc/javascript/download.html">Download 
OData 4.0 JavaScript</a></li>
+                  </ul>
+              </li>
+
+              <li class="dropdown">
+                  <a href="#" class="dropdown-toggle" 
data-toggle="dropdown">Documentation <b class="caret"></b></a>
+                  <ul class="dropdown-menu">
+                    <li><a href="/doc/odata2/index.html">Documentation OData 
2.0 Java</a></li>
+                    <li><a href="/doc/javascript/index.html">Documentation 
OData 4.0 JavaScript</a></li>
+                  </ul>
+              </li>
+              <li><a href="/support.html">Support</a></li>
+
+            </ul>
+
+                         <img class="navbar-right" height="50px" 
src="/img/asf-logo.gif">
+
+                       </div><!--/.nav-collapse -->
+        </div><!--/.container-fluid -->
+      </div><!-- Main component for a primary marketing message or call to 
action --><h1 id="batch">Batch</h1>
+<h3 id="how-to-process-an-odata-batch-request">How to process an OData Batch 
Request</h3>
+<h5 
id="implement-the-method-executebatch-of-the-class-odatasingleprocessor">Implement
 the method executeBatch of the class ODataSingleProcessor.</h5>
+<ul>
+<li>Use the method <code>EntityProvider.parseBatchRequest(contentType, 
content, batchProperties)</code> in order to parse the Batch Request Body. As a 
result you get a list with batch parts. Each part separately represents a 
ChangeSet or a query operation. </li>
+<li>Call <code>handler.handleBathPart(batchRequestPart)</code> while looping 
over the list. The handler delegates the processing of a batch part depending 
on the type of that batch part. </li>
+<li>When all batch parts are completely processed, use the method 
<code>EntityProvider.writeBatchResponse(final List&lt;BatchResponsePart&gt; 
batchResponseParts)</code> in order to write all responses in one Batch 
Response. 
+The following example shows a possible implementation:</li>
+</ul>
+<p><strong>Sample Code</strong></p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Override</span>
+  <span class="n">public</span> <span class="n">ODataResponse</span> <span 
class="n">executeBatch</span><span class="p">(</span><span 
class="n">final</span> <span class="n">BatchHandler</span> <span 
class="n">handler</span><span class="p">,</span> <span class="n">final</span> 
<span class="n">String</span> <span class="n">contentType</span><span 
class="p">,</span> <span class="n">final</span> <span 
class="n">InputStream</span> <span class="n">content</span><span 
class="p">)</span> <span class="n">throws</span> <span 
class="n">ODataException</span> <span class="p">{</span>
+    <span class="n">ODataResponse</span> <span 
class="n">batchResponse</span><span class="p">;</span>
+    <span class="n">List</span><span class="o">&lt;</span><span 
class="n">BatchResponsePart</span><span class="o">&gt;</span> <span 
class="n">batchResponseParts</span> <span class="p">=</span> <span 
class="n">new</span> <span class="n">ArrayList</span><span 
class="o">&lt;</span><span class="n">BatchResponsePart</span><span 
class="o">&gt;</span><span class="p">();</span>
+    <span class="n">PathInfo</span> <span class="n">pathInfo</span> <span 
class="p">=</span> <span class="n">getContext</span><span 
class="p">().</span><span class="n">getPathInfo</span><span class="p">();</span>
+    <span class="n">EntityProviderBatchProperties</span> <span 
class="n">batchProperties</span> <span class="p">=</span> <span 
class="n">EntityProviderBatchProperties</span><span class="p">.</span><span 
class="n">init</span><span class="p">().</span><span 
class="n">pathInfo</span><span class="p">(</span><span 
class="n">pathInfo</span><span class="p">).</span><span 
class="n">build</span><span class="p">();</span>
+    <span class="n">List</span><span class="o">&lt;</span><span 
class="n">BatchRequestPart</span><span class="o">&gt;</span> <span 
class="n">batchRequestParts</span> <span class="p">=</span> <span 
class="n">EntityProvider</span><span class="p">.</span><span 
class="n">parseBatchRequest</span><span class="p">(</span><span 
class="n">contentType</span><span class="p">,</span> <span 
class="n">content</span><span class="p">,</span> <span 
class="n">batchProperties</span><span class="p">);</span>
+    <span class="k">for</span> <span class="p">(</span><span 
class="n">BatchPart</span> <span class="n">batchPart</span> <span 
class="p">:</span> <span class="n">batchRequestParts</span><span 
class="p">)</span> <span class="p">{</span>
+      <span class="n">BatchResponsePart</span> <span 
class="n">processedBatchPart</span> <span class="p">=</span> <span 
class="n">handler</span><span class="p">.</span><span 
class="n">handleBatchPart</span><span class="p">(</span><span 
class="n">batchRequestPart</span><span class="p">)</span>
+      <span class="n">batchResponseParts</span><span class="p">.</span><span 
class="n">add</span><span class="p">(</span><span 
class="n">processedBatchPart</span><span class="p">);</span>
+    <span class="p">}</span>
+    <span class="n">batchResponse</span> <span class="p">=</span> <span 
class="n">EntityProvider</span><span class="p">.</span><span 
class="n">writeBatchResponse</span><span class="p">(</span><span 
class="n">batchResponseParts</span><span class="p">);</span>
+    <span class="k">return</span> <span class="n">batchResponse</span><span 
class="p">;</span>
+  <span class="p">}</span>
+</pre></div>
+
+
+<p><strong>NOTE:</strong> The parameter batchProperties of the method 
parseBatchRequest contains OData URI informations as PathInfo-object. These 
informations are necessary for the parsing, that's why the PathInfo-object 
should not be null.</p>
+<h5 
id="implement-the-method-executechangeset-of-the-class-odatasingleprocessor">Implement
 the method executeChangeSet of the class ODataSingleProcessor.</h5>
+<p>In order to process a request invoke 
<code>handler.handleRequest(request)</code>, that delegates a handling of the 
request to the request handler and provides ODataResponse. 
+Define a rollback semantics that may be applied when a request within a 
ChangeSet fails. 
+The following example shows a possible implementation:</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Override</span>
+ <span class="n">public</span> <span class="n">BatchResponsePart</span> <span 
class="n">executeChangeSet</span><span class="p">(</span><span 
class="n">final</span> <span class="n">BatchHandler</span> <span 
class="n">handler</span><span class="p">,</span> <span class="n">final</span> 
<span class="n">List</span><span class="o">&lt;</span><span 
class="n">ODataRequest</span><span class="o">&gt;</span> <span 
class="n">requests</span><span class="p">)</span> <span class="n">throws</span> 
<span class="n">ODataException</span> <span class="p">{</span>
+    <span class="n">List</span><span class="o">&lt;</span><span 
class="n">ODataResponse</span><span class="o">&gt;</span> <span 
class="n">responses</span> <span class="p">=</span> <span class="n">new</span> 
<span class="n">ArrayList</span><span class="o">&lt;</span><span 
class="n">ODataResponse</span><span class="o">&gt;</span><span 
class="p">();</span>
+    <span class="k">for</span> <span class="p">(</span><span 
class="n">ODataRequest</span> <span class="n">request</span> <span 
class="p">:</span> <span class="n">requests</span><span class="p">)</span> 
<span class="p">{</span>
+      <span class="n">ODataResponse</span> <span class="n">response</span> 
<span class="p">=</span> <span class="n">handler</span><span 
class="p">.</span><span class="n">handleRequest</span><span 
class="p">(</span><span class="n">request</span><span class="p">);</span>
+      <span class="k">if</span> <span class="p">(</span><span 
class="n">response</span><span class="p">.</span><span 
class="n">getStatus</span><span class="p">().</span><span 
class="n">getStatusCode</span><span class="p">()</span> <span 
class="o">&gt;</span><span class="p">=</span> <span 
class="n">HttpStatusCodes</span><span class="p">.</span><span 
class="n">BAD_REQUEST</span><span class="p">.</span><span 
class="n">getStatusCode</span><span class="p">())</span> <span 
class="p">{</span>
+        <span class="o">//</span> <span class="n">Rollback</span>
+        <span class="n">List</span><span class="o">&lt;</span><span 
class="n">ODataResponse</span><span class="o">&gt;</span> <span 
class="n">errorResponses</span> <span class="p">=</span> <span 
class="n">new</span> <span class="n">ArrayList</span><span 
class="o">&lt;</span><span class="n">ODataResponse</span><span 
class="o">&gt;</span><span class="p">(</span>1<span class="p">);</span>
+        <span class="n">errorResponses</span><span class="p">.</span><span 
class="n">add</span><span class="p">(</span><span 
class="n">response</span><span class="p">);</span>
+        <span class="k">return</span> <span 
class="n">BatchResponsePart</span><span class="p">.</span><span 
class="n">responses</span><span class="p">(</span><span 
class="n">errorResponses</span><span class="p">).</span><span 
class="n">changeSet</span><span class="p">(</span><span 
class="n">false</span><span class="p">).</span><span 
class="n">build</span><span class="p">();</span>
+      <span class="p">}</span>
+      <span class="n">responses</span><span class="p">.</span><span 
class="n">add</span><span class="p">(</span><span 
class="n">response</span><span class="p">);</span>
+    <span class="p">}</span>
+    <span class="k">return</span> <span 
class="n">BatchResponsePart</span><span class="p">.</span><span 
class="n">responses</span><span class="p">(</span><span 
class="n">responses</span><span class="p">).</span><span 
class="n">changeSet</span><span class="p">(</span><span 
class="n">true</span><span class="p">).</span><span class="n">build</span><span 
class="p">();</span>
+  <span class="p">}</span>
+</pre></div>
+
+
+<p><strong>NOTE:</strong> If a request within a ChangeSet fails, a Batch 
Response Part contains only the error response and the flag changeSet is set to 
false.</p>
+<h5 id="batch-request-body-example">Batch Request Body Example</h5>
+<div class="codehilite"><pre><span class="o">--</span><span 
class="n">batch_123</span>
+<span class="n">Content</span><span class="o">-</span><span 
class="n">Type</span><span class="p">:</span> <span 
class="n">multipart</span><span class="o">/</span><span 
class="n">mixed</span><span class="p">;</span> <span 
class="n">boundary</span><span class="p">=</span><span 
class="n">changeset_321</span>
+
+<span class="o">--</span><span class="n">changeset_321</span>
+<span class="n">Content</span><span class="o">-</span><span 
class="n">Type</span><span class="p">:</span> <span 
class="n">application</span><span class="o">/</span><span class="n">http</span>
+<span class="n">Content</span><span class="o">-</span><span 
class="n">Transfer</span><span class="o">-</span><span 
class="n">Encoding</span><span class="p">:</span> <span class="n">binary</span>
+
+<span class="n">PUT</span> <span class="n">Employees</span><span 
class="p">(</span><span class="s">&#39;2&#39;</span><span 
class="p">)</span><span class="o">/</span><span class="n">EmployeeName</span> 
<span class="n">HTTP</span><span class="o">/</span>1<span class="p">.</span>1
+<span class="n">Content</span><span class="o">-</span><span 
class="n">Length</span><span class="p">:</span> 100
+<span class="n">DataServiceVersion</span><span class="p">:</span> 1<span 
class="p">.</span>0
+<span class="n">Content</span><span class="o">-</span><span 
class="n">Type</span><span class="p">:</span> <span 
class="n">application</span><span class="o">/</span><span 
class="n">json</span><span class="p">;</span><span class="n">odata</span><span 
class="p">=</span><span class="n">verbose</span>
+<span class="n">MaxDataServiceVersion</span><span class="p">:</span> 2<span 
class="p">.</span>0
+
+<span class="p">{</span>&quot;<span class="n">EmployeeName</span>&quot;<span 
class="p">:</span>&quot;<span class="n">Frederic</span> <span 
class="n">Fall</span> <span class="n">MODIFIED</span>&quot;<span 
class="p">}</span>
+
+<span class="o">--</span><span class="n">changeset_321</span><span 
class="o">--</span>
+
+<span class="o">--</span><span class="n">batch_123</span>
+<span class="n">Content</span><span class="o">-</span><span 
class="n">Type</span><span class="p">:</span> <span 
class="n">application</span><span class="o">/</span><span class="n">http</span>
+<span class="n">Content</span><span class="o">-</span><span 
class="n">Transfer</span><span class="o">-</span><span 
class="n">Encoding</span><span class="p">:</span> <span class="n">binary</span>
+
+<span class="n">GET</span> <span class="n">Employees</span><span 
class="p">(</span><span class="s">&#39;2&#39;</span><span 
class="p">)</span><span class="o">/</span><span 
class="n">EmployeeName</span>?$<span class="n">format</span><span 
class="p">=</span><span class="n">json</span> <span class="n">HTTP</span><span 
class="o">/</span>1<span class="p">.</span>1
+<span class="n">Accept</span><span class="p">:</span> <span 
class="n">application</span><span class="o">/</span><span 
class="n">atomsvc</span><span class="o">+</span><span class="n">xml</span><span 
class="p">;</span><span class="n">q</span><span class="p">=</span>0<span 
class="p">.</span>8<span class="p">,</span> <span 
class="n">application</span><span class="o">/</span><span 
class="n">json</span><span class="p">;</span><span class="n">odata</span><span 
class="p">=</span><span class="n">verbose</span><span class="p">;</span><span 
class="n">q</span><span class="p">=</span>0<span class="p">.</span>5<span 
class="p">,</span> <span class="o">*/*</span><span class="p">;</span><span 
class="n">q</span><span class="p">=</span>0<span class="p">.</span>1
+<span class="n">MaxDataServiceVersion</span><span class="p">:</span> 2<span 
class="p">.</span>0
+
+
+<span class="o">--</span><span class="n">batch_123</span><span 
class="o">--</span>
+</pre></div>
+
+
+<p><strong>NOTE:</strong></p>
+<ul>
+<li>A Content-Type header of the Batch Request must specify a content type of 
"multipart/mixed" and a boundary parameter. </li>
+<li>Each Batch Part is separated by the boundary string, that must occur at 
the beginning of a line, following a CRLF. </li>
+<li>The boundary of the ChangeSet should be different from that used by the 
Batch. </li>
+</ul>
+<h5 id="request-line-of-a-single-request">Request Line of a single request</h5>
+<p>The following request lines of a single request (e.g. a retrieve request) 
will be accepted:</p>
+<ul>
+<li>GET http://<scheme>/<service_name>/<resource_path> HTTP/1.1 - the request 
line with an absolute URI </li>
+<li>GET <resource_path> HTTP/1.1 - the request line that contains a 
relative-path reference 
+Query Options can optionally follow the Resource Path.</li>
+</ul>
+<p><strong>Note:</strong> An absolute-path reference like 
/<service_name>/<resource_path> will not be accepted</p>
+<h5 id="content-id">Content-ID</h5>
+<p>The new entity may be referenced by subsequent requests within the same 
ChangeSet by referring to the Content-Id value. $<contentIdValue> acts as an 
alias for the Resource Path of the new entity.
+In order to refer the new entity the Request URI must begin with 
$<contentIdValue>:</p>
+<div class="codehilite"><pre><span class="n">POST</span> <span 
class="n">Customers</span> <span class="n">HTTP</span><span 
class="o">/</span>1<span class="p">.</span>1
+<span class="n">Content</span><span class="o">-</span><span 
class="n">ID</span><span class="p">:</span> <span class="n">newCustomer</span>
+<span class="p">...</span>
+<span class="n">PUT</span> $<span class="n">newCustomer</span><span 
class="o">/</span><span class="n">Name</span> <span class="n">HTTP</span><span 
class="o">/</span>1<span class="p">.</span>1
+</pre></div>
+
+
+<p><strong>Note:</strong> Requests in different ChangeSets cannot reference 
one another, even if they are in the same Batch</p>
+<h3 id="references">References</h3>
+<p><a 
href="http://www.odata.org/documentation/odata-v2-documentation/batch-processing/";
 title="External 
Link">http://www.odata.org/documentation/odata-v2-documentation/batch-processing/</a></p><div
 align="center">
+<p>Copyright © 2013-2014, The Apache Software Foundation<br>
+                                               Apache Olingo, Olingo, Apache, 
the Apache feather, and
+                               the Apache Olingo project logo are trademarks 
of the Apache Software
+                               Foundation.</p>
+        <small><a href="/doc/odata2/privacy.html">Privacy</a></small>
+      </div>
+    </div><!-- /container -->
+    <!-- Bootstrap core JavaScript
+    ================================================== -->
+    <!-- Placed at the end of the document so the pages load faster -->
+    <script src="/js/jquery.js" type="text/javascript">
+</script>
+         <script src="/js/bootstrap.js" type="text/javascript">
+         <script src="/js/offcanvas.js" type="text/javascript">
+</script>
+        <!-- Google Analytics: change UA-XXXXX-X to be your site's ID. -->
+        <script>
+            (function(b,o,i,l,e,r){b.GoogleAnalyticsObject=l;b[l]||(b[l]=
+            function(){(b[l].q=b[l].q||[]).push(arguments)});b[l].l=+new Date;
+            e=o.createElement(i);r=o.getElementsByTagName(i)[0];
+            e.src='//www.google-analytics.com/analytics.js';
+            r.parentNode.insertBefore(e,r)}(window,document,'script','ga'));
+            ga('create','UA-44963757-1');ga('send','pageview');
+        </script>
+  </body>
+</html>

Added: 
websites/staging/olingo/trunk/content/doc/odata4/tutorials/Olingo_Tutorial_AdvancedRead_FilterVisitor.html
==============================================================================
--- 
websites/staging/olingo/trunk/content/doc/odata4/tutorials/Olingo_Tutorial_AdvancedRead_FilterVisitor.html
 (added)
+++ 
websites/staging/olingo/trunk/content/doc/odata4/tutorials/Olingo_Tutorial_AdvancedRead_FilterVisitor.html
 Tue Sep 16 12:34:18 2014
@@ -0,0 +1,468 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN">
+<html lang="en">
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="description" content="Apache Olingo provides libraries which 
enable developers to implement OData producers and OData consumers. The 
available OData Java library implements OData version 2.0. In future on goal is 
to provide an OData 4.0 compliant library once the OData standard is published 
at OASIS. The focus within the community is currently on the Java technology 
but it is up to the community to discuss if other environments find interest.">
+    <meta name="author" content="">
+    <link rel="icon" href="/favicon.ico">
+    <title>
+      Apache Olingo
+    </title><!-- Bootstrap core CSS -->
+    <link href="/css/bootstrap.css" rel="stylesheet" type="text/css"><!-- 
Custom styles for this template -->
+    <link href="/css/navbar.css" rel="stylesheet" type="text/css"><!-- Just 
for debugging purposes. Don't actually copy these 2 lines! -->
+    <link href="/css/offcanvas.css" rel="stylesheet" type="text/css"><!-- 
Custom styles for this template -->
+    <link rel="stylesheet" href="/css/main.css">
+    <!--[if lt IE 9]><script 
src="/js/ie8-responsive-file-warning.js"></script><![endif]-->
+
+    <script src="/js/ie-emulation-modes-warning.js" type="text/javascript">
+</script><!-- IE10 viewport hack for Surface/desktop Windows 8 bug -->
+
+    <script src="/js/ie10-viewport-bug-workaround.js" type="text/javascript">
+</script><!-- HTML5 shim and Respond.js IE8 support of HTML5 elements and 
media queries -->
+    <!--[if lt IE 9]>
+      <script src="/js/html5shiv.min.js"></script>
+      <script src="/js/respond.min.js"></script>
+    <![endif]-->
+  </head>
+
+  <body>
+    <div class="container">
+      <!-- Static navbar -->
+      <div class="navbar navbar-default" role="navigation">
+        <div class="container-fluid">
+          <div class="navbar-header">
+            <button type="button" class="navbar-toggle" data-toggle="collapse" 
data-target=".navbar-collapse">
+              <span class="sr-only">Toggle navigation</span>
+             <span class="icon-bar"></span>
+             <span class="icon-bar"></span>
+             <span class="icon-bar"></span>
+            </button>
+              <img class="navbar-brand" src="/img/OlingoOrangeTM.png" 
style="width:62px;" >
+              <a class="navbar-brand" href="#">Apache Olingo™</a>
+          </div>
+          <div class="navbar-collapse collapse">
+            <ul class="nav navbar-nav">
+
+              <li><a href="/">Home</a></li>
+              <li class="dropdown">
+                  <a href="#" class="dropdown-toggle" 
data-toggle="dropdown">ASF <b class="caret"></b></a>
+                  <ul class="dropdown-menu">
+                      <li><a href="http://www.apache.org/foundation/";>ASF 
Home</a></li>
+                      <li><a 
href="http://projects.apache.org/";>Projects</a></li>
+                      <li><a href="http://people.apache.org/";>People</a></li>
+                      <li><a 
href="http://www.apache.org/foundation/getinvolved.html";>Get Involved</a></li>
+                      <li><a 
href="http://www.apache.org/dyn/closer.cgi";>Download</a></li>
+                      <li><a 
href="http://www.apache.org/security/";>Security</a></li>
+                      <li><a 
href="http://www.apache.org/foundation/sponsorship.html";>Support Apache</a></li>
+                  </ul>
+              </li>
+
+              <li><a href="http://www.apache.org/licenses/";>License</a></li>
+
+              <li class="dropdown">
+                  <a href="#" class="dropdown-toggle" 
data-toggle="dropdown">Download <b class="caret"></b></a>
+                  <ul class="dropdown-menu">
+                      <li><a href="/doc/odata2/download.html">Download OData 
2.0 Java</a></li>
+                      <li><a href="/doc/javascript/download.html">Download 
OData 4.0 JavaScript</a></li>
+                  </ul>
+              </li>
+
+              <li class="dropdown">
+                  <a href="#" class="dropdown-toggle" 
data-toggle="dropdown">Documentation <b class="caret"></b></a>
+                  <ul class="dropdown-menu">
+                    <li><a href="/doc/odata2/index.html">Documentation OData 
2.0 Java</a></li>
+                    <li><a href="/doc/javascript/index.html">Documentation 
OData 4.0 JavaScript</a></li>
+                  </ul>
+              </li>
+              <li><a href="/support.html">Support</a></li>
+
+            </ul>
+
+                         <img class="navbar-right" height="50px" 
src="/img/asf-logo.gif">
+
+                       </div><!--/.nav-collapse -->
+        </div><!--/.container-fluid -->
+      </div><!-- Main component for a primary marketing message or call to 
action --><h1 id="implementation-of-filter-visitor-jdbc">Implementation of 
Filter Visitor (JDBC)</h1>
+<h3 
id="how-to-guide-for-implementing-a-filter-tree-transformation-into-a-jdbc-where-clause">How
 To Guide for implementing a filter tree transformation into a JDBC where 
clause</h3>
+<p>The query option $filter can be used to apply a filter query to the result 
set. This tutorial will be about consuming and working with the filter tree 
which an application will get from the OData Java library by implementing a 
transformation of the filter expression into a JDBC where clause. The example 
explained here will be kept simple to show the mechanism of the visitor 
pattern. Security problem which occur when using user input (e.g. the filter 
string of the URI) inside a where clause will be pointed out but not solved for 
this tutorial. Knowledge about the visitor pattern is not necessary but 
helpful. If you want to read further please refer to the further information 
chapter at the end of this tutorial.</p>
+<h3 id="examples">Examples</h3>
+<h5 id="simple-example">Simple example</h5>
+<p>If a filter expression is parsed by the OData library it will be 
transformed into a filter tree. A simple tree for the expression ‘a’ eq 
‘b’ would look like this:</p>
+<p><img alt="Picture:Simple Filter Expression" 
src="/img/FilterExpressionSimple.png" /></p>
+<p>To visit a filter tree we have to implement the interface 
<code>org.apache.olingo.odata2.api.uri.expression.ExpressionVisitor</code>. For 
this simple example we will only need the following methods:</p>
+<ul>
+<li><code>visitFilter(…)</code></li>
+<li><code>visitBinary(…)</code> </li>
+<li><code>visitLiteral(…)</code> </li>
+</ul>
+<p>These methods will be called if the <code>accept(…)</code> method of the 
filter expression is called. The visitor will always start with the far left of 
the tree. First visitLiteral is called for 'a' and 'b'  before the 
<code>visitBinary()</code> and finally the <code>visitFilter()</code> is 
called.</p>
+<p>Now lets have a look at the implementation of the 
<code>visitLiteral()</code>:</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Override</span>
+<span class="n">public</span> <span class="n">Object</span> <span 
class="n">visitLiteral</span><span class="p">(</span><span 
class="n">LiteralExpression</span> <span class="n">literal</span><span 
class="p">,</span> <span class="n">EdmLiteral</span> <span 
class="n">edmLiteral</span><span class="p">)</span> <span class="p">{</span>
+  <span class="k">if</span><span class="p">(</span><span 
class="n">EdmSimpleTypeKind</span><span class="p">.</span><span 
class="n">String</span><span class="p">.</span><span 
class="n">getEdmSimpleTypeInstance</span><span class="p">().</span><span 
class="n">equals</span><span class="p">(</span><span 
class="n">edmLiteral</span><span class="p">.</span><span 
class="n">getType</span><span class="p">()))</span> <span class="p">{</span>
+    <span class="o">//</span> <span class="n">we</span> <span 
class="n">have</span> <span class="n">to</span> <span class="n">be</span> <span 
class="n">carefull</span> <span class="n">with</span> <span 
class="n">strings</span> <span class="n">due</span> <span class="n">to</span> 
<span class="n">sql</span> <span class="n">injection</span>
+    <span class="o">//</span> <span class="n">TODO</span><span 
class="p">:</span> <span class="n">Prevent</span> <span class="n">sql</span> 
<span class="n">injection</span> <span class="n">via</span> <span 
class="n">escaping</span>
+    <span class="k">return</span> &quot;<span class="s">&#39;&quot; + 
edmLiteral.getLiteral() + &quot;&#39;</span>&quot;<span class="p">;</span>
+  <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+    <span class="k">return</span> &quot;<span class="s">&#39;&quot; + 
edmLiteral.getLiteral() + &quot;&#39;</span>&quot;<span class="p">;</span>
+  <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>The signature for this method contains the literal expression as an object 
as well as the edmLiteral representation. In this case the literal would be "a" 
without the '. Inside this method we just return the literal. Since this 
literal is coming from the URL it represents user input. In the case of the 
type Edm.String we would have to escape the String to make sure no SQL 
Injection is possible.</p>
+<p>Next the method visitBinary is called:</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Override</span>
+  <span class="n">public</span> <span class="n">Object</span> <span 
class="n">visitBinary</span><span class="p">(</span><span 
class="n">BinaryExpression</span> <span class="n">binaryExpression</span><span 
class="p">,</span> <span class="n">BinaryOperator</span> <span 
class="n">operator</span><span class="p">,</span> <span class="n">Object</span> 
<span class="n">leftSide</span><span class="p">,</span> <span 
class="n">Object</span> <span class="n">rightSide</span><span 
class="p">)</span> <span class="p">{</span>    
+    <span class="o">//</span><span class="n">Transform</span> <span 
class="n">the</span> <span class="n">OData</span> <span class="n">filter</span> 
<span class="n">operator</span> <span class="n">into</span> <span 
class="n">an</span> <span class="n">equivalent</span> <span 
class="n">sql</span> <span class="n">operator</span>
+    <span class="n">String</span> <span class="n">sqlOperator</span> <span 
class="p">=</span> &quot;&quot;<span class="p">;</span>
+    <span class="k">switch</span> <span class="p">(</span><span 
class="n">operator</span><span class="p">)</span> <span class="p">{</span>
+    <span class="k">case</span> <span class="n">EQ</span><span 
class="p">:</span>
+      <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="p">=</span>&quot;<span class="p">;</span>
+      <span class="k">break</span><span class="p">;</span>
+    <span class="k">case</span> <span class="n">NE</span><span 
class="p">:</span>
+      <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&lt;&gt;</span>&quot;<span class="p">;</span>
+      <span class="k">break</span><span class="p">;</span>
+    <span class="k">case</span> <span class="n">OR</span><span 
class="p">:</span>
+      <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="n">OR</span>&quot;<span class="p">;</span>
+      <span class="k">break</span><span class="p">;</span>
+    <span class="k">case</span> <span class="n">AND</span><span 
class="p">:</span>
+      <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="n">AND</span>&quot;<span class="p">;</span>
+      <span class="k">break</span><span class="p">;</span>
+    <span class="k">case</span> <span class="n">GE</span><span 
class="p">:</span>
+      <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&gt;</span><span class="p">=</span>&quot;<span class="p">;</span>
+      <span class="k">break</span><span class="p">;</span>
+    <span class="k">case</span> <span class="n">GT</span><span 
class="p">:</span>
+      <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&gt;</span>&quot;<span class="p">;</span>
+      <span class="k">break</span><span class="p">;</span>
+    <span class="k">case</span> <span class="n">LE</span><span 
class="p">:</span>
+      <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&lt;</span><span class="p">=</span>&quot;<span class="p">;</span>
+      <span class="k">break</span><span class="p">;</span>
+    <span class="k">case</span> <span class="n">LT</span><span 
class="p">:</span>
+      <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&lt;</span>&quot;<span class="p">;</span>
+      <span class="k">break</span><span class="p">;</span>
+    <span class="n">default</span><span class="p">:</span>
+      <span class="o">//</span><span class="n">Other</span> <span 
class="n">operators</span> <span class="n">are</span> <span 
class="n">not</span> <span class="n">supported</span> <span 
class="k">for</span> <span class="n">SQL</span> <span 
class="n">Statements</span>
+      <span class="n">throw</span> <span class="n">new</span> <span 
class="n">UnsupportetOperatorException</span><span 
class="p">(</span>&quot;<span class="n">Unsupported</span> <span 
class="n">operator</span><span class="p">:</span> &quot; <span 
class="o">+</span> <span class="n">operator</span><span class="p">.</span><span 
class="n">toUriLiteral</span><span class="p">());</span>
+    <span class="p">}</span>  
+    <span class="o">//</span><span class="k">return</span> <span 
class="n">the</span> <span class="n">binary</span> <span 
class="n">statement</span>
+    <span class="k">return</span> <span class="n">leftSide</span> <span 
class="o">+</span> &quot; &quot; <span class="o">+</span> <span 
class="n">sqlOperator</span> <span class="o">+</span> &quot; &quot; <span 
class="o">+</span> <span class="n">rightSide</span><span class="p">;</span>
+  <span class="p">}</span>
+</pre></div>
+
+
+<p>The signature for this method contains the binaryExpression as an object as 
well as the left and right Side of this binary expression. In this example the 
left side would be "a" and the right side would be "b" which we got from the 
visitLiteral() method. In between we set the operator in its SQL syntax.</p>
+<p>Finally the <code>visitFilter()</code> method is called:</p>
+<div class="codehilite"><pre>  <span class="p">@</span><span 
class="n">Override</span>
+  <span class="n">public</span> <span class="n">Object</span> <span 
class="n">visitFilterExpression</span><span class="p">(</span><span 
class="n">FilterExpression</span> <span class="n">filterExpression</span><span 
class="p">,</span> <span class="n">String</span> <span 
class="n">expressionString</span><span class="p">,</span> <span 
class="n">Object</span> <span class="n">expression</span><span 
class="p">)</span> <span class="p">{</span>
+      <span class="k">return</span> &quot;<span class="n">WHERE</span> &quot; 
<span class="o">+</span> <span class="n">expression</span><span 
class="p">;</span>
+  <span class="p">}</span>
+</pre></div>
+
+
+<p>Here we just append the WHERE at the beginning and give the whole thing 
back to the caller of the <code>accept()</code> method.</p>
+<p>A simple test can show how the expression is transformed. As one can see 
the <code>UriParser</code> can parse a filter expression if necessary. Usually 
the application will already have the filter expression.</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Test</span>
+<span class="n">public</span> <span class="n">void</span> <span 
class="n">printExpression</span><span class="p">()</span> <span 
class="n">throws</span> <span class="n">Exception</span> <span 
class="p">{</span>
+    <span class="n">FilterExpression</span> <span class="n">expression</span> 
<span class="p">=</span> <span class="n">UriParser</span><span 
class="p">.</span><span class="n">parseFilter</span><span 
class="p">(</span><span class="n">null</span><span class="p">,</span> <span 
class="n">null</span><span class="p">,</span> &quot;<span 
class="s">&#39;a&#39;</span> <span class="n">eq</span> <span 
class="s">&#39;b&#39;</span>&quot;<span class="p">);</span>
+    <span class="n">String</span> <span class="n">whereClause</span> <span 
class="p">=</span> <span class="p">(</span><span class="n">String</span><span 
class="p">)</span> <span class="n">expression</span><span 
class="p">.</span><span class="n">accept</span><span class="p">(</span><span 
class="n">new</span> <span class="n">JdbcStringVisitor</span><span 
class="p">());</span>
+    <span class="n">System</span><span class="p">.</span><span 
class="n">out</span><span class="p">.</span><span class="n">println</span><span 
class="p">(</span>&quot;<span class="n">Raw</span><span class="p">:</span> 
&quot; <span class="o">+</span> <span class="n">rawExpression</span> <span 
class="o">+</span> &quot; <span class="o">------&gt;</span> <span 
class="n">Whereclause</span><span class="p">:</span> &quot; <span 
class="o">+</span> <span class="n">whereClause</span><span class="p">);</span>
+    <span class="n">System</span><span class="p">.</span><span 
class="n">out</span><span class="p">.</span><span class="n">println</span><span 
class="p">();</span>
+  <span class="p">}</span>
+</pre></div>
+
+
+<p>The output will be:</p>
+<div class="codehilite"><pre><span class="n">Raw</span><span 
class="p">:</span> <span class="s">&#39;a&#39;</span> <span class="n">eq</span> 
<span class="s">&#39;b&#39;</span> <span class="o">------&gt;</span> <span 
class="n">Whereclause</span><span class="p">:</span> <span 
class="s">&#39;a&#39;</span> <span class="p">=</span> <span 
class="s">&#39;b&#39;</span>
+</pre></div>
+
+
+<p>The implementation right now can only transform literals which will not be 
sufficient if you want to address a property. If an expression contains 
properties like "EmployeeId" we have to implement the method 
<code>visitProperty()</code>.</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Override</span>
+<span class="n">public</span> <span class="n">Object</span> <span 
class="n">visitProperty</span><span class="p">(</span><span 
class="n">PropertyExpression</span> <span 
class="n">propertyExpression</span><span class="p">,</span> <span 
class="n">String</span> <span class="n">uriLiteral</span><span 
class="p">,</span> <span class="n">EdmTyped</span> <span 
class="n">edmProperty</span><span class="p">)</span> <span class="p">{</span>
+  <span class="k">if</span> <span class="p">(</span><span 
class="n">edmProperty</span> <span class="o">==</span> <span 
class="n">null</span><span class="p">)</span> <span class="p">{</span>
+    <span class="o">//</span><span class="n">If</span> <span 
class="n">a</span> <span class="n">property</span> <span class="n">is</span> 
<span class="n">not</span> <span class="n">found</span> <span 
class="n">it</span> <span class="n">wont</span> <span class="n">be</span> <span 
class="n">represented</span> <span class="n">in</span> <span 
class="n">the</span> <span class="n">database</span> <span 
class="n">thus</span> <span class="n">we</span> <span class="n">have</span> 
<span class="n">to</span> <span class="n">throw</span> <span 
class="n">an</span> <span class="n">exception</span>
+    <span class="n">throw</span> <span class="n">new</span> <span 
class="n">PropertyNotFoundException</span><span class="p">(</span>&quot;<span 
class="n">Could</span> <span class="n">not</span> <span class="nb">find</span> 
<span class="n">Property</span><span class="p">:</span> &quot; <span 
class="o">+</span> <span class="n">uriLiteral</span><span class="p">);</span>
+  <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+    <span class="o">//</span><span class="n">It</span> <span 
class="n">is</span> <span class="n">also</span> <span class="n">possible</span> 
<span class="n">to</span> <span class="n">use</span> <span class="n">the</span> 
<span class="n">mapping</span> <span class="n">of</span> <span 
class="n">the</span> <span class="n">edmProperty</span> <span 
class="k">if</span> <span class="n">the</span> <span class="n">name</span> 
<span class="n">differs</span> <span class="n">from</span> <span 
class="n">the</span> <span class="n">databasename</span>
+    <span class="k">try</span> <span class="p">{</span>
+      <span class="k">return</span> <span class="n">edmProperty</span><span 
class="p">.</span><span class="n">getName</span><span class="p">();</span>
+    <span class="p">}</span> <span class="k">catch</span> <span 
class="p">(</span><span class="n">EdmException</span> <span 
class="n">e</span><span class="p">)</span> <span class="p">{</span>
+      <span class="n">throw</span> <span class="n">new</span> <span 
class="n">PropertyNotFoundException</span><span class="p">(</span><span 
class="n">e</span><span class="p">);</span>
+    <span class="p">}</span>
+  <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>This method has an <code>edmProperty</code> in its signature which is set 
if the <code>uriLiteral</code> matches a property in the 
<code>EntityType</code>. Now we could transform an expression like 
<code>"EmployeeId eq '1'" or "EmployeeId eq '1' and ManagerId eq '2'"</code>. 
To get a validation if the property exists we have to give an 
<code>EntityType</code> on which the filter will be applied. In this case we 
use the <code>EntityType</code> "Employee".</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Test</span>
+<span class="n">public</span> <span class="n">void</span> <span 
class="n">printExpressionWithProperty</span><span class="p">()</span> <span 
class="n">throws</span> <span class="n">Exception</span> <span 
class="p">{</span>
+  <span class="o">//</span><span class="n">Use</span> <span class="n">a</span> 
<span class="n">mocked</span> <span class="n">edmProvider</span> <span 
class="k">for</span> <span class="n">this</span> <span class="n">tutorial</span>
+  <span class="n">TestEdmProvider</span> <span class="n">provider</span> <span 
class="p">=</span> <span class="n">new</span> <span 
class="n">TestEdmProvider</span><span class="p">();</span>
+  <span class="n">Edm</span> <span class="n">edm</span> <span 
class="p">=</span> <span class="n">RuntimeDelegate</span><span 
class="p">.</span><span class="n">createEdm</span><span class="p">(</span><span 
class="n">provider</span><span class="p">);</span>
+  <span class="n">EdmEntityType</span> <span class="n">entityType</span> <span 
class="p">=</span> <span class="n">edm</span><span class="p">.</span><span 
class="n">getEntityType</span><span class="p">(</span><span 
class="n">TestEdmProvider</span><span class="p">.</span><span 
class="n">NAMESPACE_1</span><span class="p">,</span> <span 
class="n">TestEdmProvider</span><span class="p">.</span><span 
class="n">ENTITY_TYPE_1_1</span><span class="p">.</span><span 
class="n">getName</span><span class="p">());</span>
+
+  <span class="n">String</span> <span class="n">rawExpression</span> <span 
class="p">=</span> &quot;<span class="n">EmployeeId</span> <span 
class="n">eq</span> <span class="s">&#39;1&#39;</span>&quot;<span 
class="p">;</span>
+  <span class="n">FilterExpression</span> <span class="n">expression</span> 
<span class="p">=</span> <span class="n">UriParser</span><span 
class="p">.</span><span class="n">parseFilter</span> <span 
class="p">(</span><span class="n">null</span><span class="p">,</span> <span 
class="n">entityType</span><span class="p">,</span> <span 
class="n">rawExpression</span><span class="p">);</span>
+  <span class="n">String</span> <span class="n">whereClause</span> <span 
class="p">=</span> <span class="p">(</span><span class="n">String</span><span 
class="p">)</span> <span class="n">expression</span><span 
class="p">.</span><span class="n">accept</span><span class="p">(</span><span 
class="n">new</span> <span class="n">JdbcSimpleStringVisitor</span><span 
class="p">());</span>
+  <span class="n">System</span><span class="p">.</span><span 
class="n">out</span><span class="p">.</span><span class="n">println</span><span 
class="p">(</span>&quot;<span class="n">Raw</span><span class="p">:</span> 
&quot; <span class="o">+</span> <span class="n">rawExpression</span> <span 
class="o">+</span> &quot; <span class="o">------&gt;</span> <span 
class="n">Whereclause</span><span class="p">:</span> &quot; <span 
class="o">+</span> <span class="n">whereClause</span><span class="p">);</span>
+  <span class="n">System</span><span class="p">.</span><span 
class="n">out</span><span class="p">.</span><span class="n">println</span><span 
class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>The output will be:</p>
+<div class="codehilite"><pre><span class="n">Raw</span><span 
class="o">:</span> <span class="n">EmployeeId</span> <span class="n">eq</span> 
<span class="s1">&#39;1&#39;</span> <span class="o">------&gt;</span> <span 
class="n">Whereclause</span><span class="o">:</span> <span 
class="n">WHERE</span> <span class="n">EmployeeId</span> <span 
class="o">=</span> <span class="s1">&#39;1&#39;</span>
+</pre></div>
+
+
+<p>Test in the sources: JdbcSimpleStringVisitorTest.class</p>
+<h5 id="advanced-example">Advanced Example</h5>
+<p>The implementation shown in the previous chapter can transform simple 
expressions. But if the expression gets more complex like <code>"'a' eq 'b' or 
('c' eq 'd' and 'b' eq 'd')"</code> it won´t produce a correct where clause. 
The following test shows this.</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Test</span>
+<span class="n">public</span> <span class="n">void</span> <span 
class="n">compareSimpleAndAdvancedVisitor</span><span class="p">()</span> <span 
class="n">throws</span> <span class="n">Exception</span><span class="p">{</span>
+  <span class="n">String</span> <span class="n">rawExpression</span> <span 
class="p">=</span> &quot;<span class="s">&#39;a&#39;</span> <span 
class="n">eq</span> <span class="s">&#39;b&#39;</span> <span 
class="n">or</span> <span class="p">(</span><span class="s">&#39;c&#39;</span> 
<span class="n">eq</span> <span class="s">&#39;d&#39;</span> <span 
class="n">and</span> <span class="s">&#39;b&#39;</span> <span 
class="n">eq</span> <span class="s">&#39;d&#39;</span><span 
class="p">)</span>&quot;<span class="p">;</span>
+  <span class="n">FilterExpression</span> <span class="n">expression</span> 
<span class="p">=</span> <span class="n">UriParser</span><span 
class="p">.</span><span class="n">parseFilter</span><span 
class="p">(</span><span class="n">null</span><span class="p">,</span> <span 
class="n">null</span><span class="p">,</span> <span 
class="n">rawExpression</span><span class="p">);</span>
+
+  <span class="n">String</span> <span class="n">whereClauseSimple</span> <span 
class="p">=</span> <span class="p">(</span><span class="n">String</span><span 
class="p">)</span> <span class="n">expression</span><span 
class="p">.</span><span class="n">accept</span><span class="p">(</span><span 
class="n">new</span> <span class="n">JdbcSimpleStringVisitor</span><span 
class="p">());</span>
+  <span class="n">String</span> <span class="n">whereClauseAdvanced</span> 
<span class="p">=</span> <span class="p">(</span><span 
class="n">String</span><span class="p">)</span> <span 
class="n">expression</span><span class="p">.</span><span 
class="n">accept</span><span class="p">(</span><span class="n">new</span> <span 
class="n">JdbcAdvancedStringVisitor</span><span class="p">());</span>
+  <span class="n">System</span><span class="p">.</span><span 
class="n">out</span><span class="p">.</span><span class="n">println</span><span 
class="p">(</span>&quot;<span class="n">Simple</span><span class="p">:</span> 
&quot; <span class="o">+</span> <span class="n">whereClauseSimple</span> <span 
class="o">+</span> &quot; <span class="o">------&gt;</span> <span 
class="n">Advanced</span><span class="p">:</span> &quot; <span 
class="o">+</span> <span class="n">whereClauseAdvanced</span><span 
class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>The output will be:</p>
+<div class="codehilite"><pre><span class="n">Simple</span><span 
class="o">:</span> <span class="n">WHERE</span> <span 
class="s1">&#39;a&#39;</span> <span class="o">=</span> <span 
class="s1">&#39;b&#39;</span> <span class="n">OR</span> <span 
class="s1">&#39;c&#39;</span> <span class="o">=</span> <span 
class="s1">&#39;d&#39;</span> <span class="n">AND</span> <span 
class="s1">&#39;b&#39;</span> <span class="o">=</span> <span 
class="s1">&#39;d&#39;</span> <span class="o">------&gt;</span> <span 
class="n">Advanced</span><span class="o">:</span> <span class="n">WHERE</span> 
<span class="s1">&#39;a&#39;</span> <span class="o">=</span> <span 
class="s1">&#39;b&#39;</span> <span class="n">OR</span> <span 
class="o">(</span><span class="s1">&#39;c&#39;</span> <span class="o">=</span> 
<span class="s1">&#39;d&#39;</span> <span class="n">AND</span> <span 
class="s1">&#39;b&#39;</span> <span class="o">=</span> <span 
class="s1">&#39;d&#39;</span><span class="o">)</span>
+</pre></div>
+
+
+<p>In the simple implementation the brackets will not be transformed. To fix 
this the method <code>visitBinary()</code> has to be enhanced.</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Override</span>
+<span class="n">public</span> <span class="n">Object</span> <span 
class="n">visitBinary</span><span class="p">(</span><span 
class="n">BinaryExpression</span> <span class="n">binaryExpression</span><span 
class="p">,</span> <span class="n">BinaryOperator</span> <span 
class="n">operator</span><span class="p">,</span> <span class="n">Object</span> 
<span class="n">leftSide</span><span class="p">,</span> <span 
class="n">Object</span> <span class="n">rightSide</span><span 
class="p">)</span> <span class="p">{</span>
+  <span class="n">String</span> <span class="n">actualLeftSide</span> <span 
class="p">=</span> <span class="n">leftSide</span><span class="p">.</span><span 
class="n">toString</span><span class="p">();</span>
+  <span class="n">String</span> <span class="n">actualRightSide</span> <span 
class="p">=</span> <span class="n">rightSide</span><span 
class="p">.</span><span class="n">toString</span><span class="p">();</span>
+  <span class="k">if</span> <span class="p">(</span><span 
class="n">leftSide</span> <span class="n">instanceof</span> <span 
class="n">Expression</span><span class="p">)</span> <span class="p">{</span>
+    <span class="o">//</span><span class="n">If</span> <span 
class="n">something</span> <span class="n">is</span> <span 
class="n">lower</span> <span class="n">in</span> <span class="n">the</span> 
<span class="n">tree</span> <span class="n">and</span> <span 
class="n">is</span> <span class="n">of</span> <span class="n">the</span> <span 
class="n">type</span> <span class="n">AND</span> <span class="n">or</span> 
<span class="n">OR</span> <span class="n">it</span> <span 
class="n">needs</span> <span class="n">brackets</span> <span 
class="n">to</span> <span class="n">show</span> <span class="n">the</span> 
<span class="n">higher</span> <span class="n">priority</span>
+    <span class="k">if</span> <span class="p">(</span><span 
class="n">BinaryOperator</span><span class="p">.</span><span 
class="n">AND</span><span class="p">.</span><span class="n">equals</span><span 
class="p">(((</span><span class="n">Expression</span><span class="p">)</span> 
<span class="n">leftSide</span><span class="p">).</span><span 
class="n">getOperator</span><span class="p">())</span> <span 
class="o">||</span> <span class="n">BinaryOperator</span><span 
class="p">.</span><span class="n">OR</span><span class="p">.</span><span 
class="n">equals</span><span class="p">(((</span><span 
class="n">Expression</span><span class="p">)</span> <span 
class="n">leftSide</span><span class="p">).</span><span 
class="n">getOperator</span><span class="p">()))</span> <span class="p">{</span>
+    <span class="n">actualLeftSide</span> <span class="p">=</span> &quot;<span 
class="p">(</span>&quot; <span class="o">+</span> <span 
class="n">leftSide</span> <span class="o">+</span> &quot;<span 
class="p">)</span>&quot;<span class="p">;</span>
+    <span class="p">}</span>
+  <span class="p">}</span>
+  <span class="k">if</span> <span class="p">(</span><span 
class="n">rightSide</span> <span class="n">instanceof</span> <span 
class="n">Expression</span><span class="p">)</span> <span class="p">{</span>
+    <span class="o">//</span><span class="n">If</span> <span 
class="n">something</span> <span class="n">is</span> <span 
class="n">lower</span> <span class="n">in</span> <span class="n">the</span> 
<span class="n">tree</span> <span class="n">and</span> <span 
class="n">is</span> <span class="n">of</span> <span class="n">the</span> <span 
class="n">type</span> <span class="n">AND</span> <span class="n">or</span> 
<span class="n">OR</span> <span class="n">it</span> <span 
class="n">needs</span> <span class="n">brackets</span> <span 
class="n">to</span> <span class="n">show</span> <span class="n">the</span> 
<span class="n">higher</span> <span class="n">priority</span>
+    <span class="k">if</span> <span class="p">(</span><span 
class="n">BinaryOperator</span><span class="p">.</span><span 
class="n">AND</span><span class="p">.</span><span class="n">equals</span><span 
class="p">(((</span><span class="n">Expression</span><span class="p">)</span> 
<span class="n">rightSide</span><span class="p">).</span><span 
class="n">getOperator</span><span class="p">())</span> <span 
class="o">||</span> <span class="n">BinaryOperator</span><span 
class="p">.</span><span class="n">OR</span><span class="p">.</span><span 
class="n">equals</span><span class="p">(((</span><span 
class="n">Expression</span><span class="p">)</span> <span 
class="n">rightSide</span><span class="p">).</span><span 
class="n">getOperator</span><span class="p">()))</span> <span class="p">{</span>
+    <span class="n">actualRightSide</span> <span class="p">=</span> 
&quot;<span class="p">(</span>&quot; <span class="o">+</span> <span 
class="n">rightSide</span> <span class="o">+</span> &quot;<span 
class="p">)</span>&quot;<span class="p">;</span>
+    <span class="p">}</span>
+  <span class="p">}</span>
+  <span class="o">//</span><span class="n">Transform</span> <span 
class="n">the</span> <span class="n">OData</span> <span class="n">filter</span> 
<span class="n">operator</span> <span class="n">into</span> <span 
class="n">an</span> <span class="n">equivalent</span> <span 
class="n">sql</span> <span class="n">operator</span>
+  <span class="n">String</span> <span class="n">sqlOperator</span> <span 
class="p">=</span> &quot;&quot;<span class="p">;</span>
+  <span class="k">switch</span> <span class="p">(</span><span 
class="n">operator</span><span class="p">)</span> <span class="p">{</span>
+  <span class="k">case</span> <span class="n">EQ</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="p">=</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">NE</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&lt;&gt;</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">OR</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="n">OR</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">AND</span><span 
class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="n">AND</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">GE</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&gt;</span><span class="p">=</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">GT</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&gt;</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">LE</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&lt;</span><span class="p">=</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">LT</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&lt;</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="n">default</span><span class="p">:</span>
+    <span class="o">//</span><span class="n">Other</span> <span 
class="n">operators</span> <span class="n">are</span> <span 
class="n">not</span> <span class="n">supported</span> <span 
class="k">for</span> <span class="n">SQL</span>  <span 
class="n">Statements</span>
+    <span class="n">throw</span> <span class="n">new</span> <span 
class="n">UnsupportetOperatorException</span><span 
class="p">(</span>&quot;<span class="n">Unsupported</span> <span 
class="n">operator</span><span class="p">:</span> &quot; <span 
class="o">+</span> <span class="n">operator</span><span class="p">.</span><span 
class="n">toUriLiteral</span><span class="p">());</span>
+  <span class="p">}</span>
+
+  <span class="o">//</span><span class="k">return</span> <span 
class="n">the</span> <span class="n">binary</span> <span 
class="n">statement</span>
+  <span class="k">return</span> <span class="n">new</span> <span 
class="n">Expression</span><span class="p">(</span><span 
class="n">actualLeftSide</span> <span class="o">+</span> &quot; &quot; <span 
class="o">+</span> <span class="n">sqlOperator</span> <span class="o">+</span> 
&quot; &quot; <span class="o">+</span> <span 
class="n">actualRightSide</span><span class="p">,</span> <span 
class="n">operator</span><span class="p">);</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>Since simple strings cannot show this complexity a new private class 
"Expression" was introduced. The signature of all <code>visit()</code> methods 
accept any kind of object so we can mix in the new class. Now we only have to 
check if one side of the tree is of type String or Expression.</p>
+<p>Test in the sources: JdbcAdvancedStringVisitorTest.class</p>
+<h5 id="example-with-prepared-statements">Example with prepared Statements</h5>
+<p>Since string concatenation is very vulnerable against SQL Injection a best 
practice is to use prepared statements. This can be a tough challenge in this 
case because not only the value of <code>EmployeeId</code> is supplied in the 
filter expression but the field EmployeeId and the operator as well. Prepared 
Statements don´t allow statements like <code>"WHERE ? ? ?"</code> thus we have 
to find a way to prepare the prepared statements in advance which can be very 
complex as the following example will show: The filter expression 
<code>"EmployeeId eq '1' and ManagerId eq '2'"</code> is the same as 
<code>"ManagerId eq '2' and EmployeeId eq '1'"</code> but the prepared 
statement will always look like <code>"…. WHERE EmployeeId = ? and ManagerId 
= ?"</code>.</p>
+<p>This tutorial will not solve this problem. Instead it will show a first 
idea on how to implement such a prepared statement visitor. Again the Where 
clause will be created using string concatenation. But this time we will 
replace literals with a "?". These questionmarks can be set in a prepared 
statement. The methods <code>visitLiteral</code> and <code>visitProperty</code> 
will just return their value while the <code>visitBinary</code> will contain 
the logic.</p>
+<p>VisitLiteral:</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Override</span>
+<span class="n">public</span> <span class="n">Object</span> <span 
class="n">visitLiteral</span><span class="p">(</span><span 
class="n">final</span> <span class="n">LiteralExpression</span> <span 
class="n">literal</span><span class="p">,</span> <span class="n">final</span> 
<span class="n">EdmLiteral</span> <span class="n">edmLiteral</span><span 
class="p">)</span> <span class="p">{</span>
+  <span class="o">//</span><span class="n">Sql</span> <span 
class="n">Injection</span> <span class="n">is</span> <span class="n">not</span> 
<span class="n">possible</span> <span class="n">anymore</span> <span 
class="n">since</span> <span class="n">we</span> <span class="n">are</span> 
<span class="n">using</span> <span class="n">prepared</span> <span 
class="n">statements</span><span class="p">.</span> <span class="n">Thus</span> 
<span class="n">we</span> <span class="n">can</span> <span 
class="n">just</span> <span class="n">give</span> <span class="n">back</span> 
<span class="n">the</span> <span class="n">edmLiteral</span> <span 
class="n">content</span>
+  <span class="k">return</span> <span class="n">edmLiteral</span><span 
class="p">.</span><span class="n">getLiteral</span><span class="p">();</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>VisitProperty:</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Override</span>
+<span class="n">public</span> <span class="n">Object</span> <span 
class="n">visitProperty</span><span class="p">(</span><span 
class="n">final</span> <span class="n">PropertyExpression</span> <span 
class="n">propertyExpression</span><span class="p">,</span> <span 
class="n">final</span> <span class="n">String</span> <span 
class="n">uriLiteral</span><span class="p">,</span> <span 
class="n">final</span> <span class="n">EdmTyped</span> <span 
class="n">edmProperty</span><span class="p">)</span> <span class="p">{</span>
+  <span class="k">if</span> <span class="p">(</span><span 
class="n">edmProperty</span> <span class="o">==</span> <span 
class="n">null</span><span class="p">)</span> <span class="p">{</span>
+    <span class="o">//</span><span class="n">If</span> <span 
class="n">a</span> <span class="n">property</span> <span class="n">is</span> 
<span class="n">not</span> <span class="n">found</span> <span 
class="n">it</span> <span class="n">wont</span> <span class="n">be</span> <span 
class="n">represented</span> <span class="n">in</span> <span 
class="n">the</span> <span class="n">database</span> <span 
class="n">thus</span> <span class="n">we</span> <span class="n">have</span> 
<span class="n">to</span> <span class="n">throw</span> <span 
class="n">an</span> <span class="n">exception</span>
+    <span class="n">throw</span> <span class="n">new</span> <span 
class="n">PropertyNotFoundException</span><span class="p">(</span>&quot;<span 
class="n">Could</span> <span class="n">not</span> <span class="nb">find</span> 
<span class="n">Property</span><span class="p">:</span> &quot; <span 
class="o">+</span> <span class="n">uriLiteral</span><span class="p">);</span>
+  <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+    <span class="o">//</span><span class="n">To</span> <span 
class="n">distinguish</span> <span class="n">between</span> <span 
class="n">literals</span> <span class="n">and</span> <span 
class="k">properties</span> <span class="n">we</span> <span 
class="n">give</span> <span class="n">back</span> <span class="n">the</span> 
<span class="n">whole</span> <span class="n">edmProperty</span> <span 
class="n">in</span> <span class="n">this</span> <span class="k">case</span>
+    <span class="k">return</span> <span class="n">edmProperty</span><span 
class="p">;</span>
+  <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>In addition we will use the following class as a container for the where 
clause and the parameters:</p>
+<div class="codehilite"><pre><span class="n">public</span> <span 
class="n">class</span> <span class="n">Expression</span> <span 
class="p">{</span>
+  <span class="n">private</span> <span class="n">String</span> <span 
class="n">preparedWhere</span><span class="p">;</span>
+  <span class="n">private</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">Object</span><span class="o">&gt;</span> 
<span class="n">parameters</span><span class="p">;</span>
+  <span class="n">private</span> <span class="n">BinaryOperator</span> <span 
class="n">operator</span><span class="p">;</span>
+
+  <span class="n">public</span> <span class="n">Expression</span><span 
class="p">(</span><span class="n">final</span> <span 
class="n">BinaryOperator</span> <span class="n">operator</span><span 
class="p">)</span> <span class="p">{</span>
+    <span class="n">preparedWhere</span> <span class="p">=</span> 
&quot;&quot;<span class="p">;</span>
+    <span class="n">parameters</span> <span class="p">=</span> <span 
class="n">new</span> <span class="n">ArrayList</span><span 
class="o">&lt;</span><span class="n">Object</span><span 
class="o">&gt;</span><span class="p">();</span>
+    <span class="n">this</span><span class="p">.</span><span 
class="n">operator</span> <span class="p">=</span> <span 
class="n">operator</span><span class="p">;</span>
+  <span class="p">}</span>
+
+  <span class="n">public</span> <span class="n">void</span> <span 
class="n">addParameter</span><span class="p">(</span><span 
class="n">final</span> <span class="n">Object</span> <span 
class="n">parameter</span><span class="p">)</span> <span class="p">{</span>
+  <span class="n">parameters</span><span class="p">.</span><span 
class="n">add</span><span class="p">(</span><span 
class="n">parameter</span><span class="p">);</span>
+  <span class="p">}</span>
+
+  <span class="n">public</span> <span class="n">void</span> <span 
class="n">setPrepeparedWhere</span><span class="p">(</span><span 
class="n">final</span> <span class="n">String</span> <span 
class="n">where</span><span class="p">)</span> <span class="p">{</span>
+    <span class="n">preparedWhere</span> <span class="p">=</span> <span 
class="n">where</span><span class="p">;</span>
+  <span class="p">}</span>
+
+  <span class="n">public</span> <span class="n">List</span><span 
class="o">&lt;</span><span class="n">Object</span><span class="o">&gt;</span> 
<span class="n">getParameters</span><span class="p">()</span> <span 
class="p">{</span>
+    <span class="k">return</span> <span class="n">parameters</span><span 
class="p">;</span>
+  <span class="p">}</span>
+
+  <span class="n">public</span> <span class="n">BinaryOperator</span> <span 
class="n">getOperator</span><span class="p">()</span> <span class="p">{</span>
+    <span class="k">return</span> <span class="n">operator</span><span 
class="p">;</span>
+  <span class="p">}</span>
+
+  <span class="p">@</span><span class="n">Override</span>
+  <span class="n">public</span> <span class="n">String</span> <span 
class="n">toString</span><span class="p">()</span> <span class="p">{</span>
+    <span class="k">return</span> <span class="n">preparedWhere</span><span 
class="p">;</span>
+  <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>Finally the visitBinary method:</p>
+<div class="codehilite"><pre><span class="p">@</span><span 
class="n">Override</span>
+<span class="n">public</span> <span class="n">Object</span> <span 
class="n">visitBinary</span><span class="p">(</span><span 
class="n">final</span> <span class="n">BinaryExpression</span> <span 
class="n">binaryExpression</span><span class="p">,</span> <span 
class="n">final</span> <span class="n">BinaryOperator</span> <span 
class="n">operator</span><span class="p">,</span> <span class="n">final</span> 
<span class="n">Object</span> <span class="n">leftSide</span><span 
class="p">,</span> <span class="n">final</span> <span class="n">Object</span> 
<span class="n">rightSide</span><span class="p">)</span> <span 
class="p">{</span>
+  <span class="o">//</span><span class="n">Transform</span> <span 
class="n">the</span> <span class="n">OData</span> <span class="n">filter</span> 
<span class="n">operator</span> <span class="n">into</span> <span 
class="n">an</span> <span class="n">equivalent</span> <span 
class="n">sql</span> <span class="n">operator</span>
+  <span class="n">String</span> <span class="n">sqlOperator</span> <span 
class="p">=</span> &quot;&quot;<span class="p">;</span>
+  <span class="k">switch</span> <span class="p">(</span><span 
class="n">operator</span><span class="p">)</span> <span class="p">{</span>
+  <span class="k">case</span> <span class="n">EQ</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="p">=</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">NE</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&lt;&gt;</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">OR</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="n">OR</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">AND</span><span 
class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="n">AND</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">GE</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&gt;</span><span class="p">=</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">GT</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&gt;</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">LE</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&lt;</span><span class="p">=</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="k">case</span> <span class="n">LT</span><span class="p">:</span>
+    <span class="n">sqlOperator</span> <span class="p">=</span> &quot;<span 
class="o">&lt;</span>&quot;<span class="p">;</span>
+    <span class="k">break</span><span class="p">;</span>
+  <span class="n">default</span><span class="p">:</span>
+    <span class="o">//</span><span class="n">Other</span> <span 
class="n">operators</span> <span class="n">are</span> <span 
class="n">not</span> <span class="n">supported</span> <span 
class="k">for</span> <span class="n">SQL</span> <span 
class="n">Statements</span>
+    <span class="n">throw</span> <span class="n">new</span> <span 
class="n">UnsupportetOperatorException</span><span 
class="p">(</span>&quot;<span class="n">Unsupported</span> <span 
class="n">operator</span><span class="p">:</span> &quot; <span 
class="o">+</span> <span class="n">operator</span><span class="p">.</span><span 
class="n">toUriLiteral</span><span class="p">());</span>
+  <span class="p">}</span>
+  <span class="o">//</span><span class="n">The</span> <span 
class="n">idea</span> <span class="n">is</span> <span class="n">to</span> <span 
class="n">check</span> <span class="k">if</span> <span class="n">the</span> 
<span class="n">left</span> <span class="n">side</span> <span 
class="n">is</span> <span class="n">of</span> <span class="n">type</span> <span 
class="n">property</span><span class="p">.</span> <span class="n">If</span> 
<span class="n">this</span> <span class="n">is</span> <span 
class="n">the</span> <span class="k">case</span> <span class="n">we</span> 
<span class="n">append</span> <span class="n">the</span> <span 
class="n">property</span> <span class="n">name</span> <span 
class="n">and</span> <span class="n">the</span> <span class="n">operator</span> 
<span class="n">to</span> <span class="n">the</span> <span 
class="n">where</span> <span class="n">clause</span>
+  <span class="k">if</span> <span class="p">(</span><span 
class="n">leftSide</span> <span class="n">instanceof</span> <span 
class="n">EdmTyped</span> <span class="o">&amp;&amp;</span> <span 
class="n">rightSide</span> <span class="n">instanceof</span> <span 
class="n">String</span><span class="p">)</span> <span class="p">{</span>
+    <span class="n">Expression</span> <span class="n">expression</span> <span 
class="p">=</span> <span class="n">new</span> <span 
class="n">Expression</span><span class="p">(</span><span 
class="n">operator</span><span class="p">);</span>
+    <span class="k">try</span> <span class="p">{</span>
+      <span class="n">expression</span><span class="p">.</span><span 
class="n">setPrepeparedWhere</span><span class="p">(((</span><span 
class="n">EdmTyped</span><span class="p">)</span>   <span 
class="n">leftSide</span><span class="p">).</span><span 
class="n">getName</span><span class="p">()</span> <span class="o">+</span> 
&quot; &quot; <span class="o">+</span> <span class="n">sqlOperator</span> <span 
class="o">+</span> &quot; ?&quot;<span class="p">);</span>
+    <span class="p">}</span> <span class="k">catch</span> <span 
class="p">(</span><span class="n">EdmException</span> <span 
class="n">e</span><span class="p">)</span> <span class="p">{</span>
+      <span class="n">throw</span> <span class="n">new</span> <span 
class="n">RuntimeException</span><span class="p">(</span>&quot;<span 
class="n">EdmException</span> <span class="n">occured</span>&quot;<span 
class="p">);</span>
+    <span class="p">}</span>
+    <span class="n">expression</span><span class="p">.</span><span 
class="n">addParameter</span><span class="p">(</span><span 
class="n">rightSide</span><span class="p">);</span>
+    <span class="k">return</span> <span class="n">expression</span><span 
class="p">;</span>
+  <span class="p">}</span> <span class="k">else</span> <span 
class="k">if</span> <span class="p">(</span><span class="n">leftSide</span> 
<span class="n">instanceof</span> <span class="n">Expression</span> <span 
class="o">&amp;&amp;</span> <span class="n">rightSide</span> <span 
class="n">instanceof</span> <span class="n">Expression</span><span 
class="p">)</span> <span class="p">{</span>
+    <span class="n">Expression</span> <span class="n">returnExpression</span> 
<span class="p">=</span> <span class="n">new</span> <span 
class="n">Expression</span><span class="p">(</span><span 
class="n">operator</span><span class="p">);</span>
+    <span class="n">Expression</span> <span 
class="n">leftSideExpression</span> <span class="p">=</span> <span 
class="p">(</span><span class="n">Expression</span><span class="p">)</span> 
<span class="n">leftSide</span><span class="p">;</span>
+    <span class="k">if</span> <span class="p">(</span><span 
class="n">BinaryOperator</span><span class="p">.</span><span 
class="n">AND</span><span class="p">.</span><span class="n">equals</span>    
<span class="p">(</span><span class="n">leftSideExpression</span><span 
class="p">.</span><span class="n">getOperator</span><span class="p">())</span> 
<span class="o">||</span> <span class="n">BinaryOperator</span><span 
class="p">.</span><span class="n">OR</span><span class="p">.</span><span 
class="n">equals</span><span class="p">(</span><span 
class="n">leftSideExpression</span><span class="p">.</span><span 
class="n">getOperator</span><span class="p">()))</span> <span class="p">{</span>
+    <span class="n">leftSideExpression</span><span class="p">.</span><span 
class="n">setPrepeparedWhere</span><span class="p">(</span>&quot;<span 
class="p">(</span>&quot; <span class="o">+</span> <span 
class="n">leftSideExpression</span><span class="p">.</span><span 
class="n">toString</span><span class="p">()</span> <span class="o">+</span> 
&quot;<span class="p">)</span>&quot;<span class="p">);</span>
+    <span class="p">}</span>
+    <span class="n">Expression</span> <span 
class="n">rightSideExpression</span> <span class="p">=</span> <span 
class="p">(</span><span class="n">Expression</span><span class="p">)</span> 
<span class="n">rightSide</span><span class="p">;</span>
+    <span class="k">if</span> <span class="p">(</span><span 
class="n">BinaryOperator</span><span class="p">.</span><span 
class="n">AND</span><span class="p">.</span><span class="n">equals</span><span 
class="p">(</span><span class="n">rightSideExpression</span><span 
class="p">.</span><span class="n">getOperator</span><span class="p">())</span> 
<span class="o">||</span> <span class="n">BinaryOperator</span><span 
class="p">.</span><span class="n">OR</span><span class="p">.</span><span 
class="n">equals</span><span class="p">(</span><span 
class="n">rightSideExpression</span><span class="p">.</span><span 
class="n">getOperator</span><span class="p">()))</span> <span class="p">{</span>
+    <span class="n">rightSideExpression</span><span class="p">.</span><span 
class="n">setPrepeparedWhere</span><span class="p">(</span>&quot;<span 
class="p">(</span>&quot; <span class="o">+</span> <span 
class="n">rightSideExpression</span><span class="p">.</span><span 
class="n">toString</span><span class="p">()</span> <span class="o">+</span> 
&quot;<span class="p">)</span>&quot;<span class="p">);</span>
+    <span class="p">}</span>
+    <span class="n">returnExpression</span><span class="p">.</span><span 
class="n">setPrepeparedWhere</span><span class="p">(</span><span 
class="n">leftSideExpression</span><span class="p">.</span><span 
class="n">toString</span><span class="p">()</span> <span class="o">+</span> 
&quot; &quot; <span class="o">+</span> <span class="n">sqlOperator</span> <span 
class="o">+</span> &quot; &quot; <span class="o">+</span> <span 
class="n">rightSideExpression</span><span class="p">.</span><span 
class="n">toString</span><span class="p">());</span>
+
+    <span class="k">for</span> <span class="p">(</span><span 
class="n">Object</span> <span class="n">parameter</span> <span 
class="p">:</span> <span class="n">leftSideExpression</span><span 
class="p">.</span><span class="n">getParameters</span><span 
class="p">())</span> <span class="p">{</span>
+    <span class="n">returnExpression</span><span class="p">.</span><span 
class="n">addParameter</span><span class="p">(</span><span 
class="n">parameter</span><span class="p">);</span>
+    <span class="p">}</span>
+    <span class="k">for</span> <span class="p">(</span><span 
class="n">Object</span> <span class="n">parameter</span> <span 
class="p">:</span> <span class="n">rightSideExpression</span><span 
class="p">.</span><span class="n">getParameters</span><span 
class="p">())</span> <span class="p">{</span>
+      <span class="n">returnExpression</span><span class="p">.</span><span 
class="n">addParameter</span><span class="p">(</span><span 
class="n">parameter</span><span class="p">);</span>
+    <span class="p">}</span>
+    <span class="k">return</span> <span class="n">returnExpression</span><span 
class="p">;</span>
+  <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+    <span class="n">throw</span> <span class="n">new</span> <span 
class="n">RuntimeException</span><span class="p">(</span>&quot;<span 
class="n">Not</span> <span class="n">right</span> <span 
class="n">format</span>&quot;<span class="p">);</span>
+  <span class="p">}</span>
+<span class="p">}</span>
+</pre></div>
+
+
+<p>This implementation will work if the filter supplies a property on the left 
side and a literal on the right side. The output of this new implementation 
could look like this:</p>
+<div class="codehilite"><pre><span class="n">Raw</span><span 
class="o">:</span> <span class="n">EmployeeId</span> <span class="n">eq</span> 
<span class="s1">&#39;1&#39;</span> <span class="n">or</span> <span 
class="o">(</span><span class="n">ManagerId</span> <span class="n">eq</span> 
<span class="s1">&#39;2&#39;</span> <span class="n">and</span> <span 
class="n">TeamId</span> <span class="n">eq</span> <span 
class="s1">&#39;3&#39;</span><span class="o">)</span> <span 
class="o">------&gt;</span> <span class="n">Whereclause</span><span 
class="o">:</span> <span class="n">EmployeeId</span> <span class="o">=</span> 
<span class="o">?</span> <span class="n">OR</span> <span 
class="o">(</span><span class="n">ManagerId</span> <span class="o">=</span> 
<span class="o">?</span> <span class="n">AND</span> <span 
class="n">TeamId</span> <span class="o">=</span> <span class="o">?)</span>
+<span class="mi">1</span>
+<span class="mi">2</span>
+<span class="mi">3</span>
+</pre></div>
+
+
+<p>Test in the sources: JdbcPreparedStatementVisitorTest.class</p>
+<h3 id="further-information">Further Information</h3>
+<p>Documentation about how to create such a filter expression can be found 
under <a href="http://www.odata.org"; title="External 
Link">http://www.odata.org</a> in the OData protocol specification.</p>
+<p>Visitor pattern: <a href="http://en.wikipedia.org/wiki/Visitor_pattern"; 
title="External Link">http://en.wikipedia.org/wiki/Visitor_pattern</a></p><div 
align="center">
+<p>Copyright © 2013-2014, The Apache Software Foundation<br>
+                                               Apache Olingo, Olingo, Apache, 
the Apache feather, and
+                               the Apache Olingo project logo are trademarks 
of the Apache Software
+                               Foundation.</p>
+        <small><a href="/doc/odata2/privacy.html">Privacy</a></small>
+      </div>
+    </div><!-- /container -->
+    <!-- Bootstrap core JavaScript
+    ================================================== -->
+    <!-- Placed at the end of the document so the pages load faster -->
+    <script src="/js/jquery.js" type="text/javascript">
+</script>
+         <script src="/js/bootstrap.js" type="text/javascript">
+         <script src="/js/offcanvas.js" type="text/javascript">
+</script>
+        <!-- Google Analytics: change UA-XXXXX-X to be your site's ID. -->
+        <script>
+            (function(b,o,i,l,e,r){b.GoogleAnalyticsObject=l;b[l]||(b[l]=
+            function(){(b[l].q=b[l].q||[]).push(arguments)});b[l].l=+new Date;
+            e=o.createElement(i);r=o.getElementsByTagName(i)[0];
+            e.src='//www.google-analytics.com/analytics.js';
+            r.parentNode.insertBefore(e,r)}(window,document,'script','ga'));
+            ga('create','UA-44963757-1');ga('send','pageview');
+        </script>
+  </body>
+</html>


Reply via email to