UnmanagedSession

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

Use this Session as the dynamicSession for running the supplied thunk.

final def asInstanceOf[T0]: T0

lazy val capabilities: JdbcBackend.DatabaseCapabilities

def clone(): AnyRef

def close(): Unit

Close this Session.

val conn: Connection

final def createStatement(defaultType: ResultSetType = ResultSetType.ForwardOnly, defaultConcurrency: ResultSetConcurrency = ResultSetConcurrency.ReadOnly, defaultHoldability: ResultSetHoldability = ResultSetHoldability.Default): Statement

def database: JdbcBackend.Database

var doRollback: Boolean

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

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

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

def ensuring(cond: Boolean): UnmanagedSession

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def forParameters(rsType: ResultSetType = resultSetType, rsConcurrency: ResultSetConcurrency = resultSetConcurrency, rsHoldability: ResultSetHoldability = resultSetHoldability): JdbcBackend.Session

Create a new Slick Session wrapping the same JDBC connection, but using the given values as defaults for resultSetType, resultSetConcurrency and resultSetHoldability.

def force(): Unit

Force an actual database session to be opened.

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

var inTransaction: Boolean

final def isInstanceOf[T0]: Boolean

def loggingStatement(st: Statement): Statement

lazy val metaData: DatabaseMetaData

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var open: Boolean

def performRollback(): Unit

final def prepareInsertStatement(sql: String, columnIndexes: Array[Int]): PreparedStatement

final def prepareInsertStatement(sql: String, columnNames: Array[String] = new Array[String](0)): PreparedStatement

final def prepareStatement(sql: String, defaultType: ResultSetType = ResultSetType.ForwardOnly, defaultConcurrency: ResultSetConcurrency = ResultSetConcurrency.ReadOnly, defaultHoldability: ResultSetHoldability = ResultSetHoldability.Default): PreparedStatement

def resultSetConcurrency: ResultSetConcurrency

def resultSetHoldability: ResultSetHoldability

def resultSetType: ResultSetType

def rollback(): Unit

Call this method within a withTransaction call to roll back the current transaction after withTransaction returns.

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def withPreparedInsertStatement[T](sql: String, columnIndexes: Array[Int])(f: (PreparedStatement) ⇒ T): T

A wrapper around the JDBC Connection's prepareInsertStatement method, that automatically closes the statement.

final def withPreparedInsertStatement[T](sql: String, columnNames: Array[String] = new Array[String](0))(f: (PreparedStatement) ⇒ T): T

A wrapper around the JDBC Connection's prepareInsertStatement method, that automatically closes the statement.

final def withPreparedStatement[T](sql: String, defaultType: ResultSetType = ResultSetType.ForwardOnly, defaultConcurrency: ResultSetConcurrency = ResultSetConcurrency.ReadOnly, defaultHoldability: ResultSetHoldability = ResultSetHoldability.Default)(f: (PreparedStatement) ⇒ T): T

A wrapper around the JDBC Connection's prepareStatement method, that automatically closes the statement.

final def withStatement[T](defaultType: ResultSetType = ResultSetType.ForwardOnly, defaultConcurrency: ResultSetConcurrency = ResultSetConcurrency.ReadOnly, defaultHoldability: ResultSetHoldability = ResultSetHoldability.Default)(f: (Statement) ⇒ T): T

A wrapper around the JDBC Connection's createStatement method, that automatically closes the statement.

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

Run the supplied function within a transaction.

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

val self: Any

val self: Any

def x: UnmanagedSession

def x: UnmanagedSession