Query0

abstract def accumulate[F[_]](implicit arg0: MonadCombine[F]): ConnectionIO[F[B]]

Program in ConnectionIO yielding an F[B] accumulated via MonadPlus append.

abstract def analysis: ConnectionIO[Analysis]

Program to construct an analysis of this query's SQL statement and asserted parameter and column types.

abstract def map[C](f: (B) ⇒ C): Query0[C]

abstract def nel: ConnectionIO[NonEmptyList[B]]

Program in ConnectionIO yielding a NonEmptyList[B] and raising an exception if the resultset does not have at least one row.

abstract def option: ConnectionIO[Option[B]]

Program in ConnectionIO yielding an optional B and raising an exception if the resultset has more than one row.

abstract def outputAnalysis: ConnectionIO[Analysis]

Program to construct an analysis of this query's SQL statement and result set column types.

abstract def pos: Option[Pos]

An optional Pos indicating the source location where this Query was constructed.

abstract def processWithChunkSize(n: Int): Stream[ConnectionIO, B]

Process with given chunk factor, with effect type ConnectionIO yielding elements of type B.

abstract def sql: String

The SQL string.

abstract def to[F[_]](implicit cbf: CanBuildFrom[Nothing, B, F[B]]): ConnectionIO[F[B]]

Program in ConnectionIO yielding an F[B] accumulated via the provided CanBuildFrom.

abstract def toFragment: Fragment

Turn this Query0 into a Fragment.

abstract def unique: ConnectionIO[B]

Program in ConnectionIO yielding a unique B and raising an exception if the resultset does not have exactly one row.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def list: ConnectionIO[List[B]]

Convenience method; equivalent to to[List]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def process: Stream[ConnectionIO, B]

Process with default chunk factor, with effect type ConnectionIO yielding elements of type B.

def sink(f: (B) ⇒ ConnectionIO[Unit]): ConnectionIO[Unit]

Convenience method; equivalent to process.sink(f)

def stream: Stream[ConnectionIO, B]

FS2 Friendly Alias for process.

def streamWithChunkSize(n: Int): Stream[ConnectionIO, B]

FS2 Friendly Alias for processWithChunkSize.

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

def toString(): String

def vector: ConnectionIO[Vector[B]]

Convenience method; equivalent to to[Vector]

final def wait(): Unit

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

final def wait(arg0: Long): Unit