PostgresJdbcContextBase

abstract def close(): Unit

abstract val effect: ContextEffect[Result]

abstract def naming: N

abstract def probe(statement: String): Try[_]

abstract def withConnection[T](f: (Connection) ⇒ Result[T]): Result[T]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val MappedEncoding: getquill.MappedEncoding.type

def alias[T](property: (Quoted[T]) ⇒ Quoted[Any], name: String): DynamicAlias[T]

implicit macro def anyValDecoder[T <: AnyVal]: Decoder[T]

implicit macro def anyValEncoder[T <: AnyVal]: Encoder[T]

implicit def anyValMappedDecoder[I, O <: AnyVal](implicit mapped: MappedEncoding[I, O], decoder: Decoder[I]): Decoder[O]

implicit def anyValMappedEncoder[I <: AnyVal, O](implicit mapped: MappedEncoding[I, O], encoder: Encoder[O]): Encoder[I]

implicit def arrayBigDecimalDecoder[Col <: Seq[BigDecimal]](implicit bf: CBF[BigDecimal, Col]): Decoder[Col]

implicit def arrayBigDecimalEncoder[Col <: Seq[BigDecimal]]: Encoder[Col]

implicit def arrayBooleanDecoder[Col <: Seq[Boolean]](implicit bf: CBF[Boolean, Col]): Decoder[Col]

implicit def arrayBooleanEncoder[Col <: Seq[Boolean]]: Encoder[Col]

implicit def arrayByteDecoder[Col <: Seq[Byte]](implicit bf: CBF[Byte, Col]): Decoder[Col]

implicit def arrayByteEncoder[Col <: Seq[Byte]]: Encoder[Col]

implicit def arrayDateDecoder[Col <: Seq[Date]](implicit bf: CBF[Date, Col]): Decoder[Col]

implicit def arrayDateEncoder[Col <: Seq[Date]]: Encoder[Col]

def arrayDecoder[I, O, Col <: Seq[O]](mapper: (I) ⇒ O)(implicit bf: CBF[O, Col], tag: ClassTag[I]): Decoder[Col]

Generic encoder for JDBC arrays.

implicit def arrayDoubleDecoder[Col <: Seq[Double]](implicit bf: CBF[Double, Col]): Decoder[Col]

implicit def arrayDoubleEncoder[Col <: Seq[Double]]: Encoder[Col]

def arrayEncoder[T, Col <: Seq[T]](jdbcType: String, mapper: (T) ⇒ AnyRef): Encoder[Col]

Generic encoder for JDBC arrays.

implicit def arrayFloatDecoder[Col <: Seq[Float]](implicit bf: CBF[Float, Col]): Decoder[Col]

implicit def arrayFloatEncoder[Col <: Seq[Float]]: Encoder[Col]

implicit def arrayIntDecoder[Col <: Seq[Int]](implicit bf: CBF[Int, Col]): Decoder[Col]

implicit def arrayIntEncoder[Col <: Seq[Int]]: Encoder[Col]

implicit def arrayLocalDateDecoder[Col <: Seq[LocalDate]](implicit bf: CBF[LocalDate, Col]): Decoder[Col]

implicit def arrayLocalDateEncoder[Col <: Seq[LocalDate]]: Encoder[Col]

implicit def arrayLongDecoder[Col <: Seq[Long]](implicit bf: CBF[Long, Col]): Decoder[Col]

implicit def arrayLongEncoder[Col <: Seq[Long]]: Encoder[Col]

implicit def arrayMappedDecoder[I, O, Col[X] <: Seq[X]](implicit mapped: MappedEncoding[I, O], d: Decoder[Seq[I]], bf: scala.collection.compat.Factory[O, Col[O]]): Decoder[Col[O]]

implicit def arrayMappedEncoder[I, O, Col[X] <: Seq[X]](implicit mapped: MappedEncoding[I, O], e: Encoder[Seq[O]]): Encoder[Col[I]]

def arrayRawDecoder[T, Col <: Seq[T]](implicit arg0: ClassTag[T], bf: CBF[T, Col]): Decoder[Col]

Creates JDBC array decoder for type T which is already supported by database as array element.

def arrayRawEncoder[T, Col <: Seq[T]](jdbcType: Int): Encoder[Col]

Transform jdbcType int using parseJdbcType and calls overloaded method to create Encoder

def arrayRawEncoder[T, Col <: Seq[T]](jdbcType: String): Encoder[Col]

Creates JDBC array encoder for type T which is already supported by database as array element.

implicit def arrayShortDecoder[Col <: Seq[Short]](implicit bf: CBF[Short, Col]): Decoder[Col]

implicit def arrayShortEncoder[Col <: Seq[Short]]: Encoder[Col]

implicit def arrayStringDecoder[Col <: Seq[String]](implicit bf: CBF[String, Col]): Decoder[Col]

implicit def arrayStringEncoder[Col <: Seq[String]]: Encoder[Col]

implicit def arrayTimestampDecoder[Col <: Seq[Timestamp]](implicit bf: CBF[Timestamp, Col]): Decoder[Col]

implicit def arrayTimestampEncoder[Col <: Seq[Timestamp]]: Encoder[Col]

final def asInstanceOf[T0]: T0

implicit val bigDecimalDecoder: Decoder[BigDecimal]

implicit val bigDecimalEncoder: Encoder[BigDecimal]

implicit val booleanDecoder: Decoder[Boolean]

implicit val booleanEncoder: Encoder[Boolean]

implicit val byteArrayDecoder: Decoder[Array[Byte]]

implicit val byteArrayEncoder: Encoder[Array[Byte]]

implicit val byteDecoder: Decoder[Byte]

implicit val byteEncoder: Encoder[Byte]

def clone(): AnyRef

implicit val dateDecoder: Decoder[Date]

implicit val dateEncoder: Encoder[Date]

val dateTimeZone: TimeZone

def decoder[T](f: (ResultRow) ⇒ (Index) ⇒ T): Decoder[T]

def decoder[T](d: BaseDecoder[T]): Decoder[T]

implicit val doubleDecoder: Decoder[Double]

implicit val doubleEncoder: Encoder[Double]

def dynamicQuery[T](implicit t: ClassTag[T]): DynamicEntityQuery[T]

def dynamicQuerySchema[T](entity: String, columns: DynamicAlias[T]*): DynamicEntityQuery[T]

implicit macro def dynamicUnquote[T](d: DynamicQuery[T]): Query[T]

def encoder[T](sqlType: Int, f: (PrepareRow) ⇒ (Index, T) ⇒ Unit): Encoder[T]

def encoder[T](sqlType: Int, f: (Index, T, PrepareRow) ⇒ Unit): Encoder[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def executeAction[T](sql: String, prepare: Prepare = identityPrepare): Result[Long]

def executeActionReturning[O](sql: String, prepare: Prepare = identityPrepare, extractor: Extractor[O], returningBehavior: ReturnAction): Result[O]

def executeBatchAction(groups: List[BatchGroup]): Result[List[Long]]

def executeBatchActionReturning[T](groups: List[BatchGroupReturning], extractor: Extractor[T]): Result[List[T]]

def executeQuery[T](sql: String, prepare: Prepare = identityPrepare, extractor: Extractor[T] = identityExtractor): Result[List[T]]

def executeQuerySingle[T](sql: String, prepare: Prepare = identityPrepare, extractor: Extractor[T] = identityExtractor): Result[T]

def finalize(): Unit

implicit val floatDecoder: Decoder[Float]

implicit val floatEncoder: Encoder[Float]

final def getClass(): Class[_]

def handleSingleResult[T](list: List[T]): T

def handleSingleWrappedResult[T](list: Result[List[T]]): Result[T]

def hashCode(): Int

val identityExtractor: (ResultRow) ⇒ ResultRow

val identityPrepare: Prepare

val idiom: PostgresDialect.type

implicit def implicitOrd[T]: Ord[T]

def impliedQuerySchema[T](entity: String, columns: (T) ⇒ (Any, String)*): EntityQuery[T]

macro def insertMeta[T](exclude: (T) ⇒ Any*): InsertMeta[T]

implicit val intDecoder: Decoder[Int]

implicit val intEncoder: Encoder[Int]

final def isInstanceOf[T0]: Boolean

macro def lift[T](v: T): T

def liftCaseClass[T](v: T): T

macro def liftQuery[U[_] <: Iterable[_], T](v: U[T]): Query[T]

def liftQueryCaseClass[U[_] <: Iterable[_], T](v: U[T]): Query[T]

def liftQueryScalar[U[_] <: Iterable[_], T](v: U[T])(implicit e: Encoder[T]): Query[T]

def liftScalar[T](v: T)(implicit e: Encoder[T]): T

implicit val localDateDecoder: Decoder[LocalDate]

implicit val localDateEncoder: Encoder[LocalDate]

implicit val localDateTimeDecoder: Decoder[LocalDateTime]

implicit val localDateTimeEncoder: Encoder[LocalDateTime]

implicit val longDecoder: Decoder[Long]

implicit val longEncoder: Encoder[Long]

def mappedBaseDecoder[I, O](mapped: MappedEncoding[I, O], decoder: BaseDecoder[I]): BaseDecoder[O]

def mappedBaseEncoder[I, O](mapped: MappedEncoding[I, O], encoder: BaseEncoder[O]): BaseEncoder[I]

implicit def mappedDecoder[I, O](implicit mapped: MappedEncoding[I, O], d: Decoder[I]): Decoder[O]

implicit def mappedEncoder[I, O](implicit mapped: MappedEncoding[I, O], e: Encoder[O]): Encoder[I]

implicit macro def materializeInsertMeta[T]: InsertMeta[T]

implicit macro def materializeQueryMeta[T]: QueryMeta[T]

implicit macro def materializeSchemaMeta[T]: SchemaMeta[T]

implicit macro def materializeUpdateMeta[T]: UpdateMeta[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit def optionDecoder[T](implicit d: Decoder[T]): Decoder[Option[T]]

implicit def optionEncoder[T](implicit d: Encoder[T]): Encoder[Option[T]]

def parseJdbcType(intType: Int): String

Parses instances of java.sql.Types to string form so it can be used in creation of sql arrays.

macro def prepare(quoted: Quoted[BatchAction[Action[_]]]): (Session) ⇒ Result[List[PrepareRow]]

macro def prepare(quoted: Quoted[Action[_]]): (Session) ⇒ Result[PrepareRow]

macro def prepare[T](quoted: Quoted[Query[T]]): (Session) ⇒ Result[PrepareRow]

def prepareAction(sql: String, prepare: Prepare = identityPrepare): (Connection) ⇒ Result[PreparedStatement]

def prepareBatchAction(groups: List[BatchGroup]): (Connection) ⇒ Result[List[PreparedStatement]]

def prepareQuery[T](sql: String, prepare: Prepare = identityPrepare, extractor: Extractor[T] = identityExtractor): (Connection) ⇒ Result[PreparedStatement]

def prepareSingle(sql: String, prepare: Prepare = identityPrepare): (Connection) ⇒ Result[PreparedStatement]

def prepareWithReturning(sql: String, conn: Connection, returningBehavior: ReturnAction): PreparedStatement

macro def query[T]: EntityQuery[T]

macro def queryMeta[T, R](expand: Quoted[(Query[T]) ⇒ Query[R]])(extract: (R) ⇒ T): QueryMeta[T]

def querySchema[T](entity: String, columns: (T) ⇒ (Any, String)*): EntityQuery[T]

implicit macro def quote[T](body: T): Quoted[T]

macro def quote[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R](func: (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) ⇒ Quoted[R]): Quoted[(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) ⇒ R]

macro def quote[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](func: (T1, T2, T3, T4, T5, T6, T7, T8, T9) ⇒ Quoted[R]): Quoted[(T1, T2, T3, T4, T5, T6, T7, T8, T9) ⇒ R]

macro def quote[T1, T2, T3, T4, T5, T6, T7, T8, R](func: (T1, T2, T3, T4, T5, T6, T7, T8) ⇒ Quoted[R]): Quoted[(T1, T2, T3, T4, T5, T6, T7, T8) ⇒ R]

macro def quote[T1, T2, T3, T4, T5, T6, T7, R](func: (T1, T2, T3, T4, T5, T6, T7) ⇒ Quoted[R]): Quoted[(T1, T2, T3, T4, T5, T6, T7) ⇒ R]

macro def quote[T1, T2, T3, T4, T5, T6, R](func: (T1, T2, T3, T4, T5, T6) ⇒ Quoted[R]): Quoted[(T1, T2, T3, T4, T5, T6) ⇒ R]

macro def quote[T1, T2, T3, T4, T5, R](func: (T1, T2, T3, T4, T5) ⇒ Quoted[R]): Quoted[(T1, T2, T3, T4, T5) ⇒ R]

macro def quote[T1, T2, T3, T4, R](func: (T1, T2, T3, T4) ⇒ Quoted[R]): Quoted[(T1, T2, T3, T4) ⇒ R]

macro def quote[T1, T2, T3, R](func: (T1, T2, T3) ⇒ Quoted[R]): Quoted[(T1, T2, T3) ⇒ R]

macro def quote[T1, T2, R](func: (T1, T2) ⇒ Quoted[R]): Quoted[(T1, T2) ⇒ R]

macro def quote[T1, R](func: (T1) ⇒ Quoted[R]): Quoted[(T1) ⇒ R]

macro def quote[T](body: Quoted[T]): Quoted[T]

macro def run[T](quoted: Quoted[BatchAction[ActionReturning[_, T]]]): Result[RunBatchActionReturningResult[T]]

macro def run(quoted: Quoted[BatchAction[Action[_]]]): Result[RunBatchActionResult]

macro def run[T](quoted: Quoted[ActionReturning[_, T]]): Result[RunActionReturningResult[T]]

macro def run(quoted: Quoted[Action[_]]): Result[RunActionResult]

macro def run[T](quoted: Quoted[Query[T]]): Result[RunQueryResult[T]]

macro def run[T](quoted: Quoted[T]): Result[RunQuerySingleResult[T]]

macro def schemaMeta[T](entity: String, columns: (T) ⇒ (Any, String)*): SchemaMeta[T]

def set[T, U](property: String, value: Quoted[U]): DynamicSet[T, U]

def set[T, U](property: (Quoted[T]) ⇒ Quoted[U], value: Quoted[U]): DynamicSet[T, U]

def setOpt[T, U](property: (Quoted[T]) ⇒ Quoted[U], value: Option[U])(implicit enc: Encoder[U]): DynamicSet[T, U]

def setValue[T, U](property: String, value: U)(implicit enc: Encoder[U]): DynamicSet[T, U]

def setValue[T, U](property: (Quoted[T]) ⇒ Quoted[U], value: U)(implicit enc: Encoder[U]): DynamicSet[T, U]

implicit val shortDecoder: Decoder[Short]

implicit val shortEncoder: Encoder[Short]

def spliceLift[O](o: O)(implicit enc: Encoder[O]): Quoted[O]

implicit val stringDecoder: Decoder[String]

implicit val stringEncoder: Encoder[String]

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

implicit def toQuoted[T <: Action[_]](q: DynamicAction[T]): Quoted[T]

implicit def toQuoted[T](q: DynamicEntityQuery[T]): Quoted[EntityQuery[T]]

implicit def toQuoted[T](q: DynamicQuery[T]): Quoted[Query[T]]

def toString(): String

implicit def unquote[T](quoted: Quoted[T]): T

macro def updateMeta[T](exclude: (T) ⇒ Any*): UpdateMeta[T]

implicit val uuidDecoder: Decoder[UUID]

implicit val uuidEncoder: Encoder[UUID]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withConnectionWrapped[T](f: (Connection) ⇒ T): Result[T]