VersioningSupport

abstract def column2Create[T, S](column: Column[T, S]): CreateColumn[T, S]

abstract def dataSource: DataSource

abstract def ddl(drop: DropIndex): List[CallableInstruction]

abstract def ddl(drop: DropColumn): List[CallableInstruction]

abstract def ddl(drop: DropTable): List[CallableInstruction]

abstract def ddl[T, S](alter: ChangeColumnType[T, S]): List[CallableInstruction]

abstract def ddl(alter: RestartColumn): List[CallableInstruction]

abstract def ddl(alter: RenameColumn): List[CallableInstruction]

abstract def ddl(create: CreateIndex): List[CallableInstruction]

abstract def ddl(alter: CreateForeignKey): List[CallableInstruction]

abstract def ddl[T, S](create: CreateColumn[T, S]): List[CallableInstruction]

abstract def ddl(create: CreateTable): List[CallableInstruction]

abstract def ddl(tables: List[Table], ifNotExists: Boolean): List[CallableInstruction]

abstract def describe[E, R](query: Query[E, R]): (String, List[TypedValue[_, _]])

abstract def invoke(delete: Delete): Int

abstract def invoke[T](update: Update[T]): Int

abstract def invoke(merge: Merge): Int

abstract def invoke(insert: InsertMultiple): List[Int]

abstract def invoke[T](insert: InsertSingle[T]): Int

abstract def invoke[E, R](query: Query[E, R]): ResultSet

abstract def table2Create(table: Table, ifNotExists: Boolean): CreateTable

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def DefaultBinaryLength: Int

def DefaultVarCharLength: Int

val _session: ThreadLocal[Session]

def add(table: Table): Unit

def afterInvoke(delete: Delete): Unit

def afterInvoke[T](update: Update[T]): Unit

def afterInvoke(merge: Merge): Unit

def afterInvoke(insert: InsertMultiple): Unit

def afterInvoke[T](insert: InsertSingle[T]): Unit

def afterInvoke[E, R](query: Query[E, R]): Unit

final def asInstanceOf[T0]: T0

def async[Result](f: ⇒ Result): Future[Result]

def beforeInvoke(delete: Delete): Delete

def beforeInvoke[T](update: Update[T]): Update[T]

def beforeInvoke(merge: Merge): Merge

def beforeInvoke(insert: InsertMultiple): InsertMultiple

def beforeInvoke[T](insert: InsertSingle[T]): InsertSingle[T]

def beforeInvoke[E, R](query: Query[E, R]): Query[E, R]

implicit def bigDecimalType: SimpleDataType[BigDecimal]

implicit def blobType: BlobType.type

implicit def booleanType: BooleanType.type

implicit def byteArrayType: ByteArrayType.type

def calling(instructionType: InstructionType, sql: String): Unit

def changeColumnType[T, S](tableName: String, columnName: String, properties: ColumnProperty*)(implicit manifest: Manifest[T], dataType: DataType[T, S]): List[CallableInstruction]

def clone(): AnyRef

def commitTransaction(): Unit

def connection: Connection

def create(tables: Table*): Int

def createColumn[T](tableName: String, columnName: String, columnProperty: ColumnProperty*)(implicit manifest: Manifest[T], dataType: SimpleDataType[T]): List[CallableInstruction]

def createColumn[T, S](tableName: String, columnName: String, columnProperty: ColumnProperty*)(implicit manifest: Manifest[T], dataType: DataType[T, S]): List[CallableInstruction]

def createColumn[T, S](column: Column[T, S]): List[CallableInstruction]

def createSession(): Boolean

def createTable(tableName: String): List[CallableInstruction]

def createTable(table: Table): List[CallableInstruction]

def createTransaction(): Boolean

def creating(): Unit

val dataTypeInstanceProcessor: DataTypeInstanceProcessor

def debug(message: ⇒ Any): Unit

def delete(table: Table): Delete

def dispose(): Unit

def disposeSession(): Unit

def doesTableExist(name: String): Boolean

implicit def doubleType: DoubleType.type

def dropColumn(tableName: String, columnName: String): List[CallableInstruction]

def dropColumn(column: Column[_, _]): List[CallableInstruction]

def dropIndex(indexName: String): List[CallableInstruction]

def dropTable(tableName: String, cascade: Boolean): List[CallableInstruction]

def dropTable(table: Table, cascade: Boolean): List[CallableInstruction]

def empty(): Boolean

implicit def enum[T <: EnumEntry](implicit manifest: Manifest[T]): DataType[T, String]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

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

def error(message: ⇒ Any): Unit

def executionContext: ExecutionContextExecutor

def finalize(): Unit

final def getClass(): Class[_]

def hasSession: Boolean

def hashCode(): Int

def info(message: ⇒ Any): Unit

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

implicit def insert2Rows(inserts: Seq[Insert[_]]): Seq[Seq[ColumnValue[_, _]]]

def insertBatch(rows: Seq[Seq[ColumnValue[_, _]]]): InsertMultiple

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

def instantiateSession(): Session

implicit def intType: IntType.type

final def isInstanceOf[T0]: Boolean

def jdbcColumns(tableName: String): Set[String]

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

implicit def longTimestampType: LongTimestampType.type

implicit def longType: LongType.type

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

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit def option[T, S](implicit dataType: DataType[T, S]): DataType[Option[T], S]

object persistence

implicit def reference[T]: DataType[Ref[T], Int]

def register(upgrade: UpgradableVersion): Unit

def renameColumn(tableName: String, oldName: String, newName: String): List[CallableInstruction]

def restartColumn(tableName: String, columnName: String, value: Long): List[CallableInstruction]

def rollbackTransaction(): Unit

def select(expressions: List[SelectExpression[_]]): Query[Vector[SelectExpression[_]], QueryResult[_]]

def select[E1, E2, E3, E4, E5, E6, E7, E8](e1: SelectExpression[E1], e2: SelectExpression[E2], e3: SelectExpression[E3], e4: SelectExpression[E4], e5: SelectExpression[E5], e6: SelectExpression[E6], e7: SelectExpression[E7], e8: SelectExpression[E8]): Query[(SelectExpression[E1], SelectExpression[E2], SelectExpression[E3], SelectExpression[E4], SelectExpression[E5], SelectExpression[E6], SelectExpression[E7], SelectExpression[E8]), (E1, E2, E3, E4, E5, E6, E7, E8)]

def select[E1, E2, E3, E4, E5, E6, E7](e1: SelectExpression[E1], e2: SelectExpression[E2], e3: SelectExpression[E3], e4: SelectExpression[E4], e5: SelectExpression[E5], e6: SelectExpression[E6], e7: SelectExpression[E7]): Query[(SelectExpression[E1], SelectExpression[E2], SelectExpression[E3], SelectExpression[E4], SelectExpression[E5], SelectExpression[E6], SelectExpression[E7]), (E1, E2, E3, E4, E5, E6, E7)]

def select[E1, E2, E3, E4, E5, E6](e1: SelectExpression[E1], e2: SelectExpression[E2], e3: SelectExpression[E3], e4: SelectExpression[E4], e5: SelectExpression[E5], e6: SelectExpression[E6]): Query[(SelectExpression[E1], SelectExpression[E2], SelectExpression[E3], SelectExpression[E4], SelectExpression[E5], SelectExpression[E6]), (E1, E2, E3, E4, E5, E6)]

def select[E1, E2, E3, E4, E5](e1: SelectExpression[E1], e2: SelectExpression[E2], e3: SelectExpression[E3], e4: SelectExpression[E4], e5: SelectExpression[E5]): Query[(SelectExpression[E1], SelectExpression[E2], SelectExpression[E3], SelectExpression[E4], SelectExpression[E5]), (E1, E2, E3, E4, E5)]

def select[E1, E2, E3, E4](e1: SelectExpression[E1], e2: SelectExpression[E2], e3: SelectExpression[E3], e4: SelectExpression[E4]): Query[(SelectExpression[E1], SelectExpression[E2], SelectExpression[E3], SelectExpression[E4]), (E1, E2, E3, E4)]

def select[E1, E2, E3](e1: SelectExpression[E1], e2: SelectExpression[E2], e3: SelectExpression[E3]): Query[(SelectExpression[E1], SelectExpression[E2], SelectExpression[E3]), (E1, E2, E3)]

def select[E1, E2](e1: SelectExpression[E1], e2: SelectExpression[E2]): Query[(SelectExpression[E1], SelectExpression[E2]), (E1, E2)]

def select[E](e1: SelectExpression[E]): Query[SelectExpression[E], E]

def session[Result](f: ⇒ Result): Result

def session: Session

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

implicit def stringType: StringType.type

def supportsBatchInsertResponse: Boolean

def supportsMerge: Boolean

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

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

implicit def thisDatastore: Datastore

implicit val thisListenable: Listenable

implicit def timestampType: TimestampType.type

def toString(): String

def trace(message: ⇒ Any): Unit

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

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

def upgrade(): Unit

Upgrades the database to the latest version iteratively.

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

lazy val version: Property[Int]

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

implicit def wrappedStringType: SimpleDataType[WrappedString]