HikariSupport

abstract def catalog: Option[String]

The catalog name for the database.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val Avg: DerivedFunctionType

val BoolAnd: SpecificFunctionType[Boolean, Boolean]

val BoolOr: SpecificFunctionType[Boolean, Boolean]

val Concat: ValueFunctionType[String, String]

val Count: SpecificFunctionType[Long, Long]

def DefaultBinaryLength: Int

def DefaultVarCharLength: Int

val GroupConcat: SpecificFunctionType[String, String]

val Max: DerivedFunctionType

val Min: DerivedFunctionType

val Now: DefaultFunctionType[Timestamp, Timestamp]

val Sum: DerivedFunctionType

val UnixTimestamp: DefaultFunctionType[Long, Long]

val _session: ThreadLocal[Option[Session]] { def initialValue(): None.type }

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: (Session) ⇒ Result): Future[Result]

Executes the inline function asynchronously and surrounds in a session returning 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: SimpleDataType[Blob]

implicit def booleanType: SimpleDataType[Boolean]

implicit def byteArrayType: SimpleDataType[Array[Byte]]

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

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

def clone(): AnyRef

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

def columnPropertiesSQL(container: ColumnPropertyContainer): List[String]

def columnSQL(create: CreateColumn[_, _]): String

def columnSQLType(create: CreateColumn[_, _]): String

def condition2String(condition: Condition, args: ListBuffer[TypedValue[_, _]]): String

def create(tables: Table*)(implicit session: Session): Int

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

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

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

def createSession(): (Boolean, Session)

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

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

def creating(): Unit

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

def dataSource: Option[DataSource]

val dataSourceProperty: Var[Option[DataSource]]

def dataTypeForInstance[T, S](dataTypeInstance: DataTypeInstance[T, S]): DataType[T, S]

All columns that are created receive a DataType responsible for converting data between Scala and the database.

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

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

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

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

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

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

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

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

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

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

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

def delete(table: Table): Delete

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

Converts the Query to a SQL String and a List of arguments.

def dispose(): Unit

def disposeDataSource(dataSource: DataSource): Unit

def disposeSession(session: Session): Unit

implicit def doubleType: SimpleDataType[Double]

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

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

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

def dropIndex(table: Table, indexName: String): List[CallableInstruction]

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

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

def empty()(implicit session: Session): Boolean

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

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executionContext: ExecutionContextExecutor

def exportTable(table: Table, file: File, drop: Boolean = true)(implicit session: Session): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hasSession: Boolean

def hashCode(): Int

def importScript(scriptFile: URL)(implicit session: Session): Boolean

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: SimpleDataType[Int]

def invoke(delete: Delete)(implicit session: Session): Int

def invoke[T](update: Update[T])(implicit session: Session): Int

def invoke(insert: InsertMultiple)(implicit session: Session): List[Int]

def invoke(merge: Merge)(implicit session: Session): Int

def invoke[T](insert: InsertSingle[T])(implicit session: Session): Int

def invoke[E, R](query: Query[E, R])(implicit session: Session): ResultSet

final def isInstanceOf[T0]: Boolean

def jdbcColumns(tableName: String)(implicit session: Session): Set[String]

def jdbcTables(implicit session: Session): Set[String]

def logger: Logger

def loggerName: String

implicit def longTimestampType: DataType[Long, Timestamp]

implicit def longType: SimpleDataType[Long]

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]

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

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

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

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

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

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

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]): SelectQueryPart[(E1, E2, E3, E4, E5, E6, E7, 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]): SelectQueryPart[(E1, E2, E3, E4, E5, E6, 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]): SelectQueryPart[(E1, E2, E3, E4, E5, 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]): SelectQueryPart[(E1, E2, E3, E4, E5), (E1, E2, E3, E4, E5)]

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

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

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

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

implicit def stringType: SimpleDataType[String]

def supportsBatchInsertResponse: Boolean

True if this database implementation supports multiple id responses on batch insert.

def supportsMerge: Boolean

True if this database implementation supports merges.

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

def table2Create(table: Table, ifNotExists: Boolean = true): CreateTable

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

def tableExists(name: String)(implicit session: Session): Boolean

implicit def thisDatastore: Datastore

implicit def timestampType: SimpleDataType[Timestamp]

def toString(): String

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withSession[Result](f: (Session) ⇒ Result): Result