spark

Type Members

1. 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()

2. class BarrierTaskContext extends TaskContext with Logging

   

   :: Experimental :: A TaskContext with extra contextual info and tooling for tasks in a barrier stage.

   :: Experimental :: A TaskContext with extra contextual info and tooling for tasks in a barrier stage. Use BarrierTaskContext#get to obtain the barrier context for a running barrier task.

   Annotations

   @Experimental() @Since( "2.4.0" )

3. class BarrierTaskInfo extends AnyRef

   

   :: Experimental :: Carries all task infos of a barrier task.

   :: Experimental :: Carries all task infos of a barrier task.

   Annotations

   @Experimental() @Since( "2.4.0" )

4. 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 cancelling any pending jobs.

   Annotations

   @DeveloperApi()

5. abstract class Dependency[T] extends Serializable

   

   :: DeveloperApi :: Base class for dependencies.

   :: DeveloperApi :: Base class for dependencies.

   Annotations

   @DeveloperApi()

6. case class ExceptionFailure(className: String, description: String, stackTrace: Array[StackTraceElement], fullStackTrace: String, exceptionWrapper: Option[ThrowableSerializationWrapper], accumUpdates: Seq[AccumulableInfo] = Seq.empty, accums: Seq[AccumulatorV2[_, _]] = Nil) 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

   exception is the actual exception that caused the task to fail. It may be None in the case that the exception is not in fact serializable. If a task fails more than once (due to retries), exception is that one that caused the last failure.

   Annotations

   @DeveloperApi()

7. case class ExecutorLostFailure(execId: String, exitCausedByApp: Boolean = true, reason: Option[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()

8. trait ExecutorPlugin extends AnyRef

   

9. 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()

10. 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.

11. 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.

12. 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()

13. final class JobExecutionStatus extends Enum[JobExecutionStatus]

    

14. trait JobSubmitter extends AnyRef

    

    Handle via which a "run" function passed to a ComplexFutureAction can submit jobs for execution.

    Handle via which a "run" function passed to a ComplexFutureAction can submit jobs for execution.

    Annotations

    @DeveloperApi()

15. 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()

16. 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()

17. trait Partition extends Serializable

    

    An identifier for a partition in an RDD.

18. 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.

    Note that, partitioner must be deterministic, i.e. it must return the same partition id given the same partition key.

19. 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()

20. 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

    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.

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

    

    Annotations

    @DeveloperApi()

22. 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()

23. 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.

    Annotations

    @DeveloperApi()

24. class SparkConf extends Cloneable with Logging with Serializable

    

    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

    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.

25. class SparkContext extends Logging

    

    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.

26. class SparkEnv extends Logging

    

    :: DeveloperApi :: Holds all the runtime environment objects for a running Spark instance (either master or worker), including the serializer, RpcEnv, 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, RpcEnv, 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()

27. class SparkException extends Exception

    

28. trait SparkExecutorInfo extends Serializable

    

29. class SparkFirehoseListener extends SparkListenerInterface

    

30. trait SparkJobInfo extends Serializable

    

31. trait SparkStageInfo extends Serializable

    

32. 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.

33. case class TaskCommitDenied(jobID: Int, partitionID: Int, attemptNumber: 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()

34. 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()

35. 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()

36. sealed trait TaskFailedReason extends TaskEndReason

    

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

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

    Annotations

    @DeveloperApi()

37. case class TaskKilled(reason: String, accumUpdates: Seq[AccumulableInfo] = Seq.empty, accums: Seq[AccumulatorV2[_, _]] = Nil) 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()

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()

39. class Accumulable[R, T] extends Serializable

    

    A data type that can be accumulated, i.e.

    A data type that can be accumulated, i.e. has a 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.

    Operations are not thread-safe.

    R

    the full accumulated data (result type)

    T

    partial data that can be added in

    Annotations

    @deprecated

    Deprecated

    (Since version 2.0.0) use AccumulatorV2

40. 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

    Annotations

    @deprecated

    Deprecated

    (Since version 2.0.0) use AccumulatorV2

41. 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 and commutative 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 += 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: org.apache.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

    Annotations

    @deprecated

    Deprecated

    (Since version 2.0.0) use AccumulatorV2

42. 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

    Annotations

    @deprecated

    Deprecated

    (Since version 2.0.0) use AccumulatorV2