CachedDataFrame

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def agg(expr: Column, exprs: Column*): DataFrame

def agg(exprs: Map[String, String]): DataFrame

def agg(exprs: Map[String, String]): DataFrame

def agg(aggExpr: (String, String), aggExprs: (String, String)*): DataFrame

def alias(alias: Symbol): Dataset[Row]

def alias(alias: String): Dataset[Row]

val allLiterals: Array[LiteralValue]

val allbcplans: Map[SparkPlan, ArrayBuffer[Any]]

def apply(colName: String): Column

def as(alias: Symbol): Dataset[Row]

def as(alias: String): Dataset[Row]

def as[U](implicit arg0: Encoder[U]): Dataset[U]

final def asInstanceOf[T0]: T0

def cache(): CachedDataFrame.this.type

def checkpoint(eager: Boolean): Dataset[Row]

def checkpoint(): Dataset[Row]

def clone(): AnyRef

def coalesce(numPartitions: Int): Dataset[Row]

def col(colName: String): Column

def collect(): Array[Row]

def collectAsList(): List[Row]

def collectInternal(): Iterator[InternalRow]

def collectWithHandler[U, R](processPartition: (TaskContext, Iterator[InternalRow]) ⇒ (U, Int), resultHandler: (Int, U) ⇒ R, decodeResult: (R) ⇒ Iterator[InternalRow], skipUnpartitionedDataProcessing: Boolean = false, skipLocalCollectProcessing: Boolean = false)(implicit arg0: ClassTag[U], arg1: ClassTag[R]): Iterator[R]

def columns: Array[String]

def count(): Long

def createGlobalTempView(viewName: String): Unit

def createOrReplaceTempView(viewName: String): Unit

def createTempView(viewName: String): Unit

def crossJoin(right: Dataset[_]): DataFrame

def cube(col1: String, cols: String*): RelationalGroupedDataset

def cube(cols: Column*): RelationalGroupedDataset

var currentExecutionId: Option[Long]

def describe(cols: String*): DataFrame

def distinct(): Dataset[Row]

def drop(col: Column): DataFrame

def drop(colNames: String*): DataFrame

def drop(colName: String): DataFrame

def dropDuplicates(col1: String, cols: String*): Dataset[Row]

def dropDuplicates(colNames: Array[String]): Dataset[Row]

def dropDuplicates(colNames: Seq[String]): Dataset[Row]

def dropDuplicates(): Dataset[Row]

def dtypes: Array[(String, String)]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def except(other: Dataset[Row]): Dataset[Row]

def explain(): Unit

def explain(extended: Boolean): Unit

def filter(func: FilterFunction[Row]): Dataset[Row]

def filter(func: (Row) ⇒ Boolean): Dataset[Row]

def filter(conditionExpr: String): Dataset[Row]

def filter(condition: Column): Dataset[Row]

def finalize(): Unit

def first(): Row

var firstAccess: Boolean

def flatMap[U](f: FlatMapFunction[Row, U], encoder: Encoder[U]): Dataset[U]

def flatMap[U](func: (Row) ⇒ TraversableOnce[U])(implicit arg0: Encoder[U]): Dataset[U]

def foreach(func: ForeachFunction[Row]): Unit

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

def foreachPartition(func: ForeachPartitionFunction[Row]): Unit

def foreachPartition(f: (Iterator[Row]) ⇒ Unit): Unit

final def getClass(): Class[_]

def groupBy(col1: String, cols: String*): RelationalGroupedDataset

def groupBy(cols: Column*): RelationalGroupedDataset

def groupByKey[K](func: MapFunction[Row, K], encoder: Encoder[K]): KeyValueGroupedDataset[K, Row]

def groupByKey[K](func: (Row) ⇒ K)(implicit arg0: Encoder[K]): KeyValueGroupedDataset[K, Row]

val hasLocalCollectProcessing: Boolean

def hasPartitionWiseHandling: Boolean

Return true if collectWithHandler supports partition-wise separate result handling by default, else result handler is invoked for a single partition result.

def hashCode(): Int

def head(n: Int): Array[Row]

def head(): Row

def initializeLogIfNecessary(): Unit

def inputFiles: Array[String]

def intersect(other: Dataset[Row]): Dataset[Row]

final def isDebugEnabled: Boolean

final def isInfoEnabled: Boolean

final def isInstanceOf[T0]: Boolean

def isLocal: Boolean

def isStreaming: Boolean

final def isTraceEnabled: Boolean

def javaRDD: JavaRDD[Row]

def join(right: Dataset[_], joinExprs: Column, joinType: String): DataFrame

def join(right: Dataset[_], joinExprs: Column): DataFrame

def join(right: Dataset[_], usingColumns: Seq[String], joinType: String): DataFrame

def join(right: Dataset[_], usingColumns: Seq[String]): DataFrame

def join(right: Dataset[_], usingColumn: String): DataFrame

def join(right: Dataset[_]): DataFrame

def joinWith[U](other: Dataset[U], condition: Column): Dataset[(Row, U)]

def joinWith[U](other: Dataset[U], condition: Column, joinType: String): Dataset[(Row, U)]

def limit(n: Int): Dataset[Row]

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

def logWarning(msg: ⇒ String): Unit

def map[U](func: MapFunction[Row, U], encoder: Encoder[U]): Dataset[U]

def map[U](func: (Row) ⇒ U)(implicit arg0: Encoder[U]): Dataset[U]

def mapPartitions[U](f: MapPartitionsFunction[Row, U], encoder: Encoder[U]): Dataset[U]

def mapPartitions[U](func: (Iterator[Row]) ⇒ Iterator[U])(implicit arg0: Encoder[U]): Dataset[U]

def na: DataFrameNaFunctions

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def orderBy(sortExprs: Column*): Dataset[Row]

def orderBy(sortCol: String, sortCols: String*): Dataset[Row]

def persist(newLevel: StorageLevel): CachedDataFrame.this.type

def persist(): CachedDataFrame.this.type

var planProcessingTime: Long

def printSchema(): Unit

val queryExecution: QueryExecution

val queryHints: Map[String, String]

var queryString: String

def randomSplit(weights: Array[Double]): Array[Dataset[Row]]

def randomSplit(weights: Array[Double], seed: Long): Array[Dataset[Row]]

def randomSplitAsList(weights: Array[Double], seed: Long): List[Dataset[Row]]

lazy val rdd: RDD[Row]

val rddId: Int

def reduce(func: ReduceFunction[Row]): Row

def reduce(func: (Row, Row) ⇒ Row): Row

def repartition(partitionExprs: Column*): Dataset[Row]

def repartition(numPartitions: Int, partitionExprs: Column*): Dataset[Row]

def repartition(numPartitions: Int): Dataset[Row]

def resetLogger(): Unit

def rollup(col1: String, cols: String*): RelationalGroupedDataset

def rollup(cols: Column*): RelationalGroupedDataset

def sample(withReplacement: Boolean, fraction: Double): Dataset[Row]

def sample(withReplacement: Boolean, fraction: Double, seed: Long): Dataset[Row]

def schema: StructType

def select[U1, U2, U3, U4, U5](c1: TypedColumn[Row, U1], c2: TypedColumn[Row, U2], c3: TypedColumn[Row, U3], c4: TypedColumn[Row, U4], c5: TypedColumn[Row, U5]): Dataset[(U1, U2, U3, U4, U5)]

def select[U1, U2, U3, U4](c1: TypedColumn[Row, U1], c2: TypedColumn[Row, U2], c3: TypedColumn[Row, U3], c4: TypedColumn[Row, U4]): Dataset[(U1, U2, U3, U4)]

def select[U1, U2, U3](c1: TypedColumn[Row, U1], c2: TypedColumn[Row, U2], c3: TypedColumn[Row, U3]): Dataset[(U1, U2, U3)]

def select[U1, U2](c1: TypedColumn[Row, U1], c2: TypedColumn[Row, U2]): Dataset[(U1, U2)]

def select[U1](c1: TypedColumn[Row, U1]): Dataset[U1]

def select(col: String, cols: String*): DataFrame

def select(cols: Column*): DataFrame

def selectExpr(exprs: String*): DataFrame

def selectUntyped(columns: TypedColumn[_, _]*): Dataset[_]

def show(numRows: Int, truncate: Int): Unit

def show(numRows: Int, truncate: Boolean): Unit

def show(truncate: Boolean): Unit

def show(): Unit

def show(numRows: Int): Unit

def sort(sortExprs: Column*): Dataset[Row]

def sort(sortCol: String, sortCols: String*): Dataset[Row]

def sortWithinPartitions(sortExprs: Column*): Dataset[Row]

def sortWithinPartitions(sortCol: String, sortCols: String*): Dataset[Row]

val sparkSession: SparkSession

lazy val sqlContext: SQLContext

def stat: DataFrameStatFunctions

def storageLevel: StorageLevel

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

def take(n: Int): Array[Row]

def takeAsList(n: Int): List[Row]

def toDF(colNames: String*): DataFrame

def toDF(): DataFrame

def toJSON: Dataset[String]

def toJavaRDD: JavaRDD[Row]

def toLocalIterator(): Iterator[Row]

def toString(): String

def transform[U](t: (Dataset[Row]) ⇒ Dataset[U]): Dataset[U]

def union(other: Dataset[Row]): Dataset[Row]

def unpersist(): CachedDataFrame.this.type

def unpersist(blocking: Boolean): CachedDataFrame.this.type

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def where(conditionExpr: String): Dataset[Row]

def where(condition: Column): Dataset[Row]

def withColumn(colName: String, col: Column): DataFrame

def withColumnRenamed(existingName: String, newName: String): DataFrame

def withNewExecutionId[T](body: ⇒ T): T

def withWatermark(eventTime: String, delayThreshold: String): Dataset[Row]

def write: DataFrameWriter[Row]

def writeStream: DataStreamWriter[Row]

def explode[A, B](inputColumn: String, outputColumn: String)(f: (A) ⇒ TraversableOnce[B])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[B]): DataFrame

def explode[A <: Product](input: Column*)(f: (Row) ⇒ TraversableOnce[A])(implicit arg0: scala.reflect.api.JavaUniverse.TypeTag[A]): DataFrame

def registerTempTable(tableName: String): Unit

def unionAll(other: Dataset[Row]): Dataset[Row]