SchemaDStream

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

val baseScope: Option[String]

def cache(): DStream[Row]

def checkpoint(interval: Duration): DStream[Row]

def clone(): AnyRef

def columns: Array[String]

Returns all column names as an array.

def compute(validTime: Time): Option[RDD[Row]]

Method that generates a RDD for the given time

def context: StreamingContext

def count(): DStream[Long]

def countByValue(numPartitions: Int)(implicit ord: Ordering[Row]): DStream[(Row, Long)]

def countByValueAndWindow(windowDuration: Duration, slideDuration: Duration, numPartitions: Int)(implicit ord: Ordering[Row]): DStream[(Row, Long)]

def countByWindow(windowDuration: Duration, slideDuration: Duration): DStream[Long]

def createRDDWithLocalProperties[U](time: Time)(body: ⇒ U): U

def dependencies: List[DStream[InternalRow]]

List of parent DStreams on which this DStream depends on

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(filterFunc: (Row) ⇒ Boolean): DStream[Row]

Return a new DStream containing only the elements that satisfy a predicate.

def finalize(): Unit

def flatMap[U](flatMapFunc: (Row) ⇒ Traversable[U])(implicit arg0: ClassTag[U]): DStream[U]

def foreachDataFrame(foreachFunc: (DataFrame, Time) ⇒ Unit): Unit

Apply a function to each DataFrame in this SchemaDStream.

def foreachDataFrame(foreachFunc: (DataFrame) ⇒ Unit): Unit

Apply a function to each DataFrame in this SchemaDStream.

def foreachRDD(foreachFunc: (RDD[Row], Time) ⇒ Unit): Unit

def foreachRDD(foreachFunc: (RDD[Row]) ⇒ Unit): Unit

var generatedRDDs: Map[Time, RDD[Row]]

final def getClass(): Class[_]

final def getOrCompute(time: Time): Option[RDD[Row]]

def glom(): DStream[Array[Row]]

var graph: DStreamGraph

def hashCode(): Int

def initGeneratedRDDs(): Unit

def initializeAfterContextStart(time: Time): Unit

def isInitialized: Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

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

val logicalPlan: LogicalPlan

def map[U](mapFunc: (Row) ⇒ U)(implicit arg0: ClassTag[U]): DStream[U]

def mapPartitions[U](mapPartFunc: (Iterator[Row]) ⇒ Iterator[U], preservePartitioning: Boolean)(implicit arg0: ClassTag[U]): DStream[U]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def persist(): DStream[Row]

def persist(level: StorageLevel): DStream[Row]

def print(num: Int): Unit

def print(): Unit

def printSchema(): Unit

val queryExecution: QueryExecution

def reduce(reduceFunc: (Row, Row) ⇒ Row): DStream[Row]

def reduceByWindow(reduceFunc: (Row, Row) ⇒ Row, invReduceFunc: (Row, Row) ⇒ Row, windowDuration: Duration, slideDuration: Duration): DStream[Row]

def reduceByWindow(reduceFunc: (Row, Row) ⇒ Row, windowDuration: Duration, slideDuration: Duration): DStream[Row]

def register(): DStream[Row]

def registerAsTable(tableName: String): Unit

Registers this SchemaDStream as a table in the catalog.

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

def saveAsObjectFiles(prefix: String, suffix: String): Unit

def saveAsTextFiles(prefix: String, suffix: String): Unit

def schema: StructType

Returns the schema of this SchemaDStream (represented by a StructType).

def slice(fromTime: Time, toTime: Time): Seq[RDD[Row]]

def slice(interval: Interval): Seq[RDD[Row]]

def slideDuration: Duration

Time interval after which the DStream generates a RDD

val snsc: SnappyStreamingContext

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

def toString(): String

def transform[U](transformFunc: (RDD[Row], Time) ⇒ RDD[U])(implicit arg0: ClassTag[U]): DStream[U]

def transform[U](transformFunc: (RDD[Row]) ⇒ RDD[U])(implicit arg0: ClassTag[U]): DStream[U]

def transformWith[U, V](other: DStream[U], transformFunc: (RDD[Row], RDD[U], Time) ⇒ RDD[V])(implicit arg0: ClassTag[U], arg1: ClassTag[V]): DStream[V]

def transformWith[U, V](other: DStream[U], transformFunc: (RDD[Row], RDD[U]) ⇒ RDD[V])(implicit arg0: ClassTag[U], arg1: ClassTag[V]): DStream[V]

def union(that: DStream[Row]): DStream[Row]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def window(windowDuration: Duration, slideDuration: Duration): DStream[Row]

def window(windowDuration: Duration): DStream[Row]

def foreach(foreachFunc: (RDD[Row], Time) ⇒ Unit): Unit

def foreach(foreachFunc: (RDD[Row]) ⇒ Unit): Unit