Struct StateMachine

struct StateMachine<'a, A> {
    conn: &'a mut FramedConn<A>,
    adapter_client: SessionClient,
    txn_needs_commit: bool,
}

Fields

conn: &'a mut FramedConn<A>

adapter_client: SessionClient

txn_needs_commit: bool

Implementations

impl<'a, A> StateMachine<'a, A>

where A: AsyncRead + AsyncWrite + AsyncReady + Send + Sync + Unpin + 'a,

fn run(self) -> impl Future<Output = Result<(), Error>> + Send + 'a

async fn advance_ready(&mut self) -> Result<State, Error>

async fn advance_drain(&mut self) -> Result<State, Error>

async fn one_query( &mut self, stmt: Statement<Raw>, sql: String, lifecycle_timestamps: LifecycleTimestamps, ) -> Result<State, Error>

Note that lifecycle_timestamps belongs to the whole “Simple Query”, because the whole Simple Query is received and parsed together. This means that if there are multiple statements in a Simple Query, then all of them have the same lifecycle_timestamps.

async fn ensure_transaction(&mut self, num_stmts: usize) -> Result<(), Error>

fn parse_sql<'b>( &self, sql: &'b str, ) -> Result<Vec<StatementParseResult<'b>>, ErrorResponse>

async fn query( &mut self, sql: String, received: EpochMillis, ) -> Result<State, Error>

Executes a “Simple Query”, see https://www.postgresql.org/docs/current/protocol-flow.html#PROTOCOL-FLOW-SIMPLE-QUERY

For implicit transaction handling, see “Multiple Statements in a Simple Query” in the above.

async fn parse( &mut self, name: String, sql: String, param_oids: Vec<u32>, ) -> Result<State, Error>

async fn commit_transaction(&mut self) -> Result<(), Error>

Commits and clears the current transaction.

async fn rollback_transaction(&mut self) -> Result<(), Error>

Rollback and clears the current transaction.

async fn end_transaction( &mut self, action: EndTransactionAction, ) -> Result<(), Error>

End a transaction and report to the user if an error occurred.

async fn bind( &mut self, portal_name: String, statement_name: String, param_formats: Vec<Format>, raw_params: Vec<Option<Vec<u8>>>, result_formats: Vec<Format>, ) -> Result<State, Error>

fn execute( &mut self, portal_name: String, max_rows: ExecuteCount, get_response: fn(max_rows: ExecuteCount, total_sent_rows: usize, fetch_portal: Option<&mut Portal>) -> BackendMessage, fetch_portal_name: Option<String>, timeout: ExecuteTimeout, outer_ctx_extra: Option<ExecuteContextExtra>, received: Option<EpochMillis>, ) -> BoxFuture<'_, Result<State, Error>>

async fn describe_statement(&mut self, name: &str) -> Result<State, Error>

async fn describe_portal(&mut self, name: &str) -> Result<State, Error>

async fn close_statement(&mut self, name: String) -> Result<State, Error>

async fn close_portal(&mut self, name: String) -> Result<State, Error>

fn complete_portal(&mut self, name: &str)

async fn fetch( &mut self, name: String, count: Option<FetchDirection>, max_rows: ExecuteCount, fetch_portal_name: Option<String>, timeout: ExecuteTimeout, ctx_extra: ExecuteContextExtra, ) -> Result<State, Error>

async fn flush(&mut self) -> Result<State, Error>

async fn send<M>(&mut self, message: M) -> Result<(), Error>

where M: Into<BackendMessage>,

Sends a backend message to the client, after applying a severity filter.

The message is only sent if its severity is above the severity set in the session, with the default value being NOTICE.

pub async fn send_all( &mut self, messages: impl IntoIterator<Item = BackendMessage>, ) -> Result<(), Error>

async fn sync(&mut self) -> Result<State, Error>

async fn ready(&mut self) -> Result<State, Error>

async fn row_future_to_stream<'s, 'p>( &'s mut self, parent: &'p Span, rows: RowsFuture, ) -> Result<UnboundedReceiver<PeekResponseUnary>, Error>

where 'p: 's,

async fn send_execute_response( &mut self, response: ExecuteResponse, row_desc: Option<RelationDesc>, portal_name: String, max_rows: ExecuteCount, get_response: fn(max_rows: ExecuteCount, total_sent_rows: usize, fetch_portal: Option<&mut Portal>) -> BackendMessage, fetch_portal_name: Option<String>, timeout: ExecuteTimeout, execute_started: Instant, ) -> Result<State, Error>

async fn send_rows( &mut self, row_desc: RelationDesc, portal_name: String, rows: InProgressRows, max_rows: ExecuteCount, get_response: fn(max_rows: ExecuteCount, total_sent_rows: usize, fetch_portal: Option<&mut Portal>) -> BackendMessage, fetch_portal_name: Option<String>, timeout: ExecuteTimeout, ) -> Result<(State, SendRowsEndedReason), Error>

async fn copy_rows( &mut self, format: CopyFormat, row_desc: RelationDesc, stream: RecordFirstRowStream, ) -> Result<(State, SendRowsEndedReason), Error>

async fn copy_from( &mut self, id: CatalogItemId, columns: Vec<ColumnIndex>, params: CopyFormatParams<'_>, row_desc: RelationDesc, ctx_extra: ExecuteContextExtra, ) -> Result<State, Error>

Handles the copy-in mode of the postgres protocol from transferring data to the server.

async fn copy_from_inner( &mut self, id: CatalogItemId, columns: Vec<ColumnIndex>, params: CopyFormatParams<'_>, row_desc: RelationDesc, ctx_extra: &mut ExecuteContextExtra, ) -> Result<State, Error>

async fn send_pending_notices(&mut self) -> Result<(), Error>

async fn error(&mut self, err: ErrorResponse) -> Result<State, Error>

async fn aborted_txn_error(&mut self) -> Result<State, Error>

fn is_aborted_txn(&mut self) -> bool