BlockStoreColumnarTableCompanion

abstract def load(table: Table, apiKey: APIKey, tpe: JType): EitherT[M, ResourceError, Table]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object JDBMState extends Serializable

def addGlobalId(spec: TransSpec1): Scan[Source1]

object addGlobalIdScanner extends CScanner

def align(sourceLeft: Table, alignOnL: TransSpec1, sourceRight: Table, alignOnR: TransSpec1): M[(Table, Table)]

def apply(slices: StreamT[M, Slice], size: TableSize): Table

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def constBoolean(v: Set[Boolean]): Table

def constDate(v: Set[ZonedDateTime]): Table

def constDecimal(v: Set[BigDecimal]): Table

def constDouble(v: Set[Double]): Table

def constEmptyArray: Table

def constEmptyObject: Table

def constLong(v: Set[Long]): Table

def constNull: Table

def constString(v: Set[String]): Table

def cross(left: Table, right: Table, orderHint: Option[CrossOrder] = None)(spec: TransSpec2): M[(CrossOrder, Table)]

Performs a back-end specific cross.

def empty: Table

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def fromRValues(values: Stream[RValue], maxSliceSize: Option[Int] = None): Table

final def getClass(): Class[_]

implicit def groupIdShow: Show[BlockStoreColumnarTableModule.GroupId]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def join(left0: Table, right0: Table, orderHint: Option[JoinOrder] = None)(leftKeySpec: TransSpec1, rightKeySpec: TransSpec1, joinSpec: TransSpec2): M[(JoinOrder, Table)]

Joins left and right together using their left/right key specs.

def loadTable(mergeEngine: MergeEngine[SortingKey, SortBlockData], indices: IndexMap, sortOrder: DesiredSortOrder): Table

def merge[N[+_]](grouping: BlockStoreColumnarTableModule.GroupingSpec)(body: (RValue, (BlockStoreColumnarTableModule.GroupId) ⇒ M[Table]) ⇒ N[Table])(implicit nt: ~>[N, M]): M[Table]

Merge controls the iteration over the table of group key values.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def pathsM(table: Table): M[Set[Path]]

Reduce the specified table to obtain the in-memory set of strings representing the vfs paths to be loaded.

def reduceSlices(slices: StreamT[M, Slice]): StreamT[M, Slice]

Passes over all slices and returns a new slices that is the concatenation of all the slices.

def singleton(slice: Slice): SingletonTable

lazy val sortMergeEngine: MergeEngine[SortingKey, SortBlockData]

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

def toString(): String

def transformStream[A](sliceTransform: BlockStoreColumnarTableModule.SliceTransform1[A], slices: StreamT[M, Slice]): StreamT[M, Slice]

def uniformDistribution(init: MmixPrng): Table

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def writeAlignedSlices(kslice: Slice, vslice: Slice, jdbmState: JDBMState, indexNamePrefix: String, sortOrder: DesiredSortOrder): M[JDBMState]

def writeRawSlices(kslice: Slice, sortOrder: DesiredSortOrder, vslice: Slice, vrefs: List[ColumnRef], vEncoder: ColumnEncoder, indexNamePrefix: String, jdbmState: JDBMState): M[JDBMState]

def writeSlice(slice: Slice, state: WriteState, sortOrder: DesiredSortOrder, source: String = ""): M[WriteState]

def writeTables(slices: StreamT[M, Slice], valueTrans: BlockStoreColumnarTableModule.SliceTransform1[_], keyTrans: Seq[BlockStoreColumnarTableModule.SliceTransform1[_]], sortOrder: DesiredSortOrder): M[(List[String], IndexMap)]