Aggregate

Instance Constructors

new Aggregate(partial: Boolean, groupingExpressions: Seq[Expression], aggregateExpressions: Seq[NamedExpression], child: SparkPlan)(sc: SparkContext)

partial
if true then aggregation is done partially on local data without shuffling to ensure all values where groupingExpressions are equal are present.
groupingExpressions
expressions that are evaluated to determine grouping.
aggregateExpressions
expressions that are computed for each group.
child
the input data source.

Type Members

case class ComputedAggregate(unbound: AggregateExpression, aggregate: AggregateExpression, resultAttribute: AttributeReference) extends Product with Serializable

An aggregate that needs to be computed for each row in a group.

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

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

Definition Classes
Any
val aggregateExpressions: Seq[NamedExpression]

expressions that are computed for each group.
def apply(number: Int): SparkPlan

Definition Classes
TreeNode
def argString: String

Definition Classes
TreeNode
def asCode: String

Definition Classes
TreeNode
final def asInstanceOf[T0]: T0

Definition Classes
Any
def buildRow(values: Seq[Any]): Row

Attributes
protected
Definition Classes
SparkPlan
val child: SparkPlan

the input data source.
the input data source.

Definition Classes
Aggregate → UnaryNode
def children: List[SparkPlan]

Definition Classes
UnaryNode
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B](pf: PartialFunction[SparkPlan, B]): Seq[B]

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

Definition Classes
AnyRef
def execute(): RDD[catalyst.expressions.Row]

Runs this query returning the result as an RDD.
Runs this query returning the result as an RDD.

Definition Classes
Aggregate → SparkPlan
def executeCollect(): Array[Row]

Runs this query returning the result as an array.
Runs this query returning the result as an array.

Definition Classes
SparkPlan
def expressions: Seq[Expression]

Definition Classes
QueryPlan
def fastEquals(other: TreeNode[_]): Boolean

Definition Classes
TreeNode
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap[A](f: (SparkPlan) ⇒ TraversableOnce[A]): Seq[A]

Definition Classes
TreeNode
def foreach(f: (SparkPlan) ⇒ Unit): Unit

Definition Classes
TreeNode
def generateTreeString(depth: Int, builder: StringBuilder): StringBuilder

Attributes
protected
Definition Classes
TreeNode
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getNodeNumbered(number: MutableInt): SparkPlan

Attributes
protected
Definition Classes
TreeNode
val groupingExpressions: Seq[Expression]

expressions that are evaluated to determine grouping.
val id: Long

Definition Classes
TreeNode
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val logger: Logger

Attributes
protected
Definition Classes
Logging
def makeCopy(newArgs: Array[AnyRef]): Aggregate.this.type

Definition Classes
TreeNode
def map[A](f: (SparkPlan) ⇒ A): Seq[A]

Definition Classes
TreeNode
def mapChildren(f: (SparkPlan) ⇒ SparkPlan): Aggregate.this.type

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

Definition Classes
AnyRef
def nodeName: String

Definition Classes
TreeNode
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def numberedTreeString: String

Definition Classes
TreeNode
def otherCopyArgs: List[SparkContext]

Definition Classes
Aggregate → TreeNode
def output: Seq[Attribute]

Definition Classes
Aggregate → QueryPlan
def outputPartitioning: Partitioning

Specifies how data is partitioned across different nodes in the cluster.
Specifies how data is partitioned across different nodes in the cluster.

Definition Classes
UnaryNode → SparkPlan
def outputSet: Set[Attribute]

Definition Classes
QueryPlan
val partial: Boolean

if true then aggregation is done partially on local data without shuffling to ensure all values where groupingExpressions are equal are present.
def requiredChildDistribution: Seq[Distribution]

Specifies any partition requirements on the input data for this operator.
Specifies any partition requirements on the input data for this operator.

Definition Classes
Aggregate → SparkPlan
def sameInstance(other: TreeNode[_]): Boolean

Definition Classes
TreeNode
def simpleString: String

Definition Classes
TreeNode
def stringArgs: Iterator[Any]

Attributes
protected
Definition Classes
TreeNode
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
TreeNode → AnyRef → Any
def transform(rule: PartialFunction[SparkPlan, SparkPlan]): SparkPlan

Definition Classes
TreeNode
def transformAllExpressions(rule: PartialFunction[Expression, Expression]): Aggregate.this.type

Definition Classes
QueryPlan
def transformChildrenDown(rule: PartialFunction[SparkPlan, SparkPlan]): Aggregate.this.type

Definition Classes
TreeNode
def transformChildrenUp(rule: PartialFunction[SparkPlan, SparkPlan]): Aggregate.this.type

Definition Classes
TreeNode
def transformDown(rule: PartialFunction[SparkPlan, SparkPlan]): SparkPlan

Definition Classes
TreeNode
def transformExpressions(rule: PartialFunction[Expression, Expression]): Aggregate.this.type

Definition Classes
QueryPlan
def transformExpressionsDown(rule: PartialFunction[Expression, Expression]): Aggregate.this.type

Definition Classes
QueryPlan
def transformExpressionsUp(rule: PartialFunction[Expression, Expression]): Aggregate.this.type

Definition Classes
QueryPlan
def transformUp(rule: PartialFunction[SparkPlan, SparkPlan]): SparkPlan

Definition Classes
TreeNode
def treeString: String

Definition Classes
TreeNode
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 withNewChildren(newChildren: Seq[SparkPlan]): Aggregate.this.type

Definition Classes
TreeNode

case class Aggregate(partial: Boolean, groupingExpressions: Seq[Expression], aggregateExpressions: Seq[NamedExpression], child: SparkPlan)(sc: SparkContext) extends SparkPlan with UnaryNode with NoBind with Product with Serializable

Instance Constructors

new Aggregate(partial: Boolean, groupingExpressions: Seq[Expression], aggregateExpressions: Seq[NamedExpression], child: SparkPlan)(sc: SparkContext)

Type Members

case class ComputedAggregate(unbound: AggregateExpression, aggregate: AggregateExpression, resultAttribute: AttributeReference) extends Product with Serializable

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val aggregateExpressions: Seq[NamedExpression]

def apply(number: Int): SparkPlan

def argString: String

def asCode: String

final def asInstanceOf[T0]: T0

def buildRow(values: Seq[Any]): Row

val child: SparkPlan

def children: List[SparkPlan]

def clone(): AnyRef

def collect[B](pf: PartialFunction[SparkPlan, B]): Seq[B]

final def eq(arg0: AnyRef): Boolean

def execute(): RDD[catalyst.expressions.Row]

def executeCollect(): Array[Row]

def expressions: Seq[Expression]

def fastEquals(other: TreeNode[_]): Boolean

def finalize(): Unit

def flatMap[A](f: (SparkPlan) ⇒ TraversableOnce[A]): Seq[A]

def foreach(f: (SparkPlan) ⇒ Unit): Unit

def generateTreeString(depth: Int, builder: StringBuilder): StringBuilder

final def getClass(): Class[_]

def getNodeNumbered(number: MutableInt): SparkPlan

val groupingExpressions: Seq[Expression]

val id: Long

final def isInstanceOf[T0]: Boolean

lazy val logger: Logger

def makeCopy(newArgs: Array[AnyRef]): Aggregate.this.type

def map[A](f: (SparkPlan) ⇒ A): Seq[A]

def mapChildren(f: (SparkPlan) ⇒ SparkPlan): Aggregate.this.type

final def ne(arg0: AnyRef): Boolean

def nodeName: String

final def notify(): Unit

final def notifyAll(): Unit

def numberedTreeString: String

def otherCopyArgs: List[SparkContext]

def output: Seq[Attribute]

def outputPartitioning: Partitioning

def outputSet: Set[Attribute]

val partial: Boolean

def requiredChildDistribution: Seq[Distribution]

def sameInstance(other: TreeNode[_]): Boolean

def simpleString: String

def stringArgs: Iterator[Any]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def transform(rule: PartialFunction[SparkPlan, SparkPlan]): SparkPlan

def transformAllExpressions(rule: PartialFunction[Expression, Expression]): Aggregate.this.type

def transformChildrenDown(rule: PartialFunction[SparkPlan, SparkPlan]): Aggregate.this.type

def transformChildrenUp(rule: PartialFunction[SparkPlan, SparkPlan]): Aggregate.this.type

def transformDown(rule: PartialFunction[SparkPlan, SparkPlan]): SparkPlan

def transformExpressions(rule: PartialFunction[Expression, Expression]): Aggregate.this.type

def transformExpressionsDown(rule: PartialFunction[Expression, Expression]): Aggregate.this.type

def transformExpressionsUp(rule: PartialFunction[Expression, Expression]): Aggregate.this.type

def transformUp(rule: PartialFunction[SparkPlan, SparkPlan]): SparkPlan

def treeString: String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withNewChildren(newChildren: Seq[SparkPlan]): Aggregate.this.type

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from NoBind

Inherited from UnaryNode

Inherited from catalyst.trees.UnaryNode[SparkPlan]

Inherited from SparkPlan

Inherited from com.typesafe.scalalogging.slf4j.Logging

Inherited from QueryPlan[SparkPlan]