You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by ct...@apache.org on 2020/07/15 16:52:39 UTC
svn commit: r1063067 [23/28] - in
/websites/production/lucene/content/solr/guide/8_6: ./ meta-docs/
Modified: websites/production/lucene/content/solr/guide/8_6/spatial-search.html
==============================================================================
--- websites/production/lucene/content/solr/guide/8_6/spatial-search.html (original)
+++ websites/production/lucene/content/solr/guide/8_6/spatial-search.html Wed Jul 15 16:52:36 2020
@@ -8,7 +8,7 @@
<meta name="description" content="">
<meta name="keywords" content=" ">
-<title>Spatial Search | Apache Solr Reference Guide 8.6-DRAFT</title>
+<title>Spatial Search | Apache Solr Reference Guide 8.6</title>
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
<link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">
@@ -71,7 +71,7 @@
</script>
</head>
-<body class="DRAFT" id="spatial-search">
+<body class="" id="spatial-search">
<div class="container-fluid">
<div class="row">
<nav id="sidebar" class="col-2 d-none d-md-block">
@@ -79,11 +79,6 @@
<div class="sidebar-header">
<div class="sidebarTitle text-center">Apache Solr Reference Guide</div>
- <p class="draft-notice">
- This is an unofficial DRAFT of the Guide for 8.6.
- <a href="https://lucene.apache.org/solr/guide/">Official releases are available from the Solr website</a>.
- </p>
-
<!--comment out this block if you want to hide search-->
<!--start search-->
@@ -1696,9 +1691,9 @@
<section class="content">
<section id="preamble" aria-label="Preamble"><p>Solr supports location data for use in spatial/geospatial searches.</p>
<p>Using spatial search, you can:</p>
-<div class="ulist"><ul><li>Index points or other shapes</li><li>Filter search results by a bounding box or circle or by other shapes</li><li>Sort or boost scoring by distance between points, or relative area between rectangles</li><li>Generate a 2D grid of facet count numbers for heatmap generation or point-plotting.</li></ul></div>
+<div class="ulist"><ul><li><p>Index points or other shapes</p></li><li><p>Filter search results by a bounding box or circle or by other shapes</p></li><li><p>Sort or boost scoring by distance between points, or relative area between rectangles</p></li><li><p>Generate a 2D grid of facet count numbers for heatmap generation or point-plotting.</p></li></ul></div>
<p>There are four main field types available for spatial search:</p>
-<div class="ulist"><ul><li><code>LatLonPointSpatialField</code></li><li><code>LatLonType</code> (now deprecated) and its non-geodetic twin <code>PointType</code></li><li><code>SpatialRecursivePrefixTreeFieldType</code> (RPT for short), including <code>RptWithGeometrySpatialField</code>, a derivative</li><li><code>BBoxField</code></li></ul></div>
+<div class="ulist"><ul><li><p><code>LatLonPointSpatialField</code></p></li><li><p><code>LatLonType</code> (now deprecated) and its non-geodetic twin <code>PointType</code></p></li><li><p><code>SpatialRecursivePrefixTreeFieldType</code> (RPT for short), including <code>RptWithGeometrySpatialField</code>, a derivative</p></li><li><p><code>BBoxField</code></p></li></ul></div>
<p><code>LatLonPointSpatialField</code> is the ideal field type for the most common use-cases for lat-lon point data. It replaces LatLonType which still exists for backwards compatibility. RPT offers some more features for more advanced/custom use cases and options like polygons and heatmaps.</p>
<p><code>RptWithGeometrySpatialField</code> is for indexing and searching non-point data though it can do points too. It can’t do sorting/boosting.</p>
<p><code>BBoxField</code> is for indexing bounding boxes, querying by a box, specifying a search predicate (Intersects,Within,Contains,Disjoint,Equals), and a relevancy sort/boost like overlapRatio or simply the area.</p>
@@ -1714,7 +1709,7 @@
<p>The key parameter to pass in with your request is:</p>
<div class="dlist"><dl><dt><code>format</code></dt><dd>The format of the file to pass in. Accepted values: <code>WKT</code> or <code>geojson</code>.</dd></dl></div></section></section>
<section class="sect1"><h2 id="searching-with-query-parsers">Searching with Query Parsers</h2><p>There are two spatial Solr "query parsers" for geospatial search: <code>geofilt</code> and <code>bbox</code>. They take the following parameters:</p>
-<div class="dlist"><dl><dt><code>d</code></dt><dd>The radial distance, usually in kilometers. RPT & BBoxField can set other units via the setting <code>distanceUnits</code>.</dd><dt><code>pt</code></dt><dd>The center point using the format "lat,lon" if latitude & longitude. Otherwise, "x,y" for PointType or "x y" for RPT field types.</dd><dt><code>sfield</code></dt><dd>A spatial indexed field.</dd><dt><code>score</code></dt><dd>(Advanced option; not supported by LatLonType (deprecated) or PointType) If the query is used in a scoring context (e.g., as the main query in <code>q</code>), this <em><a href="local-parameters-in-queries.html#local-parameters-in-queries">local parameter</a></em> determines what scores will be produced. Valid values are:<ul><li><code>none</code>: A fixed score of 1.0. (the default)</li><li><code>kilometers</code>: distance in kilometers between the field value and the specified center point</li><li><code>miles</code>: distance in miles between the fi
eld value and the specified center point</li><li><code>degrees</code>: distance in degrees between the field value and the specified center point</li><li><code>distance</code>: distance between the field value and the specified center point in the <code>distanceUnits</code> configured for this field</li><li><p><code>recipDistance</code>: 1 / the distance</p><div class="admonitionblock warning">
+<div class="dlist"><dl><dt><code>d</code></dt><dd>The radial distance, usually in kilometers. RPT & BBoxField can set other units via the setting <code>distanceUnits</code>.</dd><dt><code>pt</code></dt><dd>The center point using the format "lat,lon" if latitude & longitude. Otherwise, "x,y" for PointType or "x y" for RPT field types.</dd><dt><code>sfield</code></dt><dd>A spatial indexed field.</dd><dt><code>score</code></dt><dd>(Advanced option; not supported by LatLonType (deprecated) or PointType) If the query is used in a scoring context (e.g., as the main query in <code>q</code>), this <em><a href="local-parameters-in-queries.html#local-parameters-in-queries">local parameter</a></em> determines what scores will be produced. Valid values are:<ul><li><p><code>none</code>: A fixed score of 1.0. (the default)</p></li><li><p><code>kilometers</code>: distance in kilometers between the field value and the specified center point</p></li><li><p><code>miles</code>: distance in mil
es between the field value and the specified center point</p></li><li><p><code>degrees</code>: distance in degrees between the field value and the specified center point</p></li><li><p><code>distance</code>: distance between the field value and the specified center point in the <code>distanceUnits</code> configured for this field</p></li><li><p><p><code>recipDistance</code>: 1 / the distance</p><div class="admonitionblock warning">
<table>
<tr>
<td class="icon">
@@ -1726,7 +1721,7 @@
</tr>
</table>
</div>
-<p>When used with <code>BBoxField</code>, additional options are supported:</p></li><li><code>overlapRatio</code>: The relative overlap between the indexed shape & query shape.</li><li><code>area</code>: haversine based area of the overlapping shapes expressed in terms of the <code>distanceUnits</code> configured for this field</li><li><code>area2D</code>: cartesian coordinates based area of the overlapping shapes expressed in terms of the <code>distanceUnits</code> configured for this field</li></ul></dd><dt><code>filter</code></dt><dd>(Advanced option; not supported by LatLonType (deprecated) or PointType). If you only want the query to score (with the above <code>score</code> local parameter), not filter, then set this local parameter to false.</dd></dl></div>
+<p>When used with <code>BBoxField</code>, additional options are supported:</p></p></li><li><p><code>overlapRatio</code>: The relative overlap between the indexed shape & query shape.</p></li><li><p><code>area</code>: haversine based area of the overlapping shapes expressed in terms of the <code>distanceUnits</code> configured for this field</p></li><li><p><code>area2D</code>: cartesian coordinates based area of the overlapping shapes expressed in terms of the <code>distanceUnits</code> configured for this field</p></li></ul></dd><dt><code>filter</code></dt><dd>(Advanced option; not supported by LatLonType (deprecated) or PointType). If you only want the query to score (with the above <code>score</code> local parameter), not filter, then set this local parameter to false.</dd></dl></div>
<section class="sect2"><h3 id="geofilt">geofilt</h3><p>The <code>geofilt</code> filter allows you to retrieve results based on the geospatial distance (AKA the "great circle distance") from a given point. Another way of looking at it is that it creates a circular shape filter. For example, to find all documents within five kilometers of a given lat/lon point, you could enter:</p>
<div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>&q=*:*&fq={!geofilt sfield=store}&pt=45.15,-93.85&d=5</code></pre></code></pre></div>
<p>This filter returns all results within a circle of the given radius around the initial point:</p>
@@ -1757,7 +1752,7 @@
<div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>&q=...mykeywords...&fq=...someotherfilters...&fq={!geofilt cache=false}&sfield=store&pt=45.15,-93.85&d=5</code></pre></code></pre></div>
<p>LLPSF does not support Solr’s "PostFilter".</p></section></section>
<section class="sect1"><h2 id="distance-sorting-or-boosting-function-queries">Distance Sorting or Boosting (Function Queries)</h2><p>There are four distance function queries:</p>
-<div class="ulist"><ul><li><code>geodist</code>, see below, usually the most appropriate;</li><li><a href="function-queries.html#dist-function"><code>dist</code></a>, to calculate the p-norm distance between multi-dimensional vectors;</li><li><a href="function-queries.html#hsin-function"><code>hsin</code></a>, to calculate the distance between two points on a sphere;</li><li><a href="function-queries.html#sqedist-function"><code>sqedist</code></a>, to calculate the squared Euclidean distance between two points.</li></ul></div>
+<div class="ulist"><ul><li><p><code>geodist</code>, see below, usually the most appropriate;</p></li><li><p><a href="function-queries.html#dist-function"><code>dist</code></a>, to calculate the p-norm distance between multi-dimensional vectors;</p></li><li><p><a href="function-queries.html#hsin-function"><code>hsin</code></a>, to calculate the distance between two points on a sphere;</p></li><li><p><a href="function-queries.html#sqedist-function"><code>sqedist</code></a>, to calculate the squared Euclidean distance between two points.</p></li></ul></div>
<p>For more information about these function queries, see the section on <a href="function-queries.html#function-queries">Function Queries</a>.</p>
<section class="sect2"><h3 id="geodist">geodist</h3><p><code>geodist</code> is a distance function that takes three optional parameters: <code>(sfield,latitude,longitude)</code>. You can use the <code>geodist</code> function to sort results by distance or score return results.</p>
<p>For example, to sort your results by ascending distance, use a request like:</p>
@@ -1775,10 +1770,10 @@
<section class="sect1"><h2 id="rpt">RPT</h2><p>RPT refers to either <code>SpatialRecursivePrefixTreeFieldType</code> (aka simply RPT) and an extended version:
<code>RptWithGeometrySpatialField</code> (aka RPT with Geometry).
RPT offers several functional improvements over LatLonPointSpatialField:</p>
-<div class="ulist"><ul><li>Non-geodetic â geo=false general x & y (<em>not</em> latitude and longitude) — if desired</li><li>Query by polygons and other complex shapes, in addition to circles & rectangles</li><li>Ability to index non-point shapes (e.g., polygons) as well as points â see RptWithGeometrySpatialField</li><li>Heatmap grid faceting</li></ul></div>
+<div class="ulist"><ul><li><p>Non-geodetic â geo=false general x & y (<em>not</em> latitude and longitude) — if desired</p></li><li><p>Query by polygons and other complex shapes, in addition to circles & rectangles</p></li><li><p>Ability to index non-point shapes (e.g., polygons) as well as points â see RptWithGeometrySpatialField</p></li><li><p>Heatmap grid faceting</p></li></ul></div>
<p>RPT <em>shares</em> various features in common with <code>LatLonPointSpatialField</code>. Some are listed here:</p>
-<div class="ulist"><ul><li>Latitude/Longitude indexed point data; possibly multi-valued</li><li>Fast filtering with <code>geofilt</code>, <code>bbox</code> filters, and range query syntax (dateline crossing is supported)</li><li>Well-Known-Text (WKT) shape syntax (required for specifying polygons & other complex shapes), and GeoJSON too.
-In addition to indexing and searching, this works with the <code>wt=geojson</code> (GeoJSON Solr response-writer) and <code>[geo f=myfield]</code> (geo Solr document-transformer).</li><li>Sort/boost via <code>geodist</code> — <em>although not recommended</em></li></ul></div>
+<div class="ulist"><ul><li><p>Latitude/Longitude indexed point data; possibly multi-valued</p></li><li><p>Fast filtering with <code>geofilt</code>, <code>bbox</code> filters, and range query syntax (dateline crossing is supported)</p></li><li><p>Well-Known-Text (WKT) shape syntax (required for specifying polygons & other complex shapes), and GeoJSON too.
+In addition to indexing and searching, this works with the <code>wt=geojson</code> (GeoJSON Solr response-writer) and <code>[geo f=myfield]</code> (geo Solr document-transformer).</p></li><li><p>Sort/boost via <code>geodist</code> — <em>although not recommended</em></p></li></ul></div>
<div class="admonitionblock important">
<table>
<tr>
@@ -1945,7 +1940,7 @@ counts_ints2D=[[0, 0, 2, 1, ....],[1, 1,
<div class="row">
<div class="col-lg-12 footer">
©2020 Apache Software Foundation. All rights reserved. <br />
- Site Version: 8.6-DRAFT <br />Site last generated: 2020-07-08 <br />
+ Site Version: 8.6 <br />Site last generated: 2020-07-15 <br />
<p><img src="images/solr-sunOnly-small.png" alt="Apache Solr"/></p>
</div>
</div>
Modified: websites/production/lucene/content/solr/guide/8_6/spell-checking.html
==============================================================================
--- websites/production/lucene/content/solr/guide/8_6/spell-checking.html (original)
+++ websites/production/lucene/content/solr/guide/8_6/spell-checking.html Wed Jul 15 16:52:36 2020
@@ -8,7 +8,7 @@
<meta name="description" content="">
<meta name="keywords" content=" ">
-<title>Spell Checking | Apache Solr Reference Guide 8.6-DRAFT</title>
+<title>Spell Checking | Apache Solr Reference Guide 8.6</title>
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
<link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">
@@ -71,7 +71,7 @@
</script>
</head>
-<body class="DRAFT" id="spell-checking">
+<body class="" id="spell-checking">
<div class="container-fluid">
<div class="row">
<nav id="sidebar" class="col-2 d-none d-md-block">
@@ -79,11 +79,6 @@
<div class="sidebar-header">
<div class="sidebarTitle text-center">Apache Solr Reference Guide</div>
- <p class="draft-notice">
- This is an unofficial DRAFT of the Guide for 8.6.
- <a href="https://lucene.apache.org/solr/guide/">Official releases are available from the Solr website</a>.
- </p>
-
<!--comment out this block if you want to hide search-->
<!--start search-->
@@ -1871,7 +1866,7 @@ This only returns a query to be used. It
<div class="row">
<div class="col-lg-12 footer">
©2020 Apache Software Foundation. All rights reserved. <br />
- Site Version: 8.6-DRAFT <br />Site last generated: 2020-07-08 <br />
+ Site Version: 8.6 <br />Site last generated: 2020-07-15 <br />
<p><img src="images/solr-sunOnly-small.png" alt="Apache Solr"/></p>
</div>
</div>
Modified: websites/production/lucene/content/solr/guide/8_6/statistics.html
==============================================================================
--- websites/production/lucene/content/solr/guide/8_6/statistics.html (original)
+++ websites/production/lucene/content/solr/guide/8_6/statistics.html Wed Jul 15 16:52:36 2020
@@ -8,7 +8,7 @@
<meta name="description" content="">
<meta name="keywords" content=" ">
-<title>Statistics | Apache Solr Reference Guide 8.6-DRAFT</title>
+<title>Statistics | Apache Solr Reference Guide 8.6</title>
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
<link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">
@@ -71,7 +71,7 @@
</script>
</head>
-<body class="DRAFT" id="statistics">
+<body class="" id="statistics">
<div class="container-fluid">
<div class="row">
<nav id="sidebar" class="col-2 d-none d-md-block">
@@ -79,11 +79,6 @@
<div class="sidebar-header">
<div class="sidebarTitle text-center">Apache Solr Reference Guide</div>
- <p class="draft-notice">
- This is an unofficial DRAFT of the Guide for 8.6.
- <a href="https://lucene.apache.org/solr/guide/">Official releases are available from the Solr website</a>.
- </p>
-
<!--comment out this block if you want to hide search-->
<!--start search-->
@@ -2007,7 +2002,7 @@ matrix.</p>
<section class="sect2"><h3 id="correlation-and-correlation-matrices">Correlation and Correlation Matrices</h3><p>Correlation is measure of covariance that has been scaled between
-1 and 1.</p>
<p>Three correlation types are supported:</p>
-<div class="ulist"><ul><li><strong>pearsons</strong> (default)</li><li><strong>kendalls</strong></li><li><strong>spearmans</strong></li></ul></div>
+<div class="ulist"><ul><li><p><strong>pearsons</strong> (default)</p></li><li><p><strong>kendalls</strong></p></li><li><p><strong>spearmans</strong></p></li></ul></div>
<p>The type of correlation is specified by adding the <strong>type</strong> named parameter in the
function call. The example below demonstrates the use of the <strong>type</strong>
named parameter.</p>
@@ -2034,17 +2029,17 @@ of the matrix passed in.</p></section></
<section class="sect1"><h2 id="statistical-inference-tests">Statistical Inference Tests</h2><p>Statistical inference tests test a hypothesis on <strong>random samples</strong> and return p-values which
can be used to infer the reliability of the test for the entire population.</p>
<p>The following statistical inference tests are available:</p>
-<div class="ulist"><ul><li><code>anova</code>: One-Way-Anova tests if there is a statistically significant difference in the
-means of two or more random samples.</li><li><code>ttest</code>: The T-test tests if there is a statistically significant difference in the means of two
-random samples.</li><li><code>pairedTtest</code>: The paired t-test tests if there is a statistically significant difference
-in the means of two random samples with paired data.</li><li><code>gTestDataSet</code>: The G-test tests if two samples of binned discrete data were drawn
-from the same population.</li><li><code>chiSquareDataset</code>: The Chi-Squared test tests if two samples of binned discrete data were
-drawn from the same population.</li><li><code>mannWhitney</code>: The Mann-Whitney test is a non-parametric test that tests if two
+<div class="ulist"><ul><li><p><code>anova</code>: One-Way-Anova tests if there is a statistically significant difference in the
+means of two or more random samples.</p></li><li><p><code>ttest</code>: The T-test tests if there is a statistically significant difference in the means of two
+random samples.</p></li><li><p><code>pairedTtest</code>: The paired t-test tests if there is a statistically significant difference
+in the means of two random samples with paired data.</p></li><li><p><code>gTestDataSet</code>: The G-test tests if two samples of binned discrete data were drawn
+from the same population.</p></li><li><p><code>chiSquareDataset</code>: The Chi-Squared test tests if two samples of binned discrete data were
+drawn from the same population.</p></li><li><p><code>mannWhitney</code>: The Mann-Whitney test is a non-parametric test that tests if two
samples of continuous were pulled
from the same population. The Mann-Whitney test is often used instead of the T-test when the
underlying assumptions of the T-test are not
-met.</li><li><code>ks</code>: The Kolmogorov-Smirnov test tests if two samples of continuous data were drawn from
-the same distribution.</li></ul></div>
+met.</p></li><li><p><code>ks</code>: The Kolmogorov-Smirnov test tests if two samples of continuous data were drawn from
+the same distribution.</p></li></ul></div>
<p>Below is a simple example of a T-test performed on two random samples.
The returned p-value of .93 means we can accept the null hypothesis
that the two samples do not have statistically significantly differences in the means.</p>
@@ -2073,8 +2068,8 @@ that the two samples do not have statist
<section class="sect1"><h2 id="transformations">Transformations</h2><p>In statistical analysis its often useful to transform data sets before performing
statistical calculations. The statistical function library includes the following
commonly used transformations:</p>
-<div class="ulist"><ul><li><code>rank</code>: Returns a numeric array with the rank-transformed value of each element of the original
-array.</li><li><code>log</code>: Returns a numeric array with the natural log of each element of the original array.</li><li><code>log10</code>: Returns a numeric array with the base 10 log of each element of the original array.</li><li><code>sqrt</code>: Returns a numeric array with the square root of each element of the original array.</li><li><code>cbrt</code>: Returns a numeric array with the cube root of each element of the original array.</li><li><code>recip</code>: Returns a numeric array with the reciprocal of each element of the original array.</li></ul></div>
+<div class="ulist"><ul><li><p><code>rank</code>: Returns a numeric array with the rank-transformed value of each element of the original
+array.</p></li><li><p><code>log</code>: Returns a numeric array with the natural log of each element of the original array.</p></li><li><p><code>log10</code>: Returns a numeric array with the base 10 log of each element of the original array.</p></li><li><p><code>sqrt</code>: Returns a numeric array with the square root of each element of the original array.</p></li><li><p><code>cbrt</code>: Returns a numeric array with the cube root of each element of the original array.</p></li><li><p><code>recip</code>: Returns a numeric array with the reciprocal of each element of the original array.</p></li></ul></div>
<p>Below is an example of a ttest performed on log transformed data sets:</p>
<div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>let(a=random(collection1, q="*:*", rows="1500", fl="price_f"),
b=random(collection1, q="*:*", rows="1500", fl="price_f"),
@@ -2240,7 +2235,7 @@ is the number of standard deviations a n
<div class="row">
<div class="col-lg-12 footer">
©2020 Apache Software Foundation. All rights reserved. <br />
- Site Version: 8.6-DRAFT <br />Site last generated: 2020-07-08 <br />
+ Site Version: 8.6 <br />Site last generated: 2020-07-15 <br />
<p><img src="images/solr-sunOnly-small.png" alt="Apache Solr"/></p>
</div>
</div>
Modified: websites/production/lucene/content/solr/guide/8_6/stream-api.html
==============================================================================
--- websites/production/lucene/content/solr/guide/8_6/stream-api.html (original)
+++ websites/production/lucene/content/solr/guide/8_6/stream-api.html Wed Jul 15 16:52:36 2020
@@ -8,7 +8,7 @@
<meta name="description" content="">
<meta name="keywords" content=" ">
-<title>Stream Request Handler API | Apache Solr Reference Guide 8.6-DRAFT</title>
+<title>Stream Request Handler API | Apache Solr Reference Guide 8.6</title>
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
<link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">
@@ -71,7 +71,7 @@
</script>
</head>
-<body class="DRAFT" id="stream-api">
+<body class="" id="stream-api">
<div class="container-fluid">
<div class="row">
<nav id="sidebar" class="col-2 d-none d-md-block">
@@ -79,11 +79,6 @@
<div class="sidebar-header">
<div class="sidebarTitle text-center">Apache Solr Reference Guide</div>
- <p class="draft-notice">
- This is an unofficial DRAFT of the Guide for 8.6.
- <a href="https://lucene.apache.org/solr/guide/">Official releases are available from the Solr website</a>.
- </p>
-
<!--comment out this block if you want to hide search-->
<!--start search-->
@@ -1822,7 +1817,7 @@ and the states are those of a Thread.</p
<div class="row">
<div class="col-lg-12 footer">
©2020 Apache Software Foundation. All rights reserved. <br />
- Site Version: 8.6-DRAFT <br />Site last generated: 2020-07-08 <br />
+ Site Version: 8.6 <br />Site last generated: 2020-07-15 <br />
<p><img src="images/solr-sunOnly-small.png" alt="Apache Solr"/></p>
</div>
</div>
Modified: websites/production/lucene/content/solr/guide/8_6/stream-decorator-reference.html
==============================================================================
--- websites/production/lucene/content/solr/guide/8_6/stream-decorator-reference.html (original)
+++ websites/production/lucene/content/solr/guide/8_6/stream-decorator-reference.html Wed Jul 15 16:52:36 2020
@@ -8,7 +8,7 @@
<meta name="description" content="">
<meta name="keywords" content=" ">
-<title>Stream Decorator Reference | Apache Solr Reference Guide 8.6-DRAFT</title>
+<title>Stream Decorator Reference | Apache Solr Reference Guide 8.6</title>
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
<link rel="stylesheet" type="text/css" href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css">
@@ -71,7 +71,7 @@
</script>
</head>
-<body class="DRAFT" id="stream-decorator-reference">
+<body class="" id="stream-decorator-reference">
<div class="container-fluid">
<div class="row">
<nav id="sidebar" class="col-2 d-none d-md-block">
@@ -79,11 +79,6 @@
<div class="sidebar-header">
<div class="sidebarTitle text-center">Apache Solr Reference Guide</div>
- <p class="draft-notice">
- This is an unofficial DRAFT of the Guide for 8.6.
- <a href="https://lucene.apache.org/solr/guide/">Official releases are available from the Solr website</a>.
- </p>
-
<!--comment out this block if you want to hide search-->
<!--start search-->
@@ -1705,7 +1700,7 @@
"fieldA": "foo",
"fieldB": "bat"
}</code></pre></code></pre></div>
-<section class="sect2"><h3 id="cartesianproduct-parameters">cartesianProduct Parameters</h3><div class="ulist"><ul><li><code>incoming stream</code>: (Mandatory) A single incoming stream.</li><li><code>fieldName or evaluator</code>: (Mandatory) Name of field to flatten values for, or evaluator whose result should be flattened.</li><li><code>productSort='fieldName ASC|DESC'</code>: (Optional) Sort order of the newly generated tuples.</li></ul></div></section>
+<section class="sect2"><h3 id="cartesianproduct-parameters">cartesianProduct Parameters</h3><div class="ulist"><ul><li><p><code>incoming stream</code>: (Mandatory) A single incoming stream.</p></li><li><p><code>fieldName or evaluator</code>: (Mandatory) Name of field to flatten values for, or evaluator whose result should be flattened.</p></li><li><p><code>productSort='fieldName ASC|DESC'</code>: (Optional) Sort order of the newly generated tuples.</p></li></ul></div></section>
<section class="sect2"><h3 id="cartesianproduct-syntax">cartesianProduct Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>cartesianProduct(
<stream>,
<fieldName | evaluator> [as newFieldName],
@@ -1968,8 +1963,8 @@
<p>As you can see in the examples above, the <code>cartesianProduct</code> function does support flattening tuples across multiple fields and/or evaluators.</p></section></section></section>
<section class="sect1"><h2 id="classify">classify</h2><p>The <code>classify</code> function classifies tuples using a logistic regression text classification model. It was designed specifically to work with models trained using the <a href="stream-source-reference.html#train">train function</a>. The <code>classify</code> function uses the <a href="stream-source-reference.html#model">model function</a> to retrieve a stored model and then scores a stream of tuples using the model. The tuples read by the classifier must contain a text field that can be used for classification. The classify function uses a Lucene analyzer to extract the features from the text so the model can be applied. By default the <code>classify</code> function looks for the analyzer using the name of text field in the tuple. If the Solr schema on the worker node does not contain this field, the analyzer can be looked up in another field by specifying the <code>analyzerField</code> parameter.</p>
<p>Each tuple that is classified is assigned two scores:</p>
-<div class="ulist"><ul><li>probability_d*: A float between 0 and 1 which describes the probability that the tuple belongs to the class. This is useful in the classification use case.</li><li>score_d*: The score of the document that has not be squashed between 0 and 1. The score may be positive or negative. The higher the score the better the document fits the class. This un-squashed score will be useful in query re-ranking and recommendation use cases. This score is particularly useful when multiple high ranking documents have a probability_d score of 1, which won’t provide a meaningful ranking between documents.</li></ul></div>
-<section class="sect2"><h3 id="classify-parameters">classify Parameters</h3><div class="ulist"><ul><li><code>model expression</code>: (Mandatory) Retrieves the stored logistic regression model.</li><li><code>field</code>: (Mandatory) The field in the tuples to apply the classifier to. By default the analyzer for this field in the schema will be used extract the features.</li><li><code>analyzerField</code>: (Optional) Specifies a different field to find the analyzer from in the schema.</li></ul></div></section>
+<div class="ulist"><ul><li><p>probability_d*: A float between 0 and 1 which describes the probability that the tuple belongs to the class. This is useful in the classification use case.</p></li><li><p>score_d*: The score of the document that has not be squashed between 0 and 1. The score may be positive or negative. The higher the score the better the document fits the class. This un-squashed score will be useful in query re-ranking and recommendation use cases. This score is particularly useful when multiple high ranking documents have a probability_d score of 1, which won’t provide a meaningful ranking between documents.</p></li></ul></div>
+<section class="sect2"><h3 id="classify-parameters">classify Parameters</h3><div class="ulist"><ul><li><p><code>model expression</code>: (Mandatory) Retrieves the stored logistic regression model.</p></li><li><p><code>field</code>: (Mandatory) The field in the tuples to apply the classifier to. By default the analyzer for this field in the schema will be used extract the features.</p></li><li><p><code>analyzerField</code>: (Optional) Specifies a different field to find the analyzer from in the schema.</p></li></ul></div></section>
<section class="sect2"><h3 id="classify-syntax">classify Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>classify(model(modelCollection,
id="model1",
cacheMillis=5000),
@@ -1981,7 +1976,7 @@
field="text_t")</code></pre></code></pre></div>
<p>In the example above the <code>classify expression</code> is retrieving the model using the <code>model</code> function. It is then classifying tuples returned by the <code>search</code> function. The <code>text_t</code> field is used for the text classification and the analyzer for the <code>text_t</code> field in the Solr schema is used to analyze the text and extract the features.</p></section></section>
<section class="sect1"><h2 id="commit">commit</h2><p>The <code>commit</code> function wraps a single stream (A) and given a collection and batch size will send commit messages to the collection when the batch size is fulfilled or the end of stream is reached. A commit stream is used most frequently with an update stream and as such the commit will take into account possible summary tuples coming from the update stream. All tuples coming into the commit stream will be returned out of the commit stream - no tuples will be dropped and no tuples will be added.</p>
-<section class="sect2"><h3 id="commit-parameters">commit Parameters</h3><div class="ulist"><ul><li><code>collection</code>: The collection to send commit messages to (required)</li><li><code>batchSize</code>: The commit batch size, sends commit message when batch size is hit. If not provided (or provided as value 0) then a commit is only sent at the end of the incoming stream.</li><li><code>waitFlush</code>: The value passed directly to the commit handler (true/false, default: false)</li><li><code>waitSearcher</code>: The value passed directly to the commit handler (true/false, default: false)</li><li><code>softCommit</code>: The value passed directly to the commit handler (true/false, default: false)</li><li><code>StreamExpression for StreamA</code> (required)</li></ul></div></section>
+<section class="sect2"><h3 id="commit-parameters">commit Parameters</h3><div class="ulist"><ul><li><p><code>collection</code>: The collection to send commit messages to (required)</p></li><li><p><code>batchSize</code>: The commit batch size, sends commit message when batch size is hit. If not provided (or provided as value 0) then a commit is only sent at the end of the incoming stream.</p></li><li><p><code>waitFlush</code>: The value passed directly to the commit handler (true/false, default: false)</p></li><li><p><code>waitSearcher</code>: The value passed directly to the commit handler (true/false, default: false)</p></li><li><p><code>softCommit</code>: The value passed directly to the commit handler (true/false, default: false)</p></li><li><p><code>StreamExpression for StreamA</code> (required)</p></li></ul></div></section>
<section class="sect2"><h3 id="commit-syntax">commit Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>commit(
destinationCollection,
batchSize=2,
@@ -1992,7 +1987,7 @@
)
)</code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="complement">complement</h2><p>The <code>complement</code> function wraps two streams (A and B) and emits tuples from A which do not exist in B. The tuples are emitted in the order in which they appear in stream A. Both streams must be sorted by the fields being used to determine equality (using the <code>on</code> parameter).</p>
-<section class="sect2"><h3 id="complement-parameters">complement Parameters</h3><div class="ulist"><ul><li><code>StreamExpression for StreamA</code></li><li><code>StreamExpression for StreamB</code></li><li><code>on</code>: Fields to be used for checking equality of tuples between A and B. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</li></ul></div></section>
+<section class="sect2"><h3 id="complement-parameters">complement Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression for StreamA</code></p></li><li><p><code>StreamExpression for StreamB</code></p></li><li><p><code>on</code>: Fields to be used for checking equality of tuples between A and B. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</p></li></ul></div></section>
<section class="sect2"><h3 id="complement-syntax">complement Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>complement(
search(collection1, q="a_s:(setA || setAB)", qt="/export", fl="id,a_s,a_i", sort="a_i asc, a_s asc"),
search(collection1, q="a_s:(setB || setAB)", qt="/export", fl="id,a_s,a_i", sort="a_i asc"),
@@ -2085,7 +2080,7 @@ complement(
<span style="background-color: #f8f8f8">daemonStream</span><span style="color: #000000;font-weight: bold">.</span><span style="color: #008080">close</span><span style="color: #000000;font-weight: bold">();</span></code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="delete">delete</h2><p>The <code>delete</code> function wraps other functions and uses the <code>id</code> and <code>_version_</code> values found to send the tuples to a SolrCloud collection as <a href="uploading-data-with-index-handlers.html#delete-operations">Delete By Id</a> commands.</p>
<p>This is similar to the <code><a href="#update">update()</a></code> function described below.</p>
-<section class="sect2"><h3 id="delete-parameters">delete Parameters</h3><div class="ulist"><ul><li><code>destinationCollection</code>: (Mandatory) The collection where the tuples will deleted.</li><li><code>batchSize</code>: (Mandatory) The indexing batch size.</li><li><code>pruneVersionField</code>: (Optional, defaults to <code>false</code>) Whether to prune <code>_version_</code> values from tuples</li><li><code>StreamExpression</code>: (Mandatory)</li></ul></div></section>
+<section class="sect2"><h3 id="delete-parameters">delete Parameters</h3><div class="ulist"><ul><li><p><code>destinationCollection</code>: (Mandatory) The collection where the tuples will deleted.</p></li><li><p><code>batchSize</code>: (Mandatory) The indexing batch size.</p></li><li><p><code>pruneVersionField</code>: (Optional, defaults to <code>false</code>) Whether to prune <code>_version_</code> values from tuples</p></li><li><p><code>StreamExpression</code>: (Mandatory)</p></li></ul></div></section>
<section class="sect2"><h3 id="delete-syntax">delete Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code> delete(collection1
batchSize=500,
search(collection1,
@@ -2113,14 +2108,14 @@ complement(
The <code>eval</code> function wraps a streaming expression and reads a single tuple from the underlying stream.
The <code>eval</code> function then retrieves a string Streaming Expressions from the <code>expr_s</code> field of the tuple.
The <code>eval</code> function then compiles the string Streaming Expression and emits the tuples.</p>
-<section class="sect2"><h3 id="eval-parameters">eval Parameters</h3><div class="ulist"><ul><li><code>StreamExpression</code>: (Mandatory) The stream which provides the streaming expression to be evaluated.</li></ul></div></section>
+<section class="sect2"><h3 id="eval-parameters">eval Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression</code>: (Mandatory) The stream which provides the streaming expression to be evaluated.</p></li></ul></div></section>
<section class="sect2"><h3 id="eval-syntax">eval Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>eval(expr)</code></pre></code></pre></div>
<p>In the example above the <code>eval</code> expression reads the first tuple from the underlying expression. It then compiles and
executes the string Streaming Expression in the expr_s field.</p></section></section>
<section class="sect1"><h2 id="executor">executor</h2><p>The <code>executor</code> function wraps a stream source that contains streaming expressions, and executes the expressions in parallel. The <code>executor</code> function looks for the expression in the <code>expr_s</code> field in each tuple. The <code>executor</code> function has an internal thread pool that runs tasks that compile and run expressions in parallel on the same worker node. This function can also be parallelized across worker nodes by wrapping it in the <a href="#parallel"><code>parallel</code></a> function to provide parallel execution of expressions across a cluster.</p>
<p>The <code>executor</code> function does not do anything specific with the output of the expressions that it runs. Therefore the expressions that are executed must contain the logic for pushing tuples to their destination. The <a href="#update">update function</a> can be included in the expression being executed to send the tuples to a SolrCloud collection for storage.</p>
<p>This model allows for asynchronous execution of jobs where the output is stored in a SolrCloud collection where it can be accessed as the job progresses.</p>
-<section class="sect2"><h3 id="executor-parameters">executor Parameters</h3><div class="ulist"><ul><li><code>threads</code>: (Optional) The number of threads in the executors thread pool for executing expressions.</li><li><code>StreamExpression</code>: (Mandatory) The stream source which contains the Streaming Expressions to execute.</li></ul></div></section>
+<section class="sect2"><h3 id="executor-parameters">executor Parameters</h3><div class="ulist"><ul><li><p><code>threads</code>: (Optional) The number of threads in the executors thread pool for executing expressions.</p></li><li><p><code>StreamExpression</code>: (Mandatory) The stream source which contains the Streaming Expressions to execute.</p></li></ul></div></section>
<section class="sect2"><h3 id="executor-syntax">executor Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>daemon(id="myDaemon",
terminate="true",
executor(threads=10,
@@ -2132,14 +2127,14 @@ executes the string Streaming Expression
id="myTopic")))</code></pre></code></pre></div>
<p>In the example above a <a href="#daemon">daemon</a> wraps an executor, which wraps a <a href="stream-source-reference.html#topic">topic</a> that is returning tuples with expressions to execute. When sent to the stream handler, the daemon will call the executor at intervals which will cause the executor to read from the topic and execute the expressions found in the <code>expr_s</code> field. The daemon will repeatedly call the executor until all the tuples that match the topic have been iterated, then it will terminate. This is the approach for executing batches of streaming expressions from a <code>topic</code> queue.</p></section></section>
<section class="sect1"><h2 id="fetch">fetch</h2><p>The <code>fetch</code> function iterates a stream and fetches additional fields and adds them to the tuples. The <code>fetch</code> function fetches in batches to limit the number of calls back to Solr. Tuples streamed from the <code>fetch</code> function will contain the original fields and the additional fields that were fetched. The <code>fetch</code> function supports one-to-one fetches. Many-to-one fetches, where the stream source contains duplicate keys, will also work, but one-to-many fetches are currently not supported by this function.</p>
-<section class="sect2"><h3 id="fetch-parameters">fetch Parameters</h3><div class="ulist"><ul><li><code>Collection</code>: (Mandatory) The collection to fetch the fields from.</li><li><code>StreamExpression</code>: (Mandatory) The stream source for the fetch function.</li><li><code>fl</code>: (Mandatory) The fields to be fetched.</li><li><code>on</code>: Fields to be used for checking equality of tuples between stream source and fetched records. Formatted as <code>on="fieldNameInTuple=fieldNameInCollection"</code>.</li><li><code>batchSize</code>: (Optional) The batch fetch size.</li></ul></div></section>
+<section class="sect2"><h3 id="fetch-parameters">fetch Parameters</h3><div class="ulist"><ul><li><p><code>Collection</code>: (Mandatory) The collection to fetch the fields from.</p></li><li><p><code>StreamExpression</code>: (Mandatory) The stream source for the fetch function.</p></li><li><p><code>fl</code>: (Mandatory) The fields to be fetched.</p></li><li><p><code>on</code>: Fields to be used for checking equality of tuples between stream source and fetched records. Formatted as <code>on="fieldNameInTuple=fieldNameInCollection"</code>.</p></li><li><p><code>batchSize</code>: (Optional) The batch fetch size.</p></li></ul></div></section>
<section class="sect2"><h3 id="fetch-syntax">fetch Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>fetch(addresses,
search(people, q="*:*", qt="/export", fl="username, firstName, lastName", sort="username asc"),
fl="streetAddress, city, state, country, zip",
on="username=userId")</code></pre></code></pre></div>
<p>The example above fetches addresses for users by matching the username in the tuple with the userId field in the addresses collection.</p></section></section>
<section class="sect1"><h2 id="having">having</h2><p>The <code>having</code> expression wraps a stream and applies a boolean operation to each tuple. It emits only tuples for which the boolean operation returns <strong>true</strong>.</p>
-<section class="sect2"><h3 id="having-parameters">having Parameters</h3><div class="ulist"><ul><li><code>StreamExpression</code>: (Mandatory) The stream source for the having function.</li><li><code>booleanEvaluator</code>: (Mandatory) The following boolean operations are supported: <code>eq</code> (equals), <code>gt</code> (greater than), <code>lt</code> (less than), <code>gteq</code> (greater than or equal to), <code>lteq</code> (less than or equal to), <code>and</code>, <code>or</code>, <code>eor</code> (exclusive or), and <code>not</code>. Boolean evaluators can be nested with other evaluators to form complex boolean logic.</li></ul></div>
+<section class="sect2"><h3 id="having-parameters">having Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression</code>: (Mandatory) The stream source for the having function.</p></li><li><p><code>booleanEvaluator</code>: (Mandatory) The following boolean operations are supported: <code>eq</code> (equals), <code>gt</code> (greater than), <code>lt</code> (less than), <code>gteq</code> (greater than or equal to), <code>lteq</code> (less than or equal to), <code>and</code>, <code>or</code>, <code>eor</code> (exclusive or), and <code>not</code>. Boolean evaluators can be nested with other evaluators to form complex boolean logic.</p></li></ul></div>
<p>The comparison evaluators compare the value in a specific field with a value, whether a string, number, or boolean. For example: <code>eq(field1, 10)</code>, returns <code>true</code> if <code>field1</code> is equal to 10.</p></section>
<section class="sect2"><h3 id="having-syntax">having Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>having(rollup(over=a_s,
sum(a_i),
@@ -2153,7 +2148,7 @@ executes the string Streaming Expression
<p>In this example, the <code>having</code> expression iterates the aggregated tuples from the <code>rollup</code> expression and emits all tuples where the field <code>sum(a_i)</code> is greater then 100 and less then 110.</p></section></section>
<section class="sect1"><h2 id="leftouterjoin">leftOuterJoin</h2><p>The <code>leftOuterJoin</code> function wraps two streams, Left and Right, and emits tuples from Left. If there is a tuple in Right equal (as defined by <code>on</code>) then the values in that tuple will be included in the emitted tuple. An equal tuple in Right <strong>need not</strong> exist for the Left tuple to be emitted. This supports one-to-one, one-to-many, many-to-one, and many-to-many left outer join scenarios. The tuples are emitted in the order in which they appear in the Left stream. Both streams must be sorted by the fields being used to determine equality (using the <code>on</code> parameter). If both tuples contain a field of the same name then the value from the Right stream will be used in the emitted tuple.</p>
<p>You can wrap the incoming streams with a <code>select</code> function to be specific about which field values are included in the emitted tuple.</p>
-<section class="sect2"><h3 id="leftouterjoin-parameters">leftOuterJoin Parameters</h3><div class="ulist"><ul><li><code>StreamExpression for StreamLeft</code></li><li><code>StreamExpression for StreamRight</code></li><li><code>on</code>: Fields to be used for checking equality of tuples between Left and Right. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</li></ul></div></section>
+<section class="sect2"><h3 id="leftouterjoin-parameters">leftOuterJoin Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression for StreamLeft</code></p></li><li><p><code>StreamExpression for StreamRight</code></p></li><li><p><code>on</code>: Fields to be used for checking equality of tuples between Left and Right. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</p></li></ul></div></section>
<section class="sect2"><h3 id="leftouterjoin-syntax">leftOuterJoin Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>leftOuterJoin(
search(people, q="*:*", qt="/export", fl="personId,name", sort="personId asc"),
search(pets, q="type:cat", qt="/export", fl="personId,petName", sort="personId asc"),
@@ -2178,7 +2173,7 @@ leftOuterJoin(
<section class="sect1"><h2 id="hashjoin">hashJoin</h2><p>The <code>hashJoin</code> function wraps two streams, Left and Right, and for every tuple in Left which exists in Right will emit a tuple containing the fields of both tuples. This supports one-to-one, one-to-many, many-to-one, and many-to-many inner join scenarios. The tuples are emitted in the order in which they appear in the Left stream. The order of the streams does not matter. If both tuples contain a field of the same name then the value from the Right stream will be used in the emitted tuple.</p>
<p>You can wrap the incoming streams with a <code>select</code> function to be specific about which field values are included in the emitted tuple.</p>
<p>The hashJoin function can be used when the tuples of Left and Right cannot be put in the same order. Because the tuples are out of order this stream functions by reading all values from the Right stream during the open operation and will store all tuples in memory. The result of this is a memory footprint equal to the size of the Right stream.</p>
-<section class="sect2"><h3 id="hashjoin-parameters">hashJoin Parameters</h3><div class="ulist"><ul><li><code>StreamExpression for StreamLeft</code></li><li><code>hashed=StreamExpression for StreamRight</code></li><li><code>on</code>: Fields to be used for checking equality of tuples between Left and Right. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</li></ul></div></section>
+<section class="sect2"><h3 id="hashjoin-parameters">hashJoin Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression for StreamLeft</code></p></li><li><p><code>hashed=StreamExpression for StreamRight</code></p></li><li><p><code>on</code>: Fields to be used for checking equality of tuples between Left and Right. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</p></li></ul></div></section>
<section class="sect2"><h3 id="hashjoin-syntax">hashJoin Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>hashJoin(
search(people, q="*:*", qt="/export", fl="personId,name", sort="personId asc"),
hashed=search(pets, q="type:cat", qt="/export", fl="personId,petName", sort="personId asc"),
@@ -2201,7 +2196,7 @@ hashJoin(
on="personId=ownerId"
)</code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="innerjoin">innerJoin</h2><p>Wraps two streams, Left and Right. For every tuple in Left which exists in Right a tuple containing the fields of both tuples will be emitted. This supports one-to-one, one-to-many, many-to-one, and many-to-many inner join scenarios. The tuples are emitted in the order in which they appear in the Left stream. Both streams must be sorted by the fields being used to determine equality (the 'on' parameter). If both tuples contain a field of the same name then the value from the Right stream will be used in the emitted tuple. You can wrap the incoming streams with a <code>select(…​)</code> expression to be specific about which field values are included in the emitted tuple.</p>
-<section class="sect2"><h3 id="innerjoin-parameters">innerJoin Parameters</h3><div class="ulist"><ul><li><code>StreamExpression for StreamLeft</code></li><li><code>StreamExpression for StreamRight</code></li><li><code>on</code>: Fields to be used for checking equality of tuples between Left and Right. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</li></ul></div></section>
+<section class="sect2"><h3 id="innerjoin-parameters">innerJoin Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression for StreamLeft</code></p></li><li><p><code>StreamExpression for StreamRight</code></p></li><li><p><code>on</code>: Fields to be used for checking equality of tuples between Left and Right. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</p></li></ul></div></section>
<section class="sect2"><h3 id="innerjoin-syntax">innerJoin Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>innerJoin(
search(people, q="*:*", qt="/export", fl="personId,name", sort="personId asc"),
search(pets, q="type:cat", qt="/export", fl="personId,petName", sort="personId asc"),
@@ -2224,7 +2219,7 @@ innerJoin(
on="personId=ownerId"
)</code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="intersect">intersect</h2><p>The <code>intersect</code> function wraps two streams, A and B, and emits tuples from A which <strong>DO</strong> exist in B. The tuples are emitted in the order in which they appear in stream A. Both streams must be sorted by the fields being used to determine equality (the <code>on</code> parameter). Only tuples from A are emitted.</p>
-<section class="sect2"><h3 id="intersect-parameters">intersect Parameters</h3><div class="ulist"><ul><li><code>StreamExpression for StreamA</code></li><li><code>StreamExpression for StreamB</code></li><li><code>on</code>: Fields to be used for checking equality of tuples between A and B. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</li></ul></div></section>
+<section class="sect2"><h3 id="intersect-parameters">intersect Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression for StreamA</code></p></li><li><p><code>StreamExpression for StreamB</code></p></li><li><p><code>on</code>: Fields to be used for checking equality of tuples between A and B. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</p></li></ul></div></section>
<section class="sect2"><h3 id="intersect-syntax">intersect Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>intersect(
search(collection1, q="a_s:(setA || setAB)", qt="/export", fl="id,a_s,a_i", sort="a_i asc, a_s asc"),
search(collection1, q="a_s:(setB || setAB)", qt="/export", fl="id,a_s,a_i", sort="a_i asc"),
@@ -2238,7 +2233,7 @@ intersect(
)</code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="list_expression">list</h2><p>The <code>list</code> function wraps N Stream Expressions and opens and iterates each stream sequentially.
This has the effect of concatenating the results of multiple Streaming Expressions.</p>
-<section class="sect2"><h3 id="list-parameters">list Parameters</h3><div class="ulist"><ul><li>StreamExpressions …​: N Streaming Expressions</li></ul></div></section>
+<section class="sect2"><h3 id="list-parameters">list Parameters</h3><div class="ulist"><ul><li><p>StreamExpressions …​: N Streaming Expressions</p></li></ul></div></section>
<section class="sect2"><h3 id="list-syntax">list Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>list(tuple(a="hello world"), tuple(a="HELLO WORLD"))
list(search(collection1, q="*:*", fl="id, prod_ss", sort="id asc"),
@@ -2247,7 +2242,7 @@ list(search(collection1, q="*:*", fl="id
list(tuple(a=search(collection1, q="*:*", fl="id, prod_ss", sort="id asc")),
tuple(a=search(collection2, q="*:*", fl="id, prod_ss", sort="id asc")))</code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="merge">merge</h2><p>The <code>merge</code> function merges two or more streaming expressions and maintains the ordering of the underlying streams. Because the order is maintained, the sorts of the underlying streams must line up with the on parameter provided to the merge function.</p>
-<section class="sect2"><h3 id="merge-parameters">merge Parameters</h3><div class="ulist"><ul><li><code>StreamExpression A</code></li><li><code>StreamExpression B</code></li><li><code>Optional StreamExpression C,D,…​.Z</code></li><li><code>on</code>: Sort criteria for performing the merge. Of the form <code>fieldName order</code> where order is <code>asc</code> or <code>desc</code>. Multiple fields can be provided in the form <code>fieldA order, fieldB order</code>.</li></ul></div></section>
+<section class="sect2"><h3 id="merge-parameters">merge Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression A</code></p></li><li><p><code>StreamExpression B</code></p></li><li><p><code>Optional StreamExpression C,D,…​.Z</code></p></li><li><p><code>on</code>: Sort criteria for performing the merge. Of the form <code>fieldName order</code> where order is <code>asc</code> or <code>desc</code>. Multiple fields can be provided in the form <code>fieldA order, fieldB order</code>.</p></li></ul></div></section>
<section class="sect2"><h3 id="merge-syntax">merge Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code># Merging two stream expressions together
merge(
search(collection1,
@@ -2288,7 +2283,7 @@ merge(
<section class="sect1"><h2 id="null">null</h2><p>The null expression is a useful utility function for understanding bottlenecks when performing parallel relational algebra (joins, intersections, rollups etc.). The null function reads all the tuples from an underlying stream and returns a single tuple with the count and processing time. Because the null stream adds minimal overhead of its own, it can be used to isolate the performance of Solr’s /export handler. If the /export handlers performance is not the bottleneck, then the bottleneck is likely occurring in the workers where the stream decorators are running.</p>
<p>The null expression can be wrapped by the parallel function and sent to worker nodes. In this scenario each worker will return one tuple with the count of tuples processed on the worker and the timing information for that worker. This gives valuable information such as:</p>
<div class="olist arabic"><ol class="arabic"><li>As more workers are added does the performance of the /export handler improve or not.</li><li>Are tuples being evenly distributed across the workers, or is the hash partitioning sending more documents to a single worker.</li><li>Are all workers processing data at the same speed, or is one of the workers the source of the bottleneck.</li></ol></div>
-<section class="sect2"><h3 id="null-parameters">null Parameters</h3><div class="ulist"><ul><li><code>StreamExpression</code>: (Mandatory) The expression read by the null function.</li></ul></div></section>
+<section class="sect2"><h3 id="null-parameters">null Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression</code>: (Mandatory) The expression read by the null function.</p></li></ul></div></section>
<section class="sect2"><h3 id="null-syntax">null Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code> parallel(workerCollection,
null(search(collection1, q="*:*", fl="id,a_s,a_i,a_f", sort="a_s desc", qt="/export", partitionKeys="a_s")),
workers="20",
@@ -2298,7 +2293,7 @@ merge(
<section class="sect1"><h2 id="outerhashjoin">outerHashJoin</h2><p>The <code>outerHashJoin</code> function wraps two streams, Left and Right, and emits tuples from Left. If there is a tuple in Right equal (as defined by the <code>on</code> parameter) then the values in that tuple will be included in the emitted tuple. An equal tuple in Right <strong>need not</strong> exist for the Left tuple to be emitted. This supports one-to-one, one-to-many, many-to-one, and many-to-many left outer join scenarios. The tuples are emitted in the order in which they appear in the Left stream. The order of the streams does not matter. If both tuples contain a field of the same name then the value from the Right stream will be used in the emitted tuple.</p>
<p>You can wrap the incoming streams with a <code>select</code> function to be specific about which field values are included in the emitted tuple.</p>
<p>The outerHashJoin stream can be used when the tuples of Left and Right cannot be put in the same order. Because the tuples are out of order, this stream functions by reading all values from the Right stream during the open operation and will store all tuples in memory. The result of this is a memory footprint equal to the size of the Right stream.</p>
-<section class="sect2"><h3 id="outerhashjoin-parameters">outerHashJoin Parameters</h3><div class="ulist"><ul><li><code>StreamExpression for StreamLeft</code></li><li><code>hashed=StreamExpression for StreamRight</code></li><li><code>on</code>: Fields to be used for checking equality of tuples between Left and Right. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</li></ul></div></section>
+<section class="sect2"><h3 id="outerhashjoin-parameters">outerHashJoin Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression for StreamLeft</code></p></li><li><p><code>hashed=StreamExpression for StreamRight</code></p></li><li><p><code>on</code>: Fields to be used for checking equality of tuples between Left and Right. Can be of the format <code>on="fieldName"</code>, <code>on="fieldNameInLeft=fieldNameInRight"</code>, or <code>on="fieldName, otherFieldName=rightOtherFieldName"</code>.</p></li></ul></div></section>
<section class="sect2"><h3 id="outerhashjoin-syntax">outerHashJoin Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>outerHashJoin(
search(people, q="*:*", qt="/export", fl="personId,name", sort="personId asc"),
hashed=search(pets, q="type:cat", qt="/export", fl="personId,petName", sort="personId asc"),
@@ -2339,7 +2334,7 @@ outerHashJoin(
</tr>
</table>
</div>
-<section class="sect2"><h3 id="parallel-parameters">parallel Parameters</h3><div class="ulist"><ul><li><code>collection</code>: Name of the worker collection to send the StreamExpression to.</li><li><code>StreamExpression</code>: Expression to send to the worker collection.</li><li><code>workers</code>: Number of workers in the worker collection to send the expression to.</li><li><code>zkHost</code>: (Optional) The ZooKeeper connect string where the worker collection resides.</li><li><code>sort</code>: The sort criteria for ordering tuples returned by the worker nodes.</li></ul></div></section>
+<section class="sect2"><h3 id="parallel-parameters">parallel Parameters</h3><div class="ulist"><ul><li><p><code>collection</code>: Name of the worker collection to send the StreamExpression to.</p></li><li><p><code>StreamExpression</code>: Expression to send to the worker collection.</p></li><li><p><code>workers</code>: Number of workers in the worker collection to send the expression to.</p></li><li><p><code>zkHost</code>: (Optional) The ZooKeeper connect string where the worker collection resides.</p></li><li><p><code>sort</code>: The sort criteria for ordering tuples returned by the worker nodes.</p></li></ul></div></section>
<section class="sect2"><h3 id="parallel-syntax">parallel Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code> parallel(workerCollection,
rollup(search(collection1, q="*:*", fl="id,year_i,month_i,day_i", qt="/export", sort="year_i desc,month_i desc,day_i asc", partitionKeys="year_i"),
over="year_i", count(*)),
@@ -2375,7 +2370,7 @@ and iterates each stream sequentially. T
the streams are opened in parallel. Since many streams such as
<code>facet</code>, <code>stats</code> and <code>significantTerms</code> push down heavy operations to Solr when they are opened,
the plist function can dramatically improve performance by doing these operations in parallel.</p>
-<section class="sect2"><h3 id="plist-parameters">plist Parameters</h3><div class="ulist"><ul><li>StreamExpressions …​: N Streaming Expressions</li></ul></div></section>
+<section class="sect2"><h3 id="plist-parameters">plist Parameters</h3><div class="ulist"><ul><li><p>StreamExpressions …​: N Streaming Expressions</p></li></ul></div></section>
<section class="sect2"><h3 id="plist-syntax">plist Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>plist(tuple(a="hello world"), tuple(a="HELLO WORLD"))
plist(search(collection1, q="*:*", fl="id, prod_ss", sort="id asc"),
@@ -2387,7 +2382,7 @@ plist(tuple(a=search(collection1, q="*:*
<p>The <code>priority</code> function wraps two <a href="stream-source-reference.html#topic">topics</a> that are both emitting tuples that contain streaming expressions to execute. The first topic is considered the higher priority task queue.</p>
<p>Each time the <code>priority</code> function is called, it checks the higher priority task queue to see if there are any tasks to execute. If tasks are waiting in the higher priority queue then the priority function will emit the higher priority tasks. If there are no high priority tasks to run, the lower priority queue tasks are emitted.</p>
<p>The <code>priority</code> function will only emit a batch of tasks from one of the queues each time it is called. This ensures that no lower priority tasks are executed until the higher priority queue has no tasks to run.</p>
-<section class="sect2"><h3 id="priority-parameters">priority Parameters</h3><div class="ulist"><ul><li><code>topic expression</code>: (Mandatory) the high priority task queue</li><li><code>topic expression</code>: (Mandatory) the lower priority task queue</li></ul></div></section>
+<section class="sect2"><h3 id="priority-parameters">priority Parameters</h3><div class="ulist"><ul><li><p><code>topic expression</code>: (Mandatory) the high priority task queue</p></li><li><p><code>topic expression</code>: (Mandatory) the lower priority task queue</p></li></ul></div></section>
<section class="sect2"><h3 id="priority-syntax">priority Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>daemon(id="myDaemon",
executor(threads=10,
priority(topic(checkpointCollection, storedExpressions, q="priority:high", fl="id, expr_s", initialCheckPoint=0,id="highPriorityTasks"),
@@ -2407,14 +2402,14 @@ plist(tuple(a=search(collection1, q="*:*
</tr>
</table>
</div>
-<section class="sect2"><h3 id="reduce-parameters">reduce Parameters</h3><div class="ulist"><ul><li><code>StreamExpression</code>: (Mandatory)</li><li><code>by</code>: (Mandatory) A comma separated list of fields to group by.</li><li><code>Reduce Operation</code>: (Mandatory)</li></ul></div></section>
+<section class="sect2"><h3 id="reduce-parameters">reduce Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression</code>: (Mandatory)</p></li><li><p><code>by</code>: (Mandatory) A comma separated list of fields to group by.</p></li><li><p><code>Reduce Operation</code>: (Mandatory)</p></li></ul></div></section>
<section class="sect2"><h3 id="reduce-syntax">reduce Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>reduce(search(collection1, q="*:*", qt="/export", fl="id,a_s,a_i,a_f", sort="a_s asc, a_f asc"),
by="a_s",
group(sort="a_f desc", n="4")
)</code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="rollup">rollup</h2><p>The <code>rollup</code> function wraps another stream function and rolls up aggregates over bucket fields. The rollup function relies on the sort order of the underlying stream to rollup aggregates one grouping at a time. Accordingly, the sort order of the underlying stream must match the fields in the <code>over</code> parameter of the rollup function.</p>
<p>The rollup function also needs to process entire result sets in order to perform its aggregations. When the underlying stream is the <code>search</code> function, the <code>/export</code> handler can be used to provide full sorted result sets to the rollup function. This sorted approach allows the rollup function to perform aggregations over very high cardinality fields. The disadvantage of this approach is that the tuples must be sorted and streamed across the network to a worker node to be aggregated. For faster aggregation over low to moderate cardinality fields, the <code>facet</code> function can be used.</p>
-<section class="sect2"><h3 id="rollup-parameters">rollup Parameters</h3><div class="ulist"><ul><li><code>StreamExpression</code> (Mandatory)</li><li><code>over</code>: (Mandatory) A list of fields to group by.</li><li><code>metrics</code>: (Mandatory) The list of metrics to compute. Currently supported metrics are <code>sum(col)</code>, <code>avg(col)</code>, <code>min(col)</code>, <code>max(col)</code>, <code>count(*)</code>.</li></ul></div></section>
+<section class="sect2"><h3 id="rollup-parameters">rollup Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression</code> (Mandatory)</p></li><li><p><code>over</code>: (Mandatory) A list of fields to group by.</p></li><li><p><code>metrics</code>: (Mandatory) The list of metrics to compute. Currently supported metrics are <code>sum(col)</code>, <code>avg(col)</code>, <code>min(col)</code>, <code>max(col)</code>, <code>count(*)</code>.</p></li></ul></div></section>
<section class="sect2"><h3 id="rollup-syntax">rollup Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>rollup(
search(collection1, q="*:*", qt="/export", fl="a_s,a_i,a_f", qt="/export", sort="a_s asc"),
over="a_s",
@@ -2431,7 +2426,7 @@ plist(tuple(a=search(collection1, q="*:*
<p>The example about shows the rollup function wrapping the search function. Notice that search function is using the <code>/export</code> handler to provide the entire result set to the rollup stream. Also notice that the search function’s <code>sort</code> parameter matches up with the rollup’s <code>over</code> parameter. This allows the rollup function to rollup the over the <code>a_s</code> field, one group at a time.</p></section></section>
<section class="sect1"><h2 id="scorenodes">scoreNodes</h2><p>See section in <a href="graph-traversal.html#using-the-scorenodes-function-to-make-a-recommendation">graph traversal</a>.</p></section>
<section class="sect1"><h2 id="select">select</h2><p>The <code>select</code> function wraps a streaming expression and outputs tuples containing a subset or modified set of fields from the incoming tuples. The list of fields included in the output tuple can contain aliases to effectively rename fields. The <code>select</code> stream supports both operations and evaluators. One can provide a list of operations and evaluators to perform on any fields, such as <code>replace, add, if</code>, etc.</p>
-<section class="sect2"><h3 id="select-parameters">select Parameters</h3><div class="ulist"><ul><li><code>StreamExpression</code></li><li><code>fieldName</code>: name of field to include in the output tuple (can include multiple of these), such as <code>outputTuple[fieldName] = inputTuple[fieldName]</code></li><li><code>fieldName as aliasFieldName</code>: aliased field name to include in the output tuple (can include multiple of these), such as <code>outputTuple[aliasFieldName] = incomingTuple[fieldName]</code></li><li><code>replace(fieldName, value, withValue=replacementValue)</code>: if <code>incomingTuple[fieldName] == value</code> then <code>outgoingTuple[fieldName]</code> will be set to <code>replacementValue</code>. <code>value</code> can be the string "null" to replace a null value with some other value.</li><li><code>replace(fieldName, value, withField=otherFieldName)</code>: if <code>incomingTuple[fieldName] == value</code> then <code>outgoingTuple[fieldName]</code> will be
set to the value of <code>incomingTuple[otherFieldName]</code>. <code>value</code> can be the string "null" to replace a null value with some other value.</li></ul></div></section>
+<section class="sect2"><h3 id="select-parameters">select Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression</code></p></li><li><p><code>fieldName</code>: name of field to include in the output tuple (can include multiple of these), such as <code>outputTuple[fieldName] = inputTuple[fieldName]</code></p></li><li><p><code>fieldName as aliasFieldName</code>: aliased field name to include in the output tuple (can include multiple of these), such as <code>outputTuple[aliasFieldName] = incomingTuple[fieldName]</code></p></li><li><p><code>replace(fieldName, value, withValue=replacementValue)</code>: if <code>incomingTuple[fieldName] == value</code> then <code>outgoingTuple[fieldName]</code> will be set to <code>replacementValue</code>. <code>value</code> can be the string "null" to replace a null value with some other value.</p></li><li><p><code>replace(fieldName, value, withField=otherFieldName)</code>: if <code>incomingTuple[fieldName] == value</code> then <code>outgoingT
uple[fieldName]</code> will be set to the value of <code>incomingTuple[otherFieldName]</code>. <code>value</code> can be the string "null" to replace a null value with some other value.</p></li></ul></div></section>
<section class="sect2"><h3 id="select-syntax">select Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>// output tuples with fields teamName, wins, losses, and winPercentages where a null value for wins or losses is translated to the value of 0
select(
search(collection1, fl="id,teamName_s,wins,losses", q="*:*", qt="/export", sort="id asc"),
@@ -2443,7 +2438,7 @@ select(
if(eq(0,wins), 0, div(add(wins,losses), wins)) as winPercentage
)</code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="sort">sort</h2><p>The <code>sort</code> function wraps a streaming expression and re-orders the tuples. The sort function emits all incoming tuples in the new sort order. The sort function reads all tuples from the incoming stream, re-orders them using an algorithm with <code>O(nlog(n))</code> performance characteristics, where n is the total number of tuples in the incoming stream, and then outputs the tuples in the new sort order. Because all tuples are read into memory, the memory consumption of this function grows linearly with the number of tuples in the incoming stream.</p>
-<section class="sect2"><h3 id="sort-parameters">sort Parameters</h3><div class="ulist"><ul><li><code>StreamExpression</code></li><li><code>by</code>: Sort criteria for re-ordering the tuples</li></ul></div></section>
+<section class="sect2"><h3 id="sort-parameters">sort Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression</code></p></li><li><p><code>by</code>: Sort criteria for re-ordering the tuples</p></li></ul></div></section>
<section class="sect2"><h3 id="sort-syntax">sort Syntax</h3><p>The expression below finds dog owners and orders the results by owner and pet name. Notice that it uses an efficient innerJoin by first ordering by the person/owner id and then re-orders the final output by the owner and pet names.</p>
<div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>sort(
innerJoin(
@@ -2454,7 +2449,7 @@ select(
by="name asc, petName asc"
)</code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="top">top</h2><p>The <code>top</code> function wraps a streaming expression and re-orders the tuples. The top function emits only the top N tuples in the new sort order. The top function re-orders the underlying stream so the sort criteria <strong>does not</strong> have to match up with the underlying stream.</p>
-<section class="sect2"><h3 id="top-parameters">top Parameters</h3><div class="ulist"><ul><li><code>n</code>: Number of top tuples to return.</li><li><code>StreamExpression</code></li><li><code>sort</code>: Sort criteria for selecting the top N tuples.</li></ul></div></section>
+<section class="sect2"><h3 id="top-parameters">top Parameters</h3><div class="ulist"><ul><li><p><code>n</code>: Number of top tuples to return.</p></li><li><p><code>StreamExpression</code></p></li><li><p><code>sort</code>: Sort criteria for selecting the top N tuples.</p></li></ul></div></section>
<section class="sect2"><h3 id="top-syntax">top Syntax</h3><p>The expression below finds the top 3 results of the underlying search. Notice that it reverses the sort order. The top function re-orders the results of the underlying stream.</p>
<div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>top(n=3,
search(collection1,
@@ -2465,7 +2460,7 @@ select(
sort="a_f asc, a_i asc")</code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="unique">unique</h2><p>The <code>unique</code> function wraps a streaming expression and emits a unique stream of tuples based on the <code>over</code> parameter. The unique function relies on the sort order of the underlying stream. The <code>over</code> parameter must match up with the sort order of the underlying stream.</p>
<p>The unique function implements a non-co-located unique algorithm. This means that records with the same unique <code>over</code> field do not need to be co-located on the same shard. When executed in the parallel, the <code>partitionKeys</code> parameter must be the same as the unique <code>over</code> field so that records with the same keys will be shuffled to the same worker.</p>
-<section class="sect2"><h3 id="unique-parameters">unique Parameters</h3><div class="ulist"><ul><li><code>StreamExpression</code></li><li><code>over</code>: The unique criteria.</li></ul></div></section>
+<section class="sect2"><h3 id="unique-parameters">unique Parameters</h3><div class="ulist"><ul><li><p><code>StreamExpression</code></p></li><li><p><code>over</code>: The unique criteria.</p></li></ul></div></section>
<section class="sect2"><h3 id="unique-syntax">unique Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code>unique(
search(collection1,
q="*:*",
@@ -2474,7 +2469,7 @@ select(
sort="a_f asc, a_i asc"),
over="a_f")</code></pre></code></pre></div></section></section>
<section class="sect1"><h2 id="update">update</h2><p>The <code>update</code> function wraps another functions and sends the tuples to a SolrCloud collection for indexing as Documents.</p>
-<section class="sect2"><h3 id="update-parameters">update Parameters</h3><div class="ulist"><ul><li><code>destinationCollection</code>: (Mandatory) The collection where the tuples will indexed.</li><li><code>batchSize</code>: (Mandatory) The indexing batch size.</li><li><code>pruneVersionField</code>: (Optional, defaults to <code>true</code>) Wether to prune <code>_version_</code> values from tuples</li><li><code>StreamExpression</code>: (Mandatory)</li></ul></div></section>
+<section class="sect2"><h3 id="update-parameters">update Parameters</h3><div class="ulist"><ul><li><p><code>destinationCollection</code>: (Mandatory) The collection where the tuples will indexed.</p></li><li><p><code>batchSize</code>: (Mandatory) The indexing batch size.</p></li><li><p><code>pruneVersionField</code>: (Optional, defaults to <code>true</code>) Wether to prune <code>_version_</code> values from tuples</p></li><li><p><code>StreamExpression</code>: (Mandatory)</p></li></ul></div></section>
<section class="sect2"><h3 id="update-syntax">update Syntax</h3><div class="listingblock"><pre class="rouge highlight"><code class="language-text" data-lang="text"><pre class="highlight"><code> update(destinationCollection,
batchSize=500,
search(collection1,
@@ -2514,7 +2509,7 @@ select(
<div class="row">
<div class="col-lg-12 footer">
©2020 Apache Software Foundation. All rights reserved. <br />
- Site Version: 8.6-DRAFT <br />Site last generated: 2020-07-08 <br />
+ Site Version: 8.6 <br />Site last generated: 2020-07-15 <br />
<p><img src="images/solr-sunOnly-small.png" alt="Apache Solr"/></p>
</div>
</div>