SourceFrame

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(other: Frame): Frame

Joins two frames together, such that the elements of the given frame are appended to the end of this frame.

final def ==(arg0: Any): Boolean

def addField(field: Field, defaultValue: Any): Frame

Returns a new Frame with the given field added at the end.

def addField(name: String, defaultValue: Any): Frame

Returns a new Frame with the new field of type String added at the end.

def addFieldIfNotExists(field: Field, defaultValue: Any): Frame

def addFieldIfNotExists(name: String, defaultValue: Any): Frame

def aggregated(): GroupedFrame

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collect(): Vector[Row]

def count(): Long

def drop(k: Int): Frame

def dropNullRows(): Frame

def dropWhile(fieldName: String, pred: (Any) ⇒ Boolean): Frame

def dropWhile(pred: (Row) ⇒ Boolean): Frame

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def exists(p: (Row) ⇒ Boolean): Boolean

def explode(fn: (Row) ⇒ Seq[Row]): Frame

def filter(fieldName: String, p: (Any) ⇒ Boolean): Frame

Filters where the given field name matches the given predicate.

def filter(p: (Row) ⇒ Boolean): Frame

def filterNot(p: (Row) ⇒ Boolean): Frame

def finalize(): Unit

def find(p: (Row) ⇒ Boolean): Option[Row]

def fold[A](initial: A)(fn: (A, Row) ⇒ A): A

def forall(p: (Row) ⇒ Boolean): Boolean

def foreach[U](fn: (Row) ⇒ U): Frame

Execute a side effecting function for every row in the frame, returning the same row.

final def getClass(): Class[_]

def groupBy(fn: (Row) ⇒ Any): GroupedFrame

def groupBy(fields: Iterable[String]): GroupedFrame

def groupBy(first: String, rest: String*): GroupedFrame

def hashCode(): Int

def head(): Row

final def isInstanceOf[T0]: Boolean

def join(other: Frame): Frame

Combines two frames together such that the fields from this frame are joined with the fields of the given frame.

def listener(listener: Listener): Frame

val logger: Logger

def map(f: (Row) ⇒ Row): Frame

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def projection(fields: Seq[String]): Frame

Returns a new frame which contains the given list of fields from the existing frame.

def projection(first: String, rest: String*): Frame

def projectionExpression(expr: String): Frame

def removeField(fieldName: String, caseSensitive: Boolean = true): Frame

def renameField(nameFrom: String, nameTo: String): Frame

def replace(fieldName: String, fn: (Any) ⇒ Any): Frame

For each row, the value corresponding to the given fieldName is applied to the function.

def replace(fieldName: String, from: String, target: Any): Frame

Replaces any values that match "form" with the value "target".

def replace(from: String, target: Any): Frame

Foreach row, any values that match "from" will be replaced with "target".

def replaceFieldType(from: DataType, toType: DataType): Frame

def replaceNullValues(defaultValue: String): Frame

def rows(): CloseableIterator[Row]

def sample(k: Int): Frame

Returns a new Frame where only each "k" row is retained.

def save(sink: Sink, listener: Listener = NoopListener): Long

lazy val schema: StructType

def size(): Long

def stripCharsFromFieldNames(chars: Seq[Char]): Frame

Returns a new Frame with the same data as this frame, but where the field names have been sanitized by removing any occurances of the given characters.

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

def take(n: Int): Frame

def takeWhile(fieldName: String, pred: (Any) ⇒ Boolean): Frame

def takeWhile(pred: (Row) ⇒ Boolean): Frame

def to(sink: Sink, listener: Listener = NoopListener): Long

def toSeq(): Seq[Row]

def toSet(): Set[Row]

def toString(): String

def toVector(): Vector[Row]

def union(other: Frame): Frame

def updateField(field: Field): Frame

def updateFieldType(fieldName: String, fieldType: DataType): Frame

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withLowerCaseSchema(): Frame

Returns a new Frame where the schema has been lowercased.

def toList(): List[Row]