FetcherBase

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

val batchIrCacheName: String

val caffeineMetricsContext: Context

def clone(): AnyRef

val dataset: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

implicit val executionContext: ExecutionContext

def fetchColumns(columnSpecs: Seq[ColumnSpec]): Future[Map[ColumnSpec, Response]]

Fetch method to simulate a random access interface for Chronon by distributing requests to relevant GroupBys.

def fetchGroupByStructured(requests: Seq[Request]): Future[Seq[StructuredResponse]]

Like fetchGroupBys, but names struct-typed values (and lists of structs) at every nesting level instead of returning them as bare positional arrays.

def fetchGroupBys(requests: Seq[Request]): Future[Seq[Response]]

def fetchJoin(requests: Seq[Request], joinConf: Option[Join] = None): Future[Seq[Response]]

def getCachedRequests(groupByRequestToKvRequest: Seq[(Request, Try[GroupByRequestMeta])]): Map[GetRequest, CachedBatchResponse]

Given a list of GetRequests, return a map of GetRequests to cached FinalBatchIrs.

final def getClass(): Class[_]

def getConf[T <: TBase[_, _]](confPathOrName: String)(implicit arg0: Manifest[T]): Try[T]

def getEntityListByTeam[T <: TBase[_, _]](team: String)(implicit arg0: Manifest[T]): Try[Seq[String]]

lazy val getGroupByListByTeam: TTLCache[String, Try[Seq[String]]]

lazy val getGroupByServingInfo: TTLCache[String, Try[GroupByServingInfoParsed]]

lazy val getJoinConf: TTLCache[String, Try[JoinOps]]

lazy val getJoinListByTeam: TTLCache[String, Try[Seq[String]]]

def getSchemaFromKVStore(dataset: String, key: String): AvroCodec

lazy val getStatsSchemaFromKVStore: TTLCache[(String, String), AvroCodec]

def hashCode(): Int

def isCacheSizeConfigured: Boolean

def isCachingEnabled(groupBy: GroupBy): Boolean

def isEntityValidityCheckEnabled: Boolean

final def isInstanceOf[T0]: Boolean

implicit lazy val logger: Logger

val maybeBatchIrCache: Option[BatchIrCache]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parseGroupByResponse(prefix: String, groupByRequest: Request, responseMap: Map[Request, Try[Map[String, AnyRef]]]): Map[String, AnyRef]

def put(kVPairs: Map[String, Seq[String]], datasetName: String = ChrononMetadataKey, batchSize: Int = CONF_BATCH_SIZE): Future[Seq[Boolean]]

def putJoinConf(join: Join): Unit

def reportKvResponse(ctx: Context, response: Seq[TimedValue], queryTsMillis: Long, latencyMillis: Long, totalResponseBytes: Int): Unit

def setPartitionMeta(format: String): Unit

def setPartitionMeta(format: String, spanMillis: Long): Unit

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

def toBatchIr(bytes: Array[Byte], gbInfo: GroupByServingInfoParsed): FinalBatchIr

Convert an array of bytes to a FinalBatchIr.

def toString(): String

def validateGroupByExist(team: String, name: String): Boolean

def validateJoinExist(team: String, name: String): Boolean

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def finalize(): Unit