KuduTieredFeatureIndex

abstract def configurePartitions(sft: SimpleFeatureType, schema: Schema, config: Map[String, String], options: CreateTableOptions): Unit

Create initial partitions based on table splitting config

abstract def createKeyValues(toIndexKey: (SimpleFeature) ⇒ Seq[U], toTieredIndexKey: (SimpleFeature) ⇒ Seq[Array[Byte]])(kf: KuduFeature): Seq[Seq[KuduValue[_]]]

abstract def createKeyValues(toIndexKey: (SimpleFeature) ⇒ Seq[U])(kf: KuduFeature): Seq[Seq[KuduValue[_]]]

Creates key values for insert

abstract def getCost(sft: SimpleFeatureType, stats: Option[GeoMesaStats], filter: TypedFilterStrategy, transform: Option[SimpleFeatureType]): Long

abstract def getFilterStrategy(sft: SimpleFeatureType, filter: Filter, transform: Option[SimpleFeatureType]): Seq[TypedFilterStrategy]

abstract def keyColumns: Seq[KuduColumnAdapter[_]]

Columns that are part of the primary key, used for range planning

abstract def keySpace: IndexKeySpace[T, U]

Primary key space used by this index

abstract def name: String

abstract def tieredKeySpace(sft: SimpleFeatureType): Option[IndexKeySpace[_, _]]

Tiered key space beyond the primary one, if any

abstract def toRowRanges(sft: SimpleFeatureType, schema: Schema, range: ScanRange[U]): (Option[PartialRow], Option[PartialRow])

Turns a scan range into a kudu range

abstract def toTieredRowRanges(sft: SimpleFeatureType, schema: Schema, range: ScanRange[U], tiers: ⇒ Seq[ByteRange], minTier: ⇒ Array[Byte], maxTier: ⇒ Array[Byte]): Seq[(Option[PartialRow], Option[PartialRow])]

abstract def version: Int

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def configure(sft: SimpleFeatureType, ds: KuduDataStore, partition: Option[String]): String

def createPartition(sft: SimpleFeatureType, table: KuduTable, splitters: Map[String, String], bin: Short): Option[Partitioning]

Creates a new ranges partition that will cover the time period.

def delete(sft: SimpleFeatureType, ds: KuduDataStore, partition: Option[String]): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def generateTableName(sft: SimpleFeatureType, ds: KuduDataStore, partition: Option[String]): String

final def getClass(): Class[_]

def getIdFromRow(sft: SimpleFeatureType): (Array[Byte], Int, Int, SimpleFeature) ⇒ String

def getPartitions(sft: SimpleFeatureType, ds: KuduDataStore): Seq[String]

def getQueryPlan(sft: SimpleFeatureType, ds: KuduDataStore, filter: KuduFilterStrategyType, hints: Hints, explain: Explainer): KuduQueryPlanType

def getSplits(sft: SimpleFeatureType, partition: Option[String]): Seq[Array[Byte]]

def getTableNames(sft: SimpleFeatureType, ds: KuduDataStore, partition: Option[String]): Seq[String]

def getTablesForQuery(sft: SimpleFeatureType, ds: KuduDataStore, filter: Option[Filter]): Seq[String]

def hashCode(): Int

lazy val identifier: String

final def isInstanceOf[T0]: Boolean

lazy val logger: Logger

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def removeAll(sft: SimpleFeatureType, ds: KuduDataStore): Unit

def remover(sft: SimpleFeatureType, ds: KuduDataStore): (KuduFeature) ⇒ Seq[WriteOperation]

def supports(sft: SimpleFeatureType): Boolean

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

def tableNameKey(partition: Option[String]): String

def tableSchema(sft: SimpleFeatureType): Schema

Gets a cached table schema for the simple feature type, which includes all the primary key columns and the feature type columns

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def writer(sft: SimpleFeatureType, ds: KuduDataStore): (KuduFeature) ⇒ Seq[WriteOperation]

def serializedWithId: Boolean