SqlParam = object
  case typ: ParamBindingType
  of paramNull:
      nil

  of paramString, paramBlob, paramJson, paramGeometry:
      strVal: string

  of paramInt:
      intVal: int64

  of paramUInt:
      uintVal: uint64

  of paramFloat:
      floatVal: float32

  of paramDouble:
      doubleVal: float64

  of paramDate, paramDateTime, paramTimestamp:
      datetimeVal: DateTime

  of paramTime:
      durVal: Duration

  

SqlPrepared = ref SqlPreparedObj

Row = seq[string]

Date = object of DateTime

ResultValue = object
  case typ: ResultValueType
  of rvtInteger:
      intVal: int

  of rvtLong:
      longVal: int64

  of rvtULong:
      uLongVal: uint64

  of rvtString, rvtBlob, rvtJson, rvtGeometry:
      strVal: string

  of rvtNull:
      nil

  of rvtFloat:
      floatVal: float32

  of rvtDouble:
      doubleVal: float64

  of rvtTime:
      durVal: Duration

  of rvtDate, rvtDateTime, rvtTimestamp:
      datetimeVal: DateTime

  

ResetConnection = true

proc asParam(s: string): SqlParam {...}{.raises: [], tags: [].}

proc asParam(i: int): SqlParam {...}{.raises: [], tags: [].}

proc asParam(i: uint): SqlParam {...}{.raises: [], tags: [].}

proc asParam(i: int64): SqlParam {...}{.raises: [], tags: [].}

proc asParam(i: uint64): SqlParam {...}{.raises: [], tags: [].}

proc asParam(f: float32): SqlParam {...}{.raises: [], tags: [].}

proc asParam(f: float64): SqlParam {...}{.raises: [], tags: [].}

proc asParam(d: DateTime): SqlParam {...}{.raises: [], tags: [].}

proc asParam(d: Date): SqlParam {...}{.raises: [], tags: [].}

proc asParam(d: Time): SqlParam {...}{.raises: [], tags: [].}

proc asParam(d: Duration): SqlParam {...}{.raises: [], tags: [].}

proc asParam(d: JsonNode): SqlParam {...}{.raises: [], tags: [].}

proc asParam(d: MyGeometry): SqlParam {...}{.raises: [], tags: [].}

proc asParam(b: bool): SqlParam {...}{.raises: [], tags: [].}

proc isNull(v: ResultValue): bool {...}{.inline, raises: [], tags: [].}

proc `$`(v: ResultValue): string {...}{.raises: [ValueError], tags: [].}

proc initDate(monthday: MonthdayRange; month: Month; year: int;
              zone: Timezone = local()): Date {...}{.raises: [], tags: [].}

proc prepare(conn: Connection; qs: string): Future[SqlPrepared] {...}{.
    raises: [Exception, ValueError],
    tags: [TimeEffect, RootEffect, ReadIOEffect].}

proc finalize(conn: Connection; pstmt: SqlPrepared): Future[void] {...}{.
    raises: [Exception], tags: [TimeEffect, RootEffect].}

proc reset(conn: Connection; pstmt: SqlPrepared): Future[void] {...}{.
    raises: [Exception], tags: [TimeEffect, RootEffect].}

proc reset(conn: Connection): Future[ResultSet[string]] {...}{.
    raises: [Exception, ValueError],
    tags: [TimeEffect, RootEffect, ReadIOEffect].}

proc formatBoundParams(conn: Connection; pstmt: SqlPrepared;
                       params: openArray[SqlParam]): string {...}{.
    raises: [ValueError, ProtocolError], tags: [].}

proc query(conn: Connection; pstmt: SqlPrepared;
           params: openArray[static[SqlParam]]): Future[void]

proc rawExec(conn: Connection; qs: string): Future[ResultSet[string]] {...}{.
    raises: [Exception, ValueError],
    tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc rawQuery(conn: Connection; qs: string; onlyFirst: bool = false): Future[
    ResultSet[string]] {...}{.raises: [Exception, ValueError],
                         tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc performPreparedQuery(conn: Connection; pstmt: SqlPrepared;
                          st: Future[void]; onlyFirst: static[bool] = false): Future[
    ResultSet[ResultValue]]

proc query(conn: Connection; pstmt: SqlPrepared;
           params: varargs[SqlParam, asParam]): Future[ResultSet[ResultValue]] {...}{.
    raises: [ValueError, ProtocolError, Exception],
    tags: [TimeEffect, RootEffect, ReadIOEffect, WriteIOEffect].}

proc selectDatabase(conn: Connection; database: string): Future[ResponseOK] {...}{.
    raises: [Exception, ValueError],
    tags: [TimeEffect, RootEffect, ReadIOEffect].}

proc exec(conn: Connection; qs: SqlQuery; args: varargs[string, `$`]): Future[
    ResultSet[string]] {...}{.raises: [Exception, ValueError],
                         tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc query(conn: Connection; qs: SqlQuery; onlyFirst: static[bool] = false;
           args: varargs[string, `$`]): Future[ResultSet[string]]

proc tryQuery(conn: Connection; qs: SqlQuery; args: varargs[string, `$`]): Future[
    bool] {...}{.raises: [Exception, ValueError],
            tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc getRow(conn: Connection; qs: SqlQuery; args: varargs[string, `$`]): Future[
    Row] {...}{.raises: [Exception, ValueError],
           tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc getAllRows(conn: Connection; qs: SqlQuery; args: varargs[string, `$`]): Future[
    seq[Row]] {...}{.raises: [Exception, ValueError],
                tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc getValue(conn: Connection; qs: SqlQuery; args: varargs[string, `$`]): Future[
    string] {...}{.raises: [Exception, ValueError],
              tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc tryInsertId(conn: Connection; qs: SqlQuery; args: varargs[string, `$`]): Future[
    int64] {...}{.raises: [Exception, ValueError],
             tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc insertId(conn: Connection; qs: SqlQuery; args: varargs[string, `$`]): Future[
    int64] {...}{.raises: [Exception, ValueError],
             tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc tryInsert(conn: Connection; qs: SqlQuery; pkName: string;
               args: varargs[string, `$`]): Future[int64] {...}{.
    raises: [Exception, ValueError],
    tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc insert(conn: Connection; qs: SqlQuery; pkName: string;
            args: varargs[string, `$`]): Future[int64] {...}{.
    raises: [Exception, ValueError],
    tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc setEncoding(conn: Connection; encoding: string): Future[bool] {...}{.
    raises: [Exception, ValueError],
    tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc startTransaction(conn: Connection): owned(Future[void]) {...}{.inline,
    raises: [Exception], tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc commit(conn: Connection): owned(Future[void]) {...}{.inline,
    raises: [Exception], tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

proc rollback(conn: Connection): owned(Future[void]) {...}{.inline,
    raises: [Exception], tags: [WriteIOEffect, RootEffect, ReadIOEffect].}

converter asInt8(v: ResultValue): int8 {...}{.raises: [ValueError], tags: [].}

converter asInt(v: ResultValue): int {...}{.raises: [ValueError], tags: [].}

converter asUInt(v: ResultValue): uint {...}{.raises: [ValueError], tags: [].}

converter asInt64(v: ResultValue): int64 {...}{.raises: [ValueError], tags: [].}

converter asUint64(v: ResultValue): uint64 {...}{.raises: [ValueError], tags: [].}

converter asFloat(v: ResultValue): float32 {...}{.raises: [ValueError], tags: [].}

converter asDouble(v: ResultValue): float64 {...}{.raises: [ValueError], tags: [].}

converter asString(v: ResultValue): string {...}{.raises: [ValueError], tags: [].}

converter asDateTime(v: ResultValue): DateTime {...}{.raises: [ValueError], tags: [].}

converter asDate(v: ResultValue): Date {...}{.raises: [], tags: [].}

converter asTime(v: ResultValue): Time {...}{.raises: [ValueError], tags: [].}

converter asDuration(v: ResultValue): Duration {...}{.raises: [ValueError], tags: [].}

converter asMyGeometry(v: ResultValue): MyGeometry {...}{.raises: [ValueError],
    tags: [].}

converter asBool(v: ResultValue): bool {...}{.raises: [ValueError], tags: [].}

converter asJson(v: ResultValue): JsonNode {...}{.
    raises: [IOError, OSError, JsonParsingError, ValueError, Exception],
    tags: [ReadIOEffect, WriteIOEffect].}

macro asParam(s: untyped): untyped

template transaction(conn: typed; process: untyped)