jaredzhou/moonpg/wire - mooncakes.io

README
U
Format
U
Value
Tr
Closer
Tr
Fetching
Tr
FromRow
Tr
FromValue
Tr
QueryExecutor
Tr
Rows
Tr
ToValue
Tr
Tx
Tr
TxBeginner
- ::to_reprPgError::to_repr
- ::to_reprValueError::to_repr
- ::closeConnRows::close
- ::columnsConnRows::columns
- ::get_rowConnRows::get_row
- ::has_nextConnRows::has_next
- ::equalConnStatus::equal
- ::not_equalConnStatus::not_equal
- ::to_reprConnStatus::to_repr
- ::backend_pidConnection::backend_pid
- ::begin_copyConnection::begin_copy
- ::begin_txConnection::begin_tx
- ::closeConnection::close
- ::copy_inConnection::copy_in
- ::deallocateConnection::deallocate
- ::executeConnection::execute
- ::fetchConnection::fetch
- ::fetch_oneConnection::fetch_one
- ::is_closedConnection::is_closed
- ::listenConnection::listen
- ::notifyConnection::notify
- ::paramConnection::param
- ::pingConnection::ping
- ::queryConnection::query
- ::query_oneConnection::query_one
- ::server_versionConnection::server_version
- ::statusConnection::status
- ::unlistenConnection::unlisten
- ::finishCopyWriter::finish
- ::write_rowCopyWriter::write_row
- ::commitDbTx::commit
- ::executeDbTx::execute
- ::fetchDbTx::fetch
- ::fetch_oneDbTx::fetch_one
- ::queryDbTx::query
- ::query_oneDbTx::query_one
- ::rollbackDbTx::rollback
- ::affected_rowsExecResult::affected_rows
- ::closeExecResult::close
T
IdleConn
T
IsolationLevel
- ::recvListener::recv
- ::acquirePool::acquire
- ::begin_txPool::begin_tx
- ::closePool::close
- ::executePool::execute
- ::fetchPool::fetch
- ::fetch_onePool::fetch_one
- ::idlePool::idle
- ::maintainPool::maintain
- ::newPool::new
- ::queryPool::query
- ::query_onePool::query_one
- ::start_maintenancePool::start_maintenance
- ::statsPool::stats
- ::totalPool::total
- ::try_acquirePool::try_acquire
- ::newPoolConfig::new
- ::begin_txPoolConn::begin_tx
- ::closePoolConn::close
- ::executePoolConn::execute
- ::fetchPoolConn::fetch
- ::fetch_onePoolConn::fetch_one
- ::queryPoolConn::query
- ::query_onePoolConn::query_one
- ::releasePoolConn::release
- ::commitPoolDbTx::commit
- ::executePoolDbTx::execute
- ::fetchPoolDbTx::fetch
- ::fetch_onePoolDbTx::fetch_one
- ::queryPoolDbTx::query
- ::query_onePoolDbTx::query_one
- ::rollbackPoolDbTx::rollback
- ::closePoolRows::close
- ::columnsPoolRows::columns
- ::get_rowPoolRows::get_row
- ::has_nextPoolRows::has_next
T
PoolStats
- ::columnsRow::columns
- ::getRow::get
- ::get_by_nameRow::get_by_name
- ::equalTimestamp::equal
- ::from_rowTimestamp::from_row
- ::from_valueTimestamp::from_value
- ::not_equalTimestamp::not_equal
- ::to_reprTimestamp::to_repr
- ::to_valueTimestamp::to_value
- ::defaultTxOptions::default
V
begin_func
V
build_begin_sql
V
connect
V
get_env
V
null
V
row_from_raw

jaredzhou/moonpg/wire does not have a README file

Message

pub(open) trait Message {
  fn encode(Self) -> Bytes raise WireError
  fn decode(BytesView) -> Self raise WireError
  fn describe(Self) -> String
}

Trait for PostgreSQL wire-protocol messages.

Every message knows how to encode itself to wire-format Bytes and decode itself from wire-format Bytes.

Transport

source

pub(open) trait Transport : @moonbitlang/async/io.Reader
Reader + @moonbitlang/async/io.Writer
Writer {
  fn close(Self) -> Unit
}

A bidirectional stream that can be closed.

Supertrait of @io.Reader + @io.Writer with an explicit close method.

WireError

source

pub(all) suberror WireError {
  PgServer(String)
  Connect(String)
  Auth(String)
  Parse(String)
  InvalidMessage(String)
  IO(String)
}

Wire-protocol errors.

AuthMethod

source

pub(all) enum AuthMethod {
  Ok
  CleartextPassword
  MD5Password
  SASL
  SASLContinue
  SASLFinal
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Authentication method requested by the server.

AuthMethod::equal

source

fn AuthMethod::equal(AuthMethod, AuthMethod) -> Bool

AuthMethod::from_int

source

fn AuthMethod::from_int(v : Int) -> AuthMethod raise WireError

AuthMethod::not_equal

source

fn AuthMethod::not_equal(x : AuthMethod, y : AuthMethod) -> Bool

AuthMethod::to_repr

source

fn AuthMethod::to_repr(AuthMethod) -> @moonbitlang/core/debug.Repr
Repr

AuthenticationCleartextPassword

source

pub(all) struct AuthenticationCleartextPassword {
}

PostgreSQL AuthenticationCleartextPassword (B).

impl Message for AuthenticationCleartextPassword

fn decode(_payload : BytesView) -> AuthenticationCleartextPassword raise WireError

source

fn describe(_self : AuthenticationCleartextPassword) -> String

source

fn encode(_self : AuthenticationCleartextPassword) -> Bytes raise WireError

source

AuthenticationCleartextPassword::decode

source

fn AuthenticationCleartextPassword::decode(_payload : BytesView) -> AuthenticationCleartextPassword raise WireError

AuthenticationCleartextPassword::describe

source

fn AuthenticationCleartextPassword::describe(_self : AuthenticationCleartextPassword) -> String

AuthenticationCleartextPassword::encode

source

fn AuthenticationCleartextPassword::encode(_self : AuthenticationCleartextPassword) -> Bytes raise WireError

AuthenticationMD5Password

source

pub(all) struct AuthenticationMD5Password {
  salt : Bytes
}

PostgreSQL AuthenticationMD5Password (B).

impl Message for AuthenticationMD5Password

fn decode(payload : BytesView) -> AuthenticationMD5Password raise WireError

source

fn describe(_self : AuthenticationMD5Password) -> String

source

fn encode(self : AuthenticationMD5Password) -> Bytes raise WireError

source

AuthenticationMD5Password::decode

source

fn AuthenticationMD5Password::decode(payload : BytesView) -> AuthenticationMD5Password raise WireError

AuthenticationMD5Password::describe

source

fn AuthenticationMD5Password::describe(_self : AuthenticationMD5Password) -> String

AuthenticationMD5Password::encode

source

fn AuthenticationMD5Password::encode(self : AuthenticationMD5Password) -> Bytes raise WireError

AuthenticationOk

source

pub(all) struct AuthenticationOk {
}

PostgreSQL AuthenticationOk (B).

impl Message for AuthenticationOk

AuthenticationOk::decode

source

fn AuthenticationOk::decode(_payload : BytesView) -> AuthenticationOk raise WireError

AuthenticationOk::describe

source

fn AuthenticationOk::describe(_self : AuthenticationOk) -> String

AuthenticationOk::encode

source

fn AuthenticationOk::encode(_self : AuthenticationOk) -> Bytes raise WireError

AuthenticationSASL

source

pub(all) struct AuthenticationSASL {
  mechanisms : Array[String]
}

PostgreSQL AuthenticationSASL (B).

impl Message for AuthenticationSASL

AuthenticationSASL::decode

source

fn AuthenticationSASL::decode(payload : BytesView) -> AuthenticationSASL raise WireError

AuthenticationSASL::describe

source

fn AuthenticationSASL::describe(self : AuthenticationSASL) -> String

AuthenticationSASL::encode

source

fn AuthenticationSASL::encode(self : AuthenticationSASL) -> Bytes raise WireError

AuthenticationSASLContinue

source

pub(all) struct AuthenticationSASLContinue {
  data : Bytes
}

PostgreSQL AuthenticationSASLContinue (B).

impl Message for AuthenticationSASLContinue

fn decode(payload : BytesView) -> AuthenticationSASLContinue raise WireError

source

fn describe(self : AuthenticationSASLContinue) -> String

source

fn encode(self : AuthenticationSASLContinue) -> Bytes raise WireError

source

AuthenticationSASLContinue::decode

source

fn AuthenticationSASLContinue::decode(payload : BytesView) -> AuthenticationSASLContinue raise WireError

AuthenticationSASLContinue::describe

source

fn AuthenticationSASLContinue::describe(self : AuthenticationSASLContinue) -> String

AuthenticationSASLContinue::encode

source

fn AuthenticationSASLContinue::encode(self : AuthenticationSASLContinue) -> Bytes raise WireError

AuthenticationSASLFinal

source

pub(all) struct AuthenticationSASLFinal {
  data : Bytes
}

PostgreSQL AuthenticationSASLFinal (B).

impl Message for AuthenticationSASLFinal

fn decode(payload : BytesView) -> AuthenticationSASLFinal raise WireError

source

fn describe(self : AuthenticationSASLFinal) -> String

source

fn encode(self : AuthenticationSASLFinal) -> Bytes raise WireError

source

AuthenticationSASLFinal::decode

source

fn AuthenticationSASLFinal::decode(payload : BytesView) -> AuthenticationSASLFinal raise WireError

AuthenticationSASLFinal::describe

source

fn AuthenticationSASLFinal::describe(self : AuthenticationSASLFinal) -> String

AuthenticationSASLFinal::encode

source

fn AuthenticationSASLFinal::encode(self : AuthenticationSASLFinal) -> Bytes raise WireError

BackendKeyData

source

pub(all) struct BackendKeyData {
  pid : Int
  secret_key : Int
}

PostgreSQL BackendKeyData (B).

impl Message for BackendKeyData

BackendKeyData::decode

source

fn BackendKeyData::decode(payload : BytesView) -> BackendKeyData raise WireError

BackendKeyData::describe

source

fn BackendKeyData::describe(self : BackendKeyData) -> String

BackendKeyData::encode

source

fn BackendKeyData::encode(self : BackendKeyData) -> Bytes raise WireError

BackendMessage

source

pub(all) enum BackendMessage {
  AuthenticationOk(AuthenticationOk)
  AuthenticationCleartextPassword(AuthenticationCleartextPassword)
  AuthenticationMD5Password(AuthenticationMD5Password)
  AuthenticationSASL(AuthenticationSASL)
  AuthenticationSASLContinue(AuthenticationSASLContinue)
  AuthenticationSASLFinal(AuthenticationSASLFinal)
  BackendKeyData(BackendKeyData)
  ReadyForQuery(ReadyForQuery)
  ParameterStatus(ParameterStatus)
  ErrorResponse(ErrorResponse)
  NoticeResponse(NoticeResponse)
  RowDescription(RowDescription)
  DataRow(DataRow)
  CommandComplete(CommandComplete)
  EmptyQueryResponse(EmptyQueryResponse)
  ParseComplete(ParseComplete)
  BindComplete(BindComplete)
  CloseComplete(CloseComplete)
  ParameterDescription(ParameterDescription)
  NoData(NoData)
  PortalSuspended(PortalSuspended)
  CopyInResponse(CopyInResponse)
  CopyOutResponse(CopyOutResponse)
  CopyBothResponse(CopyBothResponse)
  CopyData(CopyData)
  CopyDone(CopyDone)
  NotificationResponse(NotificationResponse)
  NegotiateProtocolVersion(NegotiateProtocolVersion)
  Unknown(Byte, BytesView)
}

Tagged union of all backend (server → client) messages.

Each variant wraps a concrete message struct that implements Message.

BackendMessage::describe

source

fn BackendMessage::describe(self : BackendMessage) -> String

Bind

source

pub(all) struct Bind {
  portal : String
  statement : String
  param_formats : Array[Int]
  params : Array[Bytes?]
  result_formats : Array[Int]
}

PostgreSQL Bind (F) — creates a portal from a prepared statement.

impl Message for Bind

Bind::decode

source

fn Bind::decode(payload : BytesView) -> Bind raise WireError

Bind::describe

source

fn Bind::describe(self : Bind) -> String

Bind::encode

source

fn Bind::encode(self : Bind) -> Bytes raise WireError

BindComplete

source

pub(all) struct BindComplete {
}

PostgreSQL BindComplete (B).

impl Message for BindComplete

BindComplete::decode

source

fn BindComplete::decode(_payload : BytesView) -> BindComplete raise WireError

BindComplete::describe

source

fn BindComplete::describe(_self : BindComplete) -> String

BindComplete::encode

source

fn BindComplete::encode(_self : BindComplete) -> Bytes raise WireError

BytesMut

source

pub(all) struct BytesMut {
  // private fields
}

Mutable byte buffer with random-access writes, built on Array[Byte].

Unlike Buffer (append-only), BytesMut allows writing at any position. Convert to immutable Bytes via to_bytes() (one copy).

The typical wire-protocol pattern:

append type byte + placeholder length
append payload
overwrite the length bytes via set_*
to_bytes() for the final wire-format Bytes

BytesMut::append_byte

source

fn BytesMut::append_byte(self : BytesMut, b : Byte) -> Unit

Append a single byte.

BytesMut::append_bytes

source

fn BytesMut::append_bytes(self : BytesMut, b : Bytes) -> Unit

Append raw bytes.

BytesMut::append_int_be

source

fn BytesMut::append_int_be(self : BytesMut, v : Int) -> Unit

Append a 32-bit big-endian integer (4 bytes).

BytesMut::append_string_null

source

fn BytesMut::append_string_null(self : BytesMut, s : String) -> Unit

Append a null-terminated UTF-8 string.

BytesMut::len

source

fn BytesMut::len(self : BytesMut) -> Int

BytesMut::new

source

fn BytesMut::new() -> BytesMut

BytesMut::set_byte

source

fn BytesMut::set_byte(self : BytesMut, pos : Int, b : Byte) -> Unit

Overwrite a single byte at pos. Pads with zeros if pos >= len.

BytesMut::set_int_be

source

fn BytesMut::set_int_be(self : BytesMut, pos : Int, v : Int) -> Unit

Write a 32-bit big-endian integer at pos (overwrites 4 bytes).

BytesMut::to_bytes

source

fn BytesMut::to_bytes(self : BytesMut) -> Bytes

Convert to immutable Bytes. One copy (Bytes::from_array).

Close

source

pub(all) struct Close {
  variant : Byte
  name : String
}

Close a prepared statement (b'S') or portal (b'P').

impl Message for Close

Close::decode

source

fn Close::decode(payload : BytesView) -> Close raise WireError

Close::describe

source

fn Close::describe(self : Close) -> String

Close::encode

source

fn Close::encode(self : Close) -> Bytes raise WireError

CloseComplete

source

pub(all) struct CloseComplete {
}

PostgreSQL CloseComplete (B).

impl Message for CloseComplete

CloseComplete::decode

source

fn CloseComplete::decode(_payload : BytesView) -> CloseComplete raise WireError

CloseComplete::describe

source

fn CloseComplete::describe(_self : CloseComplete) -> String

CloseComplete::encode

source

fn CloseComplete::encode(_self : CloseComplete) -> Bytes raise WireError

CommandComplete

source

pub(all) struct CommandComplete {
  tag : CommandTag
}

PostgreSQL CommandComplete (B).

The tag describes the completed command, e.g. "SELECT 1", "INSERT 0 1".

impl Message for CommandComplete

CommandComplete::decode

source

fn CommandComplete::decode(payload : BytesView) -> CommandComplete raise WireError

CommandComplete::describe

source

fn CommandComplete::describe(self : CommandComplete) -> String

CommandComplete::encode

source

fn CommandComplete::encode(self : CommandComplete) -> Bytes raise WireError

CommandTag

source

pub struct CommandTag {
  tag : String
}

Parsed command-completion tag from CommandComplete.

PostgreSQL returns tags like "SELECT 1", "INSERT 0 1", "DELETE 5".

impl Show for CommandTag

CommandTag::command

source

fn CommandTag::command(self : CommandTag) -> String

The SQL command word, e.g. "SELECT", "INSERT", "DELETE".

CommandTag::new

source

fn CommandTag::new(tag : String) -> CommandTag

CommandTag::output

source

fn CommandTag::output(self : CommandTag, logger : &Logger) -> Unit

CommandTag::raw

source

fn CommandTag::raw(self : CommandTag) -> String

The raw tag string as sent by the server.

CommandTag::rows_affected

source

fn CommandTag::rows_affected(self : CommandTag) -> Int?

Number of rows affected, if the tag includes a row count.

For SELECT 1 returns Some(1), for INSERT 0 3 returns Some(3), for CREATE TABLE returns None.

CommandTag::to_string

source

fn CommandTag::to_string(self : CommandTag) -> String

Config

source

pub(all) struct Config {
  host : String
  hostaddr : String?
  port : Int
  user : String
  database : String?
  password : String?
  sslmode : String
  sslrootcert : String?
  sslcert : String?
  sslkey : String?
  application_name : String?
  connect_timeout : Int
  statement_timeout : Int
  read_timeout : Int
  target_session_attrs : String
  trace : Bool
}

PostgreSQL connection configuration.

Two connection-string formats are accepted, mirroring libpq's fe-connect.c:

URI (parsed via @url.parse):

postgresql://[user[:password]@][host][:port][/dbname][?param=value&...]

Keyword/Value:

host=localhost port=5432 user=alice dbname=mydb password=secret

Values may be single-quoted ('has spaces') and use backslash escaping.

Config::from_connstr

source

fn Config::from_connstr(s : String) -> Config raise WireError

Parse a PostgreSQL connection string.

Auto-detects URI (postgresql:// / postgres://) vs keyword/value format.

Config::new

source

fn Config::new(user : String, host? : String, hostaddr? : String?, port? : Int, database? : String?, password? : String?, sslmode? : String, sslrootcert? : String?, sslcert? : String?, sslkey? : String?, application_name? : String?, connect_timeout? : Int, statement_timeout? : Int, read_timeout? : Int, target_session_attrs? : String, trace? : Bool) -> Config

Create a Config with explicit parameter values.

ConnParam

source

pub(all) struct ConnParam {
  key : String
  value : String
}

A key-value parameter pair used in StartupMessage.

ConnStatus

source

pub enum ConnStatus {
  Connecting
  Closed
  Idle
  Busy
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Connection lifecycle states.

ConnStatus::equal

source

fn ConnStatus::equal(ConnStatus, ConnStatus) -> Bool

ConnStatus::not_equal

source

fn ConnStatus::not_equal(x : ConnStatus, y : ConnStatus) -> Bool

ConnStatus::to_repr

source

fn ConnStatus::to_repr(ConnStatus) -> @moonbitlang/core/debug.Repr
Repr

CopyBothResponse

source

pub(all) struct CopyBothResponse {
  overall_format : Int
  column_formats : Array[Int]
}

PostgreSQL CopyBothResponse (B) — server is ready for both COPY directions.

impl Message for CopyBothResponse

CopyBothResponse::decode

source

fn CopyBothResponse::decode(payload : BytesView) -> CopyBothResponse raise WireError

CopyBothResponse::describe

source

fn CopyBothResponse::describe(_self : CopyBothResponse) -> String

CopyBothResponse::encode

source

fn CopyBothResponse::encode(self : CopyBothResponse) -> Bytes raise WireError

CopyData

source

pub(all) struct CopyData {
  data : Bytes
}

PostgreSQL CopyData (F) — data row for COPY ... FROM STDIN.

impl Message for CopyData

CopyData::decode

source

fn CopyData::decode(_payload : BytesView) -> CopyData raise WireError

CopyData::describe

source

fn CopyData::describe(_self : CopyData) -> String

CopyData::encode

source

fn CopyData::encode(self : CopyData) -> Bytes raise WireError

CopyDone

source

pub(all) struct CopyDone {
}

PostgreSQL CopyDone (F) — signal end of COPY data.

impl Message for CopyDone

CopyDone::decode

source

fn CopyDone::decode(_payload : BytesView) -> CopyDone raise WireError

CopyDone::describe

source

fn CopyDone::describe(_self : CopyDone) -> String

CopyDone::encode

source

fn CopyDone::encode(_self : CopyDone) -> Bytes raise WireError

CopyFail

source

pub(all) struct CopyFail {
  message : String
}

PostgreSQL CopyFail (F) — abort COPY with an error message.

impl Message for CopyFail

CopyFail::decode

source

fn CopyFail::decode(_payload : BytesView) -> CopyFail raise WireError

CopyFail::describe

source

fn CopyFail::describe(_self : CopyFail) -> String

CopyFail::encode

source

fn CopyFail::encode(self : CopyFail) -> Bytes raise WireError

CopyInResponse

source

pub(all) struct CopyInResponse {
  overall_format : Int
  column_formats : Array[Int]
}

PostgreSQL CopyInResponse (B) — server is ready to receive COPY data.

impl Message for CopyInResponse

fn decode(payload : BytesView) -> CopyInResponse raise WireError

source

Decode CopyInResponse. Format: Int8 overall, Int16 ncols, Int16[ncols].

fn describe(_self : CopyInResponse) -> String

source

fn encode(self : CopyInResponse) -> Bytes raise WireError

source

CopyInResponse::decode

source

fn CopyInResponse::decode(payload : BytesView) -> CopyInResponse raise WireError

CopyInResponse::describe

source

fn CopyInResponse::describe(_self : CopyInResponse) -> String

CopyInResponse::encode

source

fn CopyInResponse::encode(self : CopyInResponse) -> Bytes raise WireError

CopyOutResponse

source

pub(all) struct CopyOutResponse {
  overall_format : Int
  column_formats : Array[Int]
}

PostgreSQL CopyOutResponse (B) — server is sending COPY data.

impl Message for CopyOutResponse

CopyOutResponse::decode

source

fn CopyOutResponse::decode(payload : BytesView) -> CopyOutResponse raise WireError

CopyOutResponse::describe

source

fn CopyOutResponse::describe(_self : CopyOutResponse) -> String

CopyOutResponse::encode

source

fn CopyOutResponse::encode(self : CopyOutResponse) -> Bytes raise WireError

DataRow

source

pub(all) struct DataRow {
  values : Array[Bytes?]
}

PostgreSQL DataRow (B).

Each column value is Some(bytes) for non-NULL or None for NULL. Values are owned Bytes — safe to hold across message boundaries.

impl Message for DataRow

DataRow::decode

source

fn DataRow::decode(payload : BytesView) -> DataRow raise WireError

DataRow::describe

source

fn DataRow::describe(self : DataRow) -> String

DataRow::encode

source

fn DataRow::encode(self : DataRow) -> Bytes raise WireError

Describe

source

pub(all) struct Describe {
  variant : Byte
  name : String
}

Describe a prepared statement (b'S') or portal (b'P').

impl Message for Describe

Describe::decode

source

fn Describe::decode(payload : BytesView) -> Describe raise WireError

Describe::describe

source

fn Describe::describe(self : Describe) -> String

Describe::encode

source

fn Describe::encode(self : Describe) -> Bytes raise WireError

EmptyQueryResponse

source

pub(all) struct EmptyQueryResponse {
}

PostgreSQL EmptyQueryResponse (B).

Sent when the query string is empty or whitespace-only.

impl Message for EmptyQueryResponse

EmptyQueryResponse::decode

source

fn EmptyQueryResponse::decode(_payload : BytesView) -> EmptyQueryResponse raise WireError

EmptyQueryResponse::describe

source

fn EmptyQueryResponse::describe(_self : EmptyQueryResponse) -> String

EmptyQueryResponse::encode

source

fn EmptyQueryResponse::encode(_self : EmptyQueryResponse) -> Bytes raise WireError

ErrorField

source

pub(all) struct ErrorField {
  field_type : Byte
  value : String
} derive(@moonbitlang/core/debug.Debug
Debug)

A single typed field in an ErrorResponse or NoticeResponse.

ErrorField::to_repr

source

fn ErrorField::to_repr(ErrorField) -> @moonbitlang/core/debug.Repr
Repr

ErrorResponse

source

pub(all) struct ErrorResponse {
  fields : Array[ErrorField]
}

PostgreSQL ErrorResponse (B).

impl Message for ErrorResponse

ErrorResponse::code

source

fn ErrorResponse::code(self : ErrorResponse) -> String?

ErrorResponse::decode

source

fn ErrorResponse::decode(payload : BytesView) -> ErrorResponse raise WireError

ErrorResponse::describe

source

fn ErrorResponse::describe(self : ErrorResponse) -> String

ErrorResponse::encode

source

fn ErrorResponse::encode(self : ErrorResponse) -> Bytes raise WireError

ErrorResponse::message

source

fn ErrorResponse::message(self : ErrorResponse) -> String?

ErrorResponse::severity

source

fn ErrorResponse::severity(self : ErrorResponse) -> String?

Execute

source

pub(all) struct Execute {
  portal : String
  max_rows : Int
}

PostgreSQL Execute (F) — runs a portal.

impl Message for Execute

Execute::decode

source

fn Execute::decode(payload : BytesView) -> Execute raise WireError

Execute::describe

source

fn Execute::describe(self : Execute) -> String

Execute::encode

source

fn Execute::encode(self : Execute) -> Bytes raise WireError

FieldDescription

source

pub(all) struct FieldDescription {
  name : String
  table_oid : Int
  attr_num : Int
  type_oid : Int
  typlen : Int
  typmod : Int
  format : Int
}

Per-field metadata carried in a RowDescription message.

FieldDescription::type_name

source

fn FieldDescription::type_name(self : FieldDescription) -> String

Return the human-readable type name for this column (e.g. "int4", "text"). Looks up type_oid in the built-in OID map; returns "unknown" for unrecognised OIDs. No database round-trip.

Flush

source

pub(all) struct Flush {
}

PostgreSQL Flush (F) — flush server output buffer without Sync's transaction effects.

impl Message for Flush

Flush::decode

source

fn Flush::decode(_payload : BytesView) -> Flush raise WireError

Flush::describe

source

fn Flush::describe(_self : Flush) -> String

Flush::encode

source

fn Flush::encode(_self : Flush) -> Bytes raise WireError

NegotiateProtocolVersion

source

pub(all) struct NegotiateProtocolVersion {
  newest_minor_version : Int
  options : Array[String]
}

PostgreSQL NegotiateProtocolVersion (B).

Sent when the client requests a protocol version newer than the server supports within the same major version. The client should re-send its StartupMessage with the version offered by the server.

impl Message for NegotiateProtocolVersion

fn decode(payload : BytesView) -> NegotiateProtocolVersion raise WireError

source

fn describe(self : NegotiateProtocolVersion) -> String

source

fn encode(self : NegotiateProtocolVersion) -> Bytes raise WireError

source

NegotiateProtocolVersion::decode

source

fn NegotiateProtocolVersion::decode(payload : BytesView) -> NegotiateProtocolVersion raise WireError

NegotiateProtocolVersion::describe

source

fn NegotiateProtocolVersion::describe(self : NegotiateProtocolVersion) -> String

NegotiateProtocolVersion::encode

source

fn NegotiateProtocolVersion::encode(self : NegotiateProtocolVersion) -> Bytes raise WireError

NoData

source

pub(all) struct NoData {
}

PostgreSQL NoData (B) — returned when Describe finds no result columns.

impl Message for NoData

NoData::decode

source

fn NoData::decode(_payload : BytesView) -> NoData raise WireError

NoData::describe

source

fn NoData::describe(_self : NoData) -> String

NoData::encode

source

fn NoData::encode(_self : NoData) -> Bytes raise WireError

NoticeResponse

source

pub(all) struct NoticeResponse {
  fields : Array[ErrorField]
}

PostgreSQL NoticeResponse (B).

impl Message for NoticeResponse

NoticeResponse::decode

source

fn NoticeResponse::decode(payload : BytesView) -> NoticeResponse raise WireError

NoticeResponse::describe

source

fn NoticeResponse::describe(self : NoticeResponse) -> String

NoticeResponse::encode

source

fn NoticeResponse::encode(self : NoticeResponse) -> Bytes raise WireError

NoticeResponse::message

source

fn NoticeResponse::message(self : NoticeResponse) -> String?

NotificationResponse

source

pub(all) struct NotificationResponse {
  pid : Int
  channel : String
  payload : String
}

PostgreSQL NotificationResponse (B).

Sent when a NOTIFY command is executed for a channel the client is listening on (via LISTEN). Can arrive at any time — even during a query — so the driver queues them transparently.

impl Message for NotificationResponse

fn decode(payload : BytesView) -> NotificationResponse raise WireError

source

fn describe(self : NotificationResponse) -> String

source

fn encode(self : NotificationResponse) -> Bytes raise WireError

source

NotificationResponse::decode

source

fn NotificationResponse::decode(payload : BytesView) -> NotificationResponse raise WireError

NotificationResponse::describe

source

fn NotificationResponse::describe(self : NotificationResponse) -> String

NotificationResponse::encode

source

fn NotificationResponse::encode(self : NotificationResponse) -> Bytes raise WireError

ParameterDescription

source

pub(all) struct ParameterDescription {
  param_types : Array[Int]
}

PostgreSQL ParameterDescription (B).

Provides the OIDs of the parameters expected by a prepared statement.

impl Message for ParameterDescription

fn decode(payload : BytesView) -> ParameterDescription raise WireError

source

fn describe(self : ParameterDescription) -> String

source

fn encode(self : ParameterDescription) -> Bytes raise WireError

source

ParameterDescription::decode

source

fn ParameterDescription::decode(payload : BytesView) -> ParameterDescription raise WireError

ParameterDescription::describe

source

fn ParameterDescription::describe(self : ParameterDescription) -> String

ParameterDescription::encode

source

fn ParameterDescription::encode(self : ParameterDescription) -> Bytes raise WireError

ParameterStatus

source

pub(all) struct ParameterStatus {
  name : String
  value : String
}

PostgreSQL ParameterStatus (B).

impl Message for ParameterStatus

ParameterStatus::decode

source

fn ParameterStatus::decode(payload : BytesView) -> ParameterStatus raise WireError

ParameterStatus::describe

source

fn ParameterStatus::describe(self : ParameterStatus) -> String

ParameterStatus::encode

source

fn ParameterStatus::encode(self : ParameterStatus) -> Bytes raise WireError

Parse

source

pub(all) struct Parse {
  name : String
  query : String
  param_types : Array[Int]
}

PostgreSQL Parse (F) — creates a prepared statement.

impl Message for Parse

Parse::decode

source

fn Parse::decode(payload : BytesView) -> Parse raise WireError

Parse::describe

source

fn Parse::describe(self : Parse) -> String

Parse::encode

source

fn Parse::encode(self : Parse) -> Bytes raise WireError

ParseComplete

source

pub(all) struct ParseComplete {
}

PostgreSQL ParseComplete (B).

impl Message for ParseComplete

ParseComplete::decode

source

fn ParseComplete::decode(_payload : BytesView) -> ParseComplete raise WireError

ParseComplete::describe

source

fn ParseComplete::describe(_self : ParseComplete) -> String

ParseComplete::encode

source

fn ParseComplete::encode(_self : ParseComplete) -> Bytes raise WireError

PasswordMessage

source

pub(all) struct PasswordMessage {
  password : String
}

PostgreSQL PasswordMessage (F).

impl Message for PasswordMessage

PasswordMessage::decode

source

fn PasswordMessage::decode(payload : BytesView) -> PasswordMessage raise WireError

PasswordMessage::describe

source

fn PasswordMessage::describe(_self : PasswordMessage) -> String

PasswordMessage::encode

source

fn PasswordMessage::encode(self : PasswordMessage) -> Bytes raise WireError

PortalSuspended

source

pub(all) struct PortalSuspended {
}

PostgreSQL PortalSuspended (B) — Execute reached max_rows before the portal was fully consumed.

impl Message for PortalSuspended

PortalSuspended::decode

source

fn PortalSuspended::decode(_payload : BytesView) -> PortalSuspended raise WireError

PortalSuspended::describe

source

fn PortalSuspended::describe(_self : PortalSuspended) -> String

PortalSuspended::encode

source

fn PortalSuspended::encode(_self : PortalSuspended) -> Bytes raise WireError

ProtocolVersion

source

pub enum ProtocolVersion {
  V3_0
  V3_2
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

PostgreSQL protocol version constants.

ProtocolVersion::equal

source

fn ProtocolVersion::equal(ProtocolVersion, ProtocolVersion) -> Bool

ProtocolVersion::minor

source

fn ProtocolVersion::minor(self : ProtocolVersion) -> Int

ProtocolVersion::not_equal

source

fn ProtocolVersion::not_equal(x : ProtocolVersion, y : ProtocolVersion) -> Bool

ProtocolVersion::to_int32

source

fn ProtocolVersion::to_int32(self : ProtocolVersion) -> Int

ProtocolVersion::to_repr

source

fn ProtocolVersion::to_repr(ProtocolVersion) -> @moonbitlang/core/debug.Repr
Repr

Query

source

pub(all) struct Query {
  sql : String
}

PostgreSQL Query (F).

impl Message for Query

Query::decode

source

fn Query::decode(payload : BytesView) -> Query raise WireError

Query::describe

source

fn Query::describe(_self : Query) -> String

Query::encode

source

fn Query::encode(self : Query) -> Bytes raise WireError

RawConn

source

pub struct RawConn {
  stream : Stream
  trace : Bool
  host : String
  port : Int
  params : @moonbitlang/core/hashmap.HashMap
HashMap[String, String]
  pid : Int
  secret_key : Int
  tx_status : TransactionStatus
  status : ConnStatus
  read_timeout_ms : Int
}

Raw PostgreSQL wire-protocol connection.

Handles TCP connection, SSL negotiation, startup message exchange, authentication, and message send/receive. After a successful handshake the connection is in the Idle state and can be used for queries.

RawConn::backend_pid

source

fn RawConn::backend_pid(self : RawConn) -> Int

RawConn::begin_copy_in

source

async fn RawConn::begin_copy_in(self : RawConn, sql : String) -> Unit raise WireError

Begin a COPY ... FROM STDIN operation.

Sends the query, locks the connection, and reads until CopyInResponse. After this, use send_copy_data to stream rows and end_copy_in to finish.

RawConn::bind

source

async fn RawConn::bind(self : RawConn, portal : String, statement : String, params : Array[Bytes?], param_formats : Array[Int], result_formats : Array[Int]) -> Unit raise WireError

Bind a portal to a prepared statement, supplying concrete parameter values.

portal — portal name (empty string = unnamed). statement — source prepared statement name (empty = unnamed). params — parameter values (None = SQL NULL). param_formats — 0 = text, 1 = binary. Empty array = all text; single element = applies to all. result_formats — 0 = text, 1 = binary. Same convention as param_formats.

The server responds with BindComplete. Call describe_portal afterwards to get the result-column descriptions.

RawConn::close

source

fn RawConn::close(self : RawConn) -> Unit

RawConn::close_portal

source

async fn RawConn::close_portal(self : RawConn, name : String) -> Unit raise WireError

Close a portal.

RawConn::close_statement

source

async fn RawConn::close_statement(self : RawConn, name : String) -> Unit raise WireError

Close a prepared statement.

RawConn::copy_in

source

async fn RawConn::copy_in(self : RawConn, sql : String, rows : Iter[String]) -> Unit raise WireError

Execute COPY ... FROM STDIN with rows from an iterator.

Convenience wrapper around begin_copy_in + send_copy_data loop + end_copy_in. Rows are pulled from the iterator one at a time — only a single row is held in memory.

RawConn::describe_portal

source

async fn RawConn::describe_portal(self : RawConn, portal : String) -> Array[FieldDescription] raise WireError

Describe a portal to learn its result-column layout.

Returns the columns array suitable for passing to execute. Returns an empty array when the portal produces no result set (e.g. INSERT / UPDATE / DELETE).

RawConn::describe_statement

source

async fn RawConn::describe_statement(self : RawConn, name : String) -> Array[Int] raise WireError

Describe a prepared statement to learn its parameter types.

Returns integer OIDs for each parameter placeholder. Useful when the statement was prepared with param_types set to [] or [0].

RawConn::end_copy_in

source

async fn RawConn::end_copy_in(self : RawConn) -> Unit raise WireError

Finish a COPY ... FROM STDIN operation.

Sends CopyDone, then reads CommandComplete + ReadyForQuery and unlocks the connection. Pairs with begin_copy_in.

RawConn::end_query

source

async fn RawConn::end_query(self : RawConn) -> Unit raise WireError

Drain remaining messages until ReadyForQuery, update tx_status, and unlock the connection. Pairs with start_query.

If an ErrorResponse is encountered during drain, it finishes draining through to ReadyForQuery and then raises PgServer.

RawConn::execute

source

async fn RawConn::execute(self : RawConn, portal : String, columns : Array[FieldDescription], max_rows : Int) -> ResultReader raise WireError

Execute a portal and return a ResultReader for pulling rows.

Sends Execute followed by Sync so that ReadyForQuery follows naturally after the last row. The returned ResultReader streams DataRow messages and drains through ReadyForQuery on close.

columns — obtained from a prior describe_portal call. max_rows — row limit; 0 = unlimited.

RawConn::execute_prepared

source

async fn RawConn::execute_prepared(self : RawConn, stmt_name : String, param_values : Array[Bytes?], param_formats : Array[Int], result_formats : Array[Int]) -> ResultReader raise WireError

Execute a parameterized SQL command via the extended query protocol.

An unnamed statement is parsed from sql, bound to an unnamed portal with the given parameter values, and executed. The returned ResultReader streams rows from the server.

Parameter conventions (mirrors pgx ExecParams):

param_oids — OID for each parameter value. 0 = let the server infer. Must have length 0, 1 (applied to all), or equal to param_values. An empty array means "infer all".
param_formats — format code per parameter: 0 = text, 1 = binary. Must have length 0, 1 (applied to all), or equal to param_values. An empty array means "all text".
result_formats — format code per result column: 0 = text, 1 = binary. Must have length 0, 1 (applied to all), or equal to the number of result columns. An empty array means "all text".

RawConn::execute_statement

source

async fn RawConn::execute_statement(self : RawConn, stmt_desc : StatementDescription, param_values : Array[Bytes?], param_formats : Array[Int], result_formats? : Array[Int]) -> ResultReader raise WireError

Execute a prepared statement using its StatementDescription.

Unlike execute_prepared, this does not send a Describe message because the result-column layout is already known from the StatementDescription. Saves one network round-trip.

param_values — one element per parameter placeholder. None = NULL. Values must already be encoded per the corresponding format code.

param_formats — 0 = text, 1 = binary. Length must be 0, 1, or equal to param_values.

result_formats — optional; when absent, synthesized from stmt_desc.fields[].format.

RawConn::flush

source

async fn RawConn::flush(self : RawConn) -> Unit raise WireError

Send a Flush message to the server.

Tells the server to flush any buffered output. Used in the extended query protocol.

RawConn::is_busy

source

fn RawConn::is_busy(self : RawConn) -> Bool

RawConn::is_closed

source

fn RawConn::is_closed(self : RawConn) -> Bool

RawConn::param

source

fn RawConn::param(self : RawConn, name : String) -> String?

RawConn::prepare

source

async fn RawConn::prepare(self : RawConn, name : String, sql : String, param_types : Array[Int]) -> StatementDescription raise WireError

Create a prepared statement.

Sends Parse + Describe(S) + Sync, then reads responses until ReadyForQuery. Returns a StatementDescription with the inferred parameter OIDs and result-column layout.

If name is empty the unnamed statement is used, which is overwritten by the next Parse on that connection.

param_types — OID for each parameter; 0 = leave type unspecified. An empty array means "infer all".

RawConn::read_byte

source

async fn RawConn::read_byte(self : RawConn) -> Byte

Read a single byte from the stream. Used for the SSL negotiation response (S or N), which is not a framed message.

RawConn::receive

source

async fn RawConn::receive(self : RawConn) -> BackendMessage raise WireError

Receive the next backend message from the server.

Reads the 1-byte type tag, then the 4-byte length, then the payload, and decodes into a BackendMessage. Closes the connection on any I/O or protocol error, and applies read_timeout to every read.

RawConn::receive_wait

source

async fn RawConn::receive_wait(self : RawConn) -> BackendMessage raise WireError

Receive the next backend message, ignoring read_timeout.

For the LISTEN/NOTIFY loop, where a silent socket is the normal state: a channel can stay quiet for hours, so waiting is not a failure.

RawConn::send

source

async fn[M : Message] RawConn::send(self : RawConn, msg : M) -> Unit raise WireError

Send any frontend message.

Calls msg.encode() to get the wire-format bytes, then writes them to the socket. For StartupMessage and SSLRequest the message has no type byte; for all other messages the type byte is included.

RawConn::send_copy_data

source

async fn RawConn::send_copy_data(self : RawConn, data : Bytes) -> Unit raise WireError

Send a CopyData message — a single row or chunk of COPY data.

RawConn::send_copy_done

source

async fn RawConn::send_copy_done(self : RawConn) -> Unit raise WireError

Signal successful completion of COPY data transfer.

RawConn::send_copy_fail

source

async fn RawConn::send_copy_fail(self : RawConn, message : String) -> Unit raise WireError

Abort a COPY operation with an error message.

RawConn::set_trace

source

fn RawConn::set_trace(self : RawConn, on : Bool) -> Unit

Enable or disable protocol tracing.

RawConn::simple_query

source

async fn RawConn::simple_query(self : RawConn, sql : String) -> ResultReader raise WireError

Execute a simple query and return a ResultReader.

RawConn::start_query

source

async fn RawConn::start_query(self : RawConn, sql : String) -> Unit raise WireError

Begin a query: lock the connection and send the SQL.

After start_query, read responses via receive, then call end_query to drain remaining messages and unlock.

RawConn::status

source

fn RawConn::status(self : RawConn) -> ConnStatus

RawConn::sync

source

async fn RawConn::sync(self : RawConn) -> Unit raise WireError

Force the server to process all pending extended-query messages and return ReadyForQuery. Updates conn.tx_status.

RawConn::terminate

source

async fn RawConn::terminate(self : RawConn) -> Unit

Send Terminate and close.

RawConn::try_close

source

async fn RawConn::try_close(self : RawConn) -> Unit

Best-effort emergency close for unrecoverable errors.

Use this when the connection cannot be safely reused:

I/O errors — broken pipe, connection reset, unexpected EOF.
Protocol desynchronisation — invalid message length/type, the stream cannot be trusted any more.
Authentication failures.
Server FATAL / PANIC errors (as opposed to recoverable ERROR).

What it does:

Immediately marks the connection Closed so nothing else tries to use it.
Sends a cancel request on a new TCP connection so the server stops any in-flight query.
Sends Terminate on the original connection.
Closes the socket.

Steps 2 and 3 run concurrently via @async.all. All errors are silently ignored — this is fire-and-forget cleanup.

RawConn::tx_status

source

fn RawConn::tx_status(self : RawConn) -> TransactionStatus

ReadyForQuery

source

pub(all) struct ReadyForQuery {
  status : TransactionStatus
}

PostgreSQL ReadyForQuery (B).

impl Message for ReadyForQuery

ReadyForQuery::decode

source

fn ReadyForQuery::decode(payload : BytesView) -> ReadyForQuery raise WireError

ReadyForQuery::describe

source

fn ReadyForQuery::describe(self : ReadyForQuery) -> String

ReadyForQuery::encode

source

fn ReadyForQuery::encode(self : ReadyForQuery) -> Bytes raise WireError

Result

source

pub struct Result {
  columns : Array[FieldDescription]
  rows : Array[Array[Bytes?]]
  tag : CommandTag
}

All rows from a query, collected eagerly.

ResultReader

source

pub struct ResultReader {
  conn : RawConn
  columns : Array[FieldDescription]
  row_values : Array[Bytes?]?
  closed : Bool
  tag : CommandTag?
}

Pull-based query result reader.

Obtained from RawConn::simple_query. Two usage styles:

Pull — iterate row by row:

while r.has_next() { let row = r.data_row(); ... }
let tag = r.close()

Batch — read everything at once:

let result = r.read()

ResultReader::close

source

async fn ResultReader::close(self : ResultReader) -> CommandTag raise WireError

Close the reader: drain remaining rows and messages, unlock, return tag. Safe to call multiple times.

ResultReader::columns

source

fn ResultReader::columns(self : ResultReader) -> Array[FieldDescription]

ResultReader::data_row

source

fn ResultReader::data_row(self : ResultReader) -> Array[Bytes?] raise WireError

Return the row cached by the last has_next() call. Panics if has_next() was not called or returned false.

ResultReader::has_next

source

async fn ResultReader::has_next(self : ResultReader) -> Bool raise WireError

Wait for the next row. Returns true if a row is available (call data_row to get it), false when all rows have been consumed.

On false the remaining messages up to ReadyForQuery have already been drained and the connection unlocked.

ResultReader::read

source

async fn ResultReader::read(self : ResultReader) -> Result raise WireError

Eagerly read all remaining rows into a Result.

RowDescription

source

pub(all) struct RowDescription {
  columns : Array[FieldDescription]
}

PostgreSQL RowDescription (B).

impl Message for RowDescription

RowDescription::decode

source

fn RowDescription::decode(payload : BytesView) -> RowDescription raise WireError

RowDescription::describe

source

fn RowDescription::describe(self : RowDescription) -> String

RowDescription::encode

source

fn RowDescription::encode(self : RowDescription) -> Bytes raise WireError

SASLInitialResponse

source

pub(all) struct SASLInitialResponse {
  mechanism : String
  initial_response : Bytes
}

PostgreSQL SASLInitialResponse (F).

impl Message for SASLInitialResponse

SASLInitialResponse::decode

source

fn SASLInitialResponse::decode(payload : BytesView) -> SASLInitialResponse raise WireError

SASLInitialResponse::describe

source

fn SASLInitialResponse::describe(self : SASLInitialResponse) -> String

SASLInitialResponse::encode

source

fn SASLInitialResponse::encode(self : SASLInitialResponse) -> Bytes raise WireError

SASLResponse

source

pub(all) struct SASLResponse {
  data : Bytes
}

PostgreSQL SASLResponse (F).

impl Message for SASLResponse

SASLResponse::decode

source

fn SASLResponse::decode(payload : BytesView) -> SASLResponse raise WireError

SASLResponse::describe

source

fn SASLResponse::describe(self : SASLResponse) -> String

SASLResponse::encode

source

fn SASLResponse::encode(self : SASLResponse) -> Bytes raise WireError

SSLRequest

source

pub(all) struct SSLRequest {
}

PostgreSQL SSLRequest (F).

impl Message for SSLRequest

SSLRequest::decode

source

fn SSLRequest::decode(payload : BytesView) -> SSLRequest raise WireError

SSLRequest::describe

source

fn SSLRequest::describe(_self : SSLRequest) -> String

SSLRequest::encode

source

fn SSLRequest::encode(_self : SSLRequest) -> Bytes raise WireError

StartupMessage

source

pub(all) struct StartupMessage {
  version : ProtocolVersion
  params : Array[ConnParam]
}

PostgreSQL StartupMessage (F).

impl Message for StartupMessage

StartupMessage::decode

source

fn StartupMessage::decode(payload : BytesView) -> StartupMessage raise WireError

StartupMessage::describe

source

fn StartupMessage::describe(self : StartupMessage) -> String

StartupMessage::encode

source

fn StartupMessage::encode(self : StartupMessage) -> Bytes raise WireError

StatementDescription

source

pub(all) struct StatementDescription {
  name : String
  sql : String
  param_oids : Array[Int]
  fields : Array[FieldDescription]
}

Describes a prepared statement: its parameter OIDs and result-column layout (if the statement returns rows).

Stream

source

pub(all) enum Stream {
  Plain(@moonbitlang/async/socket.Tcp
Tcp)
  Tls(@moonbitlang/async/tls.Tls
Tls)
}

Concrete transport — either a plain TCP connection or a TLS-wrapped one.

impl Transport for Stream

impl Reader for Stream

impl Writer for Stream

Stream::_direct_read

source

async fn Stream::_direct_read(self : Stream, buf : FixedArray[Byte], offset~ : Int, max_len~ : Int) -> Int

Stream::_get_internal_buffer

source

fn Stream::_get_internal_buffer(self : Stream) -> @moonbitlang/async/io.ReaderBuffer
ReaderBuffer

Stream::close

source

fn Stream::close(self : Stream) -> Unit

Stream::drop

source

async fn Stream::drop(self : Stream, len : Int) -> Int

Stream::read

source

async fn Stream::read(self : Stream, dst : FixedArray[Byte], offset? : Int, max_len? : Int) -> Int

Stream::read_all

source

async fn Stream::read_all(self : Stream) -> &@moonbitlang/async/io.Data
Data

Stream::read_exactly

source

async fn Stream::read_exactly(self : Stream, len : Int) -> Bytes

Stream::read_some

source

async fn Stream::read_some(self : Stream, max_len? : Int) -> Bytes?

Stream::read_until

source

async fn Stream::read_until(self : Stream, sep : StringView) -> String?

Stream::write

source

async fn Stream::write(self : Stream, data : &@moonbitlang/async/io.Data
Data) -> Unit

Stream::write_once

source

async fn Stream::write_once(self : Stream, buf : Bytes, offset~ : Int, len~ : Int) -> Int

Stream::write_reader

source

async fn Stream::write_reader(self : Stream, reader : &@moonbitlang/async/io.Reader
Reader) -> Unit

Sync

source

pub(all) struct Sync {
}

PostgreSQL Sync (F) — commit point; server responds with ReadyForQuery.

impl Message for Sync

Sync::decode

source

fn Sync::decode(_payload : BytesView) -> Sync raise WireError

Sync::describe

source

fn Sync::describe(_self : Sync) -> String

Sync::encode

source

fn Sync::encode(_self : Sync) -> Bytes raise WireError

Terminate

source

pub(all) struct Terminate {
}

PostgreSQL Terminate (F).

impl Message for Terminate

Terminate::decode

source

fn Terminate::decode(_payload : BytesView) -> Terminate raise WireError

Terminate::describe

source

fn Terminate::describe(_self : Terminate) -> String

Terminate::encode

source

fn Terminate::encode(_self : Terminate) -> Bytes raise WireError

TransactionStatus

source

pub(all) enum TransactionStatus {
  Idle
  InBlock
  Failed
} derive(Eq, @moonbitlang/core/debug.Debug
Debug)

Transaction status indicator from ReadyForQuery.

impl Show for TransactionStatus

TransactionStatus::equal

source

fn TransactionStatus::equal(TransactionStatus, TransactionStatus) -> Bool

TransactionStatus::from_byte

source

fn TransactionStatus::from_byte(b : Byte) -> TransactionStatus raise WireError

TransactionStatus::not_equal

source

fn TransactionStatus::not_equal(x : TransactionStatus, y : TransactionStatus) -> Bool

TransactionStatus::output

source

fn TransactionStatus::output(self : TransactionStatus, logger : &Logger) -> Unit

TransactionStatus::to_byte

source

fn TransactionStatus::to_byte(self : TransactionStatus) -> Byte

TransactionStatus::to_repr

source

fn TransactionStatus::to_repr(TransactionStatus) -> @moonbitlang/core/debug.Repr
Repr

TransactionStatus::to_string

source

fn TransactionStatus::to_string(self : TransactionStatus) -> String

DEFAULT_PORT

source

let DEFAULT_PORT : Int

The default PostgreSQL TCP port.

MSG_AUTHENTICATION

source

let MSG_AUTHENTICATION : Byte

Message type bytes (server → client).

MSG_BACKEND_KEY_DATA

source

let MSG_BACKEND_KEY_DATA : Byte

MSG_BIND

source

let MSG_BIND : Byte

MSG_BIND_COMPLETE

source

let MSG_BIND_COMPLETE : Byte

MSG_CLOSE

source

let MSG_CLOSE : Byte

MSG_CLOSE_COMPLETE

source

let MSG_CLOSE_COMPLETE : Byte

MSG_COMMAND_COMPLETE

source

let MSG_COMMAND_COMPLETE : Byte

MSG_COPY_BOTH_RESPONSE

source

let MSG_COPY_BOTH_RESPONSE : Byte

MSG_COPY_DATA

source

let MSG_COPY_DATA : Byte

MSG_COPY_DONE

source

let MSG_COPY_DONE : Byte

MSG_COPY_FAIL

source

let MSG_COPY_FAIL : Byte

CopyFail is frontend-only (server never sends it).

MSG_COPY_IN_RESPONSE

source

let MSG_COPY_IN_RESPONSE : Byte

MSG_COPY_OUT_RESPONSE

source

let MSG_COPY_OUT_RESPONSE : Byte

MSG_DATA_ROW

source

let MSG_DATA_ROW : Byte

MSG_DESCRIBE

source

let MSG_DESCRIBE : Byte

MSG_EMPTY_QUERY

source

let MSG_EMPTY_QUERY : Byte

MSG_ERROR_RESPONSE

source

let MSG_ERROR_RESPONSE : Byte

MSG_EXECUTE

source

let MSG_EXECUTE : Byte

MSG_FLUSH

source

let MSG_FLUSH : Byte

MSG_NEGOTIATE_PROTOCOL_VERSION

source

let MSG_NEGOTIATE_PROTOCOL_VERSION : Byte

NegotiateProtocolVersion ('v') — PG 17+ protocol version negotiation.

MSG_NOTICE_RESPONSE

source

let MSG_NOTICE_RESPONSE : Byte

MSG_NOTIFICATION_RESPONSE

source

let MSG_NOTIFICATION_RESPONSE : Byte

MSG_NO_DATA

source

let MSG_NO_DATA : Byte

MSG_PARAMETER_DESCRIPTION

source

let MSG_PARAMETER_DESCRIPTION : Byte

MSG_PARAMETER_STATUS

source

let MSG_PARAMETER_STATUS : Byte

MSG_PARSE

source

let MSG_PARSE : Byte

MSG_PARSE_COMPLETE

source

let MSG_PARSE_COMPLETE : Byte

MSG_PASSWORD

source

let MSG_PASSWORD : Byte

Message type bytes (frontend → server).

MSG_PORTAL_SUSPENDED

source

let MSG_PORTAL_SUSPENDED : Byte

MSG_QUERY

source

let MSG_QUERY : Byte

MSG_READY_FOR_QUERY

source

let MSG_READY_FOR_QUERY : Byte

MSG_ROW_DESCRIPTION

source

let MSG_ROW_DESCRIPTION : Byte

MSG_SYNC

source

let MSG_SYNC : Byte

MSG_TERMINATE

source

let MSG_TERMINATE : Byte

PARAM_CLIENT_ENCODING

source

let PARAM_CLIENT_ENCODING : String

PARAM_SERVER_ENCODING

source

let PARAM_SERVER_ENCODING : String

PARAM_SERVER_VERSION

source

let PARAM_SERVER_VERSION : String

Well-known server parameter names.

PARAM_TIMEZONE

source

let PARAM_TIMEZONE : String

SSL_REQUEST_CODE

source

let SSL_REQUEST_CODE : Int

SSL request magic number.

compute_md5_password

source

fn compute_md5_password(password : String, user : String, salt : Bytes) -> String

Compute the MD5 password response for PostgreSQL authentication.

password — the plaintext password user — the database user name salt — the 4-byte salt from the server's AuthenticationMD5Password message

Returns the "md5..." string to send in a PasswordMessage.

connect

source

async fn connect(connstr : String) -> RawConn raise WireError

connect_config

source

async fn connect_config(config : Config) -> RawConn raise WireError

Connect using a Config struct.

handle_sasl_auth

source

async fn handle_sasl_auth(conn : RawConn, user : String, mechanisms : Array[String], password : String?) -> Unit raise WireError

Validate SCRAM-SHA-256 availability and delegate to handle_scram_auth.

handle_scram_auth

source

async fn handle_scram_auth(conn : RawConn, user : String, password : String) -> Unit raise WireError

Run the full SCRAM-SHA-256 handshake.

Source Files

Site source Report issue Packages Build queue Skills Statistics

#Message

#Transport

#WireError

#AuthMethod

#AuthMethod::equal

#AuthMethod::from_int

#AuthMethod::not_equal

#AuthMethod::to_repr

#AuthenticationCleartextPassword

#AuthenticationCleartextPassword::decode

#AuthenticationCleartextPassword::describe

#AuthenticationCleartextPassword::encode

#AuthenticationMD5Password

#AuthenticationMD5Password::decode

#AuthenticationMD5Password::describe

#AuthenticationMD5Password::encode

#AuthenticationOk

#AuthenticationOk::decode

#AuthenticationOk::describe

#AuthenticationOk::encode

#AuthenticationSASL

#AuthenticationSASL::decode

#AuthenticationSASL::describe

#AuthenticationSASL::encode

#AuthenticationSASLContinue

#AuthenticationSASLContinue::decode

#AuthenticationSASLContinue::describe

#AuthenticationSASLContinue::encode

#AuthenticationSASLFinal

#AuthenticationSASLFinal::decode

#AuthenticationSASLFinal::describe

#AuthenticationSASLFinal::encode

#BackendKeyData

#BackendKeyData::decode

#BackendKeyData::describe

#BackendKeyData::encode

#BackendMessage

#BackendMessage::describe

#Bind

#Bind::decode

#Bind::describe

#Bind::encode

#BindComplete

#BindComplete::decode

#BindComplete::describe

#BindComplete::encode

#BytesMut

#BytesMut::append_byte

#BytesMut::append_bytes

#BytesMut::append_int_be

#BytesMut::append_string_null

#BytesMut::len

#BytesMut::new

#BytesMut::set_byte

#BytesMut::set_int_be

#BytesMut::to_bytes

#Close

#Close::decode

#Close::describe

#Close::encode

#CloseComplete

#CloseComplete::decode

#CloseComplete::describe

#CloseComplete::encode

#CommandComplete

#CommandComplete::decode

#CommandComplete::describe

#CommandComplete::encode

#CommandTag

#CommandTag::command

#CommandTag::new

#CommandTag::output

#CommandTag::raw

#CommandTag::rows_affected

#CommandTag::to_string

#Config

#Config::from_connstr

#Config::new

#ConnParam

#ConnStatus

Message

Transport

WireError

AuthMethod

AuthMethod::equal

AuthMethod::from_int

AuthMethod::not_equal

AuthMethod::to_repr

AuthenticationCleartextPassword

AuthenticationCleartextPassword::decode

AuthenticationCleartextPassword::describe

AuthenticationCleartextPassword::encode

AuthenticationMD5Password

AuthenticationMD5Password::decode

AuthenticationMD5Password::describe

AuthenticationMD5Password::encode

AuthenticationOk

AuthenticationOk::decode

AuthenticationOk::describe

AuthenticationOk::encode

AuthenticationSASL

AuthenticationSASL::decode

AuthenticationSASL::describe

AuthenticationSASL::encode

AuthenticationSASLContinue

AuthenticationSASLContinue::decode

AuthenticationSASLContinue::describe

AuthenticationSASLContinue::encode

AuthenticationSASLFinal

AuthenticationSASLFinal::decode

AuthenticationSASLFinal::describe

AuthenticationSASLFinal::encode

BackendKeyData

BackendKeyData::decode

BackendKeyData::describe

BackendKeyData::encode

BackendMessage

BackendMessage::describe

Bind

Bind::decode

Bind::describe

Bind::encode

BindComplete

BindComplete::decode

BindComplete::describe

BindComplete::encode

BytesMut

BytesMut::append_byte

BytesMut::append_bytes

BytesMut::append_int_be

BytesMut::append_string_null

BytesMut::len

BytesMut::new

BytesMut::set_byte

BytesMut::set_int_be

BytesMut::to_bytes

Close

Close::decode

Close::describe

Close::encode

CloseComplete

CloseComplete::decode

CloseComplete::describe

CloseComplete::encode

CommandComplete

CommandComplete::decode

CommandComplete::describe

CommandComplete::encode

CommandTag

CommandTag::command

CommandTag::new

CommandTag::output

CommandTag::raw

CommandTag::rows_affected

CommandTag::to_string

Config

Config::from_connstr

Config::new

ConnParam

ConnStatus