Transactor

doobie.util.transactor.Transactor
See theTransactor companion class
object Transactor

Attributes

Companion
class
Source
transactor.scala
Graph
Supertypes
class Object
trait Matchable
class Any
Self type
Transactor.type

Members list

Grouped members

Constructors

Construct a Transactor that wraps an existing Connection. Closing the connection is the responsibility of the caller.

Construct a Transactor that wraps an existing Connection. Closing the connection is the responsibility of the caller.

Value parameters

blocker

for blocking database operations

connection

a raw JDBC Connection to wrap

Attributes

Source
transactor.scala

Construct a constructor of Transactor[M, D] for some D <: DataSource When calling this constructor you should explicitly supply the effect type M e.g. Transactor.fromDataSource[IO](myDataSource, connectEC)

Construct a constructor of Transactor[M, D] for some D <: DataSource When calling this constructor you should explicitly supply the effect type M e.g. Transactor.fromDataSource[IO](myDataSource, connectEC)

Value parameters

logHandler

For logging events emitted by this Transactor

Attributes

Source
transactor.scala

Module of constructors for Transactor that use the JDBC DriverManager to allocate connections. Note that DriverManager is unbounded and will happily allocate new connections until server resources are exhausted. It is usually preferable to use DataSourceTransactor with an underlying bounded connection pool (as with H2Transactor and HikariTransactor for instance). Blocking operations on DriverManagerTransactor are executed on an unbounded cached daemon thread pool by default, so you are also at risk of exhausting system threads. TL;DR this is fine for console apps but don't use it for a web application.

Module of constructors for Transactor that use the JDBC DriverManager to allocate connections. Note that DriverManager is unbounded and will happily allocate new connections until server resources are exhausted. It is usually preferable to use DataSourceTransactor with an underlying bounded connection pool (as with H2Transactor and HikariTransactor for instance). Blocking operations on DriverManagerTransactor are executed on an unbounded cached daemon thread pool by default, so you are also at risk of exhausting system threads. TL;DR this is fine for console apps but don't use it for a web application.

Attributes

Source
transactor.scala

Lenses

Attributes

Source
transactor.scala

Attributes

Source
transactor.scala

Attributes

Source
transactor.scala
def connect[M[_], A]: Lens[Aux[M, A], A => Resource[M, Connection]]

Attributes

Source
transactor.scala
def interpret[M[_]]: Lens[Transactor[M], Interpreter[M]]

Attributes

Source
transactor.scala
def kernel[M[_], A]: Lens[Aux[M, A], A]

Attributes

Source
transactor.scala
def oops[M[_]]: Lens[Transactor[M], ConnectionIO[Unit]]

Attributes

Source
transactor.scala
def strategy[M[_]]: Lens[Transactor[M], Strategy]

Attributes

Source
transactor.scala

Type members

Classlikes

Attributes

Source
transactor.scala
Supertypes
class Object
trait Matchable
class Any

Attributes

Source
transactor.scala
Supertypes
class Object
trait Matchable
class Any

Attributes

Source
transactor.scala
Supertypes
class Object
trait Matchable
class Any

Types

type Aux[M[_], A0] = Transactor[M] { type A = A0; }

Attributes

Source
transactor.scala

Value members

Concrete methods

def apply[M[_], A0](kernel0: A0, connect0: A0 => Resource[M, Connection], interpret0: Interpreter[M], strategy0: Strategy): Aux[M, A0]

Attributes

Source
transactor.scala