diff options
Diffstat (limited to 'site/docs/0.6.1/api/core/spark/PairRDDFunctions.html')
| -rw-r--r-- | site/docs/0.6.1/api/core/spark/PairRDDFunctions.html | 1147 |
1 files changed, 1147 insertions, 0 deletions
diff --git a/site/docs/0.6.1/api/core/spark/PairRDDFunctions.html b/site/docs/0.6.1/api/core/spark/PairRDDFunctions.html new file mode 100644 index 000000000..ccae8a360 --- /dev/null +++ b/site/docs/0.6.1/api/core/spark/PairRDDFunctions.html @@ -0,0 +1,1147 @@ +<?xml version='1.0' encoding='UTF-8'?> +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"> +<html> + <head> + <title>spark.PairRDDFunctions</title> + <meta http-equiv="content-type" content="text/html; charset=UTF-8" /> + + <link type="text/css" media="screen" rel="stylesheet" href="../lib/template.css" /> + <script type="text/javascript" src="../lib/jquery.js"></script> + <script type="text/javascript" src="../lib/jquery-ui.js"></script> + <script type="text/javascript" src="../lib/template.js"></script> + <script type="text/javascript" src="../lib/tools.tooltip.js"></script> + + </head> + <body onload="sh_highlightDocument('../lib/', '.min.js');" class="type"> + <div id="definition"> + <img src="../lib/class_big.png" /> + <p id="owner"><a name="spark" class="extype" href="package.html">spark</a></p> + <h1>PairRDDFunctions</h1> + </div> + + <h4 class="signature" id="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">class</span> + </span> + <span class="symbol"> + <span class="name">PairRDDFunctions</span><span class="tparams">[<span name="K">K</span>, <span name="V">V</span>]</span><span class="result"> extends <a name="spark.Logging" class="extype" href="Logging.html">Logging</a> with <a name="org.apache.hadoop.mapreduce.HadoopMapReduceUtil" class="extype" href="../org/apache/hadoop/mapreduce/HadoopMapReduceUtil.html">HadoopMapReduceUtil</a> with <span name="scala.Serializable" class="extype">Serializable</span></span> + </span> + </h4> + + <div class="fullcommenttop" id="comment"><div class="comment cmt"><p>Extra functions available on RDDs of (key, value) pairs through an implicit conversion. +Import <code>spark.SparkContext._</code> at the top of your program to use these functions. +</p></div><div class="toggleContainer block"> + <span class="toggle">Linear Supertypes</span> + <div class="superTypes hiddenContent"><span name="scala.Serializable" class="extype">Serializable</span>, <span name="java.io.Serializable" class="extype">Serializable</span>, <a name="org.apache.hadoop.mapreduce.HadoopMapReduceUtil" class="extype" href="../org/apache/hadoop/mapreduce/HadoopMapReduceUtil.html">HadoopMapReduceUtil</a>, <a name="spark.Logging" class="extype" href="Logging.html">Logging</a>, AnyRef, <span name="scala.Any" class="extype">Any</span></div> + </div></div> + + + <div id="mbrsel"> + <div id="textfilter"><span class="pre"></span><span class="input"><input accesskey="/" type="text" /></span><span class="post"></span></div> + <div id="order"> + <span class="filtertype">Ordering</span> + <ol><li class="alpha in"><span>Alphabetic</span></li><li class="inherit out"><span>By inheritance</span></li></ol> + </div> + <div id="ancestors"> + <span class="filtertype">Inherited</span> + <ol><li class="hideall out"><span>Hide All</span></li> + <li class="showall in"><span>Show all</span></li></ol> + <ol id="linearization"><li name="spark.PairRDDFunctions" class="in"><span>PairRDDFunctions</span></li><li name="scala.Serializable" class="in"><span>Serializable</span></li><li name="java.io.Serializable" class="in"><span>Serializable</span></li><li name="org.apache.hadoop.mapreduce.HadoopMapReduceUtil" class="in"><span>HadoopMapReduceUtil</span></li><li name="spark.Logging" class="in"><span>Logging</span></li><li name="scala.AnyRef" class="in"><span>AnyRef</span></li><li name="scala.Any" class="in"><span>Any</span></li></ol> + </div> + <div id="visbl"> + <span class="filtertype">Visibility</span> + <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol> + </div> + </div> + + <div id="template"> + <div id="allMembers"> + <div class="members" id="constructors"> + <h3>Instance Constructors</h3> + <ol><li visbl="pub" name="spark.PairRDDFunctions#this" data-isabs="false"> + <a id="this:PairRDDFunctions[K, V]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">new</span> + </span> + <span class="symbol"> + <span class="name">PairRDDFunctions</span><span class="params">(<span name="self">self: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, V)]</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="arg0">arg0: ClassManifest[K]</span>, <span name="arg1">arg1: ClassManifest[V]</span>)</span> + </span> + </h4> + + </li></ol> + </div> + + + + + + <div class="values members" id="values"> + <h3>Value Members</h3> + <ol><li visbl="pub" name="scala.AnyRef#!=" data-isabs="false"> + <a id="!=(AnyRef):Boolean"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name" title="gt4s: $bang$eq">!=</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div> + </li><li visbl="pub" name="scala.Any#!=" data-isabs="false"> + <a id="!=(Any):Boolean"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name" title="gt4s: $bang$eq">!=</span><span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div> + </li><li visbl="pub" name="scala.AnyRef###" data-isabs="false"> + <a id="##():Int"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name" title="gt4s: $hash$hash">##</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div> + </li><li visbl="pub" name="scala.AnyRef#==" data-isabs="false"> + <a id="==(AnyRef):Boolean"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name" title="gt4s: $eq$eq">==</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div> + </li><li visbl="pub" name="scala.Any#==" data-isabs="false"> + <a id="==(Any):Boolean"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name" title="gt4s: $eq$eq">==</span><span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div> + </li><li visbl="pub" name="scala.Any#asInstanceOf" data-isabs="false"> + <a id="asInstanceOf[T0]:T0"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">asInstanceOf</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="result">: T0</span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div> + </li><li visbl="prt" name="scala.AnyRef#clone" data-isabs="false"> + <a id="clone():AnyRef"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">clone</span><span class="params">()</span><span class="result">: AnyRef</span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd> + <span class="name">@throws</span><span class="args">()</span> + + </dd></dl></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#cogroup" data-isabs="false"> + <a id="cogroup[W1, W2](RDD[(K, W1)],RDD[(K, W2)],Int):RDD[(K, (Seq[V], Seq[W1], Seq[W2]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">cogroup</span><span class="tparams">[<span name="W1">W1</span>, <span name="W2">W2</span>]</span><span class="params">(<span name="other1">other1: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W1)]</span>, <span name="other2">other2: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W2)]</span>, <span name="numSplits">numSplits: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (Seq[V], Seq[W1], Seq[W2]))]</span> + </span> + </h4> + <p class="shortcomment cmt">For each key k in <code>this</code> or <code>other1</code> or <code>other2</code>, return a resulting RDD that contains a +tuple with the list of values for that key in <code>this</code>, <code>other1</code> and <code>other2</code>.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#cogroup" data-isabs="false"> + <a id="cogroup[W](RDD[(K, W)],Int):RDD[(K, (Seq[V], Seq[W]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">cogroup</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>, <span name="numSplits">numSplits: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (Seq[V], Seq[W]))]</span> + </span> + </h4> + <p class="shortcomment cmt">For each key k in <code>this</code> or <code>other</code>, return a resulting RDD that contains a tuple with the +list of values for that key in <code>this</code> as well as <code>other</code>.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#cogroup" data-isabs="false"> + <a id="cogroup[W1, W2](RDD[(K, W1)],RDD[(K, W2)]):RDD[(K, (Seq[V], Seq[W1], Seq[W2]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">cogroup</span><span class="tparams">[<span name="W1">W1</span>, <span name="W2">W2</span>]</span><span class="params">(<span name="other1">other1: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W1)]</span>, <span name="other2">other2: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W2)]</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (Seq[V], Seq[W1], Seq[W2]))]</span> + </span> + </h4> + <p class="shortcomment cmt">For each key k in <code>this</code> or <code>other1</code> or <code>other2</code>, return a resulting RDD that contains a +tuple with the list of values for that key in <code>this</code>, <code>other1</code> and <code>other2</code>.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#cogroup" data-isabs="false"> + <a id="cogroup[W](RDD[(K, W)]):RDD[(K, (Seq[V], Seq[W]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">cogroup</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (Seq[V], Seq[W]))]</span> + </span> + </h4> + <p class="shortcomment cmt">For each key k in <code>this</code> or <code>other</code>, return a resulting RDD that contains a tuple with the +list of values for that key in <code>this</code> as well as <code>other</code>.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#cogroup" data-isabs="false"> + <a id="cogroup[W1, W2](RDD[(K, W1)],RDD[(K, W2)],Partitioner):RDD[(K, (Seq[V], Seq[W1], Seq[W2]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">cogroup</span><span class="tparams">[<span name="W1">W1</span>, <span name="W2">W2</span>]</span><span class="params">(<span name="other1">other1: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W1)]</span>, <span name="other2">other2: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W2)]</span>, <span name="partitioner">partitioner: <a name="spark.Partitioner" class="extype" href="Partitioner.html">Partitioner</a></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (Seq[V], Seq[W1], Seq[W2]))]</span> + </span> + </h4> + <p class="shortcomment cmt">For each key k in <code>this</code> or <code>other1</code> or <code>other2</code>, return a resulting RDD that contains a +tuple with the list of values for that key in <code>this</code>, <code>other1</code> and <code>other2</code>.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#cogroup" data-isabs="false"> + <a id="cogroup[W](RDD[(K, W)],Partitioner):RDD[(K, (Seq[V], Seq[W]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">cogroup</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>, <span name="partitioner">partitioner: <a name="spark.Partitioner" class="extype" href="Partitioner.html">Partitioner</a></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (Seq[V], Seq[W]))]</span> + </span> + </h4> + <p class="shortcomment cmt">For each key k in <code>this</code> or <code>other</code>, return a resulting RDD that contains a tuple with the +list of values for that key in <code>this</code> as well as <code>other</code>.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#collectAsMap" data-isabs="false"> + <a id="collectAsMap():Map[K, V]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">collectAsMap</span><span class="params">()</span><span class="result">: <span name="scala.collection.Map" class="extype">Map</span>[K, V]</span> + </span> + </h4> + <p class="shortcomment cmt">Return the key-value pairs in this RDD to the master as a Map.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#combineByKey" data-isabs="false"> + <a id="combineByKey[C]((V) ⇒ C,(C, V) ⇒ C,(C, C) ⇒ C):RDD[(K, C)]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">combineByKey</span><span class="tparams">[<span name="C">C</span>]</span><span class="params">(<span name="createCombiner">createCombiner: (V) ⇒ C</span>, <span name="mergeValue">mergeValue: (C, V) ⇒ C</span>, <span name="mergeCombiners">mergeCombiners: (C, C) ⇒ C</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, C)]</span> + </span> + </h4> + <p class="shortcomment cmt">Simplified version of combineByKey that hash-partitions the resulting RDD using the default +parallelism level.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#combineByKey" data-isabs="false"> + <a id="combineByKey[C]((V) ⇒ C,(C, V) ⇒ C,(C, C) ⇒ C,Int):RDD[(K, C)]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">combineByKey</span><span class="tparams">[<span name="C">C</span>]</span><span class="params">(<span name="createCombiner">createCombiner: (V) ⇒ C</span>, <span name="mergeValue">mergeValue: (C, V) ⇒ C</span>, <span name="mergeCombiners">mergeCombiners: (C, C) ⇒ C</span>, <span name="numSplits">numSplits: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, C)]</span> + </span> + </h4> + <p class="shortcomment cmt">Simplified version of combineByKey that hash-partitions the output RDD.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#combineByKey" data-isabs="false"> + <a id="combineByKey[C]((V) ⇒ C,(C, V) ⇒ C,(C, C) ⇒ C,Partitioner,Boolean):RDD[(K, C)]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">combineByKey</span><span class="tparams">[<span name="C">C</span>]</span><span class="params">(<span name="createCombiner">createCombiner: (V) ⇒ C</span>, <span name="mergeValue">mergeValue: (C, V) ⇒ C</span>, <span name="mergeCombiners">mergeCombiners: (C, C) ⇒ C</span>, <span name="partitioner">partitioner: <a name="spark.Partitioner" class="extype" href="Partitioner.html">Partitioner</a></span>, <span name="mapSideCombine">mapSideCombine: <span name="scala.Boolean" class="extype">Boolean</span></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, C)]</span> + </span> + </h4> + <p class="shortcomment cmt">Generic function to combine the elements for each key using a custom set of aggregation +functions.</p><div class="fullcomment"><div class="comment cmt"><p>Generic function to combine the elements for each key using a custom set of aggregation +functions. Turns an RDD[(K, V)] into a result of type RDD[(K, C)], for a "combined type" C +Note that V and C can be different -- for example, one might group an RDD of type +(Int, Int) into an RDD of type (Int, Seq[Int]). Users provide three functions:</p><p>- <code>createCombiner</code>, which turns a V into a C (e.g., creates a one-element list) +- <code>mergeValue</code>, to merge a V into a C (e.g., adds it to the end of a list) +- <code>mergeCombiners</code>, to combine two C's into a single one.</p><p>In addition, users can control the partitioning of the output RDD, and whether to perform +map-side aggregation (if a mapper can produce multiple items with the same key). +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#countByKey" data-isabs="false"> + <a id="countByKey():Map[K, Long]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">countByKey</span><span class="params">()</span><span class="result">: <span name="scala.collection.Map" class="extype">Map</span>[K, <span name="scala.Long" class="extype">Long</span>]</span> + </span> + </h4> + <p class="shortcomment cmt">Count the number of elements for each key, and return the result to the master as a Map.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#countByKeyApprox" data-isabs="false"> + <a id="countByKeyApprox(Long,Double):PartialResult[Map[K, BoundedDouble]]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">countByKeyApprox</span><span class="params">(<span name="timeout">timeout: <span name="scala.Long" class="extype">Long</span></span>, <span name="confidence">confidence: <span name="scala.Double" class="extype">Double</span> = <span class="symbol">0.95</span></span>)</span><span class="result">: <a name="spark.partial.PartialResult" class="extype" href="partial/PartialResult.html">PartialResult</a>[<span name="scala.collection.Map" class="extype">Map</span>[K, <a name="spark.partial.BoundedDouble" class="extype" href="partial/BoundedDouble.html">BoundedDouble</a>]]</span> + </span> + </h4> + <p class="shortcomment cmt">(Experimental) Approximate version of countByKey that can return a partial result if it does +not finish within a timeout.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#defaultPartitioner" data-isabs="false"> + <a id="defaultPartitioner(spark.RDD[_]*):Partitioner"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">defaultPartitioner</span><span class="params">(<span name="rdds">rdds: spark.RDD[_]*</span>)</span><span class="result">: <a name="spark.Partitioner" class="extype" href="Partitioner.html">Partitioner</a></span> + </span> + </h4> + <p class="shortcomment cmt">Choose a partitioner to use for a cogroup-like operation between a number of RDDs.</p><div class="fullcomment"><div class="comment cmt"><p>Choose a partitioner to use for a cogroup-like operation between a number of RDDs. If any of +the RDDs already has a partitioner, choose that one, otherwise use a default HashPartitioner. +</p></div></div> + </li><li visbl="pub" name="scala.AnyRef#eq" data-isabs="false"> + <a id="eq(AnyRef):Boolean"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">eq</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div> + </li><li visbl="pub" name="scala.AnyRef#equals" data-isabs="false"> + <a id="equals(Any):Boolean"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">equals</span><span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div> + </li><li visbl="prt" name="scala.AnyRef#finalize" data-isabs="false"> + <a id="finalize():Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">finalize</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd> + <span class="name">@throws</span><span class="args">()</span> + + </dd></dl></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#flatMapValues" data-isabs="false"> + <a id="flatMapValues[U]((V) ⇒ TraversableOnce[U]):RDD[(K, U)]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">flatMapValues</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (V) ⇒ TraversableOnce[U]</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, U)]</span> + </span> + </h4> + <p class="shortcomment cmt">Pass each value in the key-value pair RDD through a flatMap function without changing the +keys; this also retains the original RDD's partitioning.</p> + </li><li visbl="pub" name="scala.AnyRef#getClass" data-isabs="false"> + <a id="getClass():java.lang.Class[_]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">getClass</span><span class="params">()</span><span class="result">: java.lang.Class[_]</span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#groupByKey" data-isabs="false"> + <a id="groupByKey():RDD[(K, Seq[V])]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">groupByKey</span><span class="params">()</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, Seq[V])]</span> + </span> + </h4> + <p class="shortcomment cmt">Group the values for each key in the RDD into a single sequence.</p><div class="fullcomment"><div class="comment cmt"><p>Group the values for each key in the RDD into a single sequence. Hash-partitions the +resulting RDD with the default parallelism level. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#groupByKey" data-isabs="false"> + <a id="groupByKey(Int):RDD[(K, Seq[V])]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">groupByKey</span><span class="params">(<span name="numSplits">numSplits: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, Seq[V])]</span> + </span> + </h4> + <p class="shortcomment cmt">Group the values for each key in the RDD into a single sequence.</p><div class="fullcomment"><div class="comment cmt"><p>Group the values for each key in the RDD into a single sequence. Hash-partitions the +resulting RDD with into <code>numSplits</code> partitions. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#groupByKey" data-isabs="false"> + <a id="groupByKey(Partitioner):RDD[(K, Seq[V])]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">groupByKey</span><span class="params">(<span name="partitioner">partitioner: <a name="spark.Partitioner" class="extype" href="Partitioner.html">Partitioner</a></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, Seq[V])]</span> + </span> + </h4> + <p class="shortcomment cmt">Group the values for each key in the RDD into a single sequence.</p><div class="fullcomment"><div class="comment cmt"><p>Group the values for each key in the RDD into a single sequence. Allows controlling the +partitioning of the resulting key-value pair RDD by passing a Partitioner. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#groupWith" data-isabs="false"> + <a id="groupWith[W1, W2](RDD[(K, W1)],RDD[(K, W2)]):RDD[(K, (Seq[V], Seq[W1], Seq[W2]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">groupWith</span><span class="tparams">[<span name="W1">W1</span>, <span name="W2">W2</span>]</span><span class="params">(<span name="other1">other1: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W1)]</span>, <span name="other2">other2: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W2)]</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (Seq[V], Seq[W1], Seq[W2]))]</span> + </span> + </h4> + <p class="shortcomment cmt">Alias for cogroup.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#groupWith" data-isabs="false"> + <a id="groupWith[W](RDD[(K, W)]):RDD[(K, (Seq[V], Seq[W]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">groupWith</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (Seq[V], Seq[W]))]</span> + </span> + </h4> + <p class="shortcomment cmt">Alias for cogroup.</p> + </li><li visbl="pub" name="scala.AnyRef#hashCode" data-isabs="false"> + <a id="hashCode():Int"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">hashCode</span><span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div> + </li><li visbl="prt" name="spark.Logging#initLogging" data-isabs="false"> + <a id="initLogging():Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">initLogging</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="pub" name="scala.Any#isInstanceOf" data-isabs="false"> + <a id="isInstanceOf[T0]:Boolean"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">isInstanceOf</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>Any</dd></dl></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#join" data-isabs="false"> + <a id="join[W](RDD[(K, W)],Int):RDD[(K, (V, W))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">join</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>, <span name="numSplits">numSplits: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (V, W))]</span> + </span> + </h4> + <p class="shortcomment cmt">Return an RDD containing all pairs of elements with matching keys in <code>this</code> and <code>other</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Return an RDD containing all pairs of elements with matching keys in <code>this</code> and <code>other</code>. Each +pair of elements will be returned as a (k, (v1, v2)) tuple, where (k, v1) is in <code>this</code> and +(k, v2) is in <code>other</code>. Performs a hash join across the cluster. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#join" data-isabs="false"> + <a id="join[W](RDD[(K, W)]):RDD[(K, (V, W))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">join</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (V, W))]</span> + </span> + </h4> + <p class="shortcomment cmt">Return an RDD containing all pairs of elements with matching keys in <code>this</code> and <code>other</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Return an RDD containing all pairs of elements with matching keys in <code>this</code> and <code>other</code>. Each +pair of elements will be returned as a (k, (v1, v2)) tuple, where (k, v1) is in <code>this</code> and +(k, v2) is in <code>other</code>. Performs a hash join across the cluster. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#join" data-isabs="false"> + <a id="join[W](RDD[(K, W)],Partitioner):RDD[(K, (V, W))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">join</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>, <span name="partitioner">partitioner: <a name="spark.Partitioner" class="extype" href="Partitioner.html">Partitioner</a></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (V, W))]</span> + </span> + </h4> + <p class="shortcomment cmt">Merge the values for each key using an associative reduce function.</p><div class="fullcomment"><div class="comment cmt"><p>Merge the values for each key using an associative reduce function. This will also perform +the merging locally on each mapper before sending results to a reducer, similarly to a +"combiner" in MapReduce. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#leftOuterJoin" data-isabs="false"> + <a id="leftOuterJoin[W](RDD[(K, W)],Int):RDD[(K, (V, Option[W]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">leftOuterJoin</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>, <span name="numSplits">numSplits: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (V, <span name="scala.Option" class="extype">Option</span>[W]))]</span> + </span> + </h4> + <p class="shortcomment cmt">Perform a left outer join of <code>this</code> and <code>other</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Perform a left outer join of <code>this</code> and <code>other</code>. For each element (k, v) in <code>this</code>, the +resulting RDD will either contain all pairs (k, (v, Some(w))) for w in <code>other</code>, or the +pair (k, (v, None)) if no elements in <code>other</code> have key k. Hash-partitions the output +into <code>numSplits</code> partitions. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#leftOuterJoin" data-isabs="false"> + <a id="leftOuterJoin[W](RDD[(K, W)]):RDD[(K, (V, Option[W]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">leftOuterJoin</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (V, <span name="scala.Option" class="extype">Option</span>[W]))]</span> + </span> + </h4> + <p class="shortcomment cmt">Perform a left outer join of <code>this</code> and <code>other</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Perform a left outer join of <code>this</code> and <code>other</code>. For each element (k, v) in <code>this</code>, the +resulting RDD will either contain all pairs (k, (v, Some(w))) for w in <code>other</code>, or the +pair (k, (v, None)) if no elements in <code>other</code> have key k. Hash-partitions the output +using the default level of parallelism. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#leftOuterJoin" data-isabs="false"> + <a id="leftOuterJoin[W](RDD[(K, W)],Partitioner):RDD[(K, (V, Option[W]))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">leftOuterJoin</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>, <span name="partitioner">partitioner: <a name="spark.Partitioner" class="extype" href="Partitioner.html">Partitioner</a></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (V, <span name="scala.Option" class="extype">Option</span>[W]))]</span> + </span> + </h4> + <p class="shortcomment cmt">Perform a left outer join of <code>this</code> and <code>other</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Perform a left outer join of <code>this</code> and <code>other</code>. For each element (k, v) in <code>this</code>, the +resulting RDD will either contain all pairs (k, (v, Some(w))) for w in <code>other</code>, or the +pair (k, (v, None)) if no elements in <code>other</code> have key k. Uses the given Partitioner to +partition the output RDD. +</p></div></div> + </li><li visbl="prt" name="spark.Logging#log" data-isabs="false"> + <a id="log:Logger"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">log</span><span class="result">: <span name="org.slf4j.Logger" class="extype">Logger</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="prt" name="spark.Logging#logDebug" data-isabs="false"> + <a id="logDebug(⇒ String,Throwable):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">logDebug</span><span class="params">(<span name="msg">msg: ⇒ String</span>, <span name="throwable">throwable: Throwable</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="prt" name="spark.Logging#logDebug" data-isabs="false"> + <a id="logDebug(⇒ String):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">logDebug</span><span class="params">(<span name="msg">msg: ⇒ String</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="prt" name="spark.Logging#logError" data-isabs="false"> + <a id="logError(⇒ String,Throwable):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">logError</span><span class="params">(<span name="msg">msg: ⇒ String</span>, <span name="throwable">throwable: Throwable</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="prt" name="spark.Logging#logError" data-isabs="false"> + <a id="logError(⇒ String):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">logError</span><span class="params">(<span name="msg">msg: ⇒ String</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="prt" name="spark.Logging#logInfo" data-isabs="false"> + <a id="logInfo(⇒ String,Throwable):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">logInfo</span><span class="params">(<span name="msg">msg: ⇒ String</span>, <span name="throwable">throwable: Throwable</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="prt" name="spark.Logging#logInfo" data-isabs="false"> + <a id="logInfo(⇒ String):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">logInfo</span><span class="params">(<span name="msg">msg: ⇒ String</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="prt" name="spark.Logging#logTrace" data-isabs="false"> + <a id="logTrace(⇒ String,Throwable):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">logTrace</span><span class="params">(<span name="msg">msg: ⇒ String</span>, <span name="throwable">throwable: Throwable</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="prt" name="spark.Logging#logTrace" data-isabs="false"> + <a id="logTrace(⇒ String):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">logTrace</span><span class="params">(<span name="msg">msg: ⇒ String</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="prt" name="spark.Logging#logWarning" data-isabs="false"> + <a id="logWarning(⇒ String,Throwable):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">logWarning</span><span class="params">(<span name="msg">msg: ⇒ String</span>, <span name="throwable">throwable: Throwable</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="prt" name="spark.Logging#logWarning" data-isabs="false"> + <a id="logWarning(⇒ String):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">logWarning</span><span class="params">(<span name="msg">msg: ⇒ String</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected </dd><dt>Definition Classes</dt><dd><a name="spark.Logging" class="extype" href="Logging.html">Logging</a></dd></dl></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#lookup" data-isabs="false"> + <a id="lookup(K):Seq[V]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">lookup</span><span class="params">(<span name="key">key: K</span>)</span><span class="result">: Seq[V]</span> + </span> + </h4> + <p class="shortcomment cmt">Return the list of values in the RDD for key <code>key</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Return the list of values in the RDD for key <code>key</code>. This operation is done efficiently if the +RDD has a known partitioner by only searching the partition that the key maps to. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#mapValues" data-isabs="false"> + <a id="mapValues[U]((V) ⇒ U):RDD[(K, U)]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">mapValues</span><span class="tparams">[<span name="U">U</span>]</span><span class="params">(<span name="f">f: (V) ⇒ U</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, U)]</span> + </span> + </h4> + <p class="shortcomment cmt">Pass each value in the key-value pair RDD through a map function without changing the keys; +this also retains the original RDD's partitioning.</p> + </li><li visbl="pub" name="scala.AnyRef#ne" data-isabs="false"> + <a id="ne(AnyRef):Boolean"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">ne</span><span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div> + </li><li visbl="pub" name="org.apache.hadoop.mapreduce.HadoopMapReduceUtil#newJobContext" data-isabs="false"> + <a id="newJobContext(Configuration,JobID):JobContext"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">newJobContext</span><span class="params">(<span name="conf">conf: <span name="org.apache.hadoop.conf.Configuration" class="extype">Configuration</span></span>, <span name="jobId">jobId: <span name="org.apache.hadoop.mapreduce.JobID" class="extype">JobID</span></span>)</span><span class="result">: <span name="org.apache.hadoop.mapreduce.JobContext" class="extype">JobContext</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="org.apache.hadoop.mapreduce.HadoopMapReduceUtil" class="extype" href="../org/apache/hadoop/mapreduce/HadoopMapReduceUtil.html">HadoopMapReduceUtil</a></dd></dl></div> + </li><li visbl="pub" name="org.apache.hadoop.mapreduce.HadoopMapReduceUtil#newTaskAttemptContext" data-isabs="false"> + <a id="newTaskAttemptContext(Configuration,TaskAttemptID):TaskAttemptContext"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">newTaskAttemptContext</span><span class="params">(<span name="conf">conf: <span name="org.apache.hadoop.conf.Configuration" class="extype">Configuration</span></span>, <span name="attemptId">attemptId: <span name="org.apache.hadoop.mapreduce.TaskAttemptID" class="extype">TaskAttemptID</span></span>)</span><span class="result">: <span name="org.apache.hadoop.mapreduce.TaskAttemptContext" class="extype">TaskAttemptContext</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="org.apache.hadoop.mapreduce.HadoopMapReduceUtil" class="extype" href="../org/apache/hadoop/mapreduce/HadoopMapReduceUtil.html">HadoopMapReduceUtil</a></dd></dl></div> + </li><li visbl="pub" name="scala.AnyRef#notify" data-isabs="false"> + <a id="notify():Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">notify</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div> + </li><li visbl="pub" name="scala.AnyRef#notifyAll" data-isabs="false"> + <a id="notifyAll():Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">notifyAll</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#partitionBy" data-isabs="false"> + <a id="partitionBy(Partitioner,Boolean):RDD[(K, V)]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">partitionBy</span><span class="params">(<span name="partitioner">partitioner: <a name="spark.Partitioner" class="extype" href="Partitioner.html">Partitioner</a></span>, <span name="mapSideCombine">mapSideCombine: <span name="scala.Boolean" class="extype">Boolean</span> = <span class="symbol">false</span></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, V)]</span> + </span> + </h4> + <p class="shortcomment cmt">Return a copy of the RDD partitioned using the specified partitioner.</p><div class="fullcomment"><div class="comment cmt"><p>Return a copy of the RDD partitioned using the specified partitioner. If <code>mapSideCombine</code> +is true, Spark will group values of the same key together on the map side before the +repartitioning, to only send each key over the network once. If a large number of +duplicated keys are expected, and the size of the keys are large, <code>mapSideCombine</code> should +be set to true. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#reduceByKey" data-isabs="false"> + <a id="reduceByKey((V, V) ⇒ V):RDD[(K, V)]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">reduceByKey</span><span class="params">(<span name="func">func: (V, V) ⇒ V</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, V)]</span> + </span> + </h4> + <p class="shortcomment cmt">Merge the values for each key using an associative reduce function.</p><div class="fullcomment"><div class="comment cmt"><p>Merge the values for each key using an associative reduce function. This will also perform +the merging locally on each mapper before sending results to a reducer, similarly to a +"combiner" in MapReduce. Output will be hash-partitioned with the default parallelism level. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#reduceByKey" data-isabs="false"> + <a id="reduceByKey((V, V) ⇒ V,Int):RDD[(K, V)]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">reduceByKey</span><span class="params">(<span name="func">func: (V, V) ⇒ V</span>, <span name="numSplits">numSplits: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, V)]</span> + </span> + </h4> + <p class="shortcomment cmt">Merge the values for each key using an associative reduce function.</p><div class="fullcomment"><div class="comment cmt"><p>Merge the values for each key using an associative reduce function. This will also perform +the merging locally on each mapper before sending results to a reducer, similarly to a +"combiner" in MapReduce. Output will be hash-partitioned with numSplits splits. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#reduceByKey" data-isabs="false"> + <a id="reduceByKey(Partitioner,(V, V) ⇒ V):RDD[(K, V)]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">reduceByKey</span><span class="params">(<span name="partitioner">partitioner: <a name="spark.Partitioner" class="extype" href="Partitioner.html">Partitioner</a></span>, <span name="func">func: (V, V) ⇒ V</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, V)]</span> + </span> + </h4> + <p class="shortcomment cmt">Merge the values for each key using an associative reduce function.</p><div class="fullcomment"><div class="comment cmt"><p>Merge the values for each key using an associative reduce function. This will also perform +the merging locally on each mapper before sending results to a reducer, similarly to a +"combiner" in MapReduce. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#reduceByKeyLocally" data-isabs="false"> + <a id="reduceByKeyLocally((V, V) ⇒ V):Map[K, V]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">reduceByKeyLocally</span><span class="params">(<span name="func">func: (V, V) ⇒ V</span>)</span><span class="result">: <span name="scala.collection.Map" class="extype">Map</span>[K, V]</span> + </span> + </h4> + <p class="shortcomment cmt">Merge the values for each key using an associative reduce function, but return the results +immediately to the master as a Map.</p><div class="fullcomment"><div class="comment cmt"><p>Merge the values for each key using an associative reduce function, but return the results +immediately to the master as a Map. This will also perform the merging locally on each mapper +before sending results to a reducer, similarly to a "combiner" in MapReduce. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#reduceByKeyToDriver" data-isabs="false"> + <a id="reduceByKeyToDriver((V, V) ⇒ V):Map[K, V]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">reduceByKeyToDriver</span><span class="params">(<span name="func">func: (V, V) ⇒ V</span>)</span><span class="result">: <span name="scala.collection.Map" class="extype">Map</span>[K, V]</span> + </span> + </h4> + <p class="shortcomment cmt">Alias for reduceByKeyLocally</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#rightOuterJoin" data-isabs="false"> + <a id="rightOuterJoin[W](RDD[(K, W)],Int):RDD[(K, (Option[V], W))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">rightOuterJoin</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>, <span name="numSplits">numSplits: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (<span name="scala.Option" class="extype">Option</span>[V], W))]</span> + </span> + </h4> + <p class="shortcomment cmt">Perform a right outer join of <code>this</code> and <code>other</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Perform a right outer join of <code>this</code> and <code>other</code>. For each element (k, w) in <code>other</code>, the +resulting RDD will either contain all pairs (k, (Some(v), w)) for v in <code>this</code>, or the +pair (k, (None, w)) if no elements in <code>this</code> have key k. Hash-partitions the resulting +RDD into the given number of partitions. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#rightOuterJoin" data-isabs="false"> + <a id="rightOuterJoin[W](RDD[(K, W)]):RDD[(K, (Option[V], W))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">rightOuterJoin</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (<span name="scala.Option" class="extype">Option</span>[V], W))]</span> + </span> + </h4> + <p class="shortcomment cmt">Perform a right outer join of <code>this</code> and <code>other</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Perform a right outer join of <code>this</code> and <code>other</code>. For each element (k, w) in <code>other</code>, the +resulting RDD will either contain all pairs (k, (Some(v), w)) for v in <code>this</code>, or the +pair (k, (None, w)) if no elements in <code>this</code> have key k. Hash-partitions the resulting +RDD using the default parallelism level. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#rightOuterJoin" data-isabs="false"> + <a id="rightOuterJoin[W](RDD[(K, W)],Partitioner):RDD[(K, (Option[V], W))]"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">rightOuterJoin</span><span class="tparams">[<span name="W">W</span>]</span><span class="params">(<span name="other">other: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, W)]</span>, <span name="partitioner">partitioner: <a name="spark.Partitioner" class="extype" href="Partitioner.html">Partitioner</a></span>)</span><span class="result">: <a name="spark.RDD" class="extype" href="RDD.html">RDD</a>[(K, (<span name="scala.Option" class="extype">Option</span>[V], W))]</span> + </span> + </h4> + <p class="shortcomment cmt">Perform a right outer join of <code>this</code> and <code>other</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Perform a right outer join of <code>this</code> and <code>other</code>. For each element (k, w) in <code>other</code>, the +resulting RDD will either contain all pairs (k, (Some(v), w)) for v in <code>this</code>, or the +pair (k, (None, w)) if no elements in <code>this</code> have key k. Uses the given Partitioner to +partition the output RDD. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#saveAsHadoopDataset" data-isabs="false"> + <a id="saveAsHadoopDataset(JobConf):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">saveAsHadoopDataset</span><span class="params">(<span name="conf">conf: <span name="org.apache.hadoop.mapred.JobConf" class="extype">JobConf</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <p class="shortcomment cmt">Output the RDD to any Hadoop-supported storage system, using a Hadoop JobConf object for +that storage system.</p><div class="fullcomment"><div class="comment cmt"><p>Output the RDD to any Hadoop-supported storage system, using a Hadoop JobConf object for +that storage system. The JobConf should set an OutputFormat and any output paths required +(e.g. a table name to write to) in the same way as it would be configured for a Hadoop +MapReduce job. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#saveAsHadoopFile" data-isabs="false"> + <a id="saveAsHadoopFile(String,Class[_],Class[_],Class[_ <: org.apache.hadoop.mapred.OutputFormat[_, _]],JobConf):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">saveAsHadoopFile</span><span class="params">(<span name="path">path: String</span>, <span name="keyClass">keyClass: Class[_]</span>, <span name="valueClass">valueClass: Class[_]</span>, <span name="outputFormatClass">outputFormatClass: Class[_ <: org.apache.hadoop.mapred.OutputFormat[_, _]]</span>, <span name="conf">conf: <span name="org.apache.hadoop.mapred.JobConf" class="extype">JobConf</span> = <span class="symbol"><span class="name"><a href="../org/package.html">new JobConf</a></span></span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <p class="shortcomment cmt">Output the RDD to any Hadoop-supported file system, using a Hadoop <code>OutputFormat</code> class +supporting the key and value types K and V in this RDD.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#saveAsHadoopFile" data-isabs="false"> + <a id="saveAsHadoopFile[F<:OutputFormat[K, V]](String)(ClassManifest[F]):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">saveAsHadoopFile</span><span class="tparams">[<span name="F">F <: <span name="org.apache.hadoop.mapred.OutputFormat" class="extype">OutputFormat</span>[K, V]</span>]</span><span class="params">(<span name="path">path: String</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="fm">fm: ClassManifest[F]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <p class="shortcomment cmt">Output the RDD to any Hadoop-supported file system, using a Hadoop <code>OutputFormat</code> class +supporting the key and value types K and V in this RDD.</p> + </li><li visbl="pub" name="spark.PairRDDFunctions#saveAsNewAPIHadoopFile" data-isabs="false"> + <a id="saveAsNewAPIHadoopFile(String,Class[_],Class[_],Class[_ <: org.apache.hadoop.mapreduce.OutputFormat[_, _]],Configuration):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">saveAsNewAPIHadoopFile</span><span class="params">(<span name="path">path: String</span>, <span name="keyClass">keyClass: Class[_]</span>, <span name="valueClass">valueClass: Class[_]</span>, <span name="outputFormatClass">outputFormatClass: Class[_ <: org.apache.hadoop.mapreduce.OutputFormat[_, _]]</span>, <span name="conf">conf: <span name="org.apache.hadoop.conf.Configuration" class="extype">Configuration</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <p class="shortcomment cmt">Output the RDD to any Hadoop-supported file system, using a new Hadoop API <code>OutputFormat</code> +(mapreduce.</p><div class="fullcomment"><div class="comment cmt"><p>Output the RDD to any Hadoop-supported file system, using a new Hadoop API <code>OutputFormat</code> +(mapreduce.OutputFormat) object supporting the key and value types K and V in this RDD. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#saveAsNewAPIHadoopFile" data-isabs="false"> + <a id="saveAsNewAPIHadoopFile(String,Class[_],Class[_],Class[_ <: org.apache.hadoop.mapreduce.OutputFormat[_, _]]):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">saveAsNewAPIHadoopFile</span><span class="params">(<span name="path">path: String</span>, <span name="keyClass">keyClass: Class[_]</span>, <span name="valueClass">valueClass: Class[_]</span>, <span name="outputFormatClass">outputFormatClass: Class[_ <: org.apache.hadoop.mapreduce.OutputFormat[_, _]]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <p class="shortcomment cmt">Output the RDD to any Hadoop-supported file system, using a new Hadoop API <code>OutputFormat</code> +(mapreduce.</p><div class="fullcomment"><div class="comment cmt"><p>Output the RDD to any Hadoop-supported file system, using a new Hadoop API <code>OutputFormat</code> +(mapreduce.OutputFormat) object supporting the key and value types K and V in this RDD. +</p></div></div> + </li><li visbl="pub" name="spark.PairRDDFunctions#saveAsNewAPIHadoopFile" data-isabs="false"> + <a id="saveAsNewAPIHadoopFile[F<:OutputFormat[K, V]](String)(ClassManifest[F]):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">saveAsNewAPIHadoopFile</span><span class="tparams">[<span name="F">F <: <span name="org.apache.hadoop.mapreduce.OutputFormat" class="extype">OutputFormat</span>[K, V]</span>]</span><span class="params">(<span name="path">path: String</span>)</span><span class="params">(<span class="implicit">implicit </span><span name="fm">fm: ClassManifest[F]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <p class="shortcomment cmt">Output the RDD to any Hadoop-supported file system, using a new Hadoop API <code>OutputFormat</code> +(mapreduce.</p><div class="fullcomment"><div class="comment cmt"><p>Output the RDD to any Hadoop-supported file system, using a new Hadoop API <code>OutputFormat</code> +(mapreduce.OutputFormat) object supporting the key and value types K and V in this RDD. +</p></div></div> + </li><li visbl="pub" name="scala.AnyRef#synchronized" data-isabs="false"> + <a id="synchronized[T0](⇒ T0):T0"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">synchronized</span><span class="tparams">[<span name="T0">T0</span>]</span><span class="params">(<span name="arg0">arg0: ⇒ T0</span>)</span><span class="result">: T0</span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd></dl></div> + </li><li visbl="pub" name="scala.AnyRef#toString" data-isabs="false"> + <a id="toString():String"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier"></span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">toString</span><span class="params">()</span><span class="result">: <span name="java.lang.String" class="extype">String</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div> + </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false"> + <a id="wait():Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">wait</span><span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd> + <span class="name">@throws</span><span class="args">()</span> + + </dd></dl></div> + </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false"> + <a id="wait(Long,Int):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">wait</span><span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>, <span name="arg1">arg1: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd> + <span class="name">@throws</span><span class="args">()</span> + + </dd></dl></div> + </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false"> + <a id="wait(Long):Unit"></a> + <h4 class="signature"> + <span class="modifier_kind"> + <span class="modifier">final </span> + <span class="kind">def</span> + </span> + <span class="symbol"> + <span class="name">wait</span><span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span> + </span> + </h4> + <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd> + <span class="name">@throws</span><span class="args">()</span> + + </dd></dl></div> + </li></ol> + </div> + + + </div> + + <div id="inheritedMembers"> + <div name="scala.Serializable" class="parent"> + <h3>Inherited from <span name="scala.Serializable" class="extype">Serializable</span></h3> + </div><div name="java.io.Serializable" class="parent"> + <h3>Inherited from <span name="java.io.Serializable" class="extype">Serializable</span></h3> + </div><div name="org.apache.hadoop.mapreduce.HadoopMapReduceUtil" class="parent"> + <h3>Inherited from <a name="org.apache.hadoop.mapreduce.HadoopMapReduceUtil" class="extype" href="../org/apache/hadoop/mapreduce/HadoopMapReduceUtil.html">HadoopMapReduceUtil</a></h3> + </div><div name="spark.Logging" class="parent"> + <h3>Inherited from <a name="spark.Logging" class="extype" href="Logging.html">Logging</a></h3> + </div><div name="scala.AnyRef" class="parent"> + <h3>Inherited from AnyRef</h3> + </div><div name="scala.Any" class="parent"> + <h3>Inherited from <span name="scala.Any" class="extype">Any</span></h3> + </div> + </div> + + </div> + + <div id="tooltip"></div> + + <div id="footer"> </div> + + + </body> + </html>
\ No newline at end of file |