FilteredCartesianRDD

Instance Constructors

new FilteredCartesianRDD(sc: SparkContext, pred: (T, U) ⇒ Boolean, metapred: (V, V) ⇒ Boolean, rdd1: RDD[T], summaryFn1: (Iterator[T]) ⇒ Iterator[V], rdd2: RDD[U], summaryFn2: (Iterator[U]) ⇒ Iterator[V])(implicit arg0: ClassTag[T], arg1: ClassTag[U], arg2: ClassTag[V])

sc
SparkContext
pred
refinement predicate
metapred
filter predicate
rdd1
RDD of elements on the left side of the cartisian join
rdd2
RDD of elements on the right side of the cartisian join

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++(other: RDD[(T, U)]): RDD[(T, U)]

Definition Classes
RDD
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def aggregate[U](zeroValue: U)(seqOp: (U, (T, U)) ⇒ U, combOp: (U, U) ⇒ U)(implicit arg0: ClassTag[U]): U

Definition Classes
RDD
final def asInstanceOf[T0]: T0

Definition Classes
Any
def barrier(): RDDBarrier[(T, U)]

Definition Classes
RDD
Annotations
@Experimental() @Since( "2.4.0" )
def cache(): FilteredCartesianRDD.this.type

Definition Classes
RDD
def cartesian[U](other: RDD[U])(implicit arg0: ClassTag[U]): RDD[((T, U), U)]

Definition Classes
RDD
def checkpoint(): Unit

Definition Classes
RDD
def clearDependencies(): Unit

Definition Classes
FilteredCartesianRDD → RDD
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def coalesce(numPartitions: Int, shuffle: Boolean, partitionCoalescer: Option[PartitionCoalescer])(implicit ord: Ordering[(T, U)]): RDD[(T, U)]

Definition Classes
RDD
def collect[U](f: PartialFunction[(T, U), U])(implicit arg0: ClassTag[U]): RDD[U]

Definition Classes
RDD
def collect(): Array[(T, U)]

Definition Classes
RDD
def compute(split: Partition, context: TaskContext): Iterator[(T, U)]

Definition Classes
FilteredCartesianRDD → RDD
def context: SparkContext

Definition Classes
RDD
def count(): Long

Definition Classes
RDD
def countApprox(timeout: Long, confidence: Double): PartialResult[BoundedDouble]

Definition Classes
RDD
def countApproxDistinct(relativeSD: Double): Long

Definition Classes
RDD
def countApproxDistinct(p: Int, sp: Int): Long

Definition Classes
RDD
def countByValue()(implicit ord: Ordering[(T, U)]): Map[(T, U), Long]

Definition Classes
RDD
def countByValueApprox(timeout: Long, confidence: Double)(implicit ord: Ordering[(T, U)]): PartialResult[Map[(T, U), BoundedDouble]]

Definition Classes
RDD
final def dependencies: Seq[Dependency[_]]

Definition Classes
RDD
def distinct(): RDD[(T, U)]

Definition Classes
RDD
def distinct(numPartitions: Int)(implicit ord: Ordering[(T, U)]): RDD[(T, U)]

Definition Classes
RDD
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def filter(f: ((T, U)) ⇒ Boolean): RDD[(T, U)]

Definition Classes
RDD
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def first(): (T, U)

Definition Classes
RDD
def firstParent[U](implicit arg0: ClassTag[U]): RDD[U]

Attributes
protected[org.apache.spark]
Definition Classes
RDD
def flatMap[U](f: ((T, U)) ⇒ TraversableOnce[U])(implicit arg0: ClassTag[U]): RDD[U]

Definition Classes
RDD
def fold(zeroValue: (T, U))(op: ((T, U), (T, U)) ⇒ (T, U)): (T, U)

Definition Classes
RDD
def foreach(f: ((T, U)) ⇒ Unit): Unit

Definition Classes
RDD
def foreachPartition(f: (Iterator[(T, U)]) ⇒ Unit): Unit

Definition Classes
RDD
def getCheckpointFile: Option[String]

Definition Classes
RDD
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getDependencies: Seq[Dependency[_]]

Definition Classes
FilteredCartesianRDD → RDD
final def getNumPartitions: Int

Definition Classes
RDD
Annotations
@Since( "1.6.0" )
def getOutputDeterministicLevel: DeterministicLevel.Value

Attributes
protected
Definition Classes
RDD
Annotations
@DeveloperApi()
def getPartitions: Array[Partition]

Definition Classes
FilteredCartesianRDD → RDD
def getPreferredLocations(split: Partition): Seq[String]

Definition Classes
FilteredCartesianRDD → RDD
def getStorageLevel: StorageLevel

Definition Classes
RDD
def glom(): RDD[Array[(T, U)]]

Definition Classes
RDD
def groupBy[K](f: ((T, U)) ⇒ K, p: Partitioner)(implicit kt: ClassTag[K], ord: Ordering[K]): RDD[(K, Iterable[(T, U)])]

Definition Classes
RDD
def groupBy[K](f: ((T, U)) ⇒ K, numPartitions: Int)(implicit kt: ClassTag[K]): RDD[(K, Iterable[(T, U)])]

Definition Classes
RDD
def groupBy[K](f: ((T, U)) ⇒ K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[(T, U)])]

Definition Classes
RDD
def hashCode(): Int

Definition Classes
AnyRef → Any
val id: Int

Definition Classes
RDD
def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean

Attributes
protected
Definition Classes
Logging
def initializeLogIfNecessary(isInterpreter: Boolean): Unit

Attributes
protected
Definition Classes
Logging
def intersection(other: RDD[(T, U)], numPartitions: Int): RDD[(T, U)]

Definition Classes
RDD
def intersection(other: RDD[(T, U)], partitioner: Partitioner)(implicit ord: Ordering[(T, U)]): RDD[(T, U)]

Definition Classes
RDD
def intersection(other: RDD[(T, U)]): RDD[(T, U)]

Definition Classes
RDD
lazy val isBarrier_: Boolean

Attributes
protected
Definition Classes
RDD
def isCheckpointed: Boolean

Definition Classes
RDD
def isEmpty(): Boolean

Definition Classes
RDD
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isTraceEnabled(): Boolean

Attributes
protected
Definition Classes
Logging
final def iterator(split: Partition, context: TaskContext): Iterator[(T, U)]

Definition Classes
RDD
def keyBy[K](f: ((T, U)) ⇒ K): RDD[(K, (T, U))]

Definition Classes
RDD
def localCheckpoint(): FilteredCartesianRDD.this.type

Definition Classes
RDD
def log: Logger

Attributes
protected
Definition Classes
Logging
def logDebug(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logDebug(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logError(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logError(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logInfo(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logInfo(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logName: String

Attributes
protected
Definition Classes
Logging
def logTrace(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logTrace(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logWarning(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logWarning(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def map[U](f: ((T, U)) ⇒ U)(implicit arg0: ClassTag[U]): RDD[U]

Definition Classes
RDD
def mapPartitions[U](f: (Iterator[(T, U)]) ⇒ Iterator[U], preservesPartitioning: Boolean)(implicit arg0: ClassTag[U]): RDD[U]

Definition Classes
RDD
def mapPartitionsWithIndex[U](f: (Int, Iterator[(T, U)]) ⇒ Iterator[U], preservesPartitioning: Boolean)(implicit arg0: ClassTag[U]): RDD[U]

Definition Classes
RDD
def max()(implicit ord: Ordering[(T, U)]): (T, U)

Definition Classes
RDD
val metardd1: RDD[V]
val metardd2: RDD[V]
def min()(implicit ord: Ordering[(T, U)]): (T, U)

Definition Classes
RDD
var name: String

Definition Classes
RDD
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val numPartitionsInRdd2: Int
def parent[U](j: Int)(implicit arg0: ClassTag[U]): RDD[U]

Attributes
protected[org.apache.spark]
Definition Classes
RDD
val partitioner: Option[Partitioner]

Definition Classes
RDD
final def partitions: Array[Partition]

Definition Classes
RDD
def persist(): FilteredCartesianRDD.this.type

Definition Classes
RDD
def persist(newLevel: StorageLevel): FilteredCartesianRDD.this.type

Definition Classes
RDD
def pipe(command: Seq[String], env: Map[String, String], printPipeContext: ((String) ⇒ Unit) ⇒ Unit, printRDDElement: ((T, U), (String) ⇒ Unit) ⇒ Unit, separateWorkingDir: Boolean, bufferSize: Int, encoding: String): RDD[String]

Definition Classes
RDD
def pipe(command: String, env: Map[String, String]): RDD[String]

Definition Classes
RDD
def pipe(command: String): RDD[String]

Definition Classes
RDD
final def preferredLocations(split: Partition): Seq[String]

Definition Classes
RDD
def randomSplit(weights: Array[Double], seed: Long): Array[RDD[(T, U)]]

Definition Classes
RDD
var rdd1: RDD[T]

RDD of elements on the left side of the cartisian join
var rdd2: RDD[U]

RDD of elements on the right side of the cartisian join
def reduce(f: ((T, U), (T, U)) ⇒ (T, U)): (T, U)

Definition Classes
RDD
def repartition(numPartitions: Int)(implicit ord: Ordering[(T, U)]): RDD[(T, U)]

Definition Classes
RDD
def sample(withReplacement: Boolean, fraction: Double, seed: Long): RDD[(T, U)]

Definition Classes
RDD
def saveAsObjectFile(path: String): Unit

Definition Classes
RDD
def saveAsTextFile(path: String, codec: Class[_ <: CompressionCodec]): Unit

Definition Classes
RDD
def saveAsTextFile(path: String): Unit

Definition Classes
RDD
def setName(_name: String): FilteredCartesianRDD.this.type

Definition Classes
RDD
def sortBy[K](f: ((T, U)) ⇒ K, ascending: Boolean, numPartitions: Int)(implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[(T, U)]

Definition Classes
RDD
def sparkContext: SparkContext

Definition Classes
RDD
def subtract(other: RDD[(T, U)], p: Partitioner)(implicit ord: Ordering[(T, U)]): RDD[(T, U)]

Definition Classes
RDD
def subtract(other: RDD[(T, U)], numPartitions: Int): RDD[(T, U)]

Definition Classes
RDD
def subtract(other: RDD[(T, U)]): RDD[(T, U)]

Definition Classes
RDD
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def take(num: Int): Array[(T, U)]

Definition Classes
RDD
def takeOrdered(num: Int)(implicit ord: Ordering[(T, U)]): Array[(T, U)]

Definition Classes
RDD
def takeSample(withReplacement: Boolean, num: Int, seed: Long): Array[(T, U)]

Definition Classes
RDD
def toDebugString: String

Definition Classes
RDD
def toJavaRDD(): JavaRDD[(T, U)]

Definition Classes
RDD
def toLocalIterator: Iterator[(T, U)]

Definition Classes
RDD
def toString(): String

Definition Classes
RDD → AnyRef → Any
def top(num: Int)(implicit ord: Ordering[(T, U)]): Array[(T, U)]

Definition Classes
RDD
def treeAggregate[U](zeroValue: U)(seqOp: (U, (T, U)) ⇒ U, combOp: (U, U) ⇒ U, depth: Int)(implicit arg0: ClassTag[U]): U

Definition Classes
RDD
def treeReduce(f: ((T, U), (T, U)) ⇒ (T, U), depth: Int): (T, U)

Definition Classes
RDD
def union(other: RDD[(T, U)]): RDD[(T, U)]

Definition Classes
RDD
def unpersist(blocking: Boolean): FilteredCartesianRDD.this.type

Definition Classes
RDD
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def zip[U](other: RDD[U])(implicit arg0: ClassTag[U]): RDD[((T, U), U)]

Definition Classes
RDD
def zipPartitions[B, C, D, V](rdd2: RDD[B], rdd3: RDD[C], rdd4: RDD[D])(f: (Iterator[(T, U)], Iterator[B], Iterator[C], Iterator[D]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[D], arg3: ClassTag[V]): RDD[V]

Definition Classes
RDD
def zipPartitions[B, C, D, V](rdd2: RDD[B], rdd3: RDD[C], rdd4: RDD[D], preservesPartitioning: Boolean)(f: (Iterator[(T, U)], Iterator[B], Iterator[C], Iterator[D]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[D], arg3: ClassTag[V]): RDD[V]

Definition Classes
RDD
def zipPartitions[B, C, V](rdd2: RDD[B], rdd3: RDD[C])(f: (Iterator[(T, U)], Iterator[B], Iterator[C]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[V]): RDD[V]

Definition Classes
RDD
def zipPartitions[B, C, V](rdd2: RDD[B], rdd3: RDD[C], preservesPartitioning: Boolean)(f: (Iterator[(T, U)], Iterator[B], Iterator[C]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[V]): RDD[V]

Definition Classes
RDD
def zipPartitions[B, V](rdd2: RDD[B])(f: (Iterator[(T, U)], Iterator[B]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[V]): RDD[V]

Definition Classes
RDD
def zipPartitions[B, V](rdd2: RDD[B], preservesPartitioning: Boolean)(f: (Iterator[(T, U)], Iterator[B]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[V]): RDD[V]

Definition Classes
RDD
def zipWithIndex(): RDD[((T, U), Long)]

Definition Classes
RDD
def zipWithUniqueId(): RDD[((T, U), Long)]

Definition Classes
RDD

Related Doc: package rdd

sealed class FilteredCartesianRDD[T, U, V] extends RDD[(T, U)] with Serializable

Instance Constructors

new FilteredCartesianRDD(sc: SparkContext, pred: (T, U) ⇒ Boolean, metapred: (V, V) ⇒ Boolean, rdd1: RDD[T], summaryFn1: (Iterator[T]) ⇒ Iterator[V], rdd2: RDD[U], summaryFn2: (Iterator[U]) ⇒ Iterator[V])(implicit arg0: ClassTag[T], arg1: ClassTag[U], arg2: ClassTag[V])

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(other: RDD[(T, U)]): RDD[(T, U)]

final def ==(arg0: Any): Boolean

def aggregate[U](zeroValue: U)(seqOp: (U, (T, U)) ⇒ U, combOp: (U, U) ⇒ U)(implicit arg0: ClassTag[U]): U

final def asInstanceOf[T0]: T0

def barrier(): RDDBarrier[(T, U)]

def cache(): FilteredCartesianRDD.this.type

def cartesian[U](other: RDD[U])(implicit arg0: ClassTag[U]): RDD[((T, U), U)]

def checkpoint(): Unit

def clearDependencies(): Unit

def clone(): AnyRef

def coalesce(numPartitions: Int, shuffle: Boolean, partitionCoalescer: Option[PartitionCoalescer])(implicit ord: Ordering[(T, U)]): RDD[(T, U)]

def collect[U](f: PartialFunction[(T, U), U])(implicit arg0: ClassTag[U]): RDD[U]

def collect(): Array[(T, U)]

def compute(split: Partition, context: TaskContext): Iterator[(T, U)]

def context: SparkContext

def count(): Long

def countApprox(timeout: Long, confidence: Double): PartialResult[BoundedDouble]

def countApproxDistinct(relativeSD: Double): Long

def countApproxDistinct(p: Int, sp: Int): Long

def countByValue()(implicit ord: Ordering[(T, U)]): Map[(T, U), Long]

def countByValueApprox(timeout: Long, confidence: Double)(implicit ord: Ordering[(T, U)]): PartialResult[Map[(T, U), BoundedDouble]]

final def dependencies: Seq[Dependency[_]]

def distinct(): RDD[(T, U)]

def distinct(numPartitions: Int)(implicit ord: Ordering[(T, U)]): RDD[(T, U)]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(f: ((T, U)) ⇒ Boolean): RDD[(T, U)]

def finalize(): Unit

def first(): (T, U)

def firstParent[U](implicit arg0: ClassTag[U]): RDD[U]

def flatMap[U](f: ((T, U)) ⇒ TraversableOnce[U])(implicit arg0: ClassTag[U]): RDD[U]

def fold(zeroValue: (T, U))(op: ((T, U), (T, U)) ⇒ (T, U)): (T, U)

def foreach(f: ((T, U)) ⇒ Unit): Unit

def foreachPartition(f: (Iterator[(T, U)]) ⇒ Unit): Unit

def getCheckpointFile: Option[String]

final def getClass(): Class[_]

def getDependencies: Seq[Dependency[_]]

final def getNumPartitions: Int

def getOutputDeterministicLevel: DeterministicLevel.Value

def getPartitions: Array[Partition]

def getPreferredLocations(split: Partition): Seq[String]

def getStorageLevel: StorageLevel

def glom(): RDD[Array[(T, U)]]

def groupBy[K](f: ((T, U)) ⇒ K, p: Partitioner)(implicit kt: ClassTag[K], ord: Ordering[K]): RDD[(K, Iterable[(T, U)])]

def groupBy[K](f: ((T, U)) ⇒ K, numPartitions: Int)(implicit kt: ClassTag[K]): RDD[(K, Iterable[(T, U)])]

def groupBy[K](f: ((T, U)) ⇒ K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[(T, U)])]

def hashCode(): Int

val id: Int

def initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean

def initializeLogIfNecessary(isInterpreter: Boolean): Unit

def intersection(other: RDD[(T, U)], numPartitions: Int): RDD[(T, U)]

def intersection(other: RDD[(T, U)], partitioner: Partitioner)(implicit ord: Ordering[(T, U)]): RDD[(T, U)]

def intersection(other: RDD[(T, U)]): RDD[(T, U)]

lazy val isBarrier_: Boolean

def isCheckpointed: Boolean

def isEmpty(): Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

final def iterator(split: Partition, context: TaskContext): Iterator[(T, U)]

def keyBy[K](f: ((T, U)) ⇒ K): RDD[(K, (T, U))]

def localCheckpoint(): FilteredCartesianRDD.this.type

def log: Logger

def logDebug(msg: ⇒ String, throwable: Throwable): Unit

def logDebug(msg: ⇒ String): Unit

def logError(msg: ⇒ String, throwable: Throwable): Unit

def logError(msg: ⇒ String): Unit

def logInfo(msg: ⇒ String, throwable: Throwable): Unit

def logInfo(msg: ⇒ String): Unit

def logName: String

def logTrace(msg: ⇒ String, throwable: Throwable): Unit

def logTrace(msg: ⇒ String): Unit

def logWarning(msg: ⇒ String, throwable: Throwable): Unit