StratifiedSampler

abstract def append[U](rows: Iterator[Row], init: U, processFlush: (U, InternalRow) ⇒ U, startBatch: (U, Int) ⇒ U, endBatch: (U) ⇒ U, rowEncoder: ExpressionEncoder[Row], partIndex: Int): Long

abstract def flushReservoir[U](init: U, process: (U, InternalRow) ⇒ U, startBatch: (U, Int) ⇒ U, endBatch: (U) ⇒ U): U

abstract def onTruncate(): Unit

abstract def sample(items: Iterator[InternalRow], rowEncoder: ExpressionEncoder[Row], flush: Boolean): Iterator[InternalRow]

abstract def strataReservoirSize: Int

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def concurrency: Int

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def foldDrainSegment[U](prevReservoirSize: Int, fullReset: Boolean, process: (U, InternalRow) ⇒ U)(init: U, seg: ReservoirSegment): U

final def foldReservoir[U](prevReservoirSize: Int, doReset: Boolean, fullReset: Boolean, process: (U, InternalRow) ⇒ U)(bid: Int, sr: StratumReservoir, init: U): U

def getBucketId(partIndex: Int, primaryBucketIds: IntArrayList = null)(hashValue: Int): Int

final def getClass(): Class[_]

def getReservoirSegment(newQcs: Array[Int], types: Array[DataType], numColumns: Int, initialCapacity: Int, loadFactor: Double, qcsColHandler: Option[ColumnHandler], segi: Int, nsegs: Int): ReservoirSegment

def hashCode(): Int

def initializeLogIfNecessary(): Unit

def isBucketLocal(partIndex: Int): Boolean

final def isDebugEnabled: Boolean

final def isInfoEnabled: Boolean

final def isInstanceOf[T0]: Boolean

final def isTraceEnabled: Boolean

def iterator(segmentStart: Int, segmentEnd: Int): Iterator[InternalRow]

def iteratorOnRegion(buckets: Set[Integer]): Iterator[InternalRow]

final var levelFlags: Int

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

final var log_: Logger

def module: String

final def name: String

final def ne(arg0: AnyRef): Boolean

final def newMutableRow(row: Row, rowEncoder: ExpressionEncoder[Row]): UnsafeRow

final def notify(): Unit

final def notifyAll(): Unit

final val options: SampleOptions

final val pendingBatch: AtomicReference[ArrayBuffer[InternalRow]]

Store pending values to be flushed in a separate buffer so that we do not end up creating too small ColumnBatches.

final def qcs: Array[Int]

final def qcsSparkPlan: Option[(CodeAndComment, ArrayBuffer[Any], Int, Array[DataType])]

def reservoirInRegion: Boolean

def resetLogger(): Unit

final val rng: Random

Random number generator for sampling.

final def schema: StructType

def setFlushStatus(doFlush: Boolean): Unit

final val strata: ConcurrentSegmentedHashMap[Row, StratumReservoir, ReservoirSegment]

Map of each stratum key (i.e.

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def waitForSamplers(waitUntil: Int, maxMillis: Long): Unit