Datastore

abstract def createExtras(b: StringBuilder): Unit

abstract def createTableExtras(table: Table, b: StringBuilder): Unit

abstract def createTableSQL(ifNotExist: Boolean, table: Table): String

abstract def dataSource: DataSource

abstract def exec(delete: Delete): Int

abstract def exec(update: Update): Int

abstract def exec(merge: Merge): Int

abstract def exec(insert: Insert): Iterator[Int]

abstract def exec(query: Query): QueryResultsIterator

abstract def sqlFromQuery(query: Query): (String, List[Any])

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def active[T](f: ⇒ T): T

def add(table: Table): Any

final def asInstanceOf[T0]: T0

def cleanup(thread: Thread, session: DatastoreSession): Unit

def clearSessions(): Unit

def clone(): AnyRef

def create(ifNotExist: Boolean = true): Boolean

def createSession(): DatastoreSession

def creating(): Unit

Called when the datastore is being created for the first time.

def ddl(ifNotExist: Boolean = true): String

def debug(message: ⇒ Any): Unit

def delete(table: Table): Delete

def dispose(): Unit

def empty(): Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(message: ⇒ Any, t: Throwable): Unit

def error(message: ⇒ Any): Unit

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def info(message: ⇒ Any): Unit

def insert(values: ColumnValue[_]*): Option[Int]

def insertInto(table: Table, values: Any*): Option[Int]

final def isInstanceOf[T0]: Boolean

def jdbcTables: Set[String]

def listen[Event, Response, Result](name: String, priority: Priority, modes: ListenMode*)(f: (Event) ⇒ Response)(implicit eventManifest: Manifest[Event]): FunctionalListener[Event, Response]

val listeners: Listeners

def log(level: Level, message: ⇒ Any): Unit

def logger: Logger

def loggerName: String

def merge(key: Column[_], values: ColumnValue[_]*): Int

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def select(expressions: List[SelectExpression]): Query

def select(expressions: SelectExpression*): Query

def session: DatastoreSession

def sessionTimeout: Double

def sessions: Iterable[DatastoreSession]

val sql2Value: OptionProcessor[(ColumnLike[_], Any), Any]

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

def tableByName(tableName: String): Option[Table]

def tables: Iterable[Table]

implicit val thisListenable: Listenable

def toString(): String

def trace(message: ⇒ Any): Unit

def transaction[R](f: ⇒ R): R

Creates a transaction for the contents of the supplied function.

def update(delta: Double): Unit

def update(values: ColumnValue[_]*): Update

val updater: ScheduledFuture[_]

val value2SQL: OptionProcessor[(ColumnLike[_], Any), Any]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def warn(message: ⇒ Any, t: Throwable): Unit

def warn(message: ⇒ Any): Unit