GeoMesaDataStore

abstract def acquireDistributedLock(key: String, timeOut: Long): Option[Releasable]

Gets and acquires a distributed lock based on the key.

abstract def acquireDistributedLock(key: String): Releasable

Gets and acquires a distributed lock based on the key.

abstract def adapter: IndexAdapter[DS]

abstract def metadata: GeoMesaMetadata[String]

abstract def stats: GeoMesaStats

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def acquireCatalogLock(): Releasable

Acquires a distributed lock for all data stores sharing this catalog table.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val config: GeoMesaDataStoreConfig

common datastore configuration options - subclasses can extend this

def createSchema(schema: SimpleFeatureType): Unit

Validates the schema and writes metadata to catalog.If the schema already exists, continue without error.

def delete(): Unit

Optimized method to delete everything (all tables) associated with this datastore (index tables and catalog table) NB: We are *not* currently deleting the query table and/or query information.

def dispose(): Unit

Cleanup any open connections, etc.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def getAllIndexTableNames(typeName: String): Seq[String]

Returns all index tables that may be created for the simple feature type.

def getAllTableNames(typeName: String): Seq[String]

Returns all tables that may be created for the simple feature type.

final def getClass(): Class[_]

def getClientVersion: SemanticVersion

Gets the geomesa version

def getDistributedVersion: Option[SemanticVersion]

Gets the geomesa version

def getFeatureReader(query: Query, transaction: Transaction): GeoMesaFeatureReader

def getFeatureSource(typeName: String): GeoMesaFeatureStore

def getFeatureSource(typeName: Name): SimpleFeatureSource

def getFeatureWriter(typeName: String, filter: Filter, transaction: Transaction): FlushableFeatureWriter

Create a general purpose writer that is capable of updates and deletes.

def getFeatureWriter(typeName: String, transaction: Transaction): SimpleFeatureWriter

Create a general purpose writer that is capable of updates and deletes.

def getFeatureWriterAppend(typeName: String, transaction: Transaction): FlushableFeatureWriter

Creates a feature writer only for writing - does not allow updates or deletes.

def getIndexWriterAppend(typeName: String, indices: Seq[GeoMesaFeatureIndex[_, _]]): FlushableFeatureWriter

Writes to the specified indices

def getInfo(): ServiceInfo

def getLockingManager(): LockingManager

We always return null, which indicates that we are handling transactions ourselves.

def getNames(): List[Name]

def getQueryPlan(query: Query, index: Option[String] = None, explainer: Explainer = new ExplainLogging): Seq[QueryPlan[DS]]

Gets the query plan for a given query.

def getSchema(typeName: String): SimpleFeatureType

def getSchema(name: Name): SimpleFeatureType

def getTypeNames(): Array[String]

def hashCode(): Int

val interceptors: QueryInterceptorFactory

final def isInstanceOf[T0]: Boolean

def loadIteratorVersions: Set[String]

Gets iterator versions as a string.

lazy val logger: Logger

val manager: IndexManager

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onSchemaCreated(sft: SimpleFeatureType): Unit

Called after schema metadata has been persisted.

def onSchemaDeleted(sft: SimpleFeatureType): Unit

Called after deleting schema metadata.

def onSchemaUpdated(sft: SimpleFeatureType, previous: SimpleFeatureType): Unit

Called after schema metadata has been persisted.

def preSchemaCreate(sft: SimpleFeatureType): Unit

Called just before persisting schema metadata.

def preSchemaUpdate(sft: SimpleFeatureType, previous: SimpleFeatureType): Unit

Called just before updating schema metadata.

val queryPlanner: QueryPlanner[DS]

def removeSchema(typeName: Name): Unit

def removeSchema(typeName: String): Unit

Deletes the schema metadata

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

def toString(): String

def transitionIndices(sft: SimpleFeatureType): Unit

Update the local value for sft.getIndices.

def updateSchema(typeName: Name, schema: SimpleFeatureType): Unit

Allows the following modifications to the schema: renaming the feature type renaming attributes appending new attributes enabling/disabling indices through RichSimpleFeatureType.setIndexVersion modifying keywords through user-data

def updateSchema(typeName: String, sft: SimpleFeatureType): Unit

Allows the following modifications to the schema: renaming the feature type renaming attributes appending new attributes enabling/disabling indices through RichSimpleFeatureType.setIndexVersion modifying keywords through user-data

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withLock[T](key: String, timeOut: Long, fn: ⇒ T, fallback: ⇒ T): T

Execute a function wrapped in a lock

def withLock[T](key: String, fn: ⇒ T): T

Execute a function wrapped in a lock

def catalog: String

def getDistributeVersion: Option[SemanticVersion]

def getVersion: (String, Set[String])

Gets the geomesa version