Struct PgProtocol

pub struct PgProtocol<S, SM>
where
    SM: SessionManager,
{

    stream: PgStream<S>,
    state: PgProtocolState,
    is_terminate: bool,
    session_mgr: Arc<SM>,
    session: Option<Arc<SM::Session>>,
    result_cache: HashMap<String, ResultCache<<SM::Session as Session>::ValuesStream>>,
    unnamed_prepare_statement: Option<<SM::Session as Session>::PreparedStatement>,
    prepare_statement_store: HashMap<String, <SM::Session as Session>::PreparedStatement>,
    unnamed_portal: Option<<SM::Session as Session>::Portal>,
    portal_store: HashMap<String, <SM::Session as Session>::Portal>,
    statement_portal_dependency: HashMap<String, Vec<String>>,
    tls_context: Option<SslContext>,
    ignore_util_sync: bool,
    peer_addr: AddressRef,
    redact_sql_option_keywords: Option<RedactSqlOptionKeywordsRef>,
    message_memory_manager: MessageMemoryManagerRef,
}

The state machine for each psql connection. Read pg messages from tcp stream and write results back.

Fields

stream: PgStream<S>

Used for write/read pg messages.

state: PgProtocolState

Current states of pg connection.

is_terminate: bool

Whether the connection is terminated.

session_mgr: Arc<SM>

session: Option<Arc<SM::Session>>

result_cache: HashMap<String, ResultCache<<SM::Session as Session>::ValuesStream>>

unnamed_prepare_statement: Option<<SM::Session as Session>::PreparedStatement>

prepare_statement_store: HashMap<String, <SM::Session as Session>::PreparedStatement>

unnamed_portal: Option<<SM::Session as Session>::Portal>

portal_store: HashMap<String, <SM::Session as Session>::Portal>

statement_portal_dependency: HashMap<String, Vec<String>>

tls_context: Option<SslContext>

ignore_util_sync: bool

peer_addr: AddressRef

redact_sql_option_keywords: Option<RedactSqlOptionKeywordsRef>

message_memory_manager: MessageMemoryManagerRef

Implementations

impl<S, SM> PgProtocol<S, SM>

where S: PgByteStream, SM: SessionManager,

pub fn new( stream: S, session_mgr: Arc<SM>, peer_addr: AddressRef, context: ConnectionContext, ) -> Self

pub async fn run(&mut self)

Run the protocol to serve the connection.

pub async fn process(&mut self, msg: FeMessage) -> bool

Processes one message. Returns true if the connection is terminated.

fn root_span_for_msg(&self, msg: &FeMessage) -> Span

The root tracing span for processing a message. The target of the span is [PGWIRE_ROOT_SPAN_TARGET].

This is used to provide context for the (slow) query logs and traces.

The span is only effective if there’s a current session and the message is query-related. Otherwise, Span::none() is returned.

async fn do_process(&mut self, msg: FeMessage) -> Option<()>

Return type Option<()> is essentially a bool, but allows ? for early return.

• None means to terminate the current connection
• Some(()) means to continue processing the next message

async fn do_process_inner(&mut self, msg: FeMessage) -> PsqlResult<()>

pub async fn read_message( &mut self, ) -> Result<(FeMessage, Option<MessageMemoryGuard>)>

fn ready_for_query(&mut self) -> Result<()>

Writes a ReadyForQuery message to the client without flushing.

async fn process_gss_msg(&mut self) -> PsqlResult<()>

async fn process_ssl_msg(&mut self) -> PsqlResult<()>

fn process_startup_msg(&mut self, msg: FeStartupMessage) -> PsqlResult<()>

async fn process_password_msg( &mut self, msg: FePasswordMessage, ) -> PsqlResult<()>

fn process_cancel_msg(&mut self, m: FeCancelMessage) -> PsqlResult<()>

async fn process_query_msg(&mut self, sql: Arc<str>) -> PsqlResult<()>

async fn inner_process_query_msg( &mut self, sql: Arc<str>, session: Arc<SM::Session>, ) -> PsqlResult<()>

async fn inner_process_query_msg_one_stmt( &mut self, stmt: Statement, session: Arc<SM::Session>, ) -> PsqlResult<()>

fn process_terminate(&mut self)

fn process_health_check(&mut self)

async fn process_parse_msg(&mut self, msg: FeParseMessage) -> PsqlResult<()>

async fn inner_process_parse_msg( &mut self, session: Arc<SM::Session>, sql: Arc<str>, statement_name: String, type_ids: Vec<i32>, ) -> PsqlResult<()>

fn process_bind_msg(&mut self, msg: FeBindMessage) -> PsqlResult<()>

async fn process_execute_msg(&mut self, msg: FeExecuteMessage) -> PsqlResult<()>

fn process_describe_msg(&mut self, msg: FeDescribeMessage) -> PsqlResult<()>

fn process_close_msg(&mut self, msg: FeCloseMessage) -> PsqlResult<()>

fn remove_portal(&mut self, portal_name: &str)

fn get_portal( &self, portal_name: &str, ) -> PsqlResult<<SM::Session as Session>::Portal>

fn get_statement( &self, statement_name: &str, ) -> PsqlResult<<SM::Session as Session>::PreparedStatement>

Trait Implementations

impl<S, SM> Drop for PgProtocol<S, SM>

where SM: SessionManager,

fn drop(&mut self)

Executes the destructor for this type.