NAME

       pgproto - tests PostgreSQL or any other servers that understand the frontend/backend protocol.

SYNOPSIS

       pgproto [option...]

DESCRIPTION

       pgproto tests PostgreSQL or any other servers that understand the frontend/backend protocol.

OPTIONS

       -h hostname
       --hostname=hostname
           The host name of the machine on which the server is running. If the value begins with a slash, it is
           used as the directory for the Unix-domain socket (default: Unix-domain socket).

       -p port
       --port=port
           The port number (default:5432).

       -u username
       --user=username
           The user name (default: OS user name).

       -d databasename
       --database=databasename
           The database name (default: same as user).

       -f filename
       --proto-data-file=filename
           Text file describing message data to be sent to PostgreSQL (default: pgproto.data).

       -r naptime
       --read-nap=naptime
           The nap time in micro seconds (default:0). Greater than 0 will let pgproto sleep between each data
           reading from socket. This is useful to simulate slow clients.

       -D
       --debug
           Enable debug message.

       -v
       --version
           Print the command version, then exit.

       -?
       --help
           Shows help for the command line arguments, then exit.

EXAMPLE

       In the example below, the first character in the file (i.e. 'Q') indicates the message kind specified in
       the PostgreSQL frontend/backend protocol.

       Exceptions are 'Y' and 'y'. 'Y' reads messages from backend until 'Ready for query' is received. 'y'
       reads messages from backend while messages are coming from backend then stops if messages are not
       available for 1 second. 'Y' is used for waiting for reply of 'Q' (simple query) or after 'S' (sync) in
       extended queries. 'y' can be used for receiving messages after 'H' (flush).

       If you want to include a " (double quotation) in a string data type, for example "SELECT * FROM "aaa"",
       you can qualify it by using \ (back slash) like ""SELECT * FROM "aaa"" A command line spread over
       multiple lines can be created using \ as well.

               'Q' "SELECT * FROM aaa \
               WHERE a = 1"

       Here is an example input file:

               #
               # Test data example
               #
               'Q'  "SELECT * FROM aaa"
               'Y'
               'P'  "S1" "BEGIN"   0
               'B'  ""   "S1" 0    0    0
               'E'  ""   0
               'C'  'S'  "S1"
               'P'  "foo"     "SELECT 1"     0
               'B'  "myportal"     "foo"     0    0    0
               'E'  "myportal"     0
               'P'  "S2" "COMMIT"  0
               'B'  ""   "S2" 0    0    0
               'E'  ""   0
               'C'  'S'  "S2"
               'S'
               'Y'
               'X'

       Here is an example output:

               $ pgproto -p 11000 -d test -f sample.data
               FE=> Query (query="SELECT * FROM aaa")
               <= BE RowDescription
               <= BE CommandComplete(SELECT 0)
               <= BE ReadyForQuery(I)
               FE=> Parse(stmt="S1", query="BEGIN")
               FE=> Bind(stmt="S1", portal="")
               FE=> Execute(portal="")
               FE=> Close(stmt="S1")
               FE=> Parse(stmt="foo", query="SELECT 1")
               FE=> Bind(stmt="foo", portal="myportal")
               FE=> Execute(portal="myportal")
               FE=> Parse(stmt="S2", query="COMMIT")
               FE=> Bind(stmt="S2", portal="")
               FE=> Execute(portal="")
               FE=> Close(stmt="S2")
               FE=> Sync
               <= BE ParseComplete
               <= BE BindComplete
               <= BE CommandComplete(BEGIN)
               <= BE CloseComplete
               <= BE ParseComplete
               <= BE BindComplete
               <= BE DataRow
               <= BE CommandComplete(SELECT 1)
               <= BE ParseComplete
               <= BE BindComplete
               <= BE CommandComplete(COMMIT)
               <= BE CloseComplete
               <= BE ReadyForQuery(I)
               FE=> Terminate

       Other example data files:

       Copy

               #
               # Test data example
               #

               # CopyIn
               #
               'Q'  "COPY t1 FROM STDIN"
               # CopyData
               'd'  "abc"
               # CopyDone
               'c'
               'Y'

               # CopyOut
               #
               'Q'  "COPY t1 TO STDOUT"
               'Y'

               #
               # Copy fail case
               #
               'Q'  "COPY t1 FROM STDIN"
               # CopyData
               'd'  "abc"
               # CopyFail
               'f'  "pgproto copy fail test"
               'Y'
               'X'

       Function Call

               #
               # Test data example
               #

               # Function call (lo_creat)
               # from PostgreSQL's src/include/catalog/pg_proc.data
               # { oid => '957', descr => 'large object create',
               #  proname => 'lo_creat', provolatile => 'v', proparallel => 'u',
               #  prorettype => 'oid', proargtypes => 'int4', prosrc => 'be_lo_creat' },

               'F'  957  1    0    1    1    "0"  0
               'Y'
               'X'

pgpool-II 4.3.7                                       2023                                            PGPROTO(1)