XDDataFrame

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

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): DataFrame

def alias(alias: String): DataFrame

def apply(colName: String): Column

def as(alias: Symbol): DataFrame

def as(alias: String): DataFrame

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

final def asInstanceOf[T0]: T0

def cache(): XDDataFrame.this.type

def clone(): AnyRef

def coalesce(numPartitions: Int): DataFrame

def col(colName: String): Column

def collect(executionType: ExecutionType): Array[Row]

Collect using an specific ExecutionType.

def collect(): Array[Row]

<invalid inheritdoc annotation>

def collectAsList(): List[Row]

<invalid inheritdoc annotation>

def collectToPython(): Int

def columns: Array[String]

def count(): Long

<invalid inheritdoc annotation>

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

def cube(cols: Column*): GroupedData

def describe(cols: String*): DataFrame

def distinct(): DataFrame

def drop(col: Column): DataFrame

def drop(colName: String): DataFrame

def dropDuplicates(colNames: Array[String]): DataFrame

def dropDuplicates(colNames: Seq[String]): DataFrame

def dropDuplicates(): DataFrame

def dtypes: Array[(String, String)]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def except(other: DataFrame): DataFrame

def explain(): Unit

def explain(extended: Boolean): Unit

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 filter(conditionExpr: String): DataFrame

def filter(condition: Column): DataFrame

def finalize(): Unit

def first(): Row

def flatMap[R](f: (Row) ⇒ TraversableOnce[R])(implicit arg0: ClassTag[R]): RDD[R]

def flattenedCollect(): Array[Row]

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

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

final def getClass(): Class[_]

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

def groupBy(cols: Column*): GroupedData

def hashCode(): Int

def head(): Row

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

def inputFiles: Array[String]

def intersect(other: DataFrame): DataFrame

final def isInstanceOf[T0]: Boolean

def isLocal: Boolean

def isTraceEnabled(): Boolean

def javaRDD: JavaRDD[Row]

def javaToPython: JavaRDD[Array[Byte]]

def join(right: DataFrame, joinExprs: Column, joinType: String): DataFrame

def join(right: DataFrame, joinExprs: Column): DataFrame

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

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

def join(right: DataFrame, usingColumn: String): DataFrame

def join(right: DataFrame): DataFrame

def limit(n: Int): DataFrame

<invalid inheritdoc annotation>

def log: slf4j.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

val logger: Logger

val logicalPlan: LogicalPlan

def map[R](f: (Row) ⇒ R)(implicit arg0: ClassTag[R]): RDD[R]

def mapPartitions[R](f: (Iterator[Row]) ⇒ Iterator[R])(implicit arg0: ClassTag[R]): RDD[R]

def na: DataFrameNaFunctions

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def numericColumns: Seq[Expression]

def orderBy(sortExprs: Column*): DataFrame

def orderBy(sortCol: String, sortCols: String*): DataFrame

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

def persist(): XDDataFrame.this.type

def printSchema(): Unit

val queryExecution: QueryExecution

def randomSplit(weights: Array[Double]): Array[DataFrame]

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

lazy val rdd: RDD[Row]

def registerTempTable(tableName: String): Unit

def repartition(partitionExprs: Column*): DataFrame

def repartition(numPartitions: Int, partitionExprs: Column*): DataFrame

def repartition(numPartitions: Int): DataFrame

def resolve(colName: String): NamedExpression

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

def rollup(cols: Column*): GroupedData

def sample(withReplacement: Boolean, fraction: Double): DataFrame

def sample(withReplacement: Boolean, fraction: Double, seed: Long): DataFrame

def schema: StructType

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

def select(cols: Column*): DataFrame

def selectExpr(exprs: String*): DataFrame

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

def show(truncate: Boolean): Unit

def show(): Unit

def show(numRows: Int): Unit

def sort(sortExprs: Column*): DataFrame

def sort(sortCol: String, sortCols: String*): DataFrame

def sortWithinPartitions(sortExprs: Column*): DataFrame

def sortWithinPartitions(sortCol: String, sortCols: String*): DataFrame

val sqlContext: SQLContext

def stat: DataFrameStatFunctions

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: RDD[String]

def toJavaRDD: JavaRDD[Row]

def toString(): String

def transform[U](t: (DataFrame) ⇒ DataFrame): DataFrame

def unionAll(other: DataFrame): DataFrame

def unpersist(): XDDataFrame.this.type

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def where(conditionExpr: String): DataFrame

def where(condition: Column): DataFrame

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

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

def write: DataFrameWriter

def createJDBCTable(url: String, table: String, allowExisting: Boolean): Unit

def insertInto(tableName: String): Unit

def insertInto(tableName: String, overwrite: Boolean): Unit

def insertIntoJDBC(url: String, table: String, overwrite: Boolean): Unit

def save(source: String, mode: SaveMode, options: Map[String, String]): Unit

def save(source: String, mode: SaveMode, options: Map[String, String]): Unit

def save(path: String, source: String, mode: SaveMode): Unit

def save(path: String, source: String): Unit

def save(path: String, mode: SaveMode): Unit

def save(path: String): Unit

def saveAsParquetFile(path: String): Unit

def saveAsTable(tableName: String, source: String, mode: SaveMode, options: Map[String, String]): Unit

def saveAsTable(tableName: String, source: String, mode: SaveMode, options: Map[String, String]): Unit

def saveAsTable(tableName: String, source: String, mode: SaveMode): Unit

def saveAsTable(tableName: String, source: String): Unit

def saveAsTable(tableName: String, mode: SaveMode): Unit

def saveAsTable(tableName: String): Unit

def toSchemaRDD: DataFrame