diff --git a/doc/src/sgml/protocol.sgml b/doc/src/sgml/protocol.sgml index f650738728..4906a71501 100644 --- a/doc/src/sgml/protocol.sgml +++ b/doc/src/sgml/protocol.sgml @@ -1,103 +1,216 @@ - + Frontend/Backend Protocol - - - Written by Phil Thompson (phil@river-bank.demon.co.uk). - Updates for protocol 2.0 by Tom Lane (tgl@sss.pgh.pa.us). - - - PostgreSQL uses a message-based protocol - for communication between frontends and backends. The protocol is - implemented over TCP/IP and also on Unix domain - sockets. PostgreSQL 6.3 introduced - version numbers into the protocol. This was done in such a way as - to still allow connections from earlier versions of frontends, but - this document does not cover the protocol used by those earlier - versions. + for communication between frontends and backends (clients and servers). + The protocol is supported over TCP/IP and also over + Unix-domain sockets. Port number 5432 has been registered with IANA as + the customary TCP port number for servers supporting this protocol, but + in practice any non-privileged port number may be used. - This document describes version 2.0 of the protocol, implemented in - PostgreSQL 6.4 and later. + This document describes version 3.0 of the protocol, implemented in + PostgreSQL 7.4 and later. For descriptions + of the earlier protocol versions, see previous releases of the + PostgreSQL documentation. A single server + can support multiple protocol versions. The initial + startup-request message tells the server which protocol version the + client is attempting to use, and then the server follows that protocol + if it is able. Higher level features built on this protocol (for example, how libpq passes certain environment - variables after the connection is established) are covered - elsewhere. + variables when the connection is established) are covered elsewhere. + + In order to serve multiple clients efficiently, the server launches + a new backend process for each client. + In the current implementation, a new child + process is created immediately after an incoming connection is detected. + This is transparent to the protocol, however. For purposes of the + protocol, the terms backend and server are + interchangeable; likewise frontend and client + are interchangeable. + + Overview - A frontend opens a connection to the server and sends a start-up - packet. This includes the names of the user and of the database the - user wants to connect to. The server then uses this, and the - information in the pg_hba.conf file to - determine what further authentication information it requires the - frontend to send (if any) and responds to the frontend accordingly. + The protocol has separate phases for startup and normal operation. + In the startup phase, the frontend opens a connection to the server + and authenticates itself to the satisfaction of the server. (This might + involve a single message, or multiple messages depending on the + authentication method being used.) If all goes well, the server then sends + status information to the frontend, and finally enters normal operation. + Except for the initial startup-request message, this part of the + protocol is driven by the server. - The frontend then sends any required authentication information. - Once the server validates this it responds to the frontend that it - is authenticated and sends a message indicating successful start-up - (normal case) or failure (for example, an invalid database name). + During normal operation, the frontend sends queries and + other commands to the backend, and the backend sends back query results + and other responses. There are a few cases (such as NOTIFY) + wherein the + backend will send unsolicited messages, but for the most part this portion + of a session is driven by frontend requests. - In order to serve multiple clients efficiently, the server launches - a new backend process for each client. This is transparent - to the protocol, however. In the current implementation, a new child - process is created immediately after an incoming connection is detected. + Termination of the session is normally by frontend choice, but can be + forced by the backend in certain cases. In any case, when the backend + closes the connection, it will roll back any open (incomplete) transaction + before exiting. - When the frontend wishes to disconnect it sends an appropriate packet and - closes the connection without waiting for a response from the backend. + Within normal operation, SQL commands can be executed through either of + two sub-protocols. In the simple query protocol, the frontend + just sends a textual query string, which is parsed and immediately + executed by the backend. In the extended query protocol, + processing of queries is separated into multiple steps: parsing, + binding of parameter values, and execution. This offers flexibility + and performance benefits, at the cost of extra complexity. - Packets are sent as a data stream. The first byte determines what - should be expected in the rest of the packet. The exceptions are - packets sent as part of the start-up and authentication exchange, - which comprise a packet length followed by the packet itself. The - difference is historical. + Normal operation has additional sub-protocols for special operations + such as COPY. + + + Messaging Overview + + + All communication is through a stream of messages. The first byte of a + message identifies the message type, and the next four bytes specify the + length of the rest of the message (this length count includes itself, but + not the message-type byte). The remaining contents of the message are + determined by the message type. For historical reasons, the very first + message sent by the client (the startup message) has no initial + message-type byte. + + + + To avoid losing synchronization with the message stream, both servers and + clients typically read an entire message into a buffer (using the byte + count) before attempting to process its contents. This allows easy + recovery if an error is detected while processing the contents. In + extreme situations (such as not having enough memory to buffer the + message), the receiver may use the byte count to determine how much + input to skip before it resumes reading messages. + + + + Conversely, both servers and clients must take care never to send an + incomplete message. This is commonly done by marshaling the entire message + in a buffer before beginning to send it. If a communications failure + occurs partway through sending or receiving a message, the only sensible + response is to abandon the connection, since there is little hope of + recovering message-boundary synchronization. + + + + + Extended Query Overview + + + In the extended-query protocol, execution of SQL commands is divided + into multiple steps. The state retained between steps is represented + by two types of objects: prepared statements and + portals. A prepared statement represents the result of + parsing, semantic analysis, and planning of a textual query string. A + prepared statement is not necessarily ready to execute, because it may + lack specific values for parameters. A portal represents + a ready-to-execute or already-partially-executed statement, with any + missing parameter values filled in. (For SELECT statements, + a portal is equivalent to an open cursor, but we use a different term + since cursors don't handle non-SELECT statements.) + + + + The overall execution cycle consists of a parse step, + which creates a prepared statement from a textual query string; a + bind step, which creates a portal given a prepared + statement and values for any needed parameters; and an + execute step that runs a portal's query. In the case of + a SELECT query, the execute step can be told to fetch only + a limited number of rows, so that multiple execute steps may be needed + to complete the operation. + + + + The backend can keep track of multiple prepared statements and portals + (but note that these exist only within a session, and are never shared + across sessions). Existing prepared statements and portals are + referenced by names assigned when they were created. In addition, + an unnamed prepared statement and portal exist, for use with + queries that are to be executed and forgotten. This is slightly + more efficient than using named objects, since the backend knows that + it need not save the object's state for re-use. + + - - Protocol + + Message Flow - This section describes the message flow. There are four different - types of flows depending on the state of the connection: start-up, - query, function call, and termination. There are also special - provisions for notification responses and command cancellation, + This section describes the message flow and the semantics of each + message type. There are several different sub-protocols + depending on the state of the connection: start-up, + query, function call, COPY, and termination. There are also special + provisions for asynchronous operations (including + notification responses and command cancellation), which can occur at any time after the start-up phase. - Start-up + Start-Up - Initially, the frontend sends a StartupPacket. The server uses - this info and the contents of the pg_hba.conf - file to determine what authentication method the frontend must - use. The server then responds with one of the following messages: + To begin a session, a frontend opens a connection to the server and sends + a startup message. This message includes the names of the user and of the + database the user wants to connect to; it also identifies the particular + protocol version to be used. The server then uses this information and + the contents of its configuration files (such as + pg_hba.conf) to determine + whether the connection is provisionally acceptable, and what additional + authentication is required (if any). + + + + The server then sends an appropriate authentication request message, + to which the frontend must reply with an appropriate authentication + response message (such as a password). + In principle the authentication request/response cycle could require + multiple iterations, but none of the present authentication methods + use more than one request and response. In some methods, no response + at all is needed from the frontend, and so no authentication request + occurs. + + + + The authentication cycle ends with the server either rejecting the + connection attempt (ErrorResponse), or sending AuthenticationOK. + + + + The possible messages from the server in this phase are: ErrorResponse + The connection attempt has been rejected. The server then immediately closes the connection. @@ -107,7 +220,7 @@ AuthenticationOk - The authentication exchange is completed. + The authentication exchange is successfully completed. @@ -116,7 +229,7 @@ AuthenticationKerberosV4 - The frontend must then take part in a Kerberos V4 + The frontend must now take part in a Kerberos V4 authentication dialog (not described here, part of the Kerberos specification) with the server. If this is successful, the server responds with an AuthenticationOk, @@ -129,7 +242,7 @@ AuthenticationKerberosV5 - The frontend must then take part in a Kerberos V5 + The frontend must now take part in a Kerberos V5 authentication dialog (not described here, part of the Kerberos specification) with the server. If this is successful, the server responds with an AuthenticationOk, @@ -142,7 +255,7 @@ AuthenticationCleartextPassword - The frontend must then send a PasswordPacket containing the + The frontend must now send a PasswordMessage containing the password in clear-text form. If this is the correct password, the server responds with an AuthenticationOk, otherwise it responds with an ErrorResponse. @@ -154,9 +267,9 @@ AuthenticationCryptPassword - The frontend must then send a PasswordPacket containing the + The frontend must now send a PasswordMessage containing the password encrypted via crypt(3), using the 2-character salt - specified in the AuthenticationCryptPassword packet. If + specified in the AuthenticationCryptPassword message. If this is the correct password, the server responds with an AuthenticationOk, otherwise it responds with an ErrorResponse. @@ -167,9 +280,9 @@ AuthenticationMD5Password - The frontend must then send a PasswordPacket containing the + The frontend must now send a PasswordMessage containing the password encrypted via MD5, using the 4-character salt - specified in the AuthenticationMD5Password packet. If + specified in the AuthenticationMD5Password message. If this is the correct password, the server responds with an AuthenticationOk, otherwise it responds with an ErrorResponse. @@ -180,7 +293,7 @@ AuthenticationSCMCredential - This method is only possible for local Unix-domain connections + This response is only possible for local Unix-domain connections on platforms that support SCM credential messages. The frontend must issue an SCM credential message and then send a single data byte. (The contents of the data byte are uninteresting; it's @@ -202,9 +315,16 @@ - After having received AuthenticationOk, the frontend should wait - for further messages from the server. The possible messages from - the backend in this phase are: + After having received AuthenticationOk, the frontend must wait + for further messages from the server. In this phase a backend process + is being started, and the frontend is just an interested bystander. + It is still possible for the startup attempt + to fail (ErrorResponse), but in the normal case the backend will send + BackendKeyData, some ParameterStatus messages, and finally ReadyForQuery. + + + + The possible messages from the backend in this phase are: @@ -219,12 +339,26 @@ + + ParameterStatus + + + This message informs the frontend about the current (initial) + setting of backend parameters, such as client_encoding + or DateStyle. The frontend may ignore this message, + or record the settings for its future use; see + for more detail. + The frontend should not respond to this message, but should + continue listening for a ReadyForQuery message. + + + + ReadyForQuery - Start-up is completed. The frontend may now issue query or - function call messages. + Start-up is completed. The frontend may now issue commands. @@ -254,25 +388,26 @@ The ReadyForQuery message is the same one that the backend will - issue after each query cycle. Depending on the coding needs of + issue after each command cycle. Depending on the coding needs of the frontend, it is reasonable to consider ReadyForQuery as - starting a query cycle (and then BackendKeyData indicates - successful conclusion of the start-up phase), or to consider - ReadyForQuery as ending the start-up phase and each subsequent - query cycle. + starting a command cycle, or to consider ReadyForQuery as ending the + start-up phase and each subsequent command cycle. - Query + Simple Query - A Query cycle is initiated by the frontend sending a Query message + A simple query cycle is initiated by the frontend sending a Query message to the backend. The backend then sends one or more response messages depending on the contents of the query command string, and finally a ReadyForQuery response message. ReadyForQuery - informs the frontend that it may safely send a new query or - function call. + informs the frontend that it may safely send a new command. + (It is not actually necessary for the frontend to wait for + ReadyForQuery before issuing another command, but the frontend must + then take responsibility for figuring out what happens if the earlier + command fails and already-issued later commands succeed.) @@ -280,7 +415,7 @@ - CompletedResponse + CommandComplete An SQL command completed normally. @@ -293,9 +428,7 @@ The backend is ready to copy data from the frontend to a - table. The frontend should then send a CopyDataRows message. - The backend will then respond with a CompletedResponse message - with a tag of COPY. + table; see . @@ -305,22 +438,7 @@ The backend is ready to copy data from a table to the - frontend. It then sends a CopyDataRows message, and then a - CompletedResponse message with a tag of COPY. - - - - - - CursorResponse - - - Beginning of the response to a SELECT, - FETCH, INSERT, - UPDATE, or DELETE - query. In the FETCH case the name of the - cursor being fetched from is included in the message. Otherwise - the message always mentions the blank cursor. + frontend; see . @@ -332,7 +450,7 @@ Indicates that rows are about to be returned in response to a SELECT or FETCH query. The message contents describe the layout of the rows. This - will be followed by an AsciiRow or BinaryRow message (depending on + will be followed by a DataRow or BinaryRow message (depending on whether a binary cursor was specified) for each row being returned to the frontend. @@ -363,7 +481,7 @@ Processing of the query string is complete. A separate message is sent to indicate this because the query string may - contain multiple SQL commands. (CompletedResponse marks the + contain multiple SQL commands. (CommandComplete marks the end of processing one SQL command, not the whole string.) ReadyForQuery will always be sent, whether processing terminates successfully or with an error. @@ -387,15 +505,12 @@ The response to a SELECT or FETCH query - normally consists of CursorResponse, RowDescription, zero or more - AsciiRow or BinaryRow messages, and finally CompletedResponse. - INSERT, UPDATE, and - DELETE queries produce CursorResponse followed by - CompletedResponse. + normally consists of RowDescription, zero or more + DataRow or BinaryRow messages, and then CommandComplete. COPY to or from the frontend invokes special protocol - as mentioned above. + as described below. All other query types normally produce only - a CompletedResponse message. + a CommandComplete message. @@ -423,23 +538,8 @@ A frontend must be prepared to accept ErrorResponse and NoticeResponse messages whenever it is expecting any other type of - message. - - - - Actually, it is possible for NoticeResponse to arrive even when - the frontend is not expecting any kind of message, that is, the - backend is nominally idle. (In particular, the backend can be - commanded to terminate by its parent process. In that case it will - send a NoticeResponse before closing the connection.) It is - recommended that the frontend check for such asynchronous notices - just before issuing any new command. - - - - Also, if the frontend issues any LISTEN - commands then it must be prepared to accept NotificationResponse - messages at any time; see below. + message. See also concerning messages + that the backend may generate due to outside events. @@ -449,6 +549,169 @@ + + Extended Query + + + The extended query protocol breaks down the above-described simple + query protocol into multiple steps. The results of preparatory + steps can be re-used multiple times for improved efficiency. + Furthermore, additional features are available, such as the possibility + of supplying data values as separate parameters instead of having to + insert them directly into a query string. + + + + In the extended protocol, the frontend first sends a Parse message, + which contains a textual query string, optionally some information + about datatypes of parameter placeholders, and the + name of a destination prepared-statement object (an empty string + selects the unnamed prepared statement). The response is + either ParseComplete or ErrorResponse. Parameter datatypes may be + specified by OID; if not given, the parser attempts to infer the + datatypes in the same way as it would do for untyped literal string + constants. + + + + + The query string contained in a Parse message cannot include more + than one SQL statement; else a syntax error is reported. This + restriction does not exist in the simple-query protocol, but it + does exist in the extended protocol, because allowing prepared + statements or portals to contain multiple commands would complicate + the protocol unduly. + + + + + If successfully created, a named prepared-statement object lasts till + the end of the current session, unless explicitly destroyed. An unnamed + prepared statement lasts only until the next Parse message is issued. + Named prepared statements can also be created and accessed at the SQL + command level, using PREPARE and EXECUTE. + + + + Once a prepared statement exists, it can be readied for execution using a + Bind message. The Bind message gives the name of the source prepared + statement (empty string denotes the unnamed prepared statement), the name + of the destination portal (empty string denotes the unnamed portal), and + the values to use for any parameter placeholders present in the prepared + statement. The response is either BindComplete or ErrorResponse. The + supplied parameter set must match those needed by the prepared statement. + + + + If successfully created, a named portal object lasts till + the end of the current transaction, unless explicitly destroyed. An + unnamed portal is destroyed at the end of the transaction, or as soon + as the next Parse or Bind message is executed. + Named portals can also be created and accessed at the SQL + command level, using DECLARE CURSOR and FETCH. + + + + Once a portal exists, it can be executed using an Execute message. + The Execute message specifies the portal name (empty string denotes the + unnamed portal), the desired output format (text or binary), and + a maximum result-row count (zero meaning fetch all rows). + The output format and result-row count are only meaningful for portals + containing SELECT commands; they are ignored for other types of commands. + The possible + responses to Execute are the same as those described above for queries + issued via simple query protocol, except that Execute doesn't cause + ReadyForQuery to be issued. + + + + If Execute terminates before completing the execution of a portal + (due to reaching a nonzero result-row count), it will send a + PortalSuspended message; the appearance of this message tells the frontend + that another Execute should be issued against the same portal to + complete the operation. The CommandComplete message indicating + completion of the source SELECT or FETCH command is not sent until + the command is completed. + + + + At completion of each series of extended-query messages, the frontend + should issue a Sync message. This parameterless message causes the + backend to close the current transaction if it's not inside a + BEGIN/COMMIT transaction block (close + meaning to commit if no error, or roll back if error). Then a + ReadyForQuery response is issued. The purpose of Sync is to provide + a resychronization point for error recovery. When an error is detected + while processing any extended-query message, the backend issues + ErrorResponse, then reads and discards messages until a Sync is reached, + then issues ReadyForQuery and returns to normal message processing. + (But note that no skipping occurs if an error is detected + while processing Sync --- this ensures that there is one + and only one ReadyForQuery sent for each Sync.) + + + + + Sync does not cause a transaction block opened with BEGIN + to be closed. It is possible to detect this situation since the + ReadyForQuery message includes transaction status information. + + + + + In addition to these fundamental, required operations, there are several + optional operations that can be used with extended-query protocol. + + + + The Describe message (portal variant) specifies the name of an existing + portal (or an empty string for the unnamed portal). The response is a + RowDescription message describing the rows that will be returned by + executing the portal; or a NoData message if the portal does not contain a + SELECT-type query; or ErrorResponse if there is no such portal. In most + situations the frontend will want to issue this message before issuing + Execute, to obtain a description of the results it will get back. + + + + The Describe message (statement variant) specifies the name of an existing + prepared statement (or an empty string for the unnamed prepared + statement). The response is a ParameterDescription message describing the + parameters needed by the statement (if any), followed by a RowDescription + message describing the rows that will be returned when the statement is + eventually executed (or NoData if there is no SELECT-type query in the + prepared statement). ErrorResponse is issued if there is no such prepared + statement. This message may be useful if the client library is + uncertain about the parameters needed by a prepared statement. + + + + The Close message closes an existing prepared statement or portal + and releases resources. + + + + The Flush message does not cause any specific output to be generated, + but forces the backend to deliver any data pending in its output + buffers. A Flush must be sent after any extended-query command except + Sync, if the frontend wishes to examine the results of that command before + issuing more commands. Without Flush, returning data will be combined + into the minimum possible number of packets to minimize network overhead. + + + + + The simple Query message is approximately equivalent to the series Parse, + Bind, portal Describe, Execute, Sync, using the unnamed prepared statement + and portal objects and no parameters. One difference is that it + will accept multiple SQL statements in the query string, automatically + performing the bind/describe/execute sequence for each one in succession. + Another is that it will not return ParseComplete, BindComplete, or + NoData messages. + + + + Function Call @@ -515,20 +778,115 @@ + + + + COPY Operations - A frontend must be prepared to accept ErrorResponse and - NoticeResponse messages whenever it is expecting any other type of - message. Also, if it issues any LISTEN - commands then it must be prepared to accept NotificationResponse - messages at any time; see below. + The COPY command allows high-speed bulk data transfer + to or from the server. Copy-in and copy-out operations each switch + the connection into a distinct sub-protocol, which lasts until the + operation is completed. + + + + Copy-in mode (data transfer to the server) is initiated when the + backend executes a COPY FROM STDIN SQL statement. The backend + sends a CopyInResponse message to the frontend. The frontend should + then send zero or more CopyDataRow messages, one per row to be loaded. + (For COPY BINARY, send CopyBinaryRow messages instead.) + The frontend can terminate the copy-in mode by sending either a CopyDone + message (allowing successful termination) or a CopyFail message (which + will cause the COPY SQL statement to fail with an + error). The backend then reverts to the command-processing mode it was + in before the COPY started (which will be either simple or + extended query protocol). + + + + In the event of a backend-detected error during copy-in mode (including + receipt of a CopyFail message, or indeed any frontend message other than + CopyDataRow, CopyBinaryRow, or CopyDone), the backend will issue an + ErrorResponse + message. If the COPY command was issued via an extended-query + message, the backend will now discard frontend messages until a Sync + message is received, then it will issue ReadyForQuery and return to normal + processing. If the COPY command was issued in a simple + Query message, the rest of that message is discarded and ReadyForQuery + is issued. In either case, any subsequent CopyDataRow, CopyBinaryRow, + CopyDone, or CopyFail messages issued by the frontend will simply be + dropped. + + + + Copy-out mode (data transfer from the server) is initiated when the + backend executes a COPY TO STDOUT SQL statement. The backend + sends a CopyOutResponse message to the frontend, followed by + zero or more CopyDataRow messages, one per row, followed by CopyDone. + (For COPY BINARY, CopyBinaryRow messages are sent instead.) + The backend then reverts to the command-processing mode it was + in before the COPY started. The frontend cannot abort + the transfer (short of closing the connection), but it can discard + unwanted CopyDataRow, CopyBinaryRow, and CopyDone messages. + + + + In the event of a backend-detected error during copy-out mode, + the backend will issue an ErrorResponse message and revert to normal + processing. The frontend should treat receipt of ErrorResponse (or + indeed any message type other than CopyDataRow, CopyBinaryRow, or + CopyDone) as terminating the copy-out mode. - - Notification Responses + + Asynchronous Operations - + + There are several cases in which the backend will send messages that + are not specifically prompted by the frontend's command stream. + Frontends must be prepared to deal with these messages at any time, + even when not engaged in a query. + At minimum, one should check for these cases before beginning to + read a query response. + + + + It is possible for NoticeResponse messages to be generated due to + outside activity; for example, if the database administrator commands + a fast database shutdown, the backend will send a NoticeResponse + indicating this fact before closing the connection. Accordingly, + frontends should always be prepared to accept and display NoticeResponse + messages, even when the connection is nominally idle. + + + + ParameterStatus messages will be generated whenever the active value + changes for any of the parameters the backend believes the frontend + should know about. Most commonly this occurs in response to a + SET SQL command executed by the frontend, and this case + is effectively synchronous --- but it is also possible for parameter + status changes to occur because the administrator changed a configuration + file and then SIGHUP'd the postmaster. Also, if a SET command is + rolled back, an appropriate ParameterStatus message will be generated + to report the current effective value. + + + + At present there is a hard-wired set of parameters for which + ParameterStatus will be generated: they are + version (backend version, + a pseudo-parameter that cannot change after startup); + database_encoding (also not presently changeable after start); + client_encoding, and + DateStyle. + This set might change in the future, or even become configurable. + Accordingly, a frontend should simply ignore ParameterStatus for + parameters that it does not understand or care about. + + + If a frontend issues a LISTEN command, then the backend will send a NotificationResponse message (not to be confused with NoticeResponse!) whenever a @@ -536,34 +894,16 @@ notification name. - - Notification responses are permitted at any point in the protocol - (after start-up), except within another backend message. Thus, - the frontend must be prepared to recognize a NotificationResponse - message whenever it is expecting any message. Indeed, it should - be able to handle NotificationResponse messages even when it is - not engaged in a query. - - - - NotificationResponse - - - A NOTIFY command has been executed for a - name for which a previous LISTEN command - was executed. Notifications may be sent at any time. - - - - - - - - It may be worth pointing out that the names used in listen and - notify commands need not have anything to do with names of - relations (tables) in the SQL database. Notification names are - simply arbitrarily chosen condition names. - + + + At present, NotificationResponse can only be sent outside a + transaction, and thus it will not occur in the middle of a + command-response series, though it may occur just before ReadyForQuery. + It is unwise to design frontend logic that assumes that, however. + Good practice is to be able to accept NotificationResponse at any + point in the protocol. + + @@ -583,7 +923,7 @@ To issue a cancel request, the frontend opens a new connection to the server and sends a CancelRequest message, rather than the - StartupPacket message that would ordinarily be sent across a new + StartupMessage message that would ordinarily be sent across a new connection. The server will process this request and then close the connection. For security reasons, no direct reply is made to the cancel request message. @@ -633,27 +973,37 @@ Termination - + The normal, graceful termination procedure is that the frontend sends a Terminate message and immediately closes the connection. - On receipt of the message, the backend immediately closes the - connection and terminates. + On receipt of this message, the backend closes the connection and + terminates. - - An ungraceful termination may occur due to software failure (i.e., - core dump) at either end. If either frontend or backend sees an - unexpected closure of the connection, it should clean up and - terminate. The frontend has the option of launching a new backend - by recontacting the server if it doesn't want to terminate - itself. + + In rare cases (such as an administrator-commanded database shutdown) + the backend may disconnect without any frontend request to do so. + In such cases the backend will attempt to send an error or notice message + giving the reason for the disconnection before it closes the connection. + + + + Other termination scenarios arise from various failure cases, such as core + dump at one end or the other, loss of the communications link, loss of + message-boundary synchronization, etc. If either frontend or backend sees + an unexpected closure of the connection, it should clean + up and terminate. The frontend has the option of launching a new backend + by recontacting the server if it doesn't want to terminate itself. + Closing the connection is also advisable if an unrecognizable message type + is received, since this probably indicates loss of message-boundary sync. For either normal or abnormal termination, any open transaction is rolled back, not committed. One should note however that if a - frontend disconnects while a query is being processed, the backend - will probably finish the query before noticing the disconnection. + frontend disconnects while a non-SELECT query is being processed, + the backend will probably finish the query before noticing the + disconnection. If the query is outside any transaction block (BEGIN ... COMMIT sequence) then its results may be committed before the disconnection is recognized. @@ -664,24 +1014,24 @@ SSL Session Encryption - Recent releases of PostgreSQL allow frontend/backend - communication to be encrypted using SSL. This provides communication + If PostgreSQL was built with SSL support, frontend/backend + communications can be encrypted using SSL. This provides communication security in environments where attackers might be able to capture the session traffic. To initiate an SSL-encrypted connection, the frontend initially sends - an SSLRequest message rather than a StartupPacket. The server then + an SSLRequest message rather than a StartupMessage. The server then responds with a single byte containing Y or N, indicating that it is willing or unwilling to perform SSL, respectively. The frontend may close the connection at this point if it is dissatisfied with the response. To continue after Y, perform an SSL startup handshake (not described here, part of the SSL specification) with the server. If this is successful, continue with - sending the usual StartupPacket. In this case the StartupPacket and + sending the usual StartupMessage. In this case the StartupMessage and all subsequent data will be SSL-encrypted. To continue after - N, send the usual StartupPacket and proceed without + N, send the usual StartupMessage and proceed without encryption. @@ -713,40 +1063,32 @@ This section describes the base data types used in messages. + Intn(i) - An n bit integer in network byte order. + An n bit integer in network byte + order. If i is specified it - is the literal value. Eg. Int16, Int32(42). - - - - - - LimStringn(s) - - - - A character array of exactly n bytes interpreted as a - null-terminated string. The zero-byte is omitted if there is - insufficient room. If s is specified it is the literal value. - Eg. LimString32, LimString64("user"). + is the exact value that will appear, otherwise the value + is variable. Eg. Int16, Int32(42). + String(s) - A conventional C null-terminated string with no length - limitation. - If s is specified it is the literal value. + A null-terminated string (C-style string). There is no + specific length limitation on strings. + If s is specified it is the exact + value that will appear, otherwise the value is variable. Eg. String, String("user"). @@ -761,17 +1103,20 @@ characters that don't fit into your fixed-size buffer. + Byten(c) - Exactly n bytes. If c is specified it is the literal - value. Eg. Byte, Byte1('\n'). + Exactly n bytes. If + c is specified it is the exact + value. Eg. Byte2, Byte1('\n'). + @@ -780,83 +1125,17 @@ characters that don't fit into your fixed-size buffer. Message Formats -This section describes the detailed format of each message. Each can be sent -by either a frontend (F), a backend (B), or both (F & B). +This section describes the detailed format of each message. Each is marked to +indicate that it may be sent by a frontend (F), a backend (B), or both +(F & B). +Notice that although each message includes a byte count at the beginning, +the message format is defined so that the message end can be found without +reference to the byte count. This aids validity checking. - - -AsciiRow (B) - - - - - - - Byte1('D') - - - - Identifies the message as an ASCII data row. - (A prior RowDescription message defines the number of - fields in the row and their data types.) - - - - - - Byten - - - - A bit map with one bit for each field in the row. The 1st - field corresponds to bit 7 (MSB) of the 1st byte, the 2nd - field corresponds to bit 6 of the 1st byte, the 8th field - corresponds to bit 0 (LSB) of the 1st byte, the 9th field - corresponds to bit 7 of the 2nd byte, and so on. Each bit - is set if the value of the corresponding field is not NULL. - If the number of fields is not a multiple of 8, the remainder - of the last byte in the bit map is wasted. - - - Then, for each field with a non-NULL value, there is the following: - - - - Int32 - - - - Specifies the size of the value of the field, including - this size. - - - - - - Byten - - - - Specifies the value of the field itself in ASCII - characters. n is the above - size minus 4. - There is no trailing zero-byte in the field data; the front - end must add one if it wants one. - - - - - - - - - - - AuthenticationOk (B) @@ -876,6 +1155,16 @@ AuthenticationOk (B) + + Int32(8) + + + + Length of message contents in bytes, including self. + + + + Int32(0) @@ -890,6 +1179,8 @@ AuthenticationOk (B) + + AuthenticationKerberosV4 (B) @@ -909,6 +1200,16 @@ AuthenticationKerberosV4 (B) + + Int32(8) + + + + Length of message contents in bytes, including self. + + + + Int32(1) @@ -919,11 +1220,11 @@ AuthenticationKerberosV4 (B) - - + + AuthenticationKerberosV5 (B) @@ -943,6 +1244,16 @@ AuthenticationKerberosV5 (B) + + Int32(8) + + + + Length of message contents in bytes, including self. + + + + Int32(2) @@ -953,11 +1264,11 @@ AuthenticationKerberosV5 (B) - - + + AuthenticationCleartextPassword (B) @@ -977,6 +1288,16 @@ AuthenticationCleartextPassword (B) + + Int32(8) + + + + Length of message contents in bytes, including self. + + + + Int32(3) @@ -991,6 +1312,7 @@ AuthenticationCleartextPassword (B) + AuthenticationCryptPassword (B) @@ -1010,6 +1332,16 @@ AuthenticationCryptPassword (B) + + Int32(10) + + + + Length of message contents in bytes, including self. + + + + Int32(4) @@ -1035,6 +1367,7 @@ AuthenticationCryptPassword (B) + AuthenticationMD5Password (B) @@ -1054,6 +1387,16 @@ AuthenticationMD5Password (B) + + Int32(12) + + + + Length of message contents in bytes, including self. + + + + Int32(5) @@ -1079,6 +1422,7 @@ AuthenticationMD5Password (B) + AuthenticationSCMCredential (B) @@ -1098,6 +1442,16 @@ AuthenticationSCMCredential (B) + + Int32(8) + + + + Length of message contents in bytes, including self. + + + + Int32(6) @@ -1113,6 +1467,7 @@ AuthenticationSCMCredential (B) + BackendKeyData (B) @@ -1134,6 +1489,16 @@ BackendKeyData (B) + + Int32(12) + + + + Length of message contents in bytes, including self. + + + + Int32 @@ -1155,17 +1520,17 @@ BackendKeyData (B) - + + BinaryRow (B) - @@ -1174,8 +1539,20 @@ BinaryRow (B) Identifies the message as a binary data row. - (A prior RowDescription message defines the number of - fields in the row and their data types.) + (Normally, a prior RowDescription message defines the number + of fields in the row and their data types. Note that the + receiver must know the number of fields to be + able to decode the message contents.) + + + + + + Int32 + + + + Length of message contents in bytes, including self. @@ -1194,28 +1571,30 @@ BinaryRow (B) If the number of fields is not a multiple of 8, the remainder of the last byte in the bit map is wasted. - + + + Then, for each field with a non-NULL value, there is the following: - Int32 + Int32 - Specifies the size of the value of the field, excluding - this size. + Specifies the size of the value of the field, excluding + this size. - Byten + Byten - Specifies the value of the field itself in binary - format. n is the above size. + Specifies the value of the field itself in binary + format. n is the above size. @@ -1224,11 +1603,179 @@ BinaryRow (B) + + + + +Bind (F) + + + + + + + + Byte1('B') + + + + Identifies the message as a Bind command. + + + + + + Int32 + + + + Length of message contents in bytes, including self. + + + + + + String + + + + The name of the destination portal + (an empty string selects the unnamed portal). + + + + + + String + + + + The name of the source prepared statement + (an empty string selects the unnamed prepared statement). + + + + + + Int8 + + + + 0 if parameter values are specified in textual form. + 1 if parameter values are specified in binary form. + + + + + + Int16 + + + + The number of parameter values specified + (may be zero). This must match the number of parameters + needed by the query. + + + + + If parameter values are specified in textual form, the following + appears for each parameter: + + + + Int8 + + + + 1 if the parameter is non-null. 0 if it is null. + + + + + + String + + + + The parameter value in textual form (that is, suitable + input for the parameter's datatype's input converter). + If the preceding byte specified a null parameter, then + the string is omitted. + + + + + If parameter values are specified in binary form, the following + appears for each parameter: + + + + Int16 + + + + Zero if the field is null, otherwise the typlen + for the field datatype. + + + + + + Byten + + + + The value of the field itself in binary format. + Omitted if the field is null. + n is the typlen + value if typlen is positive. If + typlen is -1 then the field value begins with + its own length as an Int32 (the length includes itself). + + + + + + + + + + + +BindComplete (B) + + + + + + + + Byte1('2') + + + + Identifies the message as a Bind-complete indicator. + + + + + + Int32(4) + + + + Length of message contents in bytes, including self. + + + + + CancelRequest (F) @@ -1243,7 +1790,7 @@ CancelRequest (F) - The size of the packet in bytes. + Length of message contents in bytes, including self. @@ -1282,13 +1829,14 @@ CancelRequest (F) - + + -CompletedResponse (B) +Close (F) @@ -1300,7 +1848,74 @@ CompletedResponse (B) - Identifies the message as a completed response. + Identifies the message as a Close command. + + + + + + Int32 + + + + Length of message contents in bytes, including self. + + + + + + Byte1 + + + + 'S' to close a prepared statement; or + 'P' to close a portal. + + + + + + String + + + + The name of the prepared statement or portal to close + (an empty string selects the unnamed prepared statement + or portal). + + + + + + + + + + + +CommandComplete (B) + + + + + + + + Byte1('C') + + + + Identifies the message as a command-completed response. + + + + + + Int32 + + + + Length of message contents in bytes, including self. @@ -1334,7 +1949,7 @@ CompletedResponse (B) For an UPDATE command, the tag is UPDATE rows where rows is the number of rows updated. - + For a MOVE command, the tag is @@ -1348,27 +1963,216 @@ CompletedResponse (B) FETCH rows where rows is the number of rows that have been retrieved from the cursor. - + + + + + + + +CopyBinaryRow (F & B) + + + + + + + Byte1('b') + + + + Identifies the message as binary COPY data. + Note that the message body format is identical to the + COPY BINARY file-format representation for + a single row of data. -CopyDataRows (B & F) + Int32 - This is a stream of rows where each row is terminated by a Byte1('\n'). - This is then followed by the sequence Byte1('\\'), Byte1('.'), - Byte1('\n'). + Length of message contents in bytes, including self. + + + Int16 + + + + Specifies the number of fields in the row (can be zero). + + + + + Then, for each field, there is the following: + + + + Int16 + + + + Zero if the field is null, otherwise the typlen + for the field datatype. + + + + + + Byten + + + + The value of the field itself in binary format. + Omitted if the field is null. + n is the typlen + value if typlen is positive. If + typlen is -1 then the field value begins with + its own length as an Int32 (the length includes itself). + + + + + + + + + + + + +CopyDataRow (F & B) + + + + + + + Byte1('d') + + + + Identifies the message as textual COPY data. + + + + + + Int32 + + + + Length of message contents in bytes, including self. + + + + + + String + + + + The textual representation of a single row of table data. + It should end with a newline. + + + + + + + + + + + +CopyDone (F & B) + + + + + + + + Byte1('c') + + + + Identifies the message as a COPY-complete indicator. + + + + + + Int32(4) + + + + Length of message contents in bytes, including self. + + + + + + + + + + + + +CopyFail (F) + + + + + + + + Byte1('f') + + + + Identifies the message as a COPY-failure indicator. + + + + + + Int32 + + + + Length of message contents in bytes, including self. + + + + + + String + + + + An error message to report as the cause of failure. + + + + + + + + + + CopyInResponse (B) @@ -1384,16 +2188,28 @@ CopyInResponse (B) Identifies the message as a Start Copy In response. - The frontend must now send a CopyDataRows message. + The frontend must now send copy-in data (if not + prepared to do so, send a CopyFail message). + + + + + + Int32(4) + + + + Length of message contents in bytes, including self. - + + CopyOutResponse (B) @@ -1409,19 +2225,114 @@ CopyOutResponse (B) Identifies the message as a Start Copy Out response. - This message will be followed by a CopyDataRows message. - - - - - - + This message will be followed by copy-out data. -CursorResponse (B) + Int32(4) + + + + Length of message contents in bytes, including self. + + + + + + + + + + + + +DataRow (B) + + + + + + + Byte1('D') + + + + Identifies the message as a text-format data row. + (Normally, a prior RowDescription message defines the number + of fields in the row and their data types. Note that the + receiver must know the number of fields to be + able to decode the message contents.) + + + + + + Int32 + + + + Length of message contents in bytes, including self. + + + + + + Byten + + + + A bit map with one bit for each field in the row. The 1st + field corresponds to bit 7 (MSB) of the 1st byte, the 2nd + field corresponds to bit 6 of the 1st byte, the 8th field + corresponds to bit 0 (LSB) of the 1st byte, the 9th field + corresponds to bit 7 of the 2nd byte, and so on. Each bit + is set if the value of the corresponding field is not NULL. + If the number of fields is not a multiple of 8, the remainder + of the last byte in the bit map is wasted. + + + + + Then, for each field with a non-NULL value, there is the following: + + + + Int32 + + + + Specifies the size of the value of the field, in + bytes; the count includes itself. + + + + + + Byten + + + + Specifies the value of the field itself in textual + form (that is, the result of the output-conversion + routine for the field's datatype). + n is the above size minus 4. + There is no trailing zero-byte in the field data; the + frontend must add one if it wants one. + + + + + + + + + + + + +Describe (F) @@ -1429,11 +2340,32 @@ CursorResponse (B) - Byte1('P') + Byte1('D') - Identifies the message as a cursor response. + Identifies the message as a Describe command. + + + + + + Int32 + + + + Length of message contents in bytes, including self. + + + + + + Byte1 + + + + 'S' to describe a prepared statement; or + 'P' to describe a portal. @@ -1443,17 +2375,18 @@ CursorResponse (B) - The name of the cursor. This will be blank if the cursor is - implicit. + The name of the prepared statement or portal to describe + (an empty string selects the unnamed prepared statement + or portal). - - + + EmptyQueryResponse (B) @@ -1473,6 +2406,16 @@ EmptyQueryResponse (B) + + Int32(5) + + + + Length of message contents in bytes, including self. + + + + String("") @@ -1484,11 +2427,11 @@ EmptyQueryResponse (B) - + ErrorResponse (B) @@ -1508,21 +2451,156 @@ ErrorResponse (B) + + Int32 + + + + Length of message contents in bytes, including self. + + + + + The message body consists of one or more identified fields, + followed by a zero-byte terminator. Fields may appear in + any order. For each field there is the following: + + + + Byte1 + + + + A code identifying the field type; if zero, this is + the message terminator and no string follows. + The presently defined field types are listed in + . + Since more field types may be added in future, + frontends should silently ignore fields of unrecognized + type. + + + + String - The error message itself. + The field value. + + + + + + + +Execute (F) + + + + + + + + Byte1('E') + + + + Identifies the message as an Execute command. + + + + + + Int32 + + + + Length of message contents in bytes, including self. + + + + + + String + + + + The name of the portal to execute + (an empty string selects the unnamed portal). + + + + + + Int8 + + + + 0 to return results in textual form (DataRow messages). + 1 to return results in binary form (BinaryRow messages). + + + + + + Int32 + + + + Maximum number of rows to return, if portal contains + a SELECT or FETCH query (ignored otherwise). Zero + denotes no limit. + + + + + + + + + + + +Flush (F) + + + + + + + + Byte1('H') + + + + Identifies the message as a Flush command. + + + + + + Int32(4) + + + + Length of message contents in bytes, including self. + + + + + + FunctionCall (F) @@ -1542,6 +2620,16 @@ FunctionCall (F) + + Int32 + + + + Length of message contents in bytes, including self. + + + + String("") @@ -1570,28 +2658,30 @@ FunctionCall (F) Specifies the number of arguments being supplied to the function. - + + + Then, for each argument, there is the following: - Int32 + Int32 - Specifies the size of the value of the argument, - excluding this size. + Specifies the size of the value of the argument, + excluding this size. - Byten + Byten - Specifies the value of the field itself in binary - format. n is the above size. + Specifies the value of the field itself in binary + format. n is the above size. @@ -1600,12 +2690,8 @@ FunctionCall (F) - - - - FunctionResultResponse (B) @@ -1625,12 +2711,22 @@ FunctionResultResponse (B) + + Int32 + + + + Length of message contents in bytes, including self. + + + + Byte1('G') - Specifies that a nonempty result was returned. + Specifies that a non-null result was returned. @@ -1670,10 +2766,11 @@ FunctionResultResponse (B) - + + FunctionVoidResponse (B) @@ -1693,21 +2790,67 @@ FunctionVoidResponse (B) + + Int32(5) + + + + Length of message contents in bytes, including self. + + + + Byte1('0') - Specifies that an empty result was returned. + Specifies that a null result was returned. + + + + + + + +NoData (B) + + + + + + + + Byte1('n') + + + + Identifies the message as a no-data indicator. + + + + + + Int32(4) + + + + Length of message contents in bytes, including self. + + + + + + NoticeResponse (B) @@ -1727,21 +2870,53 @@ NoticeResponse (B) + + Int32 + + + + Length of message contents in bytes, including self. + + + + + The message body consists of one or more identified fields, + followed by a zero-byte terminator. Fields may appear in + any order. For each field there is the following: + + + + Byte1 + + + + A code identifying the field type; if zero, this is + the message terminator and no string follows. + The presently defined field types are listed in + . + Since more field types may be added in future, + frontends should silently ignore fields of unrecognized + type. + + + + String - The notice message itself. + The field value. - + + NotificationResponse (B) @@ -1765,6 +2940,16 @@ NotificationResponse (B) Int32 + + Length of message contents in bytes, including self. + + + + + + Int32 + + The process ID of the notifying backend process. @@ -1780,28 +2965,281 @@ NotificationResponse (B) + + + String + + + + Additional information passed from the notifying process. + (Currently, this feature is unimplemented so the field + is always an empty string.) + + + - + -PasswordPacket (F) +ParameterDescription (B) + + Byte1('t') + + + + Identifies the message as a parameter description. + + + + Int32 - The size of the packet in bytes. + Length of message contents in bytes, including self. + + + + + + Int16 + + + + The number of parameters used by the statement + (may be zero). + + + + + Then, for each parameter, there is the following: + + + + Int32 + + + + Specifies the object ID of the parameter datatype. + + + + + + + + + + + +ParameterStatus (B) + + + + + + + + Byte1('S') + + + + Identifies the message as a run-time parameter status report. + + + + + + Int32 + + + + Length of message contents in bytes, including self. + + + + + + String + + + + The name of the run-time parameter being reported. + + + + + + String + + + + The current value of the parameter. + + + + + + + + + + + +Parse (F) + + + + + + + + Byte1('P') + + + + Identifies the message as a Parse command. + + + + + + Int32 + + + + Length of message contents in bytes, including self. + + + + + + String + + + + The name of the destination prepared statement + (an empty string selects the unnamed prepared statement). + + + + + + String + + + + The query string to be parsed. + + + + + + Int16 + + + + The number of parameter datatypes specified + (may be zero). Note that this is not an indication of + the number of parameters that might appear in the + query string, only the number that the frontend wants to + prespecify types for. + + + + + Then, for each parameter, there is the following: + + + + Int32 + + + + Specifies the object ID of the parameter datatype. + Placing a zero here is equivalent to leaving the type + unspecified. + + + + + + + + + + + +ParseComplete (B) + + + + + + + + Byte1('1') + + + + Identifies the message as a Parse-complete indicator. + + + + + + Int32(4) + + + + Length of message contents in bytes, including self. + + + + + + + + + + + + +PasswordMessage (F) + + + + + + + + Byte1('p') + + + + Identifies the message as a password response. + + + + + + Int32 + + + + Length of message contents in bytes, including self. @@ -1820,6 +3258,44 @@ PasswordPacket (F) + + + +PortalSuspended (B) + + + + + + + + Byte1('s') + + + + Identifies the message as a portal-suspended indicator. + Note this only appears if an Execute row-count limit + was reached. + + + + + + Int32(4) + + + + Length of message contents in bytes, including self. + + + + + + + + + + Query (F) @@ -1834,7 +3310,17 @@ Query (F) - Identifies the message as a query. + Identifies the message as a simple query. + + + + + + Int32 + + + + Length of message contents in bytes, including self. @@ -1850,10 +3336,11 @@ Query (F) - + + ReadyForQuery (B) @@ -1873,12 +3360,37 @@ ReadyForQuery (B) + + + Int32(5) + + + + Length of message contents in bytes, including self. + + + + + + Byte1 + + + + Current backend transaction status indicator. + Possible values are 'I' if idle (not in + a transaction block); 'T' if in a transaction + block; or 'E' if in a failed transaction + block (queries will be rejected until block is ended). + + + - + + RowDescription (B) @@ -1898,6 +3410,16 @@ RowDescription (B) + + Int32 + + + + Length of message contents in bytes, including self. + + + + Int16 @@ -1905,46 +3427,72 @@ RowDescription (B) Specifies the number of fields in a row (may be zero). - + + + Then, for each field, there is the following: - String + String - Specifies the field name. + The field name. - Int32 + Int32 - Specifies the object ID of the field type. + If the field can be identified as a column of a specific + table, the object ID of the table; otherwise zero. - Int16 + Int16 - Specifies the type size. + If the field can be identified as a column of a specific + table, the attribute number of the column; otherwise zero. - Int32 + Int32 - Specifies the type modifier. + The object ID of the field's datatype. + + + + + + Int16 + + + + The datatype size (see pg_type.typlen). + Note that negative values denote variable-width types. + + + + + + Int32 + + + + The type modifier (see pg_attribute.atttypmod). + The meaning of the modifier is type-specific. @@ -1953,13 +3501,8 @@ RowDescription (B) - - - - - SSLRequest (F) @@ -1974,7 +3517,7 @@ SSLRequest (F) - The size of the packet in bytes. + Length of message contents in bytes, including self. @@ -1997,9 +3540,10 @@ SSLRequest (F) + -StartupPacket (F) +StartupMessage (F) @@ -2007,11 +3551,11 @@ StartupPacket (F) - Int32(296) + Int32 - The size of the packet in bytes. + Length of message contents in bytes, including self. @@ -2022,69 +3566,120 @@ StartupPacket (F) The protocol version number. The most significant 16 bits are - the major version number. The least 16 significant bits are - the minor version number. + the major version number (3 for the format described here). + The least 16 significant bits are the minor version number. + + + + + The protocol version number is followed by one or more pairs of + parameter name and value strings. Parameters can appear in any + order. user is required, others are optional. + Each parameter is specified as: + + + + String + + + + The parameter name. Currently recognized names are: + + + + + user + + + + The database user name to connect as. Required; + there is no default. - LimString64 + database - The database name, defaults to the user name if empty. + The database to connect to. Defaults to the user name. - LimString32 + options - The user name. - - - - - - LimString64 - - - - Any additional command line arguments to be passed to the - backend child process by the server. - - - - - - LimString64 - - - - Unused. - - - - - - LimString64 - - - - The optional tty the backend should use for debugging messages. - (Currently, this field is unsupported and ignored.) + Command-line arguments for the backend. (This is + deprecated in favor of setting individual GUC + parameters.) + In addition to the above, any GUC parameter that can be + set at backend start time may be listed. Such settings + will be applied during backend start (after parsing the + command-line options if any). + + + + + + String + + + + The parameter value. + + + + + + + + +Sync (F) + + + + + + + + Byte1('S') + + + + Identifies the message as a Sync command. + + + + + + Int32(4) + + + + Length of message contents in bytes, including self. + + + + + + + + + + Terminate (F) @@ -2103,14 +3698,179 @@ Terminate (F) + + + Int32(4) + + + + Length of message contents in bytes, including self. + + + + + + + + + + + + + +Error and Notice Message Fields + + +This section describes the fields that may appear in ErrorResponse and +NoticeResponse messages. Each field type has a single-byte identification +token. + + + + + + +S + + + + Severity: the field contents are + ERROR, FATAL, or + PANIC (in an error message), or + WARNING, NOTICE, DEBUG, + INFO, or LOG (in a notice message), + or a localized translation of one of these. Always present. + + + + + + +C + + + + Code: the SQLSTATE code for the error (a 5-character + string following SQL spec conventions). Not localizable. + Always present. + + + + + + +M + + + + Message: the primary human-readable error message. + This should be accurate but terse (typically one line). + Always present. + + + + + + +D + + + + Detail: an optional secondary error message carrying more + detail about the problem. May run to multiple lines. + + + + + + +H + + + + Hint: an optional suggestion what to do about the problem. + This is intended to differ from Detail in that it offers advice + (potentially inappropriate) rather than hard facts. + May run to multiple lines. + + + + + + +P + + + + Position: the field value is a decimal ASCII integer, indicating + an error cursor position as an index into the original query string. + The first character has index 1, and positions are measured in + characters not bytes. + + + + + + +W + + + + Where: an indication of the context in which the error occurred. + Presently this includes a call stack traceback of active PL functions. + The trace is one entry per line, most recent first. + + + + + + +F + + + + File: the file name of the source-code location where the error + was reported. + + + + + + +L + + + + Line: the line number of the source-code location where the error + was reported. + + + + + + +R + + + + Routine: the name of the source-code routine reporting the error. + +The client is responsible for formatting displayed information to meet its +needs; in particular it should break long lines as needed. Newline characters +appearing in the error message fields should be treated as paragraph breaks, +not line breaks. + + + +