You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@beam.apache.org by gi...@apache.org on 2020/07/08 00:03:20 UTC
[beam] branch asf-site updated: Publishing website 2020/07/08
00:03:10 at commit 1fbc55e
This is an automated email from the ASF dual-hosted git repository.
git-site-role pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/beam.git
The following commit(s) were added to refs/heads/asf-site by this push:
new d1723c5 Publishing website 2020/07/08 00:03:10 at commit 1fbc55e
d1723c5 is described below
commit d1723c56f6129d65aa5cdf558b6125be53e31acb
Author: jenkins <us...@infra.apache.org>
AuthorDate: Wed Jul 8 00:03:11 2020 +0000
Publishing website 2020/07/08 00:03:10 at commit 1fbc55e
---
website/generated-content/documentation/index.xml | 20 ++++++++++----------
.../documentation/programming-guide/index.html | 20 ++++++++++----------
website/generated-content/sitemap.xml | 2 +-
3 files changed, 21 insertions(+), 21 deletions(-)
diff --git a/website/generated-content/documentation/index.xml b/website/generated-content/documentation/index.xml
index 593d785..aef0c4a 100644
--- a/website/generated-content/documentation/index.xml
+++ b/website/generated-content/documentation/index.xml
@@ -1891,7 +1891,7 @@ distributed data set backed by a persistent data store.</p>
<code>PCollection</code> is bounded or unbounded depends on the source of the data set that
it represents. Reading from a batch data source, such as a file or a database,
creates a bounded <code>PCollection</code>. Reading from a streaming or
-continously-updating data source, such as Pub/Sub or Kafka, creates an unbounded
+continuously-updating data source, such as Pub/Sub or Kafka, creates an unbounded
<code>PCollection</code> (unless you explicitly tell it not to).</p>
<p>The bounded (or unbounded) nature of your <code>PCollection</code> affects how Beam
processes your data. A bounded <code>PCollection</code> can be processed using a batch job,
@@ -2233,7 +2233,7 @@ transforms, including <code>Filter</code>, <code>FlatMapElements</co
the execution of the ParDo transform. The comments give useful
information to pipeline developers such as the constraints that
apply to the objects or particular cases such as failover or
-instance reuse. They also give instanciation use cases.</p>
+instance reuse. They also give instantiation use cases.</p>
<!-- The source for the sequence diagram can be found in the the SVG resource. -->
<p><img src="/images/dofn-sequence-diagram.svg" alt="This is a sequence diagram that shows the lifecycle of the DoFn"></p>
<h4 id="groupbykey">4.2.2. GroupByKey</h4>
@@ -2946,7 +2946,7 @@ together.</p>
<span class="c1">// Input PCollection to our ParDo.
</span><span class="c1"></span> <span class="n">PCollection</span><span class="o">&lt;</span><span class="n">String</span><span class="o">&gt;</span> <span class="n">words</span> <span class="o">=</span> <span class="o">...;</span>
<span class="c1">// The ParDo will filter words whose length is below a cutoff and add them to
-</span><span class="c1"></span> <span class="c1">// the main ouput PCollection&lt;String&gt;.
+</span><span class="c1"></span> <span class="c1">// the main output PCollection&lt;String&gt;.
</span><span class="c1"></span> <span class="c1">// If a word is above the cutoff, the ParDo will add the word length to an
</span><span class="c1"></span> <span class="c1">// output PCollection&lt;Integer&gt;.
</span><span class="c1"></span> <span class="c1">// If a word starts with the string &#34;MARKER&#34;, the ParDo will add that word to an
@@ -3531,7 +3531,7 @@ infer the correct schema based on the members of the class.</p>
</div>
<p>Using JavaBean classes as above is one way to map a schema to Java classes. However multiple Java classes might have
the same schema, in which case the different Java types can often be used interchangeably. Beam will add implicit
-conversions betweens types that have matching schemas. For example, the above
+conversions between types that have matching schemas. For example, the above
<code>Transaction</code> class has the same schema as the following class:</p>
<div class=language-java>
<div class="highlight"><pre class="chroma"><code class="language-java" data-lang="java"><span class="nd">@DefaultSchema</span><span class="o">(</span><span class="n">JavaFieldSchema</span><span class="o">.</span><span class="na">class</span><span class="o">)</span>
@@ -3802,8 +3802,8 @@ setters and zero-argument constructor can be omitted.</p>
<p><code>@SchemaFieldName</code> and <code>@SchemaIgnore</code> can be used to alter the schema inferred, just like with POJO classes.</p>
<h5 id="autovalue"><strong>AutoValue</strong></h5>
<p>Java value classes are notoriously difficult to generate correctly. There is a lot of boilerplate you must create in
-order to properly implement a value class. AutoValue is a popular library for easily generating such classes by i
-mplementing a simple abstract base class.</p>
+order to properly implement a value class. AutoValue is a popular library for easily generating such classes by
+implementing a simple abstract base class.</p>
<p>Beam can infer a schema from an AutoValue class. For example:</p>
<div class=language-java>
<div class="highlight"><pre class="chroma"><code class="language-java" data-lang="java"><span class="nd">@DefaultSchema</span><span class="o">(</span><span class="n">AutoValueSchema</span><span class="o">.</span><span class="na">class</span><span class="o">)</span>
@@ -3885,8 +3885,8 @@ specific keys from the map. For example, given the following schema:</p>
<div class=language-java>
<div class="highlight"><pre class="chroma"><code class="language-java" data-lang="java"><span class="n">purchasesByType</span><span class="o">.</span><span class="na">apply</span><span class="o">(</span><span class="n">Select</span><span class="o">.</span><span class="na">fieldNames</span><span class="o">(</span><span class="s">&#34;purchases{}.userId&#34;</span><span class="o">));</span></code></pre></div>
</div>
-<p>Will result in a row containing an map field with key-type string and value-type string. The selected map will contain
-all of the keys from the original map, and the values will be the userId contained in the purchasee reecord.</p>
+<p>Will result in a row containing a map field with key-type string and value-type string. The selected map will contain
+all of the keys from the original map, and the values will be the userId contained in the purchase record.</p>
<p>While the use of {} brackets in the selector is recommended, to make it clear that map value elements are being selected,
they can be omitted for brevity. In the future, map slicing will be supported, allowing selection of specific keys from
the map.</p>
@@ -4810,7 +4810,7 @@ the end of a window.</p>
<p>When you set <code>.withAllowedLateness</code> on a <code>PCollection</code>, that allowed lateness
propagates forward to any subsequent <code>PCollection</code> derived from the first
<code>PCollection</code> you applied allowed lateness to. If you want to change the allowed
-lateness later in your pipeline, you must do so explictly by applying
+lateness later in your pipeline, you must do so explicitly by applying
<code>Window.configure().withAllowedLateness()</code>.</p>
<h3 id="adding-timestamps-to-a-pcollections-elements">8.5. Adding timestamps to a PCollection&rsquo;s elements</h3>
<p>An unbounded source provides a timestamp for each element. Depending on your
@@ -5351,7 +5351,7 @@ accumulates the number of elements seen.</p>
</div>
<h4 id="bagstate">BagState</h4>
<p>A common use case for state is to accumulate multiple elements. <code>BagState</code> allows for accumulating an unordered set
-ofelements. This allows for addition of elements to the collection without requiring the reading of the entire
+of elements. This allows for addition of elements to the collection without requiring the reading of the entire
collection first, which is an efficiency gain. In addition, runners that support paged reads can allow individual
bags larger than available memory.</p>
<div class=language-java>
diff --git a/website/generated-content/documentation/programming-guide/index.html b/website/generated-content/documentation/programming-guide/index.html
index 0977954..8afd51b 100644
--- a/website/generated-content/documentation/programming-guide/index.html
+++ b/website/generated-content/documentation/programming-guide/index.html
@@ -230,7 +230,7 @@ distributed data set backed by a persistent data store.</p><p>A <code>PCollectio
<code>PCollection</code> is bounded or unbounded depends on the source of the data set that
it represents. Reading from a batch data source, such as a file or a database,
creates a bounded <code>PCollection</code>. Reading from a streaming or
-continously-updating data source, such as Pub/Sub or Kafka, creates an unbounded
+continuously-updating data source, such as Pub/Sub or Kafka, creates an unbounded
<code>PCollection</code> (unless you explicitly tell it not to).</p><p>The bounded (or unbounded) nature of your <code>PCollection</code> affects how Beam
processes your data. A bounded <code>PCollection</code> can be processed using a batch job,
which might read the entire data set once, and perform processing in a job of
@@ -455,7 +455,7 @@ transforms, including <code>Filter</code>, <code>FlatMapElements</code>, and <co
the execution of the ParDo transform. The comments give useful
information to pipeline developers such as the constraints that
apply to the objects or particular cases such as failover or
-instance reuse. They also give instanciation use cases.</p><p><img src=/images/dofn-sequence-diagram.svg alt="This is a sequence diagram that shows the lifecycle of the DoFn"></p><h4 id=groupbykey>4.2.2. GroupByKey</h4><p><code>GroupByKey</code> is a Beam transform for processing collections of key/value pairs.
+instance reuse. They also give instantiation use cases.</p><p><img src=/images/dofn-sequence-diagram.svg alt="This is a sequence diagram that shows the lifecycle of the DoFn"></p><h4 id=groupbykey>4.2.2. GroupByKey</h4><p><code>GroupByKey</code> is a Beam transform for processing collections of key/value pairs.
It’s a parallel reduction operation, analogous to the Shuffle phase of a
Map/Shuffle/Reduce-style algorithm. The input to <code>GroupByKey</code> is a collection of
key/value pairs that represents a <em>multimap</em>, where the collection contains
@@ -1017,7 +1017,7 @@ together.</p><h4 id=output-tags>4.5.1. Tags for multiple outputs</h4><div class=
</span><span class=c1></span> <span class=n>PCollection</span><span class=o><</span><span class=n>String</span><span class=o>></span> <span class=n>words</span> <span class=o>=</span> <span class=o>...;</span>
<span class=c1>// The ParDo will filter words whose length is below a cutoff and add them to
-</span><span class=c1></span> <span class=c1>// the main ouput PCollection<String>.
+</span><span class=c1></span> <span class=c1>// the main output PCollection<String>.
</span><span class=c1></span> <span class=c1>// If a word is above the cutoff, the ParDo will add the word length to an
</span><span class=c1></span> <span class=c1>// output PCollection<Integer>.
</span><span class=c1></span> <span class=c1>// If a word starts with the string "MARKER", the ParDo will add that word to an
@@ -1403,7 +1403,7 @@ having Beam understand their element schemas.</p><p class=language-java>In Java
<span class=o>}</span>
<span class=o>}</span></code></pre></div></div><p>Using JavaBean classes as above is one way to map a schema to Java classes. However multiple Java classes might have
the same schema, in which case the different Java types can often be used interchangeably. Beam will add implicit
-conversions betweens types that have matching schemas. For example, the above
+conversions between types that have matching schemas. For example, the above
<code>Transaction</code> class has the same schema as the following class:</p><div class=language-java><div class=highlight><pre class=chroma><code class=language-java data-lang=java><span class=nd>@DefaultSchema</span><span class=o>(</span><span class=n>JavaFieldSchema</span><span class=o>.</span><span class=na>class</span><span class=o>)</span>
<span class=kd>public</span> <span class=kd>class</span> <span class=nc>TransactionPojo</span> <span class=o>{</span>
<span class=kd>public</span> <span class=n>String</span> <span class=n>bank</span><span class=o>;</span>
@@ -1535,8 +1535,8 @@ setters and zero-argument constructor can be omitted.</p><div class=language-jav
<span class=kd>public</span> <span class=n>String</span> <span class=nf>getBank</span><span class=o>()</span> <span class=o>{</span> <span class=err>…</span> <span class=o>}</span>
<span class=kd>public</span> <span class=kt>double</span> <span class=nf>getPurchaseAmount</span><span class=o>()</span> <span class=o>{</span> <span class=err>…</span> <span class=o>}</span>
<span class=o>}</span></code></pre></div></div><p><code>@SchemaFieldName</code> and <code>@SchemaIgnore</code> can be used to alter the schema inferred, just like with POJO classes.</p><h5 id=autovalue><strong>AutoValue</strong></h5><p>Java value classes are notoriously difficult to generate correctly. There is a lot of boilerplate you must create in
-order to properly implement a value class. AutoValue is a popular library for easily generating such classes by i
-mplementing a simple abstract base class.</p><p>Beam can infer a schema from an AutoValue class. For example:</p><div class=language-java><div class=highlight><pre class=chroma><code class=language-java data-lang=java><span class=nd>@DefaultSchema</span><span class=o>(</span><span class=n>AutoValueSchema</span><span class=o>.</span><span class=na>class</span><span class=o>)</span>
+order to properly implement a value class. AutoValue is a popular library for easily generating such classes by
+implementing a simple abstract base class.</p><p>Beam can infer a schema from an AutoValue class. For example:</p><div class=language-java><div class=highlight><pre class=chroma><code class=language-java data-lang=java><span class=nd>@DefaultSchema</span><span class=o>(</span><span class=n>AutoValueSchema</span><span class=o>.</span><span class=na>class</span><span class=o>)</span>
<span class=nd>@AutoValue</span>
<span class=kd>public</span> <span class=kd>abstract</span> <span class=kd>class</span> <span class=nc>TransactionValue</span> <span class=o>{</span>
<span class=kd>public</span> <span class=kd>abstract</span> <span class=n>String</span> <span class=nf>getBank</span><span class=o>();</span>
@@ -1561,8 +1561,8 @@ array.</p><h5 id=maps><strong>Maps</strong></h5><p>A map field, where the value
result is a map where the keys are the same as in the original map but the value is the specified type. Similar to
arrays, the use of {} curly brackets in the selector is recommended, to make it clear that map value elements are being
selected, they can be omitted for brevity. In the future, map key selectors will be supported, allowing selection of
-specific keys from the map. For example, given the following schema:</p><p><strong>PurchasesByType</strong></p><table><thead><tr class=header><th><b>Field Name</b></th><th><b>Field Type</b></th></tr></thead><tbody><tr><td>purchases</td><td>MAP{STRING, ROW{PURCHASE}</td></tr></tbody></table><br><p>The following</p><div class=language-java><div class=highlight><pre class=chroma><code class=language-java data-lang=java><span class=n>purchasesByType</span><span class=o>.</span><span class=na [...]
-all of the keys from the original map, and the values will be the userId contained in the purchasee reecord.</p><p>While the use of {} brackets in the selector is recommended, to make it clear that map value elements are being selected,
+specific keys from the map. For example, given the following schema:</p><p><strong>PurchasesByType</strong></p><table><thead><tr class=header><th><b>Field Name</b></th><th><b>Field Type</b></th></tr></thead><tbody><tr><td>purchases</td><td>MAP{STRING, ROW{PURCHASE}</td></tr></tbody></table><br><p>The following</p><div class=language-java><div class=highlight><pre class=chroma><code class=language-java data-lang=java><span class=n>purchasesByType</span><span class=o>.</span><span class=na [...]
+all of the keys from the original map, and the values will be the userId contained in the purchase record.</p><p>While the use of {} brackets in the selector is recommended, to make it clear that map value elements are being selected,
they can be omitted for brevity. In the future, map slicing will be supported, allowing selection of specific keys from
the map.</p><h4 id=662-schema-transforms>6.6.2. Schema transforms</h4><p>Beam provides a collection of transforms that operate natively on schemas. These transforms are very expressive,
allowing selections and aggregations in terms of named schema fields. Following are some examples of useful
@@ -1930,7 +1930,7 @@ the end of a window.</p><div class=language-java><div class=highlight><pre class
<span class=n>allowed_lateness</span><span class=o>=</span><span class=n>Duration</span><span class=p>(</span><span class=n>seconds</span><span class=o>=</span><span class=mi>2</span><span class=o>*</span><span class=mi>24</span><span class=o>*</span><span class=mi>60</span><span class=o>*</span><span class=mi>60</span><span class=p>))</span> <span class=c1># 2 days</span></code></pre></div></div><p>When you set <code>.withAllowedLateness</code> on a <code>PCollection</code [...]
propagates forward to any subsequent <code>PCollection</code> derived from the first
<code>PCollection</code> you applied allowed lateness to. If you want to change the allowed
-lateness later in your pipeline, you must do so explictly by applying
+lateness later in your pipeline, you must do so explicitly by applying
<code>Window.configure().withAllowedLateness()</code>.</p><h3 id=adding-timestamps-to-a-pcollections-elements>8.5. Adding timestamps to a PCollection’s elements</h3><p>An unbounded source provides a timestamp for each element. Depending on your
unbounded source, you may need to configure how the timestamp is extracted from
the raw data stream.</p><p>However, bounded sources (such as a file from <code>TextIO</code>) do not provide
@@ -2278,7 +2278,7 @@ accumulates the number of elements seen.</p><div class=language-java><div class=
<span class=n>_</span> <span class=o>=</span> <span class=p>(</span><span class=n>p</span> <span class=o>|</span> <span class=s1>'Read per user'</span> <span class=o>>></span> <span class=n>ReadPerUser</span><span class=p>()</span>
<span class=o>|</span> <span class=s1>'Combine state pardo'</span> <span class=o>>></span> <span class=n>beam</span><span class=o>.</span><span class=n>ParDo</span><span class=p>(</span><span class=n>CombiningStateDofn</span><span class=p>()))</span></code></pre></div></div><h4 id=bagstate>BagState</h4><p>A common use case for state is to accumulate multiple elements. <code>BagState</code> allows for accumulating an unordered set
-ofelements. This allows for addition of elements to the collection without requiring the reading of the entire
+of elements. This allows for addition of elements to the collection without requiring the reading of the entire
collection first, which is an efficiency gain. In addition, runners that support paged reads can allow individual
bags larger than available memory.</p><div class=language-java><div class=highlight><pre class=chroma><code class=language-java data-lang=java><span class=n>PCollection</span><span class=o><</span><span class=n>KV</span><span class=o><</span><span class=n>String</span><span class=o>,</span> <span class=n>ValueT</span><span class=o>>></span> <span class=n>perUser</span> <span class=o>=</span> <span class=n>readPerUser</span><span class=o>();</span>
<span class=n>perUser</span><span class=o>.</span><span class=na>apply</span><span class=o>(</span><span class=n>ParDo</span><span class=o>.</span><span class=na>of</span><span class=o>(</span><span class=k>new</span> <span class=n>DoFn</span><span class=o><</span><span class=n>KV</span><span class=o><</span><span class=n>String</span><span class=o>,</span> <span class=n>ValueT</span><span class=o>>,</span> <span class=n>OutputT</span><span class=o>>()</span> <span class=o>{</span>
diff --git a/website/generated-content/sitemap.xml b/website/generated-content/sitemap.xml
index cae386f..4804c88 100644
--- a/website/generated-content/sitemap.xml
+++ b/website/generated-content/sitemap.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="utf-8" standalone="yes"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml"><url><loc>/blog/beam-2.22.0/</loc><lastmod>2020-06-08T14:13:37-07:00</lastmod></url><url><loc>/categories/blog/</loc><lastmod>2020-06-08T14:13:37-07:00</lastmod></url><url><loc>/blog/</loc><lastmod>2020-06-08T14:13:37-07:00</lastmod></url><url><loc>/categories/</loc><lastmod>2020-06-08T14:13:37-07:00</lastmod></url><url><loc>/blog/b [...]
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8" standalone="yes"?><urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml"><url><loc>/blog/beam-2.22.0/</loc><lastmod>2020-06-08T14:13:37-07:00</lastmod></url><url><loc>/categories/blog/</loc><lastmod>2020-06-08T14:13:37-07:00</lastmod></url><url><loc>/blog/</loc><lastmod>2020-06-08T14:13:37-07:00</lastmod></url><url><loc>/categories/</loc><lastmod>2020-06-08T14:13:37-07:00</lastmod></url><url><loc>/blog/b [...]
\ No newline at end of file