org.apache

spark

package spark

Core Spark functionality. org.apache.spark.SparkContext serves as the main entry point to Spark, while org.apache.spark.rdd.RDD is the data type representing a distributed collection, and provides most parallel operations.

In addition, org.apache.spark.rdd.PairRDDFunctions contains operations available only on RDDs of key-value pairs, such as groupByKey and join; org.apache.spark.rdd.DoubleRDDFunctions contains operations available only on RDDs of Doubles; and org.apache.spark.rdd.SequenceFileRDDFunctions contains operations available on RDDs that can be saved as SequenceFiles. These operations are automatically available on any RDD of the right type (e.g. RDD[(Int, Int)] through implicit conversions.

Java programmers should reference the org.apache.spark.api.java package for Spark programming APIs in Java.

Classes and methods marked with Experimental are user-facing features which have not been officially adopted by the Spark project. These are subject to change or removal in minor releases.

Classes and methods marked with Developer API are intended for advanced users want to extend Spark through lower level interfaces. These are subject to changes or removal in minor releases.

Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By inheritance
Inherited
  1. spark
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. class Accumulable[R, T] extends Serializable

    A data type that can be accumulated, ie has an commutative and associative "add" operation, but where the result type, R, may be different from the element type being added, T.

    A data type that can be accumulated, ie has an commutative and associative "add" operation, but where the result type, R, may be different from the element type being added, T.

    You must define how to add data, and how to merge two of these together. For some data types, such as a counter, these might be the same operation. In that case, you can use the simpler org.apache.spark.Accumulator. They won't always be the same, though -- e.g., imagine you are accumulating a set. You will add items to the set, and you will union two sets together.

    R

    the full accumulated data (result type)

    T

    partial data that can be added in

  2. trait AccumulableParam[R, T] extends Serializable

    Helper object defining how to accumulate values of a particular type.

    Helper object defining how to accumulate values of a particular type. An implicit AccumulableParam needs to be available when you create Accumulables of a specific type.

    R

    the full accumulated data (result type)

    T

    partial data that can be added in

  3. class Accumulator[T] extends Accumulable[T, T]

    A simpler value of Accumulable where the result type being accumulated is the same as the types of elements being merged, i.e.

    A simpler value of Accumulable where the result type being accumulated is the same as the types of elements being merged, i.e. variables that are only "added" to through an associative operation and can therefore be efficiently supported in parallel. They can be used to implement counters (as in MapReduce) or sums. Spark natively supports accumulators of numeric value types, and programmers can add support for new types.

    An accumulator is created from an initial value v by calling SparkContext#accumulator. Tasks running on the cluster can then add to it using the Accumulable#+= operator. However, they cannot read its value. Only the driver program can read the accumulator's value, using its value method.

    The interpreter session below shows an accumulator being used to add up the elements of an array:

    scala> val accum = sc.accumulator(0)
    accum: spark.Accumulator[Int] = 0
    
    scala> sc.parallelize(Array(1, 2, 3, 4)).foreach(x => accum += x)
    ...
    10/09/29 18:41:08 INFO SparkContext: Tasks finished in 0.317106 s
    
    scala> accum.value
    res2: Int = 10
    T

    result type

  4. trait AccumulatorParam[T] extends AccumulableParam[T, T]

    A simpler version of org.apache.spark.AccumulableParam where the only data type you can add in is the same type as the accumulated value.

    A simpler version of org.apache.spark.AccumulableParam where the only data type you can add in is the same type as the accumulated value. An implicit AccumulatorParam object needs to be available when you create Accumulators of a specific type.

    T

    type of value to accumulate

  5. case class Aggregator[K, V, C](createCombiner: (V) ⇒ C, mergeValue: (C, V) ⇒ C, mergeCombiners: (C, C) ⇒ C) extends Product with Serializable

    :: DeveloperApi :: A set of functions used to aggregate data.

    :: DeveloperApi :: A set of functions used to aggregate data.

    createCombiner

    function to create the initial value of the aggregation.

    mergeValue

    function to merge a new value into the aggregation result.

    mergeCombiners

    function to merge outputs from multiple mergeValue function.

    Annotations
    @DeveloperApi()
  6. class ComplexFutureAction[T] extends FutureAction[T]

    A FutureAction for actions that could trigger multiple Spark jobs.

    A FutureAction for actions that could trigger multiple Spark jobs. Examples include take, takeSample. Cancellation works by setting the cancelled flag to true and interrupting the action thread if it is being blocked by a job.

  7. abstract class Dependency[T] extends Serializable

    :: DeveloperApi :: Base class for dependencies.

    :: DeveloperApi :: Base class for dependencies.

    Annotations
    @DeveloperApi()
  8. case class ExceptionFailure(className: String, description: String, stackTrace: Array[StackTraceElement], fullStackTrace: String, metrics: Option[TaskMetrics]) extends TaskFailedReason with Product with Serializable

    :: DeveloperApi :: Task failed due to a runtime exception.

    :: DeveloperApi :: Task failed due to a runtime exception. This is the most common failure case and also captures user program exceptions.

    stackTrace contains the stack trace of the exception itself. It still exists for backward compatibility. It's better to use this(e: Throwable, metrics: Option[TaskMetrics]) to create ExceptionFailure as it will handle the backward compatibility properly.

    fullStackTrace is a better representation of the stack trace because it contains the whole stack trace including the exception and its causes

    Annotations
    @DeveloperApi()
  9. case class ExecutorLostFailure(execId: String) extends TaskFailedReason with Product with Serializable

    :: DeveloperApi :: The task failed because the executor that it was running on was lost.

    :: DeveloperApi :: The task failed because the executor that it was running on was lost. This may happen because the task crashed the JVM.

    Annotations
    @DeveloperApi()
  10. case class FetchFailed(bmAddress: BlockManagerId, shuffleId: Int, mapId: Int, reduceId: Int, message: String) extends TaskFailedReason with Product with Serializable

    :: DeveloperApi :: Task failed to fetch shuffle data from a remote node.

    :: DeveloperApi :: Task failed to fetch shuffle data from a remote node. Probably means we have lost the remote executors the task is trying to fetch from, and thus need to rerun the previous stage.

    Annotations
    @DeveloperApi()
  11. trait FutureAction[T] extends Future[T]

    A future for the result of an action to support cancellation.

    A future for the result of an action to support cancellation. This is an extension of the Scala Future interface to support cancellation.

  12. class HashPartitioner extends Partitioner

    A org.apache.spark.Partitioner that implements hash-based partitioning using Java's Object.hashCode.

    A org.apache.spark.Partitioner that implements hash-based partitioning using Java's Object.hashCode.

    Java arrays have hashCodes that are based on the arrays' identities rather than their contents, so attempting to partition an RDD[Array[_]] or RDD[(Array[_], _)] using a HashPartitioner will produce an unexpected or incorrect result.

  13. class InterruptibleIterator[+T] extends Iterator[T]

    :: DeveloperApi :: An iterator that wraps around an existing iterator to provide task killing functionality.

    :: DeveloperApi :: An iterator that wraps around an existing iterator to provide task killing functionality. It works by checking the interrupted flag in TaskContext.

    Annotations
    @DeveloperApi()
  14. class JavaSparkListener extends SparkListener

  15. class JobExecutionStatus extends Enum[JobExecutionStatus]

  16. trait Logging extends AnyRef

    :: DeveloperApi :: Utility trait for classes that want to log data.

    :: DeveloperApi :: Utility trait for classes that want to log data. Creates a SLF4J logger for the class and allows logging messages at different levels using methods that only evaluate parameters lazily if the log level is enabled.

    NOTE: DO NOT USE this class outside of Spark. It is intended as an internal utility. This will likely be changed or removed in future releases.

    Annotations
    @DeveloperApi()
  17. abstract class NarrowDependency[T] extends Dependency[T]

    :: DeveloperApi :: Base class for dependencies where each partition of the child RDD depends on a small number of partitions of the parent RDD.

    :: DeveloperApi :: Base class for dependencies where each partition of the child RDD depends on a small number of partitions of the parent RDD. Narrow dependencies allow for pipelined execution.

    Annotations
    @DeveloperApi()
  18. class OneToOneDependency[T] extends NarrowDependency[T]

    :: DeveloperApi :: Represents a one-to-one dependency between partitions of the parent and child RDDs.

    :: DeveloperApi :: Represents a one-to-one dependency between partitions of the parent and child RDDs.

    Annotations
    @DeveloperApi()
  19. trait Partition extends Serializable

    An identifier for a partition in an RDD.

  20. abstract class Partitioner extends Serializable

    An object that defines how the elements in a key-value pair RDD are partitioned by key.

    An object that defines how the elements in a key-value pair RDD are partitioned by key. Maps each key to a partition ID, from 0 to numPartitions - 1.

  21. class RangeDependency[T] extends NarrowDependency[T]

    :: DeveloperApi :: Represents a one-to-one dependency between ranges of partitions in the parent and child RDDs.

    :: DeveloperApi :: Represents a one-to-one dependency between ranges of partitions in the parent and child RDDs.

    Annotations
    @DeveloperApi()
  22. class RangePartitioner[K, V] extends Partitioner

    A org.apache.spark.Partitioner that partitions sortable records by range into roughly equal ranges.

    A org.apache.spark.Partitioner that partitions sortable records by range into roughly equal ranges. The ranges are determined by sampling the content of the RDD passed in.

    Note that the actual number of partitions created by the RangePartitioner might not be the same as the partitions parameter, in the case where the number of sampled records is less than the value of partitions.

  23. class SerializableWritable[T <: Writable] extends Serializable

    Annotations
    @DeveloperApi()
  24. class ShuffleDependency[K, V, C] extends Dependency[Product2[K, V]]

    :: DeveloperApi :: Represents a dependency on the output of a shuffle stage.

    :: DeveloperApi :: Represents a dependency on the output of a shuffle stage. Note that in the case of shuffle, the RDD is transient since we don't need it on the executor side.

    Annotations
    @DeveloperApi()
  25. class SimpleFutureAction[T] extends FutureAction[T]

    A FutureAction holding the result of an action that triggers a single job.

    A FutureAction holding the result of an action that triggers a single job. Examples include count, collect, reduce.

  26. class SparkConf extends Cloneable with Logging

    Configuration for a Spark application.

    Configuration for a Spark application. Used to set various Spark parameters as key-value pairs.

    Most of the time, you would create a SparkConf object with new SparkConf(), which will load values from any spark.* Java system properties set in your application as well. In this case, parameters you set directly on the SparkConf object take priority over system properties.

    For unit tests, you can also call new SparkConf(false) to skip loading external settings and get the same configuration no matter what the system properties are.

    All setter methods in this class support chaining. For example, you can write new SparkConf().setMaster("local").setAppName("My app").

    Note that once a SparkConf object is passed to Spark, it is cloned and can no longer be modified by the user. Spark does not support modifying the configuration at runtime.

  27. class SparkContext extends Logging with ExecutorAllocationClient

    Main entry point for Spark functionality.

    Main entry point for Spark functionality. A SparkContext represents the connection to a Spark cluster, and can be used to create RDDs, accumulators and broadcast variables on that cluster.

    Only one SparkContext may be active per JVM. You must stop() the active SparkContext before creating a new one. This limitation may eventually be removed; see SPARK-2243 for more details.

  28. class SparkEnv extends Logging

    :: DeveloperApi :: Holds all the runtime environment objects for a running Spark instance (either master or worker), including the serializer, Akka actor system, block manager, map output tracker, etc.

    :: DeveloperApi :: Holds all the runtime environment objects for a running Spark instance (either master or worker), including the serializer, Akka actor system, block manager, map output tracker, etc. Currently Spark code finds the SparkEnv through a global variable, so all the threads can access the same SparkEnv. It can be accessed by SparkEnv.get (e.g. after creating a SparkContext).

    NOTE: This is not intended for external use. This is exposed for Shark and may be made private in a future release.

    Annotations
    @DeveloperApi()
  29. class SparkException extends Exception

  30. class SparkFirehoseListener extends SparkListener

  31. trait SparkJobInfo extends Serializable

  32. trait SparkStageInfo extends Serializable

  33. class SparkStatusTracker extends AnyRef

    Low-level status reporting APIs for monitoring job and stage progress.

    Low-level status reporting APIs for monitoring job and stage progress.

    These APIs intentionally provide very weak consistency semantics; consumers of these APIs should be prepared to handle empty / missing information. For example, a job's stage ids may be known but the status API may not have any information about the details of those stages, so getStageInfo could potentially return None for a valid stage id.

    To limit memory usage, these APIs only provide information on recent jobs / stages. These APIs will provide information for the last spark.ui.retainedStages stages and spark.ui.retainedJobs jobs.

    NOTE: this class's constructor should be considered private and may be subject to change.

  34. case class TaskCommitDenied(jobID: Int, partitionID: Int, attemptID: Int) extends TaskFailedReason with Product with Serializable

    :: DeveloperApi :: Task requested the driver to commit, but was denied.

    :: DeveloperApi :: Task requested the driver to commit, but was denied.

    Annotations
    @DeveloperApi()
  35. abstract class TaskContext extends Serializable

    Contextual information about a task which can be read or mutated during execution.

    Contextual information about a task which can be read or mutated during execution. To access the TaskContext for a running task, use:

    org.apache.spark.TaskContext.get()
  36. sealed trait TaskEndReason extends AnyRef

    :: DeveloperApi :: Various possible reasons why a task ended.

    :: DeveloperApi :: Various possible reasons why a task ended. The low-level TaskScheduler is supposed to retry tasks several times for "ephemeral" failures, and only report back failures that require some old stages to be resubmitted, such as shuffle map fetch failures.

    Annotations
    @DeveloperApi()
  37. sealed trait TaskFailedReason extends TaskEndReason

    :: DeveloperApi :: Various possible reasons why a task failed.

    :: DeveloperApi :: Various possible reasons why a task failed.

    Annotations
    @DeveloperApi()
  38. class TaskKilledException extends RuntimeException

    :: DeveloperApi :: Exception thrown when a task is explicitly killed (i.e., task failure is expected).

    :: DeveloperApi :: Exception thrown when a task is explicitly killed (i.e., task failure is expected).

    Annotations
    @DeveloperApi()

Value Members

  1. object AccumulatorParam extends Serializable

  2. object HeartbeatReceiver

  3. object Partitioner extends Serializable

  4. object Resubmitted extends TaskFailedReason with Product with Serializable

    :: DeveloperApi :: A org.apache.spark.scheduler.ShuffleMapTask that completed successfully earlier, but we lost the executor before the stage completed.

    :: DeveloperApi :: A org.apache.spark.scheduler.ShuffleMapTask that completed successfully earlier, but we lost the executor before the stage completed. This means Spark needs to reschedule the task to be re-executed on a different executor.

    Annotations
    @DeveloperApi()
  5. val SPARK_VERSION: String

  6. object SparkContext extends Logging

    The SparkContext object contains a number of implicit conversions and parameters for use with various Spark features.

  7. object SparkEnv extends Logging

  8. object SparkFiles

    Resolves paths to files added through SparkContext.addFile().

  9. object Success extends TaskEndReason with Product with Serializable

    :: DeveloperApi :: Task succeeded.

    :: DeveloperApi :: Task succeeded.

    Annotations
    @DeveloperApi()
  10. object TaskContext extends Serializable

  11. object TaskKilled extends TaskFailedReason with Product with Serializable

    :: DeveloperApi :: Task was killed intentionally and needs to be rescheduled.

    :: DeveloperApi :: Task was killed intentionally and needs to be rescheduled.

    Annotations
    @DeveloperApi()
  12. object TaskResultLost extends TaskFailedReason with Product with Serializable

    :: DeveloperApi :: The task finished successfully, but the result was lost from the executor's block manager before it was fetched.

    :: DeveloperApi :: The task finished successfully, but the result was lost from the executor's block manager before it was fetched.

    Annotations
    @DeveloperApi()
  13. object UnknownReason extends TaskFailedReason with Product with Serializable

    :: DeveloperApi :: We don't know why the task ended -- for example, because of a ClassNotFound exception when deserializing the task result.

    :: DeveloperApi :: We don't know why the task ended -- for example, because of a ClassNotFound exception when deserializing the task result.

    Annotations
    @DeveloperApi()
  14. object WritableConverter extends Serializable

  15. object WritableFactory extends Serializable

  16. package annotation

    Spark annotations to mark an API experimental or intended only for advanced usages by developers.

    Spark annotations to mark an API experimental or intended only for advanced usages by developers. This package consist of these annotations, which are used project wide and are reflected in Scala and Java docs.

  17. package api

  18. package broadcast

    Spark's broadcast variables, used to broadcast immutable datasets to all nodes.

  19. package deploy

  20. package executor

    Executor components used with various cluster managers.

    Executor components used with various cluster managers. See org.apache.spark.executor.Executor.

  21. package input

  22. package io

    IO codecs used for compression.

    IO codecs used for compression. See org.apache.spark.io.CompressionCodec.

  23. package mapred

  24. package network

  25. package partial

    :: Experimental ::

    :: Experimental ::

    Support for approximate results. This provides convenient api and also implementation for approximate calculation.

    See also

    org.apache.spark.rdd.RDD.countApprox

  26. package rdd

    Provides several RDD implementations.

    Provides several RDD implementations. See org.apache.spark.rdd.RDD.

  27. package scheduler

    Spark's scheduling components.

    Spark's scheduling components. This includes the org.apache.spark.scheduler.DAGScheduler and lower level org.apache.spark.scheduler.TaskScheduler.

  28. package serializer

    Pluggable serializers for RDD and shuffle data.

    Pluggable serializers for RDD and shuffle data.

    See also

    org.apache.spark.serializer.Serializer

  29. package shuffle

  30. package status

  31. package storage

  32. package ui

  33. package util

    Spark utilities.

Inherited from AnyRef

Inherited from Any

Ungrouped