PostgresDriver

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (PostgresDriver, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object DDL

object FromPart extends JdbcDriver.StatementPart with Product with Serializable

lazy val Implicit: Implicits

object JdbcType

lazy val MappedColumnType: MappedJdbcType.type

object MappedJdbcType extends JdbcDriver.MappedColumnTypeFactory

object OtherPart extends JdbcDriver.StatementPart with Product with Serializable

object SelectPart extends JdbcDriver.StatementPart with Product with Serializable

object Sequence

object WherePart extends JdbcDriver.StatementPart with Product with Serializable

final def asInstanceOf[T0]: T0

val backend: Backend

The back-end implementation for this profile

final def buildSequenceSchemaDescription(seq: Sequence[_]): DDL

final def buildTableSchemaDescription(table: Table[_]): DDL

final val capabilities: Set[Capability]

The capabilities supported by this driver.

lazy val checkInsertCompiler: QueryCompiler

def clone(): AnyRef

val columnOptions: ColumnOptions

val columnTypes: JdbcTypes

def compileInsert(tree: Node): JdbcCompiledInsert

(Partially) ompile an AST for insert operations

final lazy val compiler: QueryCompiler

def computeCapabilities: Set[Capability]

Compute the capabilities.

def computeQueryCompiler: QueryCompiler

def createBaseResultConverter[T](ti: JdbcType[T], name: String, idx: Int): ResultConverter[JdbcResultConverterDomain, T]

Create a (possibly specialized) ResultConverter for the given JdbcType.

def createCheckInsertBuilder(node: Insert): InsertBuilder

def createColumnDDLBuilder(column: FieldSymbol, table: Table[_]): ColumnDDLBuilder

def createCountingInsertInvoker[U](compiled: CompiledInsert): CountingInsertInvokerDef[U]

def createDDLInvoker(ddl: SchemaDescription): DDLInvoker

Create a DDLInvoker -- this method should be implemented by drivers as needed

def createDeleteInvoker(tree: Node, param: Any): DeleteInvoker

def createInsertBuilder(node: Insert): InsertBuilder

def createInsertInvoker[U](tree: CompiledInsert): CountingInsertInvokerDef[U]

Create an InsertInvoker -- this method should be implemented by drivers as needed

def createModel(tables: Option[Seq[MTable]] = None, ignoreInvalidDefaults: Boolean = true)(implicit session: SessionDef): Model

Gets the Slick data model describing this data source

def createOptionResultConverter[T](ti: JdbcType[T], idx: Int): ResultConverter[JdbcResultConverterDomain, Option[T]]

Create a (possibly specialized) ResultConverter for Option values of the given JdbcType.

def createQueryBuilder(n: Node, state: CompilerState): QueryBuilder

def createQueryExecutor[R](tree: Node, param: Any): QueryExecutor[R]

Create an executor -- this method should be implemented by drivers as needed

def createQueryInvoker[R](tree: Node, param: Any): QueryInvoker[R]

def createReturningInsertInvoker[U, RU](compiled: CompiledInsert, keys: Node): ReturningInsertInvokerDef[U, RU]

def createSequenceDDLBuilder(seq: Sequence[_]): SequenceDDLBuilder

def createTableDDLBuilder(table: Table[_]): TableDDLBuilder

def createUpdateInsertBuilder(node: Insert): InsertBuilder

def createUpdateInvoker[T](tree: Node, param: Any): UpdateInvoker[T]

def createUpsertBuilder(node: Insert): InsertBuilder

def defaultSqlTypeName(tmd: JdbcType[_]): String

def defaultTables(implicit session: SessionDef): List[MTable]

Jdbc meta data for all tables included in the Slick model by default

lazy val deleteCompiler: QueryCompiler

def ensuring(cond: (PostgresDriver) ⇒ Boolean, msg: ⇒ Any): PostgresDriver

def ensuring(cond: (PostgresDriver) ⇒ Boolean): PostgresDriver

def ensuring(cond: Boolean, msg: ⇒ Any): PostgresDriver

def ensuring(cond: Boolean): PostgresDriver

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

lazy val forceInsertCompiler: QueryCompiler

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

lazy val insertCompiler: QueryCompiler

val invokerMutateConcurrency: ResultSetConcurrency

val invokerMutateType: ResultSetType

val invokerPreviousAfterDelete: Boolean

final def isInstanceOf[T0]: Boolean

def jdbcTypeFor(t: Type): JdbcType[Any]

def likeEncode(s: String): String

val mappingCompiler: MappingCompiler

The MappingCompiler for this driver.

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val profile: JdbcProfile

The external interface of this driver which defines the API.

lazy val queryCompiler: QueryCompiler

def quoteIdentifier(id: String): String

quotes identifiers to avoid collisions with SQL keywords and other syntax issues

def quoteTableName(t: TableNode): String

val scalarFrom: Option[String]

The table name for scalar selects (e.

val simple: SimpleQL

A collection of values for using the query language with a single import statement.

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

def toString(): String

lazy val updateCompiler: QueryCompiler

lazy val updateInsertCompiler: QueryCompiler

lazy val upsertCompiler: QueryCompiler

lazy val useServerSideUpsert: Boolean

lazy val useServerSideUpsertReturning: Boolean

lazy val useTransactionForUpsert: Boolean

lazy val useTransactionForUpsertReturning: Boolean

def valueToSQLLiteral(v: Any, tpe: Type): String

Create a SQL representation of a literal value.

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (PostgresDriver, B)

val self: Any

val self: Any

def createModel(implicit session: SessionDef): Model

final def getTables: Invoker[MTable]

def x: PostgresDriver

def x: PostgresDriver