skunk-docs
1.1.0-M3
API
Generated with
skunk-docs/skunk/Session/Impl

Impl

skunk.Session.Impl
abstract class Impl[F[_]] extends Session[F]

Abstract implementation that use the MonadCancelThrow constraint to implement prepared-if-needed API

Attributes

Source
Session.scala
Graph
Supertypes
trait Session[F]
class Object
trait Matchable
class Any

Members list

Grouped members

Transactions

def transaction[A](isolationLevel: TransactionIsolationLevel, accessMode: TransactionAccessMode): Resource[F, Transaction[F]]

Resource that wraps a transaction block.

Resource that wraps a transaction block. It has the ability to specify a non-default isolation level and access mode.

Attributes

See also

Session#transaction for more information

Inherited from:
Session
Source
Session.scala
def transaction[A]: Resource[F, Transaction[F]]

Resource that wraps a transaction block.

Resource that wraps a transaction block. A transaction is begun before entering the use block, on success the block is executed, and on exit the following behavior holds.

  • If the block exits normally, and the session transaction status is

    • Active, then the transaction will be committed.

    • Idle, then this means the user terminated the transaction explicitly inside the block and there is nothing to be done.

    • Error then this means the user encountered and handled an error but left the transaction in a failed state, and the transaction will be rolled back.

  • If the block exits due to cancellation or an error and the session transaction status is not Idle then the transaction will be rolled back and any error will be re-raised.

Attributes

Inherited from:
Session
Source
Session.scala

Commands

override def execute[A](command: Command[A])(args: A): F[Completion]

Prepare if needed, then execute a parameterized command and yield a Completion.

Prepare if needed, then execute a parameterized command and yield a Completion.

Attributes

Definition Classes
Source
Session.scala
def execute(command: Command[Void]): F[Completion]

Execute a non-parameterized command and yield a Completion.

Execute a non-parameterized command and yield a Completion. If you have parameters use prepare instead.

Attributes

Inherited from:
Session
Source
Session.scala
override def pipe[A, B](query: Query[A, B], chunkSize: Int): (F, A) => B

Transform a Query into a Pipe from inputs to outputs.

Transform a Query into a Pipe from inputs to outputs.

Value parameters

chunkSize

how many rows must be fetched by page

Attributes

Definition Classes
Source
Session.scala
override def pipe[A](command: Command[A]): (F, A) => Completion

Transform a Command into a Pipe from inputs to Completions.

Transform a Command into a Pipe from inputs to Completions.

Attributes

Definition Classes
Source
Session.scala
def prepare[A](command: Command[A]): F[PreparedCommand[F, A]]

Prepares then caches an INSERT, UPDATE, or DELETE command that returns no rows.

Prepares then caches an INSERT, UPDATE, or DELETE command that returns no rows. The resulting PreparedCommand can be executed multiple times with different arguments.

Attributes

Inherited from:
Session
Source
Session.scala
def prepareR[A](command: Command[A]): Resource[F, PreparedCommand[F, A]]

Prepare an INSERT, UPDATE, or DELETE command that returns no rows.

Prepare an INSERT, UPDATE, or DELETE command that returns no rows. The resulting PreparedCommand can be executed multiple times with different arguments.

Note: this method only exists to ease migration from Skunk 0.3 and prior. Use the non-resource variant instead.

Attributes

Inherited from:
Session
Source
Session.scala
override def stream[A, B](command: Query[A, B])(args: A, chunkSize: Int): Stream[F, B]

Returns a stream that prepare if needed, then execute a parameterized query

Returns a stream that prepare if needed, then execute a parameterized query

Value parameters

chunkSize

how many rows must be fetched by page

Attributes

Definition Classes
Source
Session.scala

Queries

override def cursor[A, B](query: Query[A, B])(args: A): Resource[F, Cursor[F, B]]

Prepare if needed, then execute a parameterized query and returns a resource wrapping a cursor in the result set.

Prepare if needed, then execute a parameterized query and returns a resource wrapping a cursor in the result set.

Attributes

Definition Classes
Source
Session.scala
override def execute[A, B](query: Query[A, B])(args: A): F[List[B]]

Prepare if needed, then execute a parameterized query and yield all results.

Prepare if needed, then execute a parameterized query and yield all results. If you wish to limit returned rows use prepare instead.

Attributes

Definition Classes
Source
Session.scala
def execute[A](query: Query[Void, A]): F[List[A]]

Execute a non-parameterized query and yield all results.

Execute a non-parameterized query and yield all results. If you have parameters or wish to limit returned rows use prepare instead.

Attributes

Inherited from:
Session
Source
Session.scala
override def option[A, B](query: Query[A, B])(args: A): F[Option[B]]

Prepare if needed, then execute a parameterized query and yield at most one row, raising an exception if there are more.

Prepare if needed, then execute a parameterized query and yield at most one row, raising an exception if there are more.

Attributes

Definition Classes
Source
Session.scala
def option[A](query: Query[Void, A]): F[Option[A]]

Execute a non-parameterized query and yield at most one row, raising an exception if there are more.

Execute a non-parameterized query and yield at most one row, raising an exception if there are more. If you have parameters use prepare instead.

Attributes

Inherited from:
Session
Source
Session.scala
def prepare[A, B](query: Query[A, B]): F[PreparedQuery[F, A, B]]

Prepares then caches a query, yielding a PreparedQuery which can be executed multiple times with different arguments.

Prepares then caches a query, yielding a PreparedQuery which can be executed multiple times with different arguments.

Attributes

Inherited from:
Session
Source
Session.scala
def prepareR[A, B](query: Query[A, B]): Resource[F, PreparedQuery[F, A, B]]

Resource that prepares a query, yielding a PreparedQuery which can be executed multiple times with different arguments.

Resource that prepares a query, yielding a PreparedQuery which can be executed multiple times with different arguments.

Note: this method only exists to ease migration from Skunk 0.3 and prior. Use the non-resource variant instead.

Attributes

Inherited from:
Session
Source
Session.scala
override def unique[A, B](query: Query[A, B])(args: A): F[B]

Prepare if needed, then execute a parameterized query and yield exactly one row, raising an exception if there are more or fewer.

Prepare if needed, then execute a parameterized query and yield exactly one row, raising an exception if there are more or fewer.

Attributes

Definition Classes
Source
Session.scala
def unique[A](query: Query[Void, A]): F[A]

Execute a non-parameterized query and yield exactly one row, raising an exception if there are more or fewer.

Execute a non-parameterized query and yield exactly one row, raising an exception if there are more or fewer. If you have parameters use prepare instead.

Attributes

Inherited from:
Session
Source
Session.scala

Environment

def parameter(key: String): Stream[F, String]

Stream (possibly empty) of discrete values for the specified key, via parameters.

Stream (possibly empty) of discrete values for the specified key, via parameters.

Attributes

Inherited from:
Session
Source
Session.scala
def parameters: Signal[F, Map[String, String]]

Signal representing the current state of all Postgres configuration variables announced to this session.

Signal representing the current state of all Postgres configuration variables announced to this session. These are sent after authentication and are updated asynchronously if the runtime environment changes. The current keys are as follows (with example values), but these may change with future releases so you should be prepared to handle unexpected ones.

Map(
 "application_name"            -> "",
 "client_encoding"             -> "UTF8",
 "DateStyle"                   -> "ISO, MDY",
 "integer_datetimes"           -> "on",       // cannot change after startup
 "IntervalStyle"               -> "postgres",
 "is_superuser"                -> "on",
 "server_encoding"             -> "UTF8",     // cannot change after startup
 "server_version"              -> "9.5.3",    // cannot change after startup
 "session_authorization"       -> "postgres",
 "standard_conforming_strings" -> "on",
 "TimeZone"                    -> "US/Pacific",
)

Attributes

Inherited from:
Session
Source
Session.scala
def transactionStatus: Signal[F, TransactionStatus]

Signal representing the current transaction status.

Signal representing the current transaction status.

Attributes

Inherited from:
Session
Source
Session.scala

Channels

def channel(name: Identifier): Channel[F, String, String]

A named asynchronous channel that can be used for inter-process communication.

A named asynchronous channel that can be used for inter-process communication.

Attributes

Inherited from:
Session
Source
Session.scala

Value members

Inherited methods

def describeCache: Cache[F]

Each session has access to the pool-wide cache of all statements that have been checked via the Describe protocol, which allows us to skip subsequent checks.

Each session has access to the pool-wide cache of all statements that have been checked via the Describe protocol, which allows us to skip subsequent checks. Users can inspect and clear the cache through this accessor.

Attributes

Inherited from:
Session
Source
Session.scala
def parseCache: Cache[F]

Each session has access to a cache of all statements that have been parsed by the Parse protocol, which allows us to skip a network round-trip.

Each session has access to a cache of all statements that have been parsed by the Parse protocol, which allows us to skip a network round-trip. Users can inspect and clear the cache through this accessor.

Attributes

Inherited from:
Session
Source
Session.scala
def typer: Typer

Attributes

Inherited from:
Session
Source
Session.scala

Deprecated and Inherited methods

def cursor[A, B](query: Query[A, B], args: A)(implicit ev: DummyImplicit): Resource[F, Cursor[F, B]]

Attributes

Deprecated
true
Inherited from:
Session
Source
Session.scala
def execute[A](command: Command[A], args: A)(implicit ev: DummyImplicit): F[Completion]

Attributes

Deprecated
true
Inherited from:
Session
Source
Session.scala
def execute[A, B](query: Query[A, B], args: A)(implicit ev: DummyImplicit): F[List[B]]

Attributes

Deprecated
true
Inherited from:
Session
Source
Session.scala
def option[A, B](query: Query[A, B], args: A)(implicit ev: DummyImplicit): F[Option[B]]

Attributes

Deprecated
true
Inherited from:
Session
Source
Session.scala
def stream[A, B](query: Query[A, B], args: A, chunkSize: Int)(implicit ev: DummyImplicit): Stream[F, B]

Attributes

Deprecated
true
Inherited from:
Session
Source
Session.scala
def unique[A, B](query: Query[A, B], args: A)(implicit ev: DummyImplicit): F[B]

Attributes

Deprecated
true
Inherited from:
Session
Source
Session.scala
Generated with