Skip to content

P
Postgres FD Implementation
Commit edbd5139 authored by Bruce Momjian's avatar Bruce Momjian
Browse files
Options

What I've done: 

1. Rewritten libpq to allow asynchronous clients.

2. Implemented client side of cancel protocol in library,
   and patched psql.c to send a cancel request upon SIGINT.  The
   backend doesn't notice it yet :-(

3. Implemented 'Z' protocol message addition and renaming of
   copy in/out start messages.  These are implemented conditionally,
   ie, the client protocol version is checked; so the code should
   still work with 1.0 clients.

4. Revised protocol and libpq sgml documents (don't have an SGML
   compiler, though, so there may be some markup glitches here).


What remains to be done:

1. Implement addition of atttypmod field to RowDescriptor messages.
   The client-side code is there but ifdef'd out.  I have no idea
   what to change on the backend side.  The field should be sent
   only if protocol >= 2.0, of course.

2. Implement backend response to cancel requests received as OOB
   messages.  (This prolly need not be conditional on protocol
   version; just do it if you get SIGURG.)

3. Update libpq.3.  (I'm hoping this can be generated mechanically
   from libpq.sgml... if not, will do it by hand.)  Is there any
   other doco to fix?

4. Update non-libpq interfaces as necessary.  I patched libpgtcl
   so that it would compile, but haven't tested it.  Dunno what
   needs to be done with the other interfaces.

Have at it!

Tom Lane
parent 2e12331d
Hide whitespace changes
Inline Side-by-side
Showing with 2514 additions and 1996 deletions
doc/src/sgml/libpq.sgml
View file @ edbd5139
...@@ -128,7 +128,7 @@ PGconn *PQsetdb(char *pghost, ...@@ -128,7 +128,7 @@ PGconn *PQsetdb(char *pghost,
<ListItem> <ListItem>
<Para> <Para>
<Function>PQconndefaults</Function> <Function>PQconndefaults</Function>
Returns the database name of the connection. Returns the default connection options.
<ProgramListing> <ProgramListing>
PQconninfoOption *PQconndefaults(void) PQconninfoOption *PQconndefaults(void)
...@@ -244,7 +244,7 @@ void PQfinish(PGconn *conn) ...@@ -244,7 +244,7 @@ void PQfinish(PGconn *conn)
Reset the communication port with the backend. Reset the communication port with the backend.
This function will close the IPC socket connection This function will close the IPC socket connection
to the backend and attempt to reestablish a new to the backend and attempt to reestablish a new
connection to the same backend. connection to the same postmaster.
<ProgramListing> <ProgramListing>
void PQreset(PGconn *conn) void PQreset(PGconn *conn)
</ProgramListing> </ProgramListing>
...@@ -287,11 +287,12 @@ void PQuntrace(PGconn *conn); ...@@ -287,11 +287,12 @@ void PQuntrace(PGconn *conn);
<Para> <Para>
<Function>PQexec</Function> <Function>PQexec</Function>
Submit a query to <ProductName>Postgres</ProductName>. Returns a PGresult Submit a query to <ProductName>Postgres</ProductName>. Returns a PGresult
pointer if the query was successful or a NULL otherwise. If a NULL is returned, PQerrorMessage can pointer or possibly a NULL pointer. If a NULL is returned, it
be used to get more information about the error. should be treated like a PGRES_FATAL_ERROR result: use
PQerrorMessage to get more information about the error.
<ProgramListing> <ProgramListing>
PGresult *PQexec(PGconn *conn, PGresult *PQexec(PGconn *conn,
char *query); const char *query);
</ProgramListing> </ProgramListing>
The <Function>PGresult</Function> structure encapsulates the query The <Function>PGresult</Function> structure encapsulates the query
result returned by the backend. <Function>libpq</Function> programmers result returned by the backend. <Function>libpq</Function> programmers
...@@ -310,7 +311,7 @@ PGresult *PQexec(PGconn *conn, ...@@ -310,7 +311,7 @@ PGresult *PQexec(PGconn *conn,
Returns the result status of the query. PQresultStatus can return one of the following values: Returns the result status of the query. PQresultStatus can return one of the following values:
<ProgramListing> <ProgramListing>
PGRES_EMPTY_QUERY, PGRES_EMPTY_QUERY,
PGRES_COMMAND_OK, /* the query was a command */ PGRES_COMMAND_OK, /* the query was a command returning no data */
PGRES_TUPLES_OK, /* the query successfully returned tuples */ PGRES_TUPLES_OK, /* the query successfully returned tuples */
PGRES_COPY_OUT, PGRES_COPY_OUT,
PGRES_COPY_IN, PGRES_COPY_IN,
...@@ -391,7 +392,20 @@ Oid PQftype(PGresult *res, ...@@ -391,7 +392,20 @@ Oid PQftype(PGresult *res,
returned is -1, the field is a variable length returned is -1, the field is a variable length
field. Field indices start at 0. field. Field indices start at 0.
<ProgramListing> <ProgramListing>
int2 PQfsize(PGresult *res, short PQfsize(PGresult *res,
int field_index);
</ProgramListing>
</Para>
</ListItem>
<ListItem>
<Para>
<Function>PQfmod</Function>
Returns the type-specific modification data of the field
associated with the given field index.
Field indices start at 0.
<ProgramListing>
short PQfmod(PGresult *res,
int field_index); int field_index);
</ProgramListing> </ProgramListing>
</Para> </Para>
...@@ -521,7 +535,6 @@ struct _PQprintOpt ...@@ -521,7 +535,6 @@ struct _PQprintOpt
<Function>PQprintTuples</Function> <Function>PQprintTuples</Function>
Prints out all the tuples and, optionally, the Prints out all the tuples and, optionally, the
attribute names to the specified output stream. attribute names to the specified output stream.
The programs psql and monitor both use PQprintTuples for output.
<ProgramListing> <ProgramListing>
void PQprintTuples(PGresult* res, void PQprintTuples(PGresult* res,
FILE* fout, /* output stream */ FILE* fout, /* output stream */
...@@ -566,6 +579,207 @@ void PQclear(PQresult *res); ...@@ -566,6 +579,207 @@ void PQclear(PQresult *res);
</Para> </Para>
</Sect1> </Sect1>
<Sect1>
<Title>Asynchronous Query Processing</Title>
<Para>
The PQexec function is adequate for submitting queries in simple synchronous
applications. It has a couple of major deficiencies however:
<Para>
<ItemizedList>
<ListItem>
<Para>
PQexec waits for the query to be completed. The application may have other
work to do (such as maintaining a user interface), in which case it won't
want to block waiting for the response.
</Para>
</ListItem>
<ListItem>
<Para>
Since control is buried inside PQexec, there is no way for the frontend
to decide it would like to try to cancel the ongoing query.
</Para>
</ListItem>
<ListItem>
<Para>
PQexec can return only one PGresult structure. If the submitted query
string contains multiple SQL commands, all but the last PGresult are
discarded by PQexec.
</Para>
</ListItem>
</ItemizedList>
</Para>
<Para>
Applications that do not like these limitations can instead use the
underlying functions that PQexec is built from: PQsendQuery and
PQgetResult.
<Para>
<ItemizedList>
<ListItem>
<Para>
<Function>PQsendQuery</Function>
Submit a query to <ProductName>Postgres</ProductName> without
waiting for the result(s). TRUE is returned if the query was
successfully dispatched, FALSE if not (in which case, use
PQerrorMessage to get more information about the failure).
<ProgramListing>
int PQsendQuery(PGconn *conn,
const char *query);
</ProgramListing>
After successfully calling PQsendQuery, call PQgetResult one or more
times to obtain the query results. PQsendQuery may not be called
again (on the same connection) until PQgetResult has returned NULL,
indicating that the query is done.
</Para>
</ListItem>
<ListItem>
<Para>
<Function>PQgetResult</Function>
Wait for the next result from a prior PQsendQuery,
and return it. NULL is returned when the query is complete
and there will be no more results.
<ProgramListing>
PGresult *PQgetResult(PGconn *conn);
</ProgramListing>
PQgetResult must be called repeatedly until it returns NULL,
indicating that the query is done. (If called when no query is
active, PQgetResult will just return NULL at once.)
Each non-null result from PQgetResult should be processed using
the same PGresult accessor functions previously described.
Don't forget to free each result object with PQclear when done with it.
Note that PQgetResult will block only if a query is active and the
necessary response data has not yet been read by PQconsumeInput.
</Para>
</ListItem>
</ItemizedList>
</Para>
<Para>
Using PQsendQuery and PQgetResult solves one of PQexec's problems:
if a query string contains multiple SQL commands, the results of those
commands can be obtained individually. (This allows a simple form of
overlapped processing, by the way: the frontend can be handling the
results of one query while the backend is still working on later
queries in the same query string.) However, calling PQgetResult will
still cause the frontend to block until the backend completes the
next SQL command. This can be avoided by proper use of three more
functions:
<Para>
<ItemizedList>
<ListItem>
<Para>
<Function>PQconsumeInput</Function>
If input is available from the backend, consume it.
<ProgramListing>
void PQconsumeInput(PGconn *conn);
</ProgramListing>
No direct return value is available from PQconsumeInput, but
after calling it, the application may check PQisBusy and/or
PQnotifies to see if their state has changed.
PQconsumeInput may be called even if the application is not
prepared to deal with a result or notification just yet.
It will read available data and save it in a buffer, thereby
causing a select(2) read-ready indication to go away. The
application can thus use PQconsumeInput to clear the select
condition immediately, and then examine the results at leisure.
</Para>
</ListItem>
<ListItem>
<Para>
<Function>PQisBusy</Function>
Returns TRUE if a query is busy, that is, PQgetResult would block
waiting for input. A FALSE return indicates that PQgetResult can
be called with assurance of not blocking.
<ProgramListing>
int PQisBusy(PGconn *conn);
</ProgramListing>
PQisBusy will not itself attempt to read data from the backend;
therefore PQconsumeInput must be invoked first, or the busy
state will never end.
</Para>
</ListItem>
<ListItem>
<Para>
<Function>PQsocket</Function>
Obtain the file descriptor number for the backend connection socket.
A valid descriptor will be >= 0; a result of -1 indicates that
no backend connection is currently open.
<ProgramListing>
int PQsocket(PGconn *conn);
</ProgramListing>
PQsocket should be used to obtain the backend socket descriptor
in preparation for executing select(2). This allows an application
to wait for either backend responses or other conditions.
If the result of select(2) indicates that data can be read from
the backend socket, then PQconsumeInput should be called to read the
data; after which, PQisBusy, PQgetResult, and/or PQnotifies can be
used to process the response.
</Para>
</ListItem>
</ItemizedList>
</Para>
<Para>
A typical frontend using these functions will have a main loop that uses
select(2) to wait for all the conditions that it must respond to. One of
the conditions will be input available from the backend, which in select's
terms is readable data on the file descriptor identified by PQsocket.
When the main loop detects input ready, it should call PQconsumeInput
to read the input. It can then call PQisBusy, followed by PQgetResult
if PQisBusy returns FALSE. It can also call PQnotifies to detect NOTIFY
messages (see "Asynchronous Notification", below). An example is given
in the sample programs section.
<Para>
A frontend that uses PQsendQuery/PQgetResult can also attempt to cancel
a query that is still being processed by the backend.
<Para>
<ItemizedList>
<ListItem>
<Para>
<Function>PQrequestCancel</Function>
Request that <ProductName>Postgres</ProductName> abandon
processing of the current query.
<ProgramListing>
int PQrequestCancel(PGconn *conn);
</ProgramListing>
The return value is TRUE if the cancel request was successfully
dispatched, FALSE if not. (If not, PQerrorMessage tells why not.)
Successful dispatch is no guarantee that the request will have any
effect, however. Regardless of the return value of PQrequestCancel,
the application must continue with the normal result-reading
sequence using PQgetResult. If the cancellation
is effective, the current query will terminate early and return
an error result. If the cancellation fails (say because the
backend was already done processing the query), then there will
be no visible result at all.
</Para>
</ListItem>
</ItemizedList>
</Para>
<Para>
Note that if the current query is part of a transaction, cancellation
will abort the whole transaction.
<Para>
The current implementation of cancel requests uses "out of band" messages.
This feature is supported only on TCP/IP connections. If the backend
communication is being done through a Unix socket, PQrequestCancel will
always fail.
</Sect1>
<Sect1> <Sect1>
<Title>Fast Path</Title> <Title>Fast Path</Title>
...@@ -617,48 +831,60 @@ typedef struct { ...@@ -617,48 +831,60 @@ typedef struct {
<Title>Asynchronous Notification</Title> <Title>Asynchronous Notification</Title>
<Para> <Para>
<ProductName>Postgres</ProductName> supports asynchronous notification via the <ProductName>Postgres</ProductName> supports asynchronous notification via the
LISTEN and NOTIFY commands. A backend registers its LISTEN and NOTIFY commands. A backend registers its interest in a particular
interest in a particular relation with the LISTEN command. All backends listening on a particular relation notification condition with the LISTEN command. All backends listening on a
will be notified asynchronously when a NOTIFY of that particular condition will be notified asynchronously when a NOTIFY of that
relation name is executed by another backend. No condition name is executed by any backend. No additional information is
additional information is passed from the notifier to passed from the notifier to the listener. Thus, typically, any actual data
the listener. Thus, typically, any actual data that that needs to be communicated is transferred through a database relation.
needs to be communicated is transferred through the Commonly the condition name is the same as the associated relation, but it is
relation. not necessary for there to be any associated relation.
<FileName>libpq</FileName> applications are notified whenever a connected
backend has received an asynchronous notification. <Para>
However, the communication from the backend to the <FileName>libpq</FileName> applications submit LISTEN commands as ordinary
frontend is not asynchronous. Notification comes SQL queries. Subsequently, arrival of NOTIFY messages can be detected by
piggy-backed on other query results. Thus, an application must submit queries, even empty ones, in order to calling PQnotifies().
receive notice of backend notification. In effect, the
<FileName>libpq</FileName> application must poll the backend to see if there
is any pending notification information. After the
execution of a query, a frontend may call PQNotifies to
see if any notification data is available from the
backend.
</Para>
<Para> <Para>
<ItemizedList> <ItemizedList>
<ListItem> <ListItem>
<Para> <Para>
<Function>PQNotifies</Function> <Function>PQnotifies</Function>
returns the notification from a list of unhandled Returns the next notification from a list of unhandled
notifications from the backend. Returns NULL if notification messages received from the backend. Returns NULL if
there are no pending notifications from the backend. PQNotifies behaves like the popping of a there are no pending notifications. PQnotifies behaves like the
stack. Once a notification is returned from PQnotifies, it is considered handled and will be popping of a stack. Once a notification is returned from
removed from the list of notifications. PQnotifies, it is considered handled and will be removed from the
list of notifications.
<ProgramListing> <ProgramListing>
PGnotify* PQNotifies(PGconn *conn); PGnotify* PQnotifies(PGconn *conn);
</ProgramListing> </ProgramListing>
The second sample program gives an example of the use After processing a PGnotify object returned by PQnotifies,
of asynchronous notification. be sure to free it with free() to avoid a memory leak.
The second sample program gives an example of the use
of asynchronous notification.
</Para> </Para>
</ListItem> </ListItem>
</ItemizedList> </ItemizedList>
</Para> </Para>
<Para>
PQnotifies() does not actually read backend data; it just returns messages
previously absorbed by another <FileName>libpq</FileName> function. In prior
releases of <FileName>libpq</FileName>, the only way to ensure timely receipt
of NOTIFY messages was to constantly submit queries, even empty ones, and then
check PQnotifies() after each PQexec(). While this still works, it is
deprecated as a waste of processing power. A better way to check for NOTIFY
messages when you have no useful queries to make is to call PQconsumeInput(),
then check PQnotifies(). You can use select(2) to wait for backend data to
arrive, thereby using no CPU power unless there is something to do. Note that
this will work OK whether you use PQsendQuery/PQgetResult or plain old PQexec
for queries. You should, however, remember to check PQnotifies() after each
PQgetResult or PQexec to see if any notifications came in during the
processing of the query.
</Para>
</Sect1> </Sect1>
<Sect1> <Sect1>
...@@ -671,6 +897,11 @@ PGnotify* PQNotifies(PGconn *conn); ...@@ -671,6 +897,11 @@ PGnotify* PQNotifies(PGconn *conn);
advantage of this capability. advantage of this capability.
</Para> </Para>
<Para>
These functions should be executed only after obtaining a PGRES_COPY_OUT
or PGRES_COPY_IN result object from PQexec or PQgetResult.
</Para>
<Para> <Para>
<ItemizedList> <ItemizedList>
<ListItem> <ListItem>
...@@ -685,7 +916,7 @@ PGnotify* PQNotifies(PGconn *conn); ...@@ -685,7 +916,7 @@ PGnotify* PQNotifies(PGconn *conn);
has been read, and 1 if the buffer is full but the has been read, and 1 if the buffer is full but the
terminating newline has not yet been read. terminating newline has not yet been read.
Notice that the application must check to see if a Notice that the application must check to see if a
new line consists of the single character ".", new line consists of the two characters "\.",
which indicates that the backend server has finished sending the results of the copy command. which indicates that the backend server has finished sending the results of the copy command.
Therefore, if the application ever expects to Therefore, if the application ever expects to
receive lines that are more than length-1 characters long, the application must be sure to check receive lines that are more than length-1 characters long, the application must be sure to check
...@@ -708,8 +939,8 @@ int PQgetline(PGconn *conn, ...@@ -708,8 +939,8 @@ int PQgetline(PGconn *conn,
<Function>PQputline</Function> <Function>PQputline</Function>
Sends a null-terminated string to the backend Sends a null-terminated string to the backend
server. server.
The application must explicitly send the single The application must explicitly send the two
character "." to indicate to the backend that it characters "\." on a final line to indicate to the backend that it
has finished sending its data. has finished sending its data.
<ProgramListing> <ProgramListing>
void PQputline(PGconn *conn, void PQputline(PGconn *conn,
...@@ -736,18 +967,35 @@ void PQputline(PGconn *conn, ...@@ -736,18 +967,35 @@ void PQputline(PGconn *conn,
int PQendcopy(PGconn *conn); int PQendcopy(PGconn *conn);
</ProgramListing> </ProgramListing>
<ProgramListing> <ProgramListing>
PQexec(conn, "create table foo (a int4, b text, d float8)"); PQexec(conn, "create table foo (a int4, b char16, d float8)");
PQexec(conn, "copy foo from stdin"); PQexec(conn, "copy foo from stdin");
PQputline(conn, "3&lt;TAB&gt;hello world&lt;TAB&gt;4.5\n"); PQputline(conn, "3&lt;TAB&gt;hello world&lt;TAB&gt;4.5\n");
PQputline(conn,"4&lt;TAB&gt;goodbye world&lt;TAB&gt;7.11\n"); PQputline(conn,"4&lt;TAB&gt;goodbye world&lt;TAB&gt;7.11\n");
... ...
PQputline(conn,".\n"); PQputline(conn,"\\.\n");
PQendcopy(conn); PQendcopy(conn);
</ProgramListing> </ProgramListing>
</Para> </Para>
</ListItem> </ListItem>
</ItemizedList> </ItemizedList>
</Para> </Para>
<Para>
When using PQgetResult, the application should respond to
a PGRES_COPY_OUT result by executing PQgetline repeatedly,
followed by PQendcopy after the terminator line is seen.
It should then return to the PQgetResult loop until PQgetResult
returns NULL. Similarly a PGRES_COPY_IN result is processed
by a series of PQputline calls followed by PQendcopy, then
return to the PQgetResult loop. This arrangement will ensure that
a copy in or copy out command embedded in a series of SQL commands
will be executed correctly.
Older applications are likely to submit a copy in or copy out
via PQexec and assume that the transaction is done after PQendcopy.
This will work correctly only if the copy in/out is the only
SQL command in the query string.
</Para>
</Sect1> </Sect1>
<Sect1> <Sect1>
...@@ -833,7 +1081,7 @@ void fe_setauthsvc(char *name, ...@@ -833,7 +1081,7 @@ void fe_setauthsvc(char *name,
<Para> <Para>
The query buffer is 8192 bytes long, and queries over The query buffer is 8192 bytes long, and queries over
that length will be silently truncated. that length will be rejected.
</Para> </Para>
</Sect1> </Sect1>
...@@ -888,7 +1136,7 @@ void fe_setauthsvc(char *name, ...@@ -888,7 +1136,7 @@ void fe_setauthsvc(char *name,
/* check to see that the backend connection was successfully made */ /* check to see that the backend connection was successfully made */
if (PQstatus(conn) == CONNECTION_BAD) { if (PQstatus(conn) == CONNECTION_BAD) {
fprintf(stderr,"Connection to database '&percnt;s' failed.0, dbName); fprintf(stderr,"Connection to database '&percnt;s' failed.\n", dbName);
fprintf(stderr,"&percnt;s",PQerrorMessage(conn)); fprintf(stderr,"&percnt;s",PQerrorMessage(conn));
exit_nicely(conn); exit_nicely(conn);
} }
...@@ -900,7 +1148,7 @@ void fe_setauthsvc(char *name, ...@@ -900,7 +1148,7 @@ void fe_setauthsvc(char *name,
res = PQexec(conn,"BEGIN"); res = PQexec(conn,"BEGIN");
if (PQresultStatus(res) != PGRES_COMMAND_OK) { if (PQresultStatus(res) != PGRES_COMMAND_OK) {
fprintf(stderr,"BEGIN command failed0); fprintf(stderr,"BEGIN command failed\n");
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
...@@ -911,7 +1159,7 @@ void fe_setauthsvc(char *name, ...@@ -911,7 +1159,7 @@ void fe_setauthsvc(char *name,
/* fetch instances from the pg_database, the system catalog of databases*/ /* fetch instances from the pg_database, the system catalog of databases*/
res = PQexec(conn,"DECLARE myportal CURSOR FOR select * from pg_database"); res = PQexec(conn,"DECLARE myportal CURSOR FOR select * from pg_database");
if (PQresultStatus(res) != PGRES_COMMAND_OK) { if (PQresultStatus(res) != PGRES_COMMAND_OK) {
fprintf(stderr,"DECLARE CURSOR command failed0); fprintf(stderr,"DECLARE CURSOR command failed\n");
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
...@@ -919,7 +1167,7 @@ void fe_setauthsvc(char *name, ...@@ -919,7 +1167,7 @@ void fe_setauthsvc(char *name,
res = PQexec(conn,"FETCH ALL in myportal"); res = PQexec(conn,"FETCH ALL in myportal");
if (PQresultStatus(res) != PGRES_TUPLES_OK) { if (PQresultStatus(res) != PGRES_TUPLES_OK) {
fprintf(stderr,"FETCH ALL command didn't return tuples properly0); fprintf(stderr,"FETCH ALL command didn't return tuples properly\n");
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
...@@ -929,14 +1177,14 @@ void fe_setauthsvc(char *name, ...@@ -929,14 +1177,14 @@ void fe_setauthsvc(char *name,
for (i=0; i &lt; nFields; i++) { for (i=0; i &lt; nFields; i++) {
printf("&percnt;-15s",PQfname(res,i)); printf("&percnt;-15s",PQfname(res,i));
} }
printf("0); printf("\n");
/* next, print out the instances */ /* next, print out the instances */
for (i=0; i &lt; PQntuples(res); i++) { for (i=0; i &lt; PQntuples(res); i++) {
for (j=0 ; j &lt; nFields; j++) { for (j=0 ; j &lt; nFields; j++) {
printf("&percnt;-15s", PQgetvalue(res,i,j)); printf("&percnt;-15s", PQgetvalue(res,i,j));
} }
printf("0); printf("\n");
} }
PQclear(res); PQclear(res);
...@@ -1018,14 +1266,14 @@ void fe_setauthsvc(char *name, ...@@ -1018,14 +1266,14 @@ void fe_setauthsvc(char *name,
/* check to see that the backend connection was successfully made */ /* check to see that the backend connection was successfully made */
if (PQstatus(conn) == CONNECTION_BAD) { if (PQstatus(conn) == CONNECTION_BAD) {
fprintf(stderr,"Connection to database '&percnt;s' failed.0, dbName); fprintf(stderr,"Connection to database '&percnt;s' failed.\n", dbName);
fprintf(stderr,"&percnt;s",PQerrorMessage(conn)); fprintf(stderr,"&percnt;s",PQerrorMessage(conn));
exit_nicely(conn); exit_nicely(conn);
} }
res = PQexec(conn, "LISTEN TBL2"); res = PQexec(conn, "LISTEN TBL2");
if (PQresultStatus(res) != PGRES_COMMAND_OK) { if (PQresultStatus(res) != PGRES_COMMAND_OK) {
fprintf(stderr,"LISTEN command failed0); fprintf(stderr,"LISTEN command failed\n");
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
...@@ -1034,20 +1282,19 @@ void fe_setauthsvc(char *name, ...@@ -1034,20 +1282,19 @@ void fe_setauthsvc(char *name,
PQclear(res); PQclear(res);
while (1) { while (1) {
/* async notification only come back as a result of a query*/ /* wait a little bit between checks;
/* we can send empty queries */ * waiting with select() would be more efficient.
res = PQexec(conn, " "); */
/* printf("res-&gt;status = &percnt;s0, pgresStatus[PQresultStatus(res)]); */ sleep(1);
/* check for asynchronous returns */ /* collect any asynchronous backend messages */
notify = PQnotifies(conn); PQconsumeInput(conn);
if (notify) { /* check for asynchronous notify messages */
while ((notify = PQnotifies(conn)) != NULL) {
fprintf(stderr, fprintf(stderr,
"ASYNC NOTIFY of '&percnt;s' from backend pid '&percnt;d' received0, "ASYNC NOTIFY of '&percnt;s' from backend pid '&percnt;d' received\n",
notify-&gt;relname, notify-&gt;be_pid); notify-&gt;relname, notify-&gt;be_pid);
free(notify); free(notify);
break;
} }
PQclear(res);
} }
/* close the connection to the database and cleanup */ /* close the connection to the database and cleanup */
...@@ -1128,7 +1375,7 @@ void fe_setauthsvc(char *name, ...@@ -1128,7 +1375,7 @@ void fe_setauthsvc(char *name,
/* check to see that the backend connection was successfully made */ /* check to see that the backend connection was successfully made */
if (PQstatus(conn) == CONNECTION_BAD) { if (PQstatus(conn) == CONNECTION_BAD) {
fprintf(stderr,"Connection to database '&percnt;s' failed.0, dbName); fprintf(stderr,"Connection to database '&percnt;s' failed.\n", dbName);
fprintf(stderr,"&percnt;s",PQerrorMessage(conn)); fprintf(stderr,"&percnt;s",PQerrorMessage(conn));
exit_nicely(conn); exit_nicely(conn);
} }
...@@ -1136,7 +1383,7 @@ void fe_setauthsvc(char *name, ...@@ -1136,7 +1383,7 @@ void fe_setauthsvc(char *name,
/* start a transaction block */ /* start a transaction block */
res = PQexec(conn,"BEGIN"); res = PQexec(conn,"BEGIN");
if (PQresultStatus(res) != PGRES_COMMAND_OK) { if (PQresultStatus(res) != PGRES_COMMAND_OK) {
fprintf(stderr,"BEGIN command failed0); fprintf(stderr,"BEGIN command failed\n");
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
...@@ -1147,7 +1394,7 @@ void fe_setauthsvc(char *name, ...@@ -1147,7 +1394,7 @@ void fe_setauthsvc(char *name,
/* fetch instances from the pg_database, the system catalog of databases*/ /* fetch instances from the pg_database, the system catalog of databases*/
res = PQexec(conn,"DECLARE mycursor BINARY CURSOR FOR select * from test1"); res = PQexec(conn,"DECLARE mycursor BINARY CURSOR FOR select * from test1");
if (PQresultStatus(res) != PGRES_COMMAND_OK) { if (PQresultStatus(res) != PGRES_COMMAND_OK) {
fprintf(stderr,"DECLARE CURSOR command failed0); fprintf(stderr,"DECLARE CURSOR command failed\n");
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
...@@ -1155,7 +1402,7 @@ void fe_setauthsvc(char *name, ...@@ -1155,7 +1402,7 @@ void fe_setauthsvc(char *name,
res = PQexec(conn,"FETCH ALL in mycursor"); res = PQexec(conn,"FETCH ALL in mycursor");
if (PQresultStatus(res) != PGRES_TUPLES_OK) { if (PQresultStatus(res) != PGRES_TUPLES_OK) {
fprintf(stderr,"FETCH ALL command didn't return tuples properly0); fprintf(stderr,"FETCH ALL command didn't return tuples properly\n");
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
...@@ -1165,7 +1412,7 @@ void fe_setauthsvc(char *name, ...@@ -1165,7 +1412,7 @@ void fe_setauthsvc(char *name,
p_fnum = PQfnumber(res,"p"); p_fnum = PQfnumber(res,"p");
for (i=0;i&lt;3;i++) { for (i=0;i&lt;3;i++) {
printf("type[&percnt;d] = &percnt;d, size[&percnt;d] = &percnt;d0, printf("type[&percnt;d] = &percnt;d, size[&percnt;d] = &percnt;d\n",
i, PQftype(res,i), i, PQftype(res,i),
i, PQfsize(res,i)); i, PQfsize(res,i));
} }
...@@ -1183,12 +1430,12 @@ void fe_setauthsvc(char *name, ...@@ -1183,12 +1430,12 @@ void fe_setauthsvc(char *name,
pval = (POLYGON*) malloc(plen + VARHDRSZ); pval = (POLYGON*) malloc(plen + VARHDRSZ);
pval-&gt;size = plen; pval-&gt;size = plen;
memmove((char*)&amp;pval-&gt;npts, PQgetvalue(res,i,p_fnum), plen); memmove((char*)&amp;pval-&gt;npts, PQgetvalue(res,i,p_fnum), plen);
printf("tuple &percnt;d: got0, i); printf("tuple &percnt;d: got\n", i);
printf(" i = (&percnt;d bytes) &percnt;d,0, printf(" i = (&percnt;d bytes) &percnt;d,\n",
PQgetlength(res,i,i_fnum), *ival); PQgetlength(res,i,i_fnum), *ival);
printf(" d = (&percnt;d bytes) &percnt;f,0, printf(" d = (&percnt;d bytes) &percnt;f,\n",
PQgetlength(res,i,d_fnum), *dval); PQgetlength(res,i,d_fnum), *dval);
printf(" p = (&percnt;d bytes) &percnt;d points boundbox = (hi=&percnt;f/&percnt;f, lo = &percnt;f,&percnt;f)0, printf(" p = (&percnt;d bytes) &percnt;d points boundbox = (hi=&percnt;f/&percnt;f, lo = &percnt;f,&percnt;f)\n",
PQgetlength(res,i,d_fnum), PQgetlength(res,i,d_fnum),
pval-&gt;npts, pval-&gt;npts,
pval-&gt;boundbox.xh, pval-&gt;boundbox.xh,
......
doc/src/sgml/protocol.sgml
View file @ edbd5139
...@@ -4,14 +4,15 @@ ...@@ -4,14 +4,15 @@
<FirstName>Phil</FirstName> <FirstName>Phil</FirstName>
<Surname>Thompson</Surname> <Surname>Thompson</Surname>
</Author> </Author>
<Date>1998-02-02</Date> <Date>1998-05-04</Date>
</DocInfo> </DocInfo>
<Title>Frontend/Backend Protocol</Title> <Title>Frontend/Backend Protocol</Title>
<Para> <Para>
<Note> <Note>
<Para> <Para>
Written by <ULink url="mailto:phil@river-bank.demon.co.uk">Phil Thompson</ULink> Written by <ULink url="mailto:phil@river-bank.demon.co.uk">Phil Thompson</ULink>.
Updates for protocol 2.0 by <ULink url="mailto:tgl@sss.pgh.pa.us">Tom Lane</ULink>.
</Para> </Para>
</Note> </Note>
...@@ -24,7 +25,7 @@ a way as to still allow connections from earlier versions of frontends, but ...@@ -24,7 +25,7 @@ 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. this document does not cover the protocol used by those earlier versions.
<Para> <Para>
This document describes the initial version-numbered protocol, designated v1.0. This document describes version 2.0 of the protocol.
Higher level features built on this protocol (for example, how <FileName>libpq</FileName> passes Higher level features built on this protocol (for example, how <FileName>libpq</FileName> passes
certain environment variables after the connection is established) certain environment variables after the connection is established)
are covered elsewhere. are covered elsewhere.
...@@ -47,7 +48,9 @@ and responds to the frontend accordingly. ...@@ -47,7 +48,9 @@ and responds to the frontend accordingly.
<Para> <Para>
The frontend then sends any required authentication information. Once the The frontend then sends any required authentication information. Once the
postmaster validates this it responds to the frontend that it is authenticated postmaster validates this it responds to the frontend that it is authenticated
and hands over to a backend. and hands over the connection to a backend. The backend then sends a message
indicating successful startup (normal case) or failure (for example, an
invalid database name).
<Para> <Para>
Subsequent communications are query and result packets exchanged between the Subsequent communications are query and result packets exchanged between the
...@@ -60,7 +63,7 @@ closes the connection without waiting for a response for the backend. ...@@ -60,7 +63,7 @@ closes the connection without waiting for a response for the backend.
<Para> <Para>
Packets are sent as a data stream. The first byte determines what should be Packets are sent as a data stream. The first byte determines what should be
expected in the rest of the packet. The exception is packets send from a expected in the rest of the packet. The exception is packets sent from a
frontend to the postmaster, which comprise a packet length then the packet frontend to the postmaster, which comprise a packet length then the packet
itself. The difference is historical. itself. The difference is historical.
...@@ -70,15 +73,22 @@ itself. The difference is historical. ...@@ -70,15 +73,22 @@ itself. The difference is historical.
<Para> <Para>
This section describes the message flow. There are four different types of This section describes the message flow. There are four different types of
flows depending on the state of the connection: flows depending on the state of the connection:
authentication, query, function call, and termination. startup, query, function call, and termination.
There are also special provisions for notification responses and command
cancellation, which can occur at any time after the startup phase.
<Sect2> <Sect2>
<Title>Authentication</Title> <Title>Startup</Title>
<Para>
Startup is divided into an authentication phase and a backend startup phase.
<Para> <Para>
The frontend sends a StartupPacket. The postmaster uses this and the contents Initially, the frontend sends a StartupPacket. The postmaster uses this info
of the pg_hba.conf(5) file to determine what authentication method the frontend and the contents of the pg_hba.conf(5) file to determine what authentication
must use. The postmaster then responds with one of the following messages: method the frontend must use. The postmaster then responds with one of the
following messages:
<Para> <Para>
<VariableList> <VariableList>
...@@ -162,13 +172,65 @@ must use. The postmaster then responds with one of the following messages: ...@@ -162,13 +172,65 @@ must use. The postmaster then responds with one of the following messages:
If the frontend does not support the authentication method requested by the If the frontend does not support the authentication method requested by the
postmaster, then it should immediately close the connection. postmaster, then it should immediately close the connection.
<Para>
After sending AuthenticationOk, the postmaster attempts to launch a backend
process. Since this might fail, or the backend might encounter a failure
during startup, the frontend must wait for the backend to acknowledge
successful startup. The frontend should send no messages at this point.
The possible messages from the backend during this phase are:
<Para>
<VariableList>
<VarListEntry>
<Term>
ReadyForQuery
</Term>
<ListItem>
<Para>
Backend startup is successful. The frontend may now issue
query or function call messages.
</Para>
</ListItem>
</VarListEntry>
<VarListEntry>
<Term>
ErrorResponse
</Term>
<ListItem>
<Para>
Backend startup failed. The connection is closed after
sending this message.
</Para>
</ListItem>
</VarListEntry>
<VarListEntry>
<Term>
NoticeResponse
</Term>
<ListItem>
<Para>
A warning message has been issued. The frontend should
display the message but continue listening for ReadyForQuery
or ErrorResponse.
</Para>
</ListItem>
</VarListEntry>
</VariableList>
</Para>
<Sect2> <Sect2>
<Title>Query</Title> <Title>Query</Title>
<Para> <Para>
The frontend sends a Query message to the backend. The response sent by the A Query cycle is initiated by the frontend sending a Query message to the
backend depends on the contents of the query. The possible responses are as backend. The backend then sends one or more response messages depending
follows. 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.
<Para>
The possible response messages from the backend are:
<Para> <Para>
<VariableList> <VariableList>
...@@ -178,7 +240,7 @@ follows. ...@@ -178,7 +240,7 @@ follows.
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
The query completed normally. An SQL command completed normally.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -240,7 +302,7 @@ follows. ...@@ -240,7 +302,7 @@ follows.
<Para> <Para>
For a fetch(l) or select(l) command, the backend sends a For a fetch(l) or select(l) command, the backend sends a
RowDescription message. This is then followed by an AsciiRow RowDescription message. This is then followed by an AsciiRow
or BinaryRow message (depending on if a binary cursor was or BinaryRow message (depending on whether a binary cursor was
specified) for each row being returned to the frontend. specified) for each row being returned to the frontend.
Finally, the backend sends a CompletedResponse message with a Finally, the backend sends a CompletedResponse message with a
tag of "SELECT". tag of "SELECT".
...@@ -253,7 +315,8 @@ follows. ...@@ -253,7 +315,8 @@ follows.
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
The query was empty. An empty query string was recognized. (The need to specially
distinguish this case is historical.)
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -269,26 +332,28 @@ follows. ...@@ -269,26 +332,28 @@ follows.
</VarListEntry> </VarListEntry>
<VarListEntry> <VarListEntry>
<Term> <Term>
NoticeResponse ReadyForQuery
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
A warning message has been issued in relation to the query. Processing of the query string is complete. A separate
Notices are in addition to other responses, ie. the backend message is sent to indicate this because the query string
will send another response message immediately afterwards. may contain multiple SQL commands. (CompletedResponse 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.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
<VarListEntry> <VarListEntry>
<Term> <Term>
NotificationResponse NoticeResponse
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
A notify(l) command has been executed for a relation for A warning message has been issued in relation to the query.
which a previous listen(l) command was executed. Notifications Notices are in addition to other responses, ie. the backend
are in addition to other responses, ie. the backend will send will continue processing the command.
another response message immediately afterwards.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -297,15 +362,23 @@ follows. ...@@ -297,15 +362,23 @@ follows.
<Para> <Para>
A frontend must be prepared to accept ErrorResponse and NoticeResponse A frontend must be prepared to accept ErrorResponse and NoticeResponse
messages whenever it is expecting any other type of message. messages whenever it is expecting any other type of message. Also,
if it issues any listen(l) commands then it must be prepared to accept
NotificationResponse messages at any time; see below.
<Sect2> <Sect2>
<Title>Function Call</Title> <Title>Function Call</Title>
<Para> <Para>
The frontend sends a FunctionCall message to the backend. The response sent by A Function Call cycle is initiated by the frontend sending a FunctionCall
the backend depends on the result of the function call. The possible responses message to the backend. The backend then sends one or more response messages
are as follows. depending on the results of the function call, and finally a ReadyForQuery
response message. ReadyForQuery informs the frontend that it may safely send
a new query or function call.
<Para>
The possible response messages from the backend are:
<Para> <Para>
<VariableList> <VariableList>
...@@ -340,15 +413,27 @@ are as follows. ...@@ -340,15 +413,27 @@ are as follows.
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
<VarListEntry> <VarListEntry>
<Term>
ReadyForQuery
</Term>
<ListItem>
<Para>
Processing of the function call is complete.
ReadyForQuery will always be sent, whether processing
terminates successfully or with an error.
</Para>
</ListItem>
</VarListEntry>
<VarListEntry>
<Term> <Term>
NoticeResponse NoticeResponse
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
A warning message has been issued in relation to the function A warning message has been issued in relation to the function
call. Notices are in addition to other responses, ie. the call.
backend will send another response message immediately Notices are in addition to other responses, ie. the backend
afterwards. will continue processing the command.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -357,7 +442,58 @@ are as follows. ...@@ -357,7 +442,58 @@ are as follows.
<Para> <Para>
A frontend must be prepared to accept ErrorResponse and NoticeResponse A frontend must be prepared to accept ErrorResponse and NoticeResponse
messages whenever it is expecting any other type of message. messages whenever it is expecting any other type of message. Also,
if it issues any listen(l) commands then it must be prepared to accept
NotificationResponse messages at any time; see below.
<Sect2>
<Title>Notification Responses</Title>
<Para>
If a frontend issues a listen(l) command, then the backend will send a
NotificationResponse message (not to be confused with NoticeResponse!)
whenever a notify(l) command is executed for the same relation name.
<Para>
Notification responses are permitted at any point in the protocol (after
startup), 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.
<Para>
<VariableList>
<VarListEntry>
<Term>
NotificationResponse
</Term>
<ListItem>
<Para>
A notify(l) command has been executed for a relation for
which a previous listen(l) command was executed. Notifications
may be sent at any time.
</Para>
</ListItem>
</VarListEntry>
</VariableList>
</Para>
<Sect2>
<Title>Cancelling Requests in Progress</Title>
<Para>
During the processing of a query, the frontend may request cancellation of the
query by sending a single byte of OOB (out-of-band) data. The contents of the
data byte should be zero (although the backend does not currently check this).
If the cancellation is effective, it results in the current command being
terminated with an error message. Note that the backend makes no specific
reply to the cancel request itself. If the cancel request is ineffective
(say, because it arrived after processing was complete) then it will have
no visible effect at all. Thus, the frontend must continue with its normal
processing of query cycle responses after issuing a cancel request.
<Sect2> <Sect2>
<Title>Termination</Title> <Title>Termination</Title>
...@@ -409,7 +545,7 @@ This section describes the base data types used in messages. ...@@ -409,7 +545,7 @@ This section describes the base data types used in messages.
<Para> <Para>
A conventional C '\0' terminated string with no length A conventional C '\0' terminated string with no length
limitation. A frontend should always read the full string limitation. A frontend should always read the full string
even though it may have to discard characters if it's buffers even though it may have to discard characters if its buffers
aren't big enough. aren't big enough.
<Note> <Note>
<Para> <Para>
...@@ -458,8 +594,9 @@ AsciiRow (B) ...@@ -458,8 +594,9 @@ AsciiRow (B)
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
Identifies the message, in the context in which it is sent (see Identifies the message as an <Acronym>ASCII</Acronym> data row.
CopyInResponse), as an <Acronym>ASCII</Acronym> row. (A prior RowDescription message defines the number of
fields in the row and their data types.)
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -704,8 +841,9 @@ BinaryRow (B) ...@@ -704,8 +841,9 @@ BinaryRow (B)
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
Identifies the message, in the context in which it is sent (see Identifies the message as a binary data row.
CopyOutResponse), as a binary row. (A prior RowDescription message defines the number of
fields in the row and their data types.)
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -814,12 +952,12 @@ CopyInResponse (B) ...@@ -814,12 +952,12 @@ CopyInResponse (B)
<VariableList> <VariableList>
<VarListEntry> <VarListEntry>
<Term> <Term>
Byte1('D') Byte1('G')
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
Identifies the message, in the context in which it is sent (see Identifies the message as a Start Copy In response.
AsciiRow), as a copy in started response. The frontend must now send a CopyDataRows message.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -839,12 +977,12 @@ CopyOutResponse (B) ...@@ -839,12 +977,12 @@ CopyOutResponse (B)
<VariableList> <VariableList>
<VarListEntry> <VarListEntry>
<Term> <Term>
Byte1('B') Byte1('H')
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
Identifies the message, in the context in which it is sent (see Identifies the message as a Start Copy Out response.
BinaryRow), as a copy out started response. This message will be followed by a CopyDataRows message.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -903,7 +1041,7 @@ EmptyQueryResponse (B) ...@@ -903,7 +1041,7 @@ EmptyQueryResponse (B)
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
Identifies the message as an empty query response. Identifies the message as a response to an empty query string.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -954,6 +1092,31 @@ EncryptedPasswordPacket (F) ...@@ -954,6 +1092,31 @@ EncryptedPasswordPacket (F)
</VariableList> </VariableList>
</Para>
</ListItem>
</VarListEntry>
<VarListEntry>
<Term>
ReadyForQuery (B)
</Term>
<ListItem>
<Para>
<VariableList>
<VarListEntry>
<Term>
Byte1('Z')
</Term>
<ListItem>
<Para>
Identifies the message type. ReadyForQuery is sent
whenever the backend is ready for a new query cycle.
</Para>
</ListItem>
</VarListEntry>
</VariableList>
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -1099,7 +1262,7 @@ FunctionResultResponse (B) ...@@ -1099,7 +1262,7 @@ FunctionResultResponse (B)
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
Specifies that an actual result was returned. Specifies that a nonempty result was returned.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -1167,7 +1330,7 @@ FunctionVoidResponse (B) ...@@ -1167,7 +1330,7 @@ FunctionVoidResponse (B)
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
Specifies that no actual result was returned. Specifies that an empty result was returned.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -1269,7 +1432,7 @@ Query (F) ...@@ -1269,7 +1432,7 @@ Query (F)
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
Identifies the message as query. Identifies the message as a query.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -1279,7 +1442,7 @@ Query (F) ...@@ -1279,7 +1442,7 @@ Query (F)
</Term> </Term>
<ListItem> <ListItem>
<Para> <Para>
The query itself. The query string itself.
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
...@@ -1348,6 +1511,16 @@ RowDescription (B) ...@@ -1348,6 +1511,16 @@ RowDescription (B)
</Para> </Para>
</ListItem> </ListItem>
</VarListEntry> </VarListEntry>
<VarListEntry>
<Term>
Int16
</Term>
<ListItem>
<Para>
Specifies the type modifier.
</Para>
</ListItem>
</VarListEntry>
</VariableList> </VariableList>
</Para> </Para>
......
src/backend/commands/async.c
View file @ edbd5139
...@@ -7,7 +7,7 @@ ...@@ -7,7 +7,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.31 1998/04/27 04:05:08 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/commands/async.c,v 1.32 1998/05/06 23:49:52 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
...@@ -20,8 +20,7 @@ ...@@ -20,8 +20,7 @@
* end of commit), * end of commit),
* 2.a If the process is the same as the backend process that issued * 2.a If the process is the same as the backend process that issued
* notification (we are notifying something that we are listening), * notification (we are notifying something that we are listening),
* signal the corresponding frontend over the comm channel using the * signal the corresponding frontend over the comm channel.
* out-of-band channel.
* 2.b For all other listening processes, we send kill(2) to wake up * 2.b For all other listening processes, we send kill(2) to wake up
* the listening backend. * the listening backend.
* 3. Upon receiving a kill(2) signal from another backend process notifying * 3. Upon receiving a kill(2) signal from another backend process notifying
...@@ -30,7 +29,7 @@ ...@@ -30,7 +29,7 @@
* 3.a We are sleeping, wake up and signal our frontend. * 3.a We are sleeping, wake up and signal our frontend.
* 3.b We are in middle of another transaction, wait until the end of * 3.b We are in middle of another transaction, wait until the end of
* of the current transaction and signal our frontend. * of the current transaction and signal our frontend.
* 4. Each frontend receives this notification and prcesses accordingly. * 4. Each frontend receives this notification and processes accordingly.
* *
* -- jw, 12/28/93 * -- jw, 12/28/93
* *
...@@ -547,12 +546,6 @@ Async_UnlistenOnExit(int code, /* from exitpg */ ...@@ -547,12 +546,6 @@ Async_UnlistenOnExit(int code, /* from exitpg */
* Results: * Results:
* XXX * XXX
* *
* Side effects:
*
* We make use of the out-of-band channel to transmit the
* notification to the front end. The actual data transfer takes
* place at the front end's request.
*
* -------------------------------------------------------------- * --------------------------------------------------------------
*/ */
GlobalMemory notifyContext = NULL; GlobalMemory notifyContext = NULL;
......
src/backend/tcop/dest.c
View file @ edbd5139
...@@ -7,7 +7,7 @@ ...@@ -7,7 +7,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/tcop/dest.c,v 1.17 1998/02/26 04:36:24 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/tcop/dest.c,v 1.18 1998/05/06 23:49:59 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
...@@ -15,7 +15,8 @@ ...@@ -15,7 +15,8 @@
* INTERFACE ROUTINES * INTERFACE ROUTINES
* BeginCommand - prepare destination for tuples of the given type * BeginCommand - prepare destination for tuples of the given type
* EndCommand - tell destination that no more tuples will arrive * EndCommand - tell destination that no more tuples will arrive
* NullCommand - tell dest that the last of a query sequence was processed * NullCommand - tell dest that an empty query string was recognized
* ReadyForQuery - tell dest that we are ready for a new query
* *
* NOTES * NOTES
* These routines do the appropriate work before and after * These routines do the appropriate work before and after
...@@ -115,16 +116,10 @@ EndCommand(char *commandTag, CommandDest dest) ...@@ -115,16 +116,10 @@ EndCommand(char *commandTag, CommandDest dest)
sprintf(buf, "%s%s", commandTag, CommandInfo); sprintf(buf, "%s%s", commandTag, CommandInfo);
CommandInfo[0] = 0; CommandInfo[0] = 0;
pq_putstr(buf); pq_putstr(buf);
pq_flush();
break; break;
case Local: case Local:
case Debug: case Debug:
break;
case CopyEnd:
pq_putnchar("Z", 1);
pq_flush();
break;
case None: case None:
default: default:
break; break;
...@@ -139,28 +134,37 @@ EndCommand(char *commandTag, CommandDest dest) ...@@ -139,28 +134,37 @@ EndCommand(char *commandTag, CommandDest dest)
* *
* COPY rel FROM stdin * COPY rel FROM stdin
* *
* NOTE: the message code letters are changed at protocol version 2.0
* to eliminate possible confusion with data tuple messages.
*/ */
void void
SendCopyBegin(void) SendCopyBegin(void)
{ {
pq_putnchar("B", 1); if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
/* pq_putint(0, 4); */ pq_putnchar("H", 1); /* new way */
pq_flush(); else
pq_putnchar("B", 1); /* old way */
} }
void void
ReceiveCopyBegin(void) ReceiveCopyBegin(void)
{ {
pq_putnchar("D", 1); if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
/* pq_putint(0, 4); */ pq_putnchar("G", 1); /* new way */
else
pq_putnchar("D", 1); /* old way */
/* We *must* flush here to ensure FE knows it can send. */
pq_flush(); pq_flush();
} }
/* ---------------- /* ----------------
* NullCommand - tell dest that the last of a query sequence was processed * NullCommand - tell dest that an empty query string was recognized
* *
* Necessary to implement the hacky FE/BE interface to handle * In FE/BE protocol version 1.0, this hack is necessary to support
* multiple-return queries. * libpq's crufty way of determining whether a multiple-command
* query string is done. In protocol 2.0 it's probably not really
* necessary to distinguish empty queries anymore, but we still do it
* for backwards compatibility with 1.0.
* ---------------- * ----------------
*/ */
void void
...@@ -168,46 +172,46 @@ NullCommand(CommandDest dest) ...@@ -168,46 +172,46 @@ NullCommand(CommandDest dest)
{ {
switch (dest) switch (dest)
{ {
case RemoteInternal: case RemoteInternal:
case Remote: case Remote:
{ {
#if 0
/*
* Do any asynchronous notification. If front end wants
* to poll, it can send null queries to call this
* function.
*/
PQNotifyList *nPtr;
MemoryContext orig;
if (notifyContext == NULL)
{
notifyContext = CreateGlobalMemory("notify");
}
orig = MemoryContextSwitchTo((MemoryContext) notifyContext);
for (nPtr = PQnotifies();
nPtr != NULL;
nPtr = (PQNotifyList *) SLGetSucc(&nPtr->Node))
{
pq_putnchar("A", 1);
pq_putint(0, sizeof(int4));
pq_putstr(nPtr->relname);
pq_putint(nPtr->be_pid, sizeof(nPtr->be_pid));
PQremoveNotify(nPtr);
}
pq_flush();
PQcleanNotify();/* garbage collect */
MemoryContextSwitchTo(orig);
#endif
/* ---------------- /* ----------------
* tell the fe that the last of the queries has finished * tell the fe that we saw an empty query string
* ---------------- * ----------------
*/ */
/* pq_putnchar("I", 1); */
pq_putstr("I"); pq_putstr("I");
/* pq_putint(0, 4); */ }
break;
case Local:
case Debug:
case None:
default:
break;
}
}
/* ----------------
* ReadyForQuery - tell dest that we are ready for a new query
*
* The ReadyForQuery message is sent in protocol versions 2.0 and up
* so that the FE can tell when we are done processing a query string.
*
* Note that by flushing the stdio buffer here, we can avoid doing it
* most other places and thus reduce the number of separate packets sent.
* ----------------
*/
void
ReadyForQuery(CommandDest dest)
{
switch (dest)
{
case RemoteInternal:
case Remote:
{
if (PG_PROTOCOL_MAJOR(FrontendProtocol) >= 2)
pq_putnchar("Z", 1);
/* Flush output at end of cycle in any case. */
pq_flush(); pq_flush();
} }
break; break;
...@@ -264,7 +268,6 @@ BeginCommand(char *pname, ...@@ -264,7 +268,6 @@ BeginCommand(char *pname,
* send fe info on tuples we're about to send * send fe info on tuples we're about to send
* ---------------- * ----------------
*/ */
pq_flush();
pq_putnchar("P", 1);/* new portal.. */ pq_putnchar("P", 1);/* new portal.. */
pq_putstr(pname); /* portal name */ pq_putstr(pname); /* portal name */
......
src/backend/tcop/fastpath.c
View file @ edbd5139
...@@ -7,7 +7,7 @@ ...@@ -7,7 +7,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.16 1998/04/26 04:07:22 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/tcop/fastpath.c,v 1.17 1998/05/06 23:50:10 momjian Exp $
* *
* NOTES * NOTES
* This cruft is the server side of PQfn. * This cruft is the server side of PQfn.
...@@ -113,7 +113,6 @@ SendFunctionResult(Oid fid, /* function id */ ...@@ -113,7 +113,6 @@ SendFunctionResult(Oid fid, /* function id */
} }
pq_putnchar("0", 1); pq_putnchar("0", 1);
pq_flush();
} }
/* /*
......
src/backend/tcop/postgres.c
View file @ edbd5139
...@@ -7,7 +7,7 @@ ...@@ -7,7 +7,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.67 1998/02/26 04:36:31 momjian Exp $ * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.68 1998/05/06 23:50:19 momjian Exp $
* *
* NOTES * NOTES
* this is the "main" module of the postgres backend and * this is the "main" module of the postgres backend and
...@@ -1302,7 +1302,7 @@ PostgresMain(int argc, char *argv[]) ...@@ -1302,7 +1302,7 @@ PostgresMain(int argc, char *argv[])
if (IsUnderPostmaster == false) if (IsUnderPostmaster == false)
{ {
puts("\nPOSTGRES backend interactive interface"); puts("\nPOSTGRES backend interactive interface");
puts("$Revision: 1.67 $ $Date: 1998/02/26 04:36:31 $"); puts("$Revision: 1.68 $ $Date: 1998/05/06 23:50:19 $");
} }
/* ---------------- /* ----------------
...@@ -1316,6 +1316,12 @@ PostgresMain(int argc, char *argv[]) ...@@ -1316,6 +1316,12 @@ PostgresMain(int argc, char *argv[])
for (;;) for (;;)
{ {
/* ----------------
* (0) tell the frontend we're ready for a new query.
* ----------------
*/
ReadyForQuery(Remote);
/* ---------------- /* ----------------
* (1) read a command. * (1) read a command.
* ---------------- * ----------------
...@@ -1391,8 +1397,8 @@ PostgresMain(int argc, char *argv[]) ...@@ -1391,8 +1397,8 @@ PostgresMain(int argc, char *argv[])
* ---------------- * ----------------
*/ */
case 'X': case 'X':
IsEmptyQuery = true;
pq_close(); pq_close();
exitpg(0);
break; break;
default: default:
......
src/bin/psql/psql.c
View file @ edbd5139
...@@ -7,7 +7,7 @@ ...@@ -7,7 +7,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/bin/psql/Attic/psql.c,v 1.139 1998/05/04 02:02:01 momjian Exp $ * $Header: /cvsroot/pgsql/src/bin/psql/Attic/psql.c,v 1.140 1998/05/06 23:50:23 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
...@@ -283,6 +283,38 @@ PSQLexec(PsqlSettings *pset, char *query) ...@@ -283,6 +283,38 @@ PSQLexec(PsqlSettings *pset, char *query)
return NULL; return NULL;
} }
/*
* Code to support command cancellation.
* If interactive, we enable a SIGINT signal catcher that sends
* a cancel request to the backend.
* Note that sending the cancel directly from the signal handler
* is safe only because the cancel is sent as an OOB message.
* If it were inline data, then we'd risk inserting it into the
* middle of a normal data message by doing this.
* (It's probably not too cool to write on stderr, for that matter...
* but for debugging purposes we'll risk that.)
*/
static PGconn * cancelConn = NULL; /* connection to try cancel on */
static void
handle_sigint (SIGNAL_ARGS)
{
if (cancelConn == NULL)
exit(1); /* accept signal if no connection */
/* Try to send cancel request */
if (PQrequestCancel(cancelConn))
{
fprintf(stderr, "\nCANCEL request sent\n");
}
else
{
fprintf(stderr, "\nCannot send cancel request:\n%s\n",
PQerrorMessage(cancelConn));
}
}
/* /*
* listAllDbs * listAllDbs
* *
...@@ -1099,8 +1131,7 @@ SendQuery(bool *success_p, PsqlSettings *pset, const char *query, ...@@ -1099,8 +1131,7 @@ SendQuery(bool *success_p, PsqlSettings *pset, const char *query,
exit(2); /* we are out'ta here */ exit(2); /* we are out'ta here */
} }
/* check for asynchronous returns */ /* check for asynchronous returns */
notify = PQnotifies(pset->db); while ((notify = PQnotifies(pset->db)) != NULL)
if (notify)
{ {
fprintf(stderr, fprintf(stderr,
"ASYNC NOTIFY of '%s' from backend pid '%d' received\n", "ASYNC NOTIFY of '%s' from backend pid '%d' received\n",
...@@ -1416,6 +1447,7 @@ do_connect(const char *new_dbname, ...@@ -1416,6 +1447,7 @@ do_connect(const char *new_dbname,
} }
else else
{ {
cancelConn = pset->db; /* redirect sigint's loving attentions */
PQfinish(olddb); PQfinish(olddb);
free(pset->prompt); free(pset->prompt);
pset->prompt = malloc(strlen(PQdb(pset->db)) + 10); pset->prompt = malloc(strlen(PQdb(pset->db)) + 10);
...@@ -2462,11 +2494,18 @@ main(int argc, char **argv) ...@@ -2462,11 +2494,18 @@ main(int argc, char **argv)
settings.opt.fieldSep = strdup(DEFAULT_FIELD_SEP); settings.opt.fieldSep = strdup(DEFAULT_FIELD_SEP);
settings.opt.pager = 1; settings.opt.pager = 1;
if (!isatty(0) || !isatty(1)) if (!isatty(0) || !isatty(1))
{
/* Noninteractive defaults */
settings.notty = 1; settings.notty = 1;
#ifdef USE_READLINE }
else else
{
/* Interactive defaults */
pqsignal(SIGINT, handle_sigint); /* control-C => cancel */
#ifdef USE_READLINE
settings.useReadline = 1; settings.useReadline = 1;
#endif #endif
}
#ifdef PSQL_ALWAYS_GET_PASSWORDS #ifdef PSQL_ALWAYS_GET_PASSWORDS
settings.getPassword = 1; settings.getPassword = 1;
#else #else
...@@ -2580,6 +2619,9 @@ main(int argc, char **argv) ...@@ -2580,6 +2619,9 @@ main(int argc, char **argv)
PQfinish(settings.db); PQfinish(settings.db);
exit(1); exit(1);
} }
cancelConn = settings.db; /* enable SIGINT to send cancel */
if (listDatabases) if (listDatabases)
{ {
exit(listAllDbs(&settings)); exit(listAllDbs(&settings));
......
src/include/libpq/pqcomm.h
View file @ edbd5139
...@@ -6,7 +6,7 @@ ...@@ -6,7 +6,7 @@
* *
* Copyright (c) 1994, Regents of the University of California * Copyright (c) 1994, Regents of the University of California
* *
* $Id: pqcomm.h,v 1.24 1998/03/02 05:42:15 scrappy Exp $ * $Id: pqcomm.h,v 1.25 1998/05/06 23:50:32 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
...@@ -66,7 +66,7 @@ typedef union SockAddr ...@@ -66,7 +66,7 @@ typedef union SockAddr
/* The earliest and latest frontend/backend protocol version supported. */ /* The earliest and latest frontend/backend protocol version supported. */
#define PG_PROTOCOL_EARLIEST PG_PROTOCOL(0,0) #define PG_PROTOCOL_EARLIEST PG_PROTOCOL(0,0)
#define PG_PROTOCOL_LATEST PG_PROTOCOL(1,0) #define PG_PROTOCOL_LATEST PG_PROTOCOL(2,0)
/* /*
* All packets sent to the postmaster start with the length. This is omitted * All packets sent to the postmaster start with the length. This is omitted
......
src/include/tcop/dest.h
View file @ edbd5139
...@@ -26,7 +26,7 @@ ...@@ -26,7 +26,7 @@
* *
* Copyright (c) 1994, Regents of the University of California * Copyright (c) 1994, Regents of the University of California
* *
* $Id: dest.h,v 1.13 1998/02/26 04:43:39 momjian Exp $ * $Id: dest.h,v 1.14 1998/05/06 23:50:49 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
...@@ -46,10 +46,6 @@ typedef enum ...@@ -46,10 +46,6 @@ typedef enum
Debug, /* results go to debugging output */ Debug, /* results go to debugging output */
Local, /* results go in local portal buffer */ Local, /* results go in local portal buffer */
Remote, /* results sent to frontend process */ Remote, /* results sent to frontend process */
CopyBegin, /* results sent to frontend process but
* are strings */
CopyEnd, /* results sent to frontend process but
* are strings */
RemoteInternal, /* results sent to frontend process in RemoteInternal, /* results sent to frontend process in
* internal (binary) form */ * internal (binary) form */
SPI /* results sent to SPI manager */ SPI /* results sent to SPI manager */
...@@ -70,6 +66,7 @@ extern void EndCommand(char *commandTag, CommandDest dest); ...@@ -70,6 +66,7 @@ extern void EndCommand(char *commandTag, CommandDest dest);
extern void SendCopyBegin(void); extern void SendCopyBegin(void);
extern void ReceiveCopyBegin(void); extern void ReceiveCopyBegin(void);
extern void NullCommand(CommandDest dest); extern void NullCommand(CommandDest dest);
extern void ReadyForQuery(CommandDest dest);
extern void extern void
BeginCommand(char *pname, int operation, TupleDesc attinfo, BeginCommand(char *pname, int operation, TupleDesc attinfo,
bool isIntoRel, bool isIntoPortal, char *tag, bool isIntoRel, bool isIntoPortal, char *tag,
......
src/interfaces/libpgtcl/pgtclId.c
View file @ edbd5139
...@@ -12,7 +12,7 @@ ...@@ -12,7 +12,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclId.c,v 1.8 1998/03/15 08:03:00 scrappy Exp $ * $Header: /cvsroot/pgsql/src/interfaces/libpgtcl/Attic/pgtclId.c,v 1.9 1998/05/06 23:51:00 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
...@@ -48,7 +48,7 @@ int PgInputProc(DRIVER_INPUT_PROTO) ...@@ -48,7 +48,7 @@ int PgInputProc(DRIVER_INPUT_PROTO)
{ {
Pg_ConnectionId *connid; Pg_ConnectionId *connid;
PGconn *conn; PGconn *conn;
int c; char c;
int avail; int avail;
connid = (Pg_ConnectionId *)cData; connid = (Pg_ConnectionId *)cData;
...@@ -64,13 +64,24 @@ int PgInputProc(DRIVER_INPUT_PROTO) ...@@ -64,13 +64,24 @@ int PgInputProc(DRIVER_INPUT_PROTO)
return PgEndCopy(connid, errorCodePtr); return PgEndCopy(connid, errorCodePtr);
} }
/* Try to load any newly arrived data */
errno = 0;
if (pqReadData(conn) < 0) {
*errorCodePtr = errno ? errno : EIO;
return -1;
}
/* Move data from libpq's buffer to tcl's */
conn->inCursor = conn->inStart;
avail = bufSize; avail = bufSize;
while (avail > 0 && while (avail > 0 &&
(c = pqGetc(conn->Pfin, conn->Pfdebug)) != EOF) { pqGetc(&c, conn) == 0) {
/* fprintf(stderr, "%d: got char %c\n", bufSize-avail, c); */
*buf++ = c; *buf++ = c;
--avail; --avail;
if (c == '\n' && bufSize-avail > 3) { if (c == '\n' && bufSize-avail >= 3) {
if ((bufSize-avail == 3 || buf[-4] == '\n') && if ((bufSize-avail == 3 || buf[-4] == '\n') &&
buf[-3] == '\\' && buf[-2] == '.') { buf[-3] == '\\' && buf[-2] == '.') {
avail += 3; avail += 3;
...@@ -79,6 +90,8 @@ int PgInputProc(DRIVER_INPUT_PROTO) ...@@ -79,6 +90,8 @@ int PgInputProc(DRIVER_INPUT_PROTO)
} }
} }
} }
/* Accept the data permanently */
conn->inStart = conn->inCursor;
/* fprintf(stderr, "returning %d chars\n", bufSize - avail); */ /* fprintf(stderr, "returning %d chars\n", bufSize - avail); */
return bufSize - avail; return bufSize - avail;
} }
...@@ -100,16 +113,15 @@ int PgOutputProc(DRIVER_OUTPUT_PROTO) ...@@ -100,16 +113,15 @@ int PgOutputProc(DRIVER_OUTPUT_PROTO)
return -1; return -1;
} }
/* errno = 0;
fprintf(stderr, "PgOutputProc called: bufSize=%d: atend:%d <", bufSize,
strncmp(buf, "\\.\n", 3)); if (pqPutnchar(buf, bufSize, conn)) {
fwrite(buf, 1, bufSize, stderr); *errorCodePtr = errno ? errno : EIO;
fputs(">\n", stderr); return -1;
*/ }
fwrite(buf, 1, bufSize, conn->Pfout);
if (bufSize > 2 && strncmp(&buf[bufSize-3], "\\.\n", 3) == 0) { if (bufSize >= 3 && strncmp(&buf[bufSize-3], "\\.\n", 3) == 0) {
/* fprintf(stderr,"checking closure\n"); */ (void) pqFlush(conn);
fflush(conn->Pfout);
if (PgEndCopy(connid, errorCodePtr) == -1) if (PgEndCopy(connid, errorCodePtr) == -1)
return -1; return -1;
} }
...@@ -156,10 +168,10 @@ PgSetConnectionId(Tcl_Interp *interp, PGconn *conn) ...@@ -156,10 +168,10 @@ PgSetConnectionId(Tcl_Interp *interp, PGconn *conn)
for (i = 0; i < RES_START; i++) connid->results[i] = NULL; for (i = 0; i < RES_START; i++) connid->results[i] = NULL;
Tcl_InitHashTable(&connid->notify_hash, TCL_STRING_KEYS); Tcl_InitHashTable(&connid->notify_hash, TCL_STRING_KEYS);
sprintf(connid->id, "pgsql%d", fileno(conn->Pfout)); sprintf(connid->id, "pgsql%d", PQsocket(conn));
#if TCL_MAJOR_VERSION == 7 && TCL_MINOR_VERSION == 5 #if TCL_MAJOR_VERSION == 7 && TCL_MINOR_VERSION == 5
conn_chan = Tcl_CreateChannel(&Pg_ConnType, connid->id, conn->Pfin, conn->Pfout, (ClientData)connid); conn_chan = Tcl_CreateChannel(&Pg_ConnType, connid->id, NULL, NULL, (ClientData)connid);
#else #else
conn_chan = Tcl_CreateChannel(&Pg_ConnType, connid->id, (ClientData)connid, conn_chan = Tcl_CreateChannel(&Pg_ConnType, connid->id, (ClientData)connid,
TCL_READABLE | TCL_WRITABLE); TCL_READABLE | TCL_WRITABLE);
......
src/interfaces/libpq/Makefile.in
View file @ edbd5139
...@@ -7,7 +7,7 @@ ...@@ -7,7 +7,7 @@
# #
# #
# IDENTIFICATION # IDENTIFICATION
# $Header: /cvsroot/pgsql/src/interfaces/libpq/Attic/Makefile.in,v 1.16 1998/04/27 14:55:46 scrappy Exp $ # $Header: /cvsroot/pgsql/src/interfaces/libpq/Attic/Makefile.in,v 1.17 1998/05/06 23:51:06 momjian Exp $
# #
#------------------------------------------------------------------------- #-------------------------------------------------------------------------
...@@ -25,14 +25,13 @@ ifdef KRBVERS ...@@ -25,14 +25,13 @@ ifdef KRBVERS
CFLAGS+= $(KRBFLAGS) CFLAGS+= $(KRBFLAGS)
endif endif
OBJS= fe-auth.o fe-connect.o fe-exec.o fe-misc.o fe-lobj.o \ OBJS= fe-auth.o fe-connect.o fe-exec.o fe-misc.o fe-print.o fe-lobj.o \
dllist.o pqsignal.o pqcomprim.o dllist.o pqsignal.o
# Shared library stuff # Shared library stuff
shlib := shlib :=
install-shlib-dep := install-shlib-dep :=
ifeq ($(PORTNAME), linux) ifeq ($(PORTNAME), linux)
LINUX_ELF=@LINUX_ELF@
ifdef LINUX_ELF ifdef LINUX_ELF
install-shlib-dep := install-shlib install-shlib-dep := install-shlib
shlib := libpq.so.$(SO_MAJOR_VERSION).$(SO_MINOR_VERSION) shlib := libpq.so.$(SO_MAJOR_VERSION).$(SO_MINOR_VERSION)
...@@ -84,9 +83,6 @@ fe-lobj.o: $(SRCDIR)/backend/fmgr.h ...@@ -84,9 +83,6 @@ fe-lobj.o: $(SRCDIR)/backend/fmgr.h
dllist.c: $(SRCDIR)/backend/lib/dllist.c dllist.c: $(SRCDIR)/backend/lib/dllist.c
-ln -s $(SRCDIR)/backend/lib/dllist.c . -ln -s $(SRCDIR)/backend/lib/dllist.c .
pqcomprim.c: $(SRCDIR)/backend/libpq/pqcomprim.c
-ln -s $(SRCDIR)/backend/libpq/pqcomprim.c .
# The following rules cause dependencies in the backend directory to # The following rules cause dependencies in the backend directory to
# get made if they don't exist, but don't cause them to get remade if they # get made if they don't exist, but don't cause them to get remade if they
# are out of date. # are out of date.
...@@ -183,7 +179,7 @@ depend dep: ...@@ -183,7 +179,7 @@ depend dep:
.PHONY: clean .PHONY: clean
clean: clean:
rm -f libpq.a $(shlib) $(OBJS) c.h dllist.c pqcomprim.c libpq.so rm -f libpq.a $(shlib) $(OBJS) c.h dllist.c libpq.so
ifeq (depend,$(wildcard depend)) ifeq (depend,$(wildcard depend))
include depend include depend
......
src/interfaces/libpq/fe-connect.c
View file @ edbd5139
...@@ -7,7 +7,7 @@ ...@@ -7,7 +7,7 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-connect.c,v 1.65 1998/04/21 04:00:06 scrappy Exp $ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-connect.c,v 1.66 1998/05/06 23:51:11 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
...@@ -41,14 +41,14 @@ ...@@ -41,14 +41,14 @@
#endif #endif
/* use a local version instead of the one found in pqpacket.c */
static ConnStatusType connectDB(PGconn *conn); static ConnStatusType connectDB(PGconn *conn);
static PGconn *makeEmptyPGconn(void);
static void freePGconn(PGconn *conn); static void freePGconn(PGconn *conn);
static void closePGconn(PGconn *conn); static void closePGconn(PGconn *conn);
static int conninfo_parse(const char *conninfo, char *errorMessage); static int conninfo_parse(const char *conninfo, char *errorMessage);
static char *conninfo_getval(char *keyword); static char *conninfo_getval(char *keyword);
static void conninfo_free(void); static void conninfo_free(void);
/* XXX Why is this not static? */
void PQsetenv(PGconn *conn); void PQsetenv(PGconn *conn);
#define NOTIFYLIST_INITIAL_SIZE 10 #define NOTIFYLIST_INITIAL_SIZE 10
...@@ -162,44 +162,30 @@ PGconn * ...@@ -162,44 +162,30 @@ PGconn *
PQconnectdb(const char *conninfo) PQconnectdb(const char *conninfo)
{ {
PGconn *conn; PGconn *conn;
char errorMessage[ERROR_MSG_LENGTH];
char *tmp; char *tmp;
/* ---------- /* ----------
* Allocate memory for the conn structure * Allocate memory for the conn structure
* ---------- * ----------
*/ */
conn = (PGconn *) malloc(sizeof(PGconn)); conn = makeEmptyPGconn();
if (conn == NULL) if (conn == NULL)
{ {
fprintf(stderr, fprintf(stderr,
"FATAL: PQsetdb() -- unable to allocate memory for a PGconn"); "FATAL: PQconnectdb() -- unable to allocate memory for a PGconn");
return (PGconn *) NULL; return (PGconn *) NULL;
} }
MemSet((char *) conn, 0, sizeof(PGconn));
/* ---------- /* ----------
* Parse the conninfo string and get the fallback resources * Parse the conninfo string and save settings in conn structure
* ---------- * ----------
*/ */
if (conninfo_parse(conninfo, errorMessage) < 0) if (conninfo_parse(conninfo, conn->errorMessage) < 0)
{ {
conn->status = CONNECTION_BAD; conn->status = CONNECTION_BAD;
strcpy(conn->errorMessage, errorMessage);
conninfo_free(); conninfo_free();
return conn; return conn;
} }
/* ----------
* Setup the conn structure
* ----------
*/
conn->lobjfuncs = (PGlobjfuncs *) NULL;
conn->Pfout = NULL;
conn->Pfin = NULL;
conn->Pfdebug = NULL;
conn->notifyList = DLNewList();
tmp = conninfo_getval("host"); tmp = conninfo_getval("host");
conn->pghost = tmp ? strdup(tmp) : NULL; conn->pghost = tmp ? strdup(tmp) : NULL;
tmp = conninfo_getval("port"); tmp = conninfo_getval("port");
...@@ -208,12 +194,12 @@ PQconnectdb(const char *conninfo) ...@@ -208,12 +194,12 @@ PQconnectdb(const char *conninfo)
conn->pgtty = tmp ? strdup(tmp) : NULL; conn->pgtty = tmp ? strdup(tmp) : NULL;
tmp = conninfo_getval("options"); tmp = conninfo_getval("options");
conn->pgoptions = tmp ? strdup(tmp) : NULL; conn->pgoptions = tmp ? strdup(tmp) : NULL;
tmp = conninfo_getval("dbname");
conn->dbName = tmp ? strdup(tmp) : NULL;
tmp = conninfo_getval("user"); tmp = conninfo_getval("user");
conn->pguser = tmp ? strdup(tmp) : NULL; conn->pguser = tmp ? strdup(tmp) : NULL;
tmp = conninfo_getval("password"); tmp = conninfo_getval("password");
conn->pgpass = tmp ? strdup(tmp) : NULL; conn->pgpass = tmp ? strdup(tmp) : NULL;
tmp = conninfo_getval("dbname");
conn->dbName = tmp ? strdup(tmp) : NULL;
/* ---------- /* ----------
* Free the connection info - all is in conn now * Free the connection info - all is in conn now
...@@ -226,24 +212,6 @@ PQconnectdb(const char *conninfo) ...@@ -226,24 +212,6 @@ PQconnectdb(const char *conninfo)
* ---------- * ----------
*/ */
conn->status = connectDB(conn); conn->status = connectDB(conn);
if (conn->status == CONNECTION_OK)
{
PGresult *res;
/*
* Send a blank query to make sure everything works; in
* particular, that the database exists.
*/
res = PQexec(conn, " ");
if (res == NULL || res->resultStatus != PGRES_EMPTY_QUERY)
{
/* PQexec has put error message in conn->errorMessage */
closePGconn(conn);
}
PQclear(res);
}
PQsetenv(conn);
return conn; return conn;
} }
...@@ -311,150 +279,119 @@ PQsetdbLogin(const char *pghost, const char *pgport, const char *pgoptions, cons ...@@ -311,150 +279,119 @@ PQsetdbLogin(const char *pghost, const char *pgport, const char *pgoptions, cons
{ {
PGconn *conn; PGconn *conn;
char *tmp; char *tmp;
char errorMessage[ERROR_MSG_LENGTH];
/* An error message from some service we call. */ /* An error message from some service we call. */
bool error; bool error = FALSE;
/* We encountered an error that prevents successful completion */ /* We encountered an error that prevents successful completion */
int i; int i;
conn = (PGconn *) malloc(sizeof(PGconn)); conn = makeEmptyPGconn();
if (conn == NULL) if (conn == NULL)
{
fprintf(stderr, fprintf(stderr,
"FATAL: PQsetdb() -- unable to allocate memory for a PGconn"); "FATAL: PQsetdbLogin() -- unable to allocate memory for a PGconn");
return (PGconn *) NULL;
}
if ((pghost == NULL) || pghost[0] == '\0')
{
if ((tmp = getenv("PGHOST")) != NULL)
conn->pghost = strdup(tmp);
}
else else
conn->pghost = strdup(pghost);
if ((pgport == NULL) || pgport[0] == '\0')
{ {
conn->lobjfuncs = (PGlobjfuncs *) NULL; if ((tmp = getenv("PGPORT")) == NULL)
conn->Pfout = NULL; tmp = DEF_PGPORT;
conn->Pfin = NULL; conn->pgport = strdup(tmp);
conn->Pfdebug = NULL; }
conn->notifyList = DLNewList(); else
conn->pgport = strdup(pgport);
if ((pghost == NULL) || pghost[0] == '\0') if ((pgtty == NULL) || pgtty[0] == '\0')
{ {
conn->pghost = NULL; if ((tmp = getenv("PGTTY")) == NULL)
if ((tmp = getenv("PGHOST")) != NULL) tmp = DefaultTty;
conn->pghost = strdup(tmp); conn->pgtty = strdup(tmp);
} }
else else
conn->pghost = strdup(pghost); conn->pgtty = strdup(pgtty);
if ((pgport == NULL) || pgport[0] == '\0') if ((pgoptions == NULL) || pgoptions[0] == '\0')
{ {
if ((tmp = getenv("PGPORT")) == NULL) if ((tmp = getenv("PGOPTIONS")) == NULL)
tmp = DEF_PGPORT; tmp = DefaultOption;
conn->pgport = strdup(tmp); conn->pgoptions = strdup(tmp);
} }
else else
conn->pgport = strdup(pgport); conn->pgoptions = strdup(pgoptions);
if ((pgtty == NULL) || pgtty[0] == '\0') if (login)
{ {
if ((tmp = getenv("PGTTY")) == NULL) conn->pguser = strdup(login);
tmp = DefaultTty; }
conn->pgtty = strdup(tmp); else if ((tmp = getenv("PGUSER")) != NULL)
} {
else conn->pguser = strdup(tmp);
conn->pgtty = strdup(pgtty); }
else
{
conn->pguser = fe_getauthname(conn->errorMessage);
}
if ((pgoptions == NULL) || pgoptions[0] == '\0') if (conn->pguser == NULL)
{ {
if ((tmp = getenv("PGOPTIONS")) == NULL) error = TRUE;
tmp = DefaultOption; sprintf(conn->errorMessage,
conn->pgoptions = strdup(tmp); "FATAL: PQsetdbLogin(): Unable to determine a Postgres username!\n");
} }
else
conn->pgoptions = strdup(pgoptions);
if (login) if (pwd)
{ {
error = FALSE; conn->pgpass = strdup(pwd);
conn->pguser = strdup(login); }
} else if ((tmp = getenv("PGPASSWORD")) != NULL)
else if ((tmp = getenv("PGUSER")) != NULL) {
{ conn->pgpass = strdup(tmp);
error = FALSE; }
conn->pguser = strdup(tmp); else
} {
else conn->pgpass = strdup(DefaultPassword);
{ }
tmp = fe_getauthname(errorMessage);
if (tmp == 0)
{
error = TRUE;
sprintf(conn->errorMessage,
"FATAL: PQsetdb: Unable to determine a Postgres username!\n");
}
else
{
error = FALSE;
conn->pguser = tmp;
}
}
if (pwd) if ((dbName == NULL) || dbName[0] == '\0')
{ {
conn->pgpass = strdup(pwd); if ((tmp = getenv("PGDATABASE")) != NULL)
} conn->dbName = strdup(tmp);
else if ((tmp = getenv("PGPASSWORD")) != NULL) else if (conn->pguser)
{ conn->dbName = strdup(conn->pguser);
conn->pgpass = strdup(tmp); }
} else
else conn->dbName = strdup(dbName);
conn->pgpass = strdup(DefaultPassword);
if (!error) if (conn->dbName)
{
/*
* if the database name is surrounded by double-quotes, then
* don't convert case
*/
if (*conn->dbName == '"')
{ {
if ((((tmp = (char *) dbName) != NULL) && (dbName[0] != '\0')) strcpy(conn->dbName, conn->dbName + 1);
|| ((tmp = getenv("PGDATABASE")))) conn->dbName[strlen(conn->dbName) - 1] = '\0';
conn->dbName = strdup(tmp);
else
conn->dbName = strdup(conn->pguser);
/*
* if the database name is surrounded by double-quotes, then
* don't convert case
*/
if (*conn->dbName == '"')
{
strcpy(conn->dbName, conn->dbName + 1);
*(conn->dbName + strlen(conn->dbName) - 1) = '\0';
}
else
for (i = 0; conn->dbName[i]; i++)
if (isupper(conn->dbName[i]))
conn->dbName[i] = tolower(conn->dbName[i]);
} }
else else
conn->dbName = NULL; for (i = 0; conn->dbName[i]; i++)
if (isupper(conn->dbName[i]))
if (error) conn->dbName[i] = tolower(conn->dbName[i]);
conn->status = CONNECTION_BAD;
else
{
conn->status = connectDB(conn);
/* Puts message in conn->errorMessage */
if (conn->status == CONNECTION_OK)
{
PGresult *res;
/*
* Send a blank query to make sure everything works; in
* particular, that the database exists.
*/
res = PQexec(conn, " ");
if (res == NULL || res->resultStatus != PGRES_EMPTY_QUERY)
{
/* PQexec has put error message in conn->errorMessage */
closePGconn(conn);
}
PQclear(res);
}
PQsetenv(conn);
}
} }
if (error)
conn->status = CONNECTION_BAD;
else
conn->status = connectDB(conn);
return conn; return conn;
} }
...@@ -468,6 +405,7 @@ PQsetdbLogin(const char *pghost, const char *pgport, const char *pgoptions, cons ...@@ -468,6 +405,7 @@ PQsetdbLogin(const char *pghost, const char *pgport, const char *pgoptions, cons
static ConnStatusType static ConnStatusType
connectDB(PGconn *conn) connectDB(PGconn *conn)
{ {
PGresult *res;
struct hostent *hp; struct hostent *hp;
StartupPacket sp; StartupPacket sp;
...@@ -476,6 +414,7 @@ connectDB(PGconn *conn) ...@@ -476,6 +414,7 @@ connectDB(PGconn *conn)
int portno, int portno,
family, family,
len; len;
char beresp;
/* /*
* Initialize the startup packet. * Initialize the startup packet.
...@@ -506,16 +445,17 @@ connectDB(PGconn *conn) ...@@ -506,16 +445,17 @@ connectDB(PGconn *conn)
conn->pghost); conn->pghost);
goto connect_errReturn; goto connect_errReturn;
} }
family = AF_INET;
} }
else else {
hp = NULL; hp = NULL;
family = AF_UNIX;
}
#if FALSE MemSet((char *) &conn->raddr, 0, sizeof(conn->raddr));
MemSet((char *) &port->raddr, 0, sizeof(port->raddr));
#endif
portno = atoi(conn->pgport);
family = (conn->pghost != NULL) ? AF_INET : AF_UNIX;
conn->raddr.sa.sa_family = family; conn->raddr.sa.sa_family = family;
portno = atoi(conn->pgport);
if (family == AF_INET) if (family == AF_INET)
{ {
memmove((char *) &(conn->raddr.in.sin_addr), memmove((char *) &(conn->raddr.in.sin_addr),
...@@ -528,7 +468,8 @@ connectDB(PGconn *conn) ...@@ -528,7 +468,8 @@ connectDB(PGconn *conn)
{ {
len = UNIXSOCK_PATH(conn->raddr.un, portno); len = UNIXSOCK_PATH(conn->raddr.un, portno);
} }
/* connect to the server */
/* Connect to the server */
if ((conn->sock = socket(family, SOCK_STREAM, 0)) < 0) if ((conn->sock = socket(family, SOCK_STREAM, 0)) < 0)
{ {
(void) sprintf(conn->errorMessage, (void) sprintf(conn->errorMessage,
...@@ -545,6 +486,20 @@ connectDB(PGconn *conn) ...@@ -545,6 +486,20 @@ connectDB(PGconn *conn)
conn->pgport); conn->pgport);
goto connect_errReturn; goto connect_errReturn;
} }
/*
* Set the right options.
* We need nonblocking I/O, and we don't want delay of outgoing data.
*/
if (fcntl(conn->sock, F_SETFL, O_NONBLOCK) < 0)
{
(void) sprintf(conn->errorMessage,
"connectDB() -- fcntl() failed: errno=%d\n%s\n",
errno, strerror(errno));
goto connect_errReturn;
}
if (family == AF_INET) if (family == AF_INET)
{ {
struct protoent *pe; struct protoent *pe;
...@@ -561,109 +516,155 @@ connectDB(PGconn *conn) ...@@ -561,109 +516,155 @@ connectDB(PGconn *conn)
&on, sizeof(on)) < 0) &on, sizeof(on)) < 0)
{ {
(void) sprintf(conn->errorMessage, (void) sprintf(conn->errorMessage,
"connectDB(): setsockopt failed\n"); "connectDB() -- setsockopt failed: errno=%d\n%s\n",
errno, strerror(errno));
goto connect_errReturn; goto connect_errReturn;
} }
} }
/* fill in the client address */ /* Fill in the client address */
if (getsockname(conn->sock, &conn->laddr.sa, &laddrlen) < 0) if (getsockname(conn->sock, &conn->laddr.sa, &laddrlen) < 0)
{ {
(void) sprintf(conn->errorMessage, (void) sprintf(conn->errorMessage,
"connectDB() -- getsockname() failed: errno=%d\n%s\n", "connectDB() -- getsockname() failed: errno=%d\n%s\n",
errno, strerror(errno)); errno, strerror(errno));
goto connect_errReturn; goto connect_errReturn;
} }
/* set up the socket file descriptors */ /* Ensure our buffers are empty */
conn->Pfout = fdopen(conn->sock, "w"); conn->inStart = conn->inCursor = conn->inEnd = 0;
conn->Pfin = fdopen(dup(conn->sock), "r"); conn->outCount = 0;
if ((conn->Pfout == NULL) || (conn->Pfin == NULL))
{
(void) sprintf(conn->errorMessage,
"connectDB() -- fdopen() failed: errno=%d\n%s\n",
errno, strerror(errno));
goto connect_errReturn;
}
/* Send the startup packet. */ /* Send the startup packet. */
if (packetSend(conn, (char *) &sp, sizeof(StartupPacket)) != STATUS_OK) if (packetSend(conn, (char *) &sp, sizeof(StartupPacket)) != STATUS_OK)
{ {
sprintf(conn->errorMessage, sprintf(conn->errorMessage,
"connectDB() -- couldn't send complete packet: errno=%d\n%s\n", errno, strerror(errno)); "connectDB() -- couldn't send startup packet: errno=%d\n%s\n",
errno, strerror(errno));
goto connect_errReturn; goto connect_errReturn;
} }
/* /*
* Get the response from the backend, either an error message or an * Perform the authentication exchange:
* authentication request. * wait for backend messages and respond as necessary.
* We fall out of this loop when done talking to the postmaster.
*/ */
do for (;;)
{ {
int beresp; /* Wait for some data to arrive (or for the channel to close) */
if (pqWait(TRUE, FALSE, conn))
if ((beresp = pqGetc(conn->Pfin, conn->Pfdebug)) == EOF)
{
(void) sprintf(conn->errorMessage,
"connectDB() -- error getting authentication request\n");
goto connect_errReturn; goto connect_errReturn;
} /* Load data, or detect EOF */
if (pqReadData(conn) < 0)
goto connect_errReturn;
/* Scan the message.
* If we run out of data, loop around to try again.
*/
conn->inCursor = conn->inStart;
/* Handle errors. */ if (pqGetc(&beresp, conn))
continue; /* no data yet */
/* Handle errors. */
if (beresp == 'E') if (beresp == 'E')
{ {
pqGets(conn->errorMessage, sizeof(conn->errorMessage), if (pqGets(conn->errorMessage, sizeof(conn->errorMessage), conn))
conn->Pfin, conn->Pfdebug); continue;
goto connect_errReturn; goto connect_errReturn;
} }
/* Check it was an authentication request. */ /* Otherwise it should be an authentication request. */
if (beresp != 'R') if (beresp != 'R')
{ {
(void) sprintf(conn->errorMessage, (void) sprintf(conn->errorMessage,
"connectDB() -- expected authentication request\n"); "connectDB() -- expected authentication request\n");
goto connect_errReturn; goto connect_errReturn;
} }
/* Get the type of request. */ /* Get the type of request. */
if (pqGetInt((int *) &areq, 4, conn))
continue;
if (pqGetInt((int *) &areq, 4, conn->Pfin, conn->Pfdebug)) /* Get the password salt if there is one. */
if (areq == AUTH_REQ_CRYPT)
{ {
(void) sprintf(conn->errorMessage, if (pqGetnchar(conn->salt, sizeof(conn->salt), conn))
"connectDB() -- error getting authentication request type\n"); continue;
}
/* OK, we successfully read the message; mark data consumed */
conn->inStart = conn->inCursor;
/* Respond to the request if necessary. */
if (fe_sendauth(areq, conn, conn->pghost, conn->pgpass,
conn->errorMessage) != STATUS_OK)
goto connect_errReturn;
if (pqFlush(conn))
goto connect_errReturn; goto connect_errReturn;
}
/* Get the password salt if there is one. */ /* Are we done? */
if (areq == AUTH_REQ_OK)
break;
}
if (areq == AUTH_REQ_CRYPT && /*
pqGetnchar(conn->salt, sizeof(conn->salt), * Now we expect to hear from the backend.
conn->Pfin, conn->Pfdebug)) * A ReadyForQuery message indicates that startup is successful,
{ * but we might also get an Error message indicating failure.
(void) sprintf(conn->errorMessage, * (Notice messages indicating nonfatal warnings are also allowed
"connectDB() -- error getting password salt\n"); * by the protocol.)
* Easiest way to handle this is to let PQgetResult() read the messages.
* We just have to fake it out about the state of the connection.
*/
goto connect_errReturn; conn->status = CONNECTION_OK;
} conn->asyncStatus = PGASYNC_BUSY;
res = PQgetResult(conn);
/* NULL return indicating we have gone to IDLE state is expected */
if (res) {
if (res->resultStatus != PGRES_FATAL_ERROR)
sprintf(conn->errorMessage,
"connectDB() -- unexpected message during startup\n");
PQclear(res);
goto connect_errReturn;
}
/* Given the new protocol that sends a ReadyForQuery message
* after successful backend startup, it should no longer be
* necessary to send an empty query to test for startup.
*/
/* Respond to the request. */ #if 0
if (fe_sendauth(areq, conn, conn->pghost, conn->pgpass, /*
conn->errorMessage) != STATUS_OK) * Send a blank query to make sure everything works; in
goto connect_errReturn; * particular, that the database exists.
*/
res = PQexec(conn, " ");
if (res == NULL || res->resultStatus != PGRES_EMPTY_QUERY)
{
/* PQexec has put error message in conn->errorMessage */
closePGconn(conn);
PQclear(res);
goto connect_errReturn;
} }
while (areq != AUTH_REQ_OK); PQclear(res);
/* free the password so it's not hanging out in memory forever */ #endif
/* Post-connection housekeeping.
* Send environment variables to server
*/
PQsetenv(conn);
/* Free the password so it's not hanging out in memory forever */
/* XXX Is this *really* a good idea? The security gain is marginal
* if not totally illusory, and it breaks PQreset() for databases
* that use passwords.
*/
if (conn->pgpass != NULL) if (conn->pgpass != NULL)
{ {
free(conn->pgpass); free(conn->pgpass);
...@@ -673,6 +674,11 @@ connectDB(PGconn *conn) ...@@ -673,6 +674,11 @@ connectDB(PGconn *conn)
return CONNECTION_OK; return CONNECTION_OK;
connect_errReturn: connect_errReturn:
if (conn->sock >= 0)
{
close(conn->sock);
conn->sock = -1;
}
return CONNECTION_BAD; return CONNECTION_BAD;
} }
...@@ -704,6 +710,36 @@ PQsetenv(PGconn *conn) ...@@ -704,6 +710,36 @@ PQsetenv(PGconn *conn)
} }
} /* PQsetenv() */ } /* PQsetenv() */
/*
* makeEmptyPGconn
* - create a PGconn data structure with (as yet) no interesting data
*/
static PGconn *
makeEmptyPGconn(void)
{
PGconn *conn = (PGconn *) malloc(sizeof(PGconn));
if (conn == NULL)
return conn;
/* Zero all pointers */
MemSet((char *) conn, 0, sizeof(PGconn));
conn->status = CONNECTION_BAD;
conn->asyncStatus = PGASYNC_IDLE;
conn->notifyList = DLNewList();
conn->sock = -1;
conn->inBufSize = 8192;
conn->inBuffer = (char *) malloc(conn->inBufSize);
conn->outBufSize = 8192;
conn->outBuffer = (char *) malloc(conn->outBufSize);
if (conn->inBuffer == NULL || conn->outBuffer == NULL)
{
freePGconn(conn);
conn = NULL;
}
return conn;
}
/* /*
* freePGconn * freePGconn
* - free the PGconn data structure * - free the PGconn data structure
...@@ -714,22 +750,32 @@ freePGconn(PGconn *conn) ...@@ -714,22 +750,32 @@ freePGconn(PGconn *conn)
{ {
if (!conn) if (!conn)
return; return;
PQclearAsyncResult(conn); /* deallocate result and curTuple */
if (conn->sock >= 0)
close(conn->sock); /* shouldn't happen, but... */
if (conn->pghost) if (conn->pghost)
free(conn->pghost); free(conn->pghost);
if (conn->pgport)
free(conn->pgport);
if (conn->pgtty) if (conn->pgtty)
free(conn->pgtty); free(conn->pgtty);
if (conn->pgoptions) if (conn->pgoptions)
free(conn->pgoptions); free(conn->pgoptions);
if (conn->pgport)
free(conn->pgport);
if (conn->dbName) if (conn->dbName)
free(conn->dbName); free(conn->dbName);
if (conn->pguser) if (conn->pguser)
free(conn->pguser); free(conn->pguser);
if (conn->pgpass) if (conn->pgpass)
free(conn->pgpass); free(conn->pgpass);
/* Note that conn->Pfdebug is not ours to close or free */
if (conn->notifyList) if (conn->notifyList)
DLFreeList(conn->notifyList); DLFreeList(conn->notifyList);
if (conn->lobjfuncs)
free(conn->lobjfuncs);
if (conn->inBuffer)
free(conn->inBuffer);
if (conn->outBuffer)
free(conn->outBuffer);
free(conn); free(conn);
} }
...@@ -740,42 +786,54 @@ freePGconn(PGconn *conn) ...@@ -740,42 +786,54 @@ freePGconn(PGconn *conn)
static void static void
closePGconn(PGconn *conn) closePGconn(PGconn *conn)
{ {
/* GH: What to do for !USE_POSIX_SIGNALS ? */ if (conn->sock >= 0)
{
/*
* Try to send close message.
* If connection is already gone, that's cool. No reason for kernel
* to kill us when we try to write to it. So ignore SIGPIPE signals.
*/
#if defined(USE_POSIX_SIGNALS) #if defined(USE_POSIX_SIGNALS)
struct sigaction ignore_action; struct sigaction ignore_action;
struct sigaction oldaction;
/* ignore_action.sa_handler = SIG_IGN;
* This is used as a constant, but not declared as such because the sigemptyset(&ignore_action.sa_mask);
* sigaction structure is defined differently on different systems ignore_action.sa_flags = 0;
*/ sigaction(SIGPIPE, (struct sigaction *) & ignore_action, &oldaction);
struct sigaction oldaction;
/* (void) pqPuts("X", conn);
* If connection is already gone, that's cool. No reason for kernel (void) pqFlush(conn);
* to kill us when we try to write to it. So ignore SIGPIPE signals.
*/ sigaction(SIGPIPE, &oldaction, NULL);
ignore_action.sa_handler = SIG_IGN;
sigemptyset(&ignore_action.sa_mask);
ignore_action.sa_flags = 0;
sigaction(SIGPIPE, (struct sigaction *) & ignore_action, &oldaction);
fputs("X\0", conn->Pfout);
fflush(conn->Pfout);
sigaction(SIGPIPE, &oldaction, NULL);
#else #else
signal(SIGPIPE, SIG_IGN); void (*oldsignal)(int);
fputs("X\0", conn->Pfout);
fflush(conn->Pfout); oldsignal = signal(SIGPIPE, SIG_IGN);
signal(SIGPIPE, SIG_DFL);
(void) pqPuts("X", conn);
(void) pqFlush(conn);
signal(SIGPIPE, oldsignal);
#endif #endif
if (conn->Pfout) }
fclose(conn->Pfout);
if (conn->Pfin) /*
fclose(conn->Pfin); * Close the connection, reset all transient state, flush I/O buffers.
if (conn->Pfdebug) */
fclose(conn->Pfdebug); if (conn->sock >= 0)
close(conn->sock);
conn->sock = -1;
conn->status = CONNECTION_BAD; /* Well, not really _bad_ - just conn->status = CONNECTION_BAD; /* Well, not really _bad_ - just
* absent */ * absent */
conn->asyncStatus = PGASYNC_IDLE;
PQclearAsyncResult(conn); /* deallocate result and curTuple */
if (conn->lobjfuncs)
free(conn->lobjfuncs);
conn->lobjfuncs = NULL;
conn->inStart = conn->inCursor = conn->inEnd = 0;
conn->outCount = 0;
} }
/* /*
...@@ -793,8 +851,7 @@ PQfinish(PGconn *conn) ...@@ -793,8 +851,7 @@ PQfinish(PGconn *conn)
} }
else else
{ {
if (conn->status == CONNECTION_OK) closePGconn(conn);
closePGconn(conn);
freePGconn(conn); freePGconn(conn);
} }
} }
...@@ -818,12 +875,8 @@ PQreset(PGconn *conn) ...@@ -818,12 +875,8 @@ PQreset(PGconn *conn)
} }
/* /*
* PacketSend() * PacketSend() -- send a single-packet message.
* * this is like PacketSend(), defined in backend/libpq/pqpacket.c
this is just like PacketSend(), defined in backend/libpq/pqpacket.c
but we define it here to avoid linking in all of libpq.a
* packetSend -- send a single-packet message.
* *
* RETURNS: STATUS_ERROR if the write fails, STATUS_OK otherwise. * RETURNS: STATUS_ERROR if the write fails, STATUS_OK otherwise.
* SIDE_EFFECTS: may block. * SIDE_EFFECTS: may block.
...@@ -833,15 +886,16 @@ packetSend(PGconn *conn, const char *buf, size_t len) ...@@ -833,15 +886,16 @@ packetSend(PGconn *conn, const char *buf, size_t len)
{ {
/* Send the total packet size. */ /* Send the total packet size. */
if (pqPutInt(4 + len, 4, conn->Pfout, conn->Pfdebug)) if (pqPutInt(4 + len, 4, conn))
return STATUS_ERROR; return STATUS_ERROR;
/* Send the packet itself. */ /* Send the packet itself. */
if (pqPutnchar(buf, len, conn->Pfout, conn->Pfdebug)) if (pqPutnchar(buf, len, conn))
return STATUS_ERROR; return STATUS_ERROR;
pqFlush(conn->Pfout, conn->Pfdebug); if (pqFlush(conn))
return STATUS_ERROR;
return STATUS_OK; return STATUS_OK;
} }
...@@ -1203,6 +1257,17 @@ PQerrorMessage(PGconn *conn) ...@@ -1203,6 +1257,17 @@ PQerrorMessage(PGconn *conn)
return conn->errorMessage; return conn->errorMessage;
} }
int
PQsocket(PGconn *conn)
{
if (!conn)
{
fprintf(stderr, "PQsocket() -- pointer to PGconn is null\n");
return -1;
}
return conn->sock;
}
void void
PQtrace(PGconn *conn, FILE *debug_port) PQtrace(PGconn *conn, FILE *debug_port)
{ {
...@@ -1218,8 +1283,8 @@ PQtrace(PGconn *conn, FILE *debug_port) ...@@ -1218,8 +1283,8 @@ PQtrace(PGconn *conn, FILE *debug_port)
void void
PQuntrace(PGconn *conn) PQuntrace(PGconn *conn)
{ {
if (conn == NULL || /* note: better allow untrace even when connection bad */
conn->status == CONNECTION_BAD) if (conn == NULL)
{ {
return; return;
} }
......
src/interfaces/libpq/fe-exec.c
View file @ edbd5139
...@@ -7,46 +7,28 @@ ...@@ -7,46 +7,28 @@
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-exec.c,v 1.49 1998/04/29 02:04:01 scrappy Exp $ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-exec.c,v 1.50 1998/05/06 23:51:13 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
#include <stdio.h> #include <stdio.h>
#include <signal.h>
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
#include <ctype.h> #include <ctype.h>
#if !defined(NO_UNISTD_H)
#include <unistd.h>
#endif
#include "postgres.h" #include "postgres.h"
#include "libpq/pqcomm.h" #include "libpq/pqcomm.h"
#include "libpq/pqsignal.h"
#include "libpq-fe.h" #include "libpq-fe.h"
#include <sys/ioctl.h>
#ifndef HAVE_TERMIOS_H
#include <sys/termios.h>
#else
#include <termios.h>
#endif
#ifdef TIOCGWINSZ
struct winsize screen_size;
#else
struct winsize
{
int ws_row;
int ws_col;
} screen_size;
#endif
/* the rows array in a PGresGroup has to grow to accommodate the rows */ /* the rows array in a PGresGroup has to grow to accommodate the rows */
/* returned. Each time, we grow by this much: */ /* returned. Each time, we grow by this much: */
#define TUPARR_GROW_BY 100 #define TUPARR_GROW_BY 100
/* keep this in same order as ExecStatusType in pgtclCmds.h */ /* keep this in same order as ExecStatusType in libpq-fe.h */
const char *pgresStatus[] = { const char *pgresStatus[] = {
"PGRES_EMPTY_QUERY", "PGRES_EMPTY_QUERY",
"PGRES_COMMAND_OK", "PGRES_COMMAND_OK",
...@@ -59,56 +41,15 @@ const char *pgresStatus[] = { ...@@ -59,56 +41,15 @@ const char *pgresStatus[] = {
}; };
static PGresult *makePGresult(PGconn *conn, char *pname);
static void addTuple(PGresult *res, PGresAttValue *tup);
static PGresAttValue *getTuple(PGconn *conn, PGresult *res, int binary);
static PGresult *makeEmptyPGresult(PGconn *conn, ExecStatusType status); static PGresult *makeEmptyPGresult(PGconn *conn, ExecStatusType status);
static void fill(int length, int max, char filler, FILE *fp); static void freeTuple(PGresAttValue *tuple, int numAttributes);
static char * static void addTuple(PGresult *res, PGresAttValue *tup);
do_header(FILE *fout, PQprintOpt *po, const int nFields, static void parseInput(PGconn *conn);
int fieldMax[], char *fieldNames[], unsigned char fieldNotNum[], static int getRowDescriptions(PGconn *conn);
const int fs_len, PGresult *res); static int getAnotherTuple(PGconn *conn, int binary);
static int getNotify(PGconn *conn);
/* static int getNotice(PGconn *conn);
* PQclear -
* free's the memory associated with a PGresult
*
*/
void
PQclear(PGresult *res)
{
int i,
j;
if (!res)
return;
/* free all the rows */
for (i = 0; i < res->ntups; i++)
{
for (j = 0; j < res->numAttributes; j++)
{
if (res->tuples[i][j].value)
free(res->tuples[i][j].value);
}
if (res->tuples[i])
free(res->tuples[i]);
}
if (res->tuples)
free(res->tuples);
/* free all the attributes */
for (i = 0; i < res->numAttributes; i++)
{
if (res->attDescs[i].name)
free(res->attDescs[i].name);
}
if (res->attDescs)
free(res->attDescs);
/* free the structure itself */
free(res);
}
/* /*
* PGresult - * PGresult -
...@@ -136,1347 +77,933 @@ makeEmptyPGresult(PGconn *conn, ExecStatusType status) ...@@ -136,1347 +77,933 @@ makeEmptyPGresult(PGconn *conn, ExecStatusType status)
} }
/* /*
* getTuple - * PQclear -
* get the next row from the stream * free's the memory associated with a PGresult
* *
* the CALLER is responsible from freeing the PGresAttValue returned
*/ */
void
static PGresAttValue * PQclear(PGresult *res)
getTuple(PGconn *conn, PGresult *result, int binary)
{ {
char bitmap[MAX_FIELDS]; /* the backend sends us a bitmap
* of */
/* which attributes are null */
int bitmap_index = 0;
int i; int i;
int nbytes; /* the number of bytes in bitmap */
char bmap; /* One byte of the bitmap */
int bitcnt = 0; /* number of bits examined in current byte */
int vlen; /* length of the current field value */
FILE *pfin = conn->Pfin;
FILE *pfdebug = conn->Pfdebug;
PGresAttValue *tup;
int nfields = result->numAttributes;
result->binary = binary;
tup = (PGresAttValue *) malloc(nfields * sizeof(PGresAttValue));
nbytes = nfields / BYTELEN; if (!res)
if ((nfields % BYTELEN) > 0) return;
nbytes++;
if (nbytes >= MAX_FIELDS || pqGetnchar(bitmap, nbytes, pfin, pfdebug) == 1) /* free all the rows */
if (res->tuples)
{ {
sprintf(conn->errorMessage, for (i = 0; i < res->ntups; i++)
"Error reading null-values bitmap from row data stream\n"); freeTuple(res->tuples[i], res->numAttributes);
return NULL; free(res->tuples);
} }
bmap = bitmap[bitmap_index]; /* free all the attributes */
if (res->attDescs)
for (i = 0; i < nfields; i++)
{ {
if (!(bmap & 0200)) for (i = 0; i < res->numAttributes; i++)
{
/* if the field value is absent, make it '\0' */
tup[i].value = (char *) malloc(1);
tup[i].value[0] = '\0';
tup[i].len = NULL_LEN;
}
else
{ {
/* get the value length (the first four bytes are for length) */ if (res->attDescs[i].name)
pqGetInt(&vlen, 4, pfin, pfdebug); free(res->attDescs[i].name);
if (binary == 0)
{
vlen = vlen - 4;
}
if (vlen < 0)
vlen = 0;
tup[i].len = vlen;
tup[i].value = (char *) malloc(vlen + 1);
/* read in the value; */
if (vlen > 0)
pqGetnchar((char *) (tup[i].value), vlen, pfin, pfdebug);
tup[i].value[vlen] = '\0';
} }
/* get the appropriate bitmap */ free(res->attDescs);
bitcnt++; }
if (bitcnt == BYTELEN)
/* free the structure itself */
free(res);
}
/*
* Free a single tuple structure.
*/
static void
freeTuple(PGresAttValue *tuple, int numAttributes)
{
int i;
if (tuple)
{
for (i = 0; i < numAttributes; i++)
{ {
bitmap_index++; if (tuple[i].value)
bmap = bitmap[bitmap_index]; free(tuple[i].value);
bitcnt = 0;
} }
else free(tuple);
bmap <<= 1;
} }
}
/*
* Handy subroutine to deallocate any partially constructed async result.
*/
return tup; void
PQclearAsyncResult(PGconn *conn)
{
/* Get rid of incomplete result and any not-yet-added tuple */
if (conn->result)
{
if (conn->curTuple)
freeTuple(conn->curTuple, conn->result->numAttributes);
PQclear(conn->result);
}
conn->result = NULL;
conn->curTuple = NULL;
} }
/* /*
* addTuple * addTuple
* add a row to the PGresult structure, growing it if necessary * add a row to the PGresult structure, growing it if necessary
* to accommodate
*
*/ */
static void static void
addTuple(PGresult *res, PGresAttValue *tup) addTuple(PGresult *res, PGresAttValue *tup)
{ {
if (res->ntups == res->tupArrSize) if (res->ntups >= res->tupArrSize)
{ {
/* grow the array */ /* grow the array */
res->tupArrSize += TUPARR_GROW_BY; res->tupArrSize += TUPARR_GROW_BY;
/*
if (res->ntups == 0) * we can use realloc because shallow copying of the structure
res->tuples = (PGresAttValue **) * is okay. Note that the first time through, res->tuples is NULL.
malloc(res->tupArrSize * sizeof(PGresAttValue *)); * realloc is supposed to do the right thing in that case.
else * Also note that the positions beyond res->ntups are garbage,
* not necessarily NULL.
/* */
* we can use realloc because shallow copying of the structure res->tuples = (PGresAttValue **)
* is okay realloc(res->tuples, res->tupArrSize * sizeof(PGresAttValue *));
*/
res->tuples = (PGresAttValue **)
realloc(res->tuples, res->tupArrSize * sizeof(PGresAttValue *));
} }
res->tuples[res->ntups] = tup; res->tuples[res->ntups] = tup;
res->ntups++; res->ntups++;
} }
/* /*
* PGresult * PQsendQuery
* fill out the PGresult structure with result rows from the backend * Submit a query, but don't wait for it to finish
* this is called after query has been successfully run and we have
* a portal name
*
* ASSUMPTION: we assume only *1* row group is returned from the backend
*
* the CALLER is reponsible for free'ing the new PGresult allocated here
* *
* Returns: 1 if successfully submitted
* 0 if error (conn->errorMessage is set)
*/ */
static PGresult * int
makePGresult(PGconn *conn, char *pname) PQsendQuery(PGconn *conn, const char *query)
{ {
PGresult *result; if (!conn)
int id; return 0;
int nfields; if (!query)
int i;
int done = 0;
PGresAttValue *newTup;
FILE *pfin = conn->Pfin;
FILE *pfdebug = conn->Pfdebug;
result = makeEmptyPGresult(conn, PGRES_TUPLES_OK);
/* makePGresult() should only be called when the */
/* id of the stream is 'T' to start with */
/* the next two bytes are the number of fields */
if (pqGetInt(&nfields, 2, pfin, pfdebug) == 1)
{ {
sprintf(conn->errorMessage, sprintf(conn->errorMessage, "PQsendQuery() -- query pointer is null.");
"could not get the number of fields from the 'T' message\n"); return 0;
goto makePGresult_badResponse_return;
} }
else if (conn->asyncStatus != PGASYNC_IDLE)
result->numAttributes = nfields;
/* allocate space for the attribute descriptors */
if (nfields > 0)
{ {
result->attDescs = (PGresAttDesc *) malloc(nfields * sizeof(PGresAttDesc)); sprintf(conn->errorMessage,
"PQsendQuery() -- another query already in progress.");
return 0;
} }
/* get type info */ /* clear the error string */
for (i = 0; i < nfields; i++) conn->errorMessage[0] = '\0';
{
char typName[MAX_MESSAGE_LEN];
int adtid;
int adtsize;
if (pqGets(typName, MAX_MESSAGE_LEN, pfin, pfdebug) ||
pqGetInt(&adtid, 4, pfin, pfdebug) ||
pqGetInt(&adtsize, 2, pfin, pfdebug))
{
sprintf(conn->errorMessage,
"error reading type information from the 'T' message\n");
goto makePGresult_badResponse_return;
}
result->attDescs[i].name = malloc(strlen(typName) + 1);
strcpy(result->attDescs[i].name, typName);
result->attDescs[i].adtid = adtid;
result->attDescs[i].adtsize = adtsize; /* casting from int to
* int2 here */
}
id = pqGetc(pfin, pfdebug); /* initialize async result-accumulation state */
conn->result = NULL;
conn->curTuple = NULL;
conn->asyncErrorMessage[0] = '\0';
/* process the data stream until we're finished */ /* check to see if the query string is too long */
while (!done) if (strlen(query) > MAX_MESSAGE_LEN-2)
{ {
switch (id) sprintf(conn->errorMessage, "PQsendQuery() -- query is too long. "
{ "Maximum length is %d\n", MAX_MESSAGE_LEN - 2);
case 'T': /* a new row group */ return 0;
sprintf(conn->errorMessage, }
"makePGresult() -- "
"is not equipped to handle multiple row groups.\n");
goto makePGresult_badResponse_return;
case 'B': /* a row in binary format */
case 'D': /* a row in ASCII format */
newTup = getTuple(conn, result, (id == 'B'));
if (newTup == NULL)
goto makePGresult_badResponse_return;
addTuple(result, newTup);
break;
case 'C': /* end of portal row stream */
{
char command[MAX_MESSAGE_LEN];
pqGets(command, MAX_MESSAGE_LEN, pfin, pfdebug); /* read command tag */
done = 1;
}
break;
case 'E': /* errors */
if (pqGets(conn->errorMessage, ERROR_MSG_LENGTH, pfin, pfdebug) == 1)
{
sprintf(conn->errorMessage,
"Error return detected from backend, "
"but error message cannot be read");
}
result->resultStatus = PGRES_FATAL_ERROR;
return result;
break;
case 'N': /* notices from the backend */
if (pqGets(conn->errorMessage, ERROR_MSG_LENGTH, pfin, pfdebug) == 1)
{
sprintf(conn->errorMessage,
"Notice return detected from backend, "
"but error message cannot be read");
}
else
/* XXXX send Notices to stderr for now */
fprintf(stderr, "%s\n", conn->errorMessage);
break;
default: /* uh-oh this should never happen but
* frequently does when the backend dumps
* core */
sprintf(conn->errorMessage,
"FATAL: unrecognized data from the backend. "
"It probably dumped core.\n");
fprintf(stderr, conn->errorMessage);
result->resultStatus = PGRES_FATAL_ERROR;
return result;
break;
}
if (!done)
id = getc(pfin);
} /* while (1) */
result->resultStatus = PGRES_TUPLES_OK; /* Don't try to send if we know there's no live connection. */
return result; if (conn->status != CONNECTION_OK)
{
sprintf(conn->errorMessage, "PQsendQuery() -- There is no connection "
"to the backend.\n");
return 0;
}
makePGresult_badResponse_return: /* send the query to the backend; */
result->resultStatus = PGRES_BAD_RESPONSE; /* the frontend-backend protocol uses 'Q' to designate queries */
return result; if (pqPutnchar("Q", 1, conn))
return 0;
if (pqPuts(query, conn))
return 0;
if (pqFlush(conn))
return 0;
/* OK, it's launched! */
conn->asyncStatus = PGASYNC_BUSY;
return 1;
} }
/* /*
* Assuming that we just sent a query to the backend, read the backend's * Consume any available input from the backend
* response from stream <pfin> and respond accordingly.
*
* If <pfdebug> is non-null, write to that stream whatever we receive
* (it's a debugging trace).
*
* Return as <result> a pointer to a proper final PGresult structure,
* newly allocated, for the query based on the response we get. If the
* response we get indicates that the query didn't execute, return a
* null pointer and don't allocate any space, but also place a text
* string explaining the problem at <*reason>.
*/ */
static void void
process_response_from_backend(FILE *pfin, FILE *pfout, FILE *pfdebug, PQconsumeInput(PGconn *conn)
PGconn *conn,
PGresult **result_p, char *const reason)
{ {
if (!conn)
return;
int id; /* Load more data, if available.
* We do this no matter what state we are in, since we are probably
/* * getting called because the application wants to get rid
* The protocol character received from the backend. The protocol * of a read-select condition.
* character is the first character in the backend's response to our * Note that we will NOT block waiting for more input.
* query. It defines the nature of the response.
*/ */
PGnotify *newNotify; if (pqReadData(conn) < 0)
bool done; {
strcpy(conn->asyncErrorMessage, conn->errorMessage);
}
/* Parsing of the data waits till later. */
}
/* We're all done with the query and ready to return the result. */
int emptiesSent;
/* /*
* Number of empty queries we have sent in order to flush out multiple * parseInput: if appropriate, parse input data from backend
* responses, less the number of corresponding responses we have * until input is exhausted or a stopping state is reached.
* received. * Note that this function will NOT attempt to read more data from the backend.
*/ */
int errors;
/* static void
* If an error is received, we must still drain out the empty queries parseInput(PGconn *conn)
* sent. So we need another flag. {
*/ char id;
char cmdStatus[MAX_MESSAGE_LEN];
char pname[MAX_MESSAGE_LEN]; /* portal name */
/* /*
* loop because multiple messages, especially NOTICES, can come back * Loop to parse successive complete messages available in the buffer.
* from the backend. NOTICES are output directly to stderr
*/ */
for (;;)
emptiesSent = 0; /* No empty queries sent yet */
errors = 0; /* No errors received yet */
pname[0] = '\0';
done = false; /* initial value */
while (!done)
{ {
/* read the result id */ /*
id = pqGetc(pfin, pfdebug); * Quit if in COPY_OUT state: we expect raw data from the server until
if (id == EOF) * PQendcopy is called. Don't try to parse it according to the normal
* protocol. (This is bogus. The data lines ought to be part of the
* protocol and have identifying leading characters.)
*/
if (conn->asyncStatus == PGASYNC_COPY_OUT)
return;
/*
* OK to try to read a message type code.
*/
conn->inCursor = conn->inStart;
if (pqGetc(&id, conn))
return;
/*
* NOTIFY messages can happen in any state besides COPY OUT;
* always process them right away.
*/
if (id == 'A')
{ {
/* hmm, no response from the backend-end, that's bad */ /* Notify responses can happen at any time */
(void) sprintf(reason, "PQexec() -- Request was sent to backend" if (getNotify(conn))
", but backend closed the channel before responding." return;
"\n\tThis probably means the backend terminated abnormally"
" before or while processing the request.\n");
conn->status = CONNECTION_BAD; /* No more connection to
* backend */
*result_p = (PGresult *) NULL;
done = true;
} }
else else
{ {
/*
* Other messages should only be processed while in BUSY state.
* (In particular, in READY state we hold off further parsing
* until the application collects the current PGresult.)
* If the state is IDLE then we got trouble.
*/
if (conn->asyncStatus != PGASYNC_BUSY)
{
if (conn->asyncStatus == PGASYNC_IDLE)
{
fprintf(stderr,
"Backend message type 0x%02x arrived while idle\n",
id);
/* Discard the unexpected message; good idea?? */
conn->inStart = conn->inEnd;
}
return;
}
switch (id) switch (id)
{ {
case 'A': case 'C': /* command complete */
newNotify = (PGnotify *) malloc(sizeof(PGnotify)); if (conn->result == NULL)
pqGetInt(&(newNotify->be_pid), 4, pfin, pfdebug); conn->result = makeEmptyPGresult(conn,
pqGets(newNotify->relname, NAMEDATALEN, pfin, pfdebug); PGRES_COMMAND_OK);
DLAddTail(conn->notifyList, DLNewElem(newNotify)); if (pqGets(conn->result->cmdStatus, CMDSTATUS_LEN, conn))
return;
/* conn->asyncStatus = PGASYNC_READY;
* async messages are piggy'ed back on other messages, break;
* so we stay in the while loop for other messages case 'E': /* error return */
if (pqGets(conn->asyncErrorMessage,ERROR_MSG_LENGTH,conn))
return;
/* delete any partially constructed result */
PQclearAsyncResult(conn);
/* we leave result NULL while setting asyncStatus=READY;
* this signals an error condition to PQgetResult.
*/ */
conn->asyncStatus = PGASYNC_READY;
break;
case 'Z': /* backend is ready for new query */
conn->asyncStatus = PGASYNC_IDLE;
break; break;
case 'C': /* portal query command, no rows returned */ case 'I': /* empty query */
if (pqGets(cmdStatus, MAX_MESSAGE_LEN, pfin, pfdebug) == 1) /* read and throw away the closing '\0' */
if (pqGetc(&id, conn))
return;
if (id != '\0')
fprintf(stderr,
"unexpected character %c following 'I'\n", id);
if (conn->result == NULL)
conn->result = makeEmptyPGresult(conn,
PGRES_EMPTY_QUERY);
conn->asyncStatus = PGASYNC_READY;
break;
case 'N': /* notices from the backend */
if (getNotice(conn))
return;
break;
case 'P': /* synchronous (normal) portal */
if (pqGets(conn->errorMessage, ERROR_MSG_LENGTH, conn))
return;
/* We pretty much ignore this message type... */
break;
case 'T': /* row descriptions (start of query results) */
if (conn->result == NULL)
{ {
sprintf(reason, /* First 'T' in a query sequence */
"PQexec() -- query command completed, " if (getRowDescriptions(conn))
"but return message from backend cannot be read."); return;
*result_p = (PGresult *) NULL;
done = true;
} }
else else
{ {
/* A new 'T' message is treated as the start of
/* * another PGresult. (It is not clear that this
* since backend may produce more than one result * is really possible with the current backend.)
* for some commands need to poll until clear send * We stop parsing until the application accepts
* an empty query down, and keep reading out of * the current result.
* the pipe until an 'I' is received.
*/
pqPuts("Q ", pfout, pfdebug); /* send an empty query */
/*
* Increment a flag and process messages in the
* usual way because there may be async
* notifications pending. DZ - 31-8-1996
*/ */
emptiesSent++; conn->asyncStatus = PGASYNC_READY;
return;
} }
break; break;
case 'E': /* error return */ case 'D': /* ASCII data tuple */
if (pqGets(conn->errorMessage, ERROR_MSG_LENGTH, pfin, pfdebug) == 1) if (conn->result != NULL)
{ {
(void) sprintf(reason, /* Read another tuple of a normal query response */
"PQexec() -- error return detected from backend, " if (getAnotherTuple(conn, FALSE))
"but attempt to read the error message failed."); return;
} }
*result_p = (PGresult *) NULL; else
errors++;
if (emptiesSent == 0)
{ {
done = true; fprintf(stderr,
} "Backend sent D message without prior T\n");
break; /* Discard the unexpected message; good idea?? */
case 'I': conn->inStart = conn->inEnd;
{ /* empty query */ return;
/* read and throw away the closing '\0' */
int c;
if ((c = pqGetc(pfin, pfdebug)) != '\0')
{
fprintf(stderr, "error!, unexpected character %c following 'I'\n", c);
}
if (emptiesSent)
{
if (--emptiesSent == 0)
{ /* is this the last one? */
/*
* If this is the result of a portal query
* command set the command status and
* message accordingly. DZ - 31-8-1996
*/
if (!errors)
{
*result_p = makeEmptyPGresult(conn, PGRES_COMMAND_OK);
strncpy((*result_p)->cmdStatus, cmdStatus, CMDSTATUS_LEN - 1);
}
else
{
*result_p = (PGresult *) NULL;
}
done = true;
}
}
else
{
if (!errors)
{
*result_p = makeEmptyPGresult(conn, PGRES_EMPTY_QUERY);
}
else
{
*result_p = (PGresult *) NULL;
}
done = true;
}
} }
break; break;
case 'N': /* notices from the backend */ case 'B': /* Binary data tuple */
if (pqGets(reason, ERROR_MSG_LENGTH, pfin, pfdebug) == 1) if (conn->result != NULL)
{ {
sprintf(reason, /* Read another tuple of a normal query response */
"PQexec() -- Notice detected from backend, " if (getAnotherTuple(conn, TRUE))
"but attempt to read the notice failed."); return;
*result_p = (PGresult *) NULL;
done = true;
} }
else else
{
/* fprintf(stderr,
* Should we really be doing this? These notices "Backend sent B message without prior T\n");
* are not important enough for us to presume to /* Discard the unexpected message; good idea?? */
* put them on stderr. Maybe the caller should conn->inStart = conn->inEnd;
* decide whether to put them on stderr or not. return;
* BJH 96.12.27 }
*/
fprintf(stderr, "%s", reason);
break;
case 'P': /* synchronous (normal) portal */
pqGets(pname, MAX_MESSAGE_LEN, pfin, pfdebug); /* read in portal name */
break;
case 'T': /* actual row results: */
*result_p = makePGresult(conn, pname);
done = true;
break; break;
case 'D': /* copy command began successfully */ case 'G': /* Start Copy In */
*result_p = makeEmptyPGresult(conn, PGRES_COPY_IN); conn->asyncStatus = PGASYNC_COPY_IN;
done = true;
break; break;
case 'B': /* copy command began successfully */ case 'H': /* Start Copy Out */
*result_p = makeEmptyPGresult(conn, PGRES_COPY_OUT); conn->asyncStatus = PGASYNC_COPY_OUT;
done = true;
break; break;
default: default:
sprintf(reason, sprintf(conn->asyncErrorMessage,
"unknown protocol character '%c' read from backend. " "unknown protocol character '%c' read from backend. "
"(The protocol character is the first character the " "(The protocol character is the first character the "
"backend sends in response to a query it receives).\n", "backend sends in response to a query it receives).\n",
id); id);
*result_p = (PGresult *) NULL; /* Discard the unexpected message; good idea?? */
done = true; conn->inStart = conn->inEnd;
/* delete any partially constructed result */
PQclearAsyncResult(conn);
conn->asyncStatus = PGASYNC_READY;
return;
} /* switch on protocol character */ } /* switch on protocol character */
} /* if character was received */ }
} /* while not done */ /* Successfully consumed this message */
conn->inStart = conn->inCursor;
}
} }
/* /*
* PQexec * parseInput subroutine to read a 'T' (row descriptions) message.
* send a query to the backend and package up the result in a Pgresult * We build a PGresult structure containing the attribute data.
* * Returns: 0 if completed message, EOF if not enough data yet.
* if the query failed, return NULL, conn->errorMessage is set to
* a relevant message
* if query is successful, a new PGresult is returned
* the use is responsible for freeing that structure when done with it
* *
* Note that if we run out of data, we have to release the partially
* constructed PGresult, and rebuild it again next time. Fortunately,
* that shouldn't happen often, since 'T' messages usually fit in a packet.
*/ */
PGresult * static int
PQexec(PGconn *conn, const char *query) getRowDescriptions(PGconn *conn)
{ {
PGresult *result; PGresult *result;
char buffer[MAX_MESSAGE_LEN]; int nfields;
int i;
if (!conn)
return NULL;
if (!query)
{
sprintf(conn->errorMessage, "PQexec() -- query pointer is null.");
return NULL;
}
/* clear the error string */ result = makeEmptyPGresult(conn, PGRES_TUPLES_OK);
conn->errorMessage[0] = '\0';
/* check to see if the query string is too long */ /* parseInput already read the 'T' label. */
if (strlen(query) > MAX_MESSAGE_LEN) /* the next two bytes are the number of fields */
if (pqGetInt(&(result->numAttributes), 2, conn))
{ {
sprintf(conn->errorMessage, "PQexec() -- query is too long. " PQclear(result);
"Maximum length is %d\n", MAX_MESSAGE_LEN - 2); return EOF;
return NULL;
} }
nfields = result->numAttributes;
/* Don't try to send if we know there's no live connection. */ /* allocate space for the attribute descriptors */
if (conn->status != CONNECTION_OK) if (nfields > 0)
{ {
sprintf(conn->errorMessage, "PQexec() -- There is no connection " result->attDescs = (PGresAttDesc *)
"to the backend.\n"); malloc(nfields * sizeof(PGresAttDesc));
return NULL; MemSet((char *) result->attDescs, 0, nfields * sizeof(PGresAttDesc));
} }
/* the frontend-backend protocol uses 'Q' to designate queries */ /* get type info */
sprintf(buffer, "Q%s", query); for (i = 0; i < nfields; i++)
/* send the query to the backend; */
if (pqPuts(buffer, conn->Pfout, conn->Pfdebug) == 1)
{ {
(void) sprintf(conn->errorMessage, char typName[MAX_MESSAGE_LEN];
"PQexec() -- while sending query: %s\n" int adtid;
"-- fprintf to Pfout failed: errno=%d\n%s\n", int adtsize;
query, errno, strerror(errno)); int adtmod = -1;
return NULL;
if (pqGets(typName, MAX_MESSAGE_LEN, conn) ||
pqGetInt(&adtid, 4, conn) ||
pqGetInt(&adtsize, 2, conn)
#if 0 /* backend support not there yet */
|| pqGetInt(&adtmod, 2, conn)
#endif
)
{
PQclear(result);
return EOF;
}
result->attDescs[i].name = strdup(typName);
result->attDescs[i].adtid = adtid;
result->attDescs[i].adtsize = (short) adtsize;
result->attDescs[i].adtmod = (short) adtmod;
} }
process_response_from_backend(conn->Pfin, conn->Pfout, conn->Pfdebug, conn, /* Success! */
&result, conn->errorMessage); conn->result = result;
return (result); return 0;
} }
/* /*
* PQnotifies * parseInput subroutine to read a 'B' or 'D' (row data) message.
* returns a PGnotify* structure of the latest async notification * We add another tuple to the existing PGresult structure.
* that has not yet been handled * Returns: 0 if completed message, EOF if not enough data yet.
* *
* returns NULL, if there is currently * Note that if we run out of data, we have to suspend and reprocess
* no unhandled async notification from the backend * the message after more data is received. We keep a partially constructed
* * tuple in conn->curTuple, and avoid reallocating already-allocated storage.
* the CALLER is responsible for FREE'ing the structure returned
*/ */
PGnotify * static int
PQnotifies(PGconn *conn) getAnotherTuple(PGconn *conn, int binary)
{ {
Dlelem *e; int nfields = conn->result->numAttributes;
PGresAttValue *tup;
char bitmap[MAX_FIELDS]; /* the backend sends us a bitmap
* of which attributes are null */
int i;
int nbytes; /* the number of bytes in bitmap */
char bmap; /* One byte of the bitmap */
int bitmap_index; /* Its index */
int bitcnt; /* number of bits examined in current byte */
int vlen; /* length of the current field value */
if (!conn) conn->result->binary = binary;
return NULL;
if (conn->status != CONNECTION_OK) /* Allocate tuple space if first time for this data message */
return NULL; if (conn->curTuple == NULL)
/* RemHead returns NULL if list is empy */ {
e = DLRemHead(conn->notifyList); conn->curTuple = (PGresAttValue *)
if (e) malloc(nfields * sizeof(PGresAttValue));
return (PGnotify *) DLE_VAL(e); MemSet((char *) conn->curTuple, 0, nfields * sizeof(PGresAttValue));
else }
return NULL; tup = conn->curTuple;
}
/* /* Get the null-value bitmap */
* PQgetline - gets a newline-terminated string from the backend. nbytes = (nfields + BYTELEN-1) / BYTELEN;
* if (nbytes >= MAX_FIELDS)
* Chiefly here so that applications can use "COPY <rel> to stdout" {
* and read the output string. Returns a null-terminated string in s. sprintf(conn->asyncErrorMessage,
* "getAnotherTuple() -- null-values bitmap is too large\n");
* PQgetline reads up to maxlen-1 characters (like fgets(3)) but strips PQclearAsyncResult(conn);
* the terminating \n (like gets(3)). conn->asyncStatus = PGASYNC_READY;
* /* Discard the broken message */
* RETURNS: conn->inStart = conn->inEnd;
* EOF if it is detected or invalid arguments are given return EOF;
* 0 if EOL is reached (i.e., \n has been read) }
* (this is required for backward-compatibility -- this
* routine used to always return EOF or 0, assuming that
* the line ended within maxlen bytes.)
* 1 in other cases
*/
int
PQgetline(PGconn *conn, char *s, int maxlen)
{
int c = '\0';
if (!conn) if (pqGetnchar(bitmap, nbytes, conn))
return EOF; return EOF;
if (!conn->Pfin || !s || maxlen <= 1) /* Scan the fields */
return (EOF); bitmap_index = 0;
bmap = bitmap[bitmap_index];
bitcnt = 0;
for (; maxlen > 1 && for (i = 0; i < nfields; i++)
(c = pqGetc(conn->Pfin, conn->Pfdebug)) != '\n' &&
c != EOF;
--maxlen)
{ {
*s++ = c; if (!(bmap & 0200))
{
/* if the field value is absent, make it a null string */
if (tup[i].value == NULL)
tup[i].value = strdup("");
tup[i].len = NULL_LEN;
}
else
{
/* get the value length (the first four bytes are for length) */
if (pqGetInt(&vlen, 4, conn))
return EOF;
if (binary == 0)
{
vlen = vlen - 4;
}
if (vlen < 0)
vlen = 0;
if (tup[i].value == NULL)
tup[i].value = (char *) malloc(vlen + 1);
tup[i].len = vlen;
/* read in the value */
if (vlen > 0)
if (pqGetnchar((char *) (tup[i].value), vlen, conn))
return EOF;
tup[i].value[vlen] = '\0';
}
/* advance the bitmap stuff */
bitcnt++;
if (bitcnt == BYTELEN)
{
bitmap_index++;
bmap = bitmap[bitmap_index];
bitcnt = 0;
}
else
bmap <<= 1;
} }
*s = '\0';
if (c == EOF) /* Success! Store the completed tuple in the result */
{ addTuple(conn->result, tup);
return (EOF); /* error -- reached EOF before \n */ /* and reset for a new message */
} conn->curTuple = NULL;
else if (c == '\n') return 0;
{
return (0); /* done with this line */
}
return (1); /* returning a full buffer */
} }
/*
* PQputline -- sends a string to the backend.
*
* Chiefly here so that applications can use "COPY <rel> from stdin".
*
*/
void
PQputline(PGconn *conn, const char *s)
{
if (conn && (conn->Pfout))
{
(void) fputs(s, conn->Pfout);
fflush(conn->Pfout);
}
}
/* /*
* PQendcopy * PQisBusy
* called while waiting for the backend to respond with success/failure * Return TRUE if PQgetResult would block waiting for input.
* to a "copy".
*
* RETURNS:
* 0 on success
* 1 on failure
*/ */
int int
PQendcopy(PGconn *conn) PQisBusy(PGconn *conn)
{ {
FILE *pfin,
*pfdebug;
bool valid = true;
if (!conn) if (!conn)
return (int) NULL; return FALSE;
pfin = conn->Pfin;
pfdebug = conn->Pfdebug;
if (pqGetc(pfin, pfdebug) == 'C') /* Parse any available data, if our state permits. */
{ parseInput(conn);
char command[MAX_MESSAGE_LEN];
pqGets(command, MAX_MESSAGE_LEN, pfin, pfdebug); /* read command tag */
}
else
valid = false;
if (valid) /* PQgetResult will return immediately in all states except BUSY. */
return (0); return (conn->asyncStatus == PGASYNC_BUSY);
else
{
sprintf(conn->errorMessage,
"Error return detected from backend, "
"but attempt to read the message failed.");
fprintf(stderr, "resetting connection\n");
PQreset(conn);
return (1);
}
} }
/* simply send out max-length number of filler characters to fp */
static void
fill(int length, int max, char filler, FILE *fp)
{
int count;
char filltmp[2];
filltmp[0] = filler;
filltmp[1] = 0;
count = max - length;
while (count-- >= 0)
{
fprintf(fp, "%s", filltmp);
}
}
/* /*
* PQdisplayTuples() * PQgetResult
* kept for backward compatibility * Get the next PGresult produced by a query.
* Returns NULL if and only if no query work remains.
*/ */
void
PQdisplayTuples(PGresult *res,
FILE *fp, /* where to send the output */
int fillAlign, /* pad the fields with spaces */
const char *fieldSep, /* field separator */
int printHeader,/* display headers? */
int quiet
)
{
#define DEFAULT_FIELD_SEP " "
int i,
j;
int nFields;
int nTuples;
int fLength[MAX_FIELDS];
if (fieldSep == NULL) PGresult *
fieldSep = DEFAULT_FIELD_SEP; PQgetResult(PGconn *conn)
{
PGresult *res;
/* Get some useful info about the results */ if (!conn)
nFields = PQnfields(res); return NULL;
nTuples = PQntuples(res);
if (fp == NULL) /* Parse any available data, if our state permits. */
fp = stdout; parseInput(conn);
/* Zero the initial field lengths */ /* If not ready to return something, block until we are. */
for (j = 0; j < nFields; j++) while (conn->asyncStatus == PGASYNC_BUSY)
{
fLength[j] = strlen(PQfname(res, j));
}
/* Find the max length of each field in the result */
/* will be somewhat time consuming for very large results */
if (fillAlign)
{ {
for (i = 0; i < nTuples; i++) /* Wait for some more data, and load it. */
if (pqWait(TRUE, FALSE, conn) ||
pqReadData(conn) < 0)
{ {
for (j = 0; j < nFields; j++) PQclearAsyncResult(conn);
{ conn->asyncStatus = PGASYNC_IDLE;
if (PQgetlength(res, i, j) > fLength[j]) /* conn->errorMessage has been set by pqWait or pqReadData. */
fLength[j] = PQgetlength(res, i, j); return makeEmptyPGresult(conn, PGRES_FATAL_ERROR);
}
} }
/* Parse it. */
parseInput(conn);
} }
if (printHeader) /* Return the appropriate thing. */
switch (conn->asyncStatus)
{ {
/* first, print out the attribute names */ case PGASYNC_IDLE:
for (i = 0; i < nFields; i++) res = NULL; /* query is complete */
{ break;
fputs(PQfname(res, i), fp); case PGASYNC_READY:
if (fillAlign) /*
fill(strlen(PQfname(res, i)), fLength[i], ' ', fp); * conn->result is the PGresult to return, or possibly NULL
fputs(fieldSep, fp); * indicating an error.
} * conn->asyncErrorMessage holds the errorMessage to return.
fprintf(fp, "\n"); * (We keep it stashed there so that other user calls can't
* overwrite it prematurely.)
/* Underline the attribute names */ */
for (i = 0; i < nFields; i++) res = conn->result;
{ conn->result = NULL; /* handing over ownership to caller */
if (fillAlign) conn->curTuple = NULL; /* just in case */
fill(0, fLength[i], '-', fp); if (!res)
fputs(fieldSep, fp); res = makeEmptyPGresult(conn, PGRES_FATAL_ERROR);
} strcpy(conn->errorMessage, conn->asyncErrorMessage);
fprintf(fp, "\n"); /* Set the state back to BUSY, allowing parsing to proceed. */
} conn->asyncStatus = PGASYNC_BUSY;
break;
/* next, print out the instances */ case PGASYNC_COPY_IN:
for (i = 0; i < nTuples; i++) res = makeEmptyPGresult(conn, PGRES_COPY_IN);
{ break;
for (j = 0; j < nFields; j++) case PGASYNC_COPY_OUT:
{ res = makeEmptyPGresult(conn, PGRES_COPY_OUT);
fprintf(fp, "%s", PQgetvalue(res, i, j)); break;
if (fillAlign) default:
fill(strlen(PQgetvalue(res, i, j)), fLength[j], ' ', fp); sprintf(conn->errorMessage,
fputs(fieldSep, fp); "PQgetResult: Unexpected asyncStatus %d\n",
} (int) conn->asyncStatus);
fprintf(fp, "\n"); res = makeEmptyPGresult(conn, PGRES_FATAL_ERROR);
break;
} }
if (!quiet) return res;
fprintf(fp, "\nQuery returned %d row%s.\n", PQntuples(res),
(PQntuples(res) == 1) ? "" : "s");
fflush(fp);
} }
/* /*
* PQprintTuples() * PQexec
* send a query to the backend and package up the result in a PGresult
* *
* kept for backward compatibility * if the query failed, return NULL, conn->errorMessage is set to
* a relevant message
* if query is successful, a new PGresult is returned
* the user is responsible for freeing that structure when done with it
* *
*/ */
void
PQprintTuples(PGresult *res,
FILE *fout, /* output stream */
int PrintAttNames,/* print attribute names or not */
int TerseOutput, /* delimiter bars or not? */
int colWidth /* width of column, if 0, use variable
* width */
)
{
int nFields;
int nTups;
int i,
j;
char formatString[80];
char *tborder = NULL;
nFields = PQnfields(res);
nTups = PQntuples(res);
if (colWidth > 0)
{
sprintf(formatString, "%%s %%-%ds", colWidth);
}
else
sprintf(formatString, "%%s %%s");
if (nFields > 0) PGresult *
{ /* only print rows with at least 1 field. */ PQexec(PGconn *conn, const char *query)
if (!TerseOutput)
{
int width;
width = nFields * 14;
tborder = malloc(width + 1);
for (i = 0; i <= width; i++)
tborder[i] = '-';
tborder[i] = '\0';
fprintf(fout, "%s\n", tborder);
}
for (i = 0; i < nFields; i++)
{
if (PrintAttNames)
{
fprintf(fout, formatString,
TerseOutput ? "" : "|",
PQfname(res, i));
}
}
if (PrintAttNames)
{
if (TerseOutput)
fprintf(fout, "\n");
else
fprintf(fout, "|\n%s\n", tborder);
}
for (i = 0; i < nTups; i++)
{
for (j = 0; j < nFields; j++)
{
char *pval = PQgetvalue(res, i, j);
fprintf(fout, formatString,
TerseOutput ? "" : "|",
pval ? pval : "");
}
if (TerseOutput)
fprintf(fout, "\n");
else
fprintf(fout, "|\n%s\n", tborder);
}
}
}
static void
do_field(PQprintOpt *po, PGresult *res,
const int i, const int j, char *buf, const int fs_len,
char *fields[],
const int nFields, char *fieldNames[],
unsigned char fieldNotNum[], int fieldMax[],
const int fieldMaxLen, FILE *fout
)
{ {
PGresult *result;
PGresult *lastResult;
char *pval, /* Silently discard any prior query result that application didn't eat.
*p, * This is probably poor design, but it's here for backward compatibility.
*o; */
int plen; while ((result = PQgetResult(conn)) != NULL)
bool skipit;
plen = PQgetlength(res, i, j);
pval = PQgetvalue(res, i, j);
if (plen < 1 || !pval || !*pval)
{ {
if (po->align || po->expanded) if (result->resultStatus == PGRES_COPY_IN ||
skipit = true; result->resultStatus == PGRES_COPY_OUT)
else
{ {
skipit = false; PQclear(result);
goto efield; sprintf(conn->errorMessage,
"PQexec: you gotta get out of a COPY state yourself.\n");
return NULL;
} }
PQclear(result);
} }
else
skipit = false;
if (!skipit) /* OK to send the message */
{ if (! PQsendQuery(conn, query))
for (p = pval, o = buf; *p; *(o++) = *(p++)) return NULL;
{
if ((fs_len == 1 && (*p == *(po->fieldSep))) || *p == '\\' || *p == '\n')
*(o++) = '\\';
if (po->align && (*pval == 'E' || *pval == 'e' ||
!((*p >= '0' && *p <= '9') ||
*p == '.' ||
*p == 'E' ||
*p == 'e' ||
*p == ' ' ||
*p == '-')))
fieldNotNum[j] = 1;
}
*o = '\0';
if (!po->expanded && (po->align || po->html3))
{
int n = strlen(buf);
if (n > fieldMax[j]) /* For backwards compatibility, return the last result if there are
fieldMax[j] = n; * more than one.
if (!(fields[i * nFields + j] = (char *) malloc(n + 1))) */
{ lastResult = NULL;
perror("malloc"); while ((result = PQgetResult(conn)) != NULL)
exit(1); {
} if (lastResult)
strcpy(fields[i * nFields + j], buf); PQclear(lastResult);
} lastResult = result;
else
{
if (po->expanded)
{
if (po->html3)
fprintf(fout,
"<tr><td align=left><b>%s</b></td>"
"<td align=%s>%s</td></tr>\n",
fieldNames[j],
fieldNotNum[j] ? "left" : "right",
buf);
else
{
if (po->align)
fprintf(fout,
"%-*s%s %s\n",
fieldMaxLen - fs_len, fieldNames[j], po->fieldSep,
buf);
else
fprintf(fout, "%s%s%s\n", fieldNames[j], po->fieldSep, buf);
}
}
else
{
if (!po->html3)
{
fputs(buf, fout);
efield:
if ((j + 1) < nFields)
fputs(po->fieldSep, fout);
else
fputc('\n', fout);
}
}
}
} }
return lastResult;
} }
static char * /*
do_header(FILE *fout, PQprintOpt *po, const int nFields, int fieldMax[], * Attempt to request cancellation of the current operation.
char *fieldNames[], unsigned char fieldNotNum[], *
const int fs_len, PGresult *res) * The return value is TRUE if the cancel request was successfully
* dispatched, FALSE if not (in which case errorMessage is set).
* Note: successful dispatch is no guarantee that there will be any effect at
* the backend. The application must read the operation result as usual.
*/
int
PQrequestCancel(PGconn *conn)
{ {
char msg[1];
int j; /* for loop index */ if (!conn)
char *border = NULL; return FALSE;
if (po->html3) if (conn->sock < 0)
fputs("<tr>", fout);
else
{ {
int j; /* for loop index */ sprintf(conn->errorMessage,
int tot = 0; "PQrequestCancel() -- connection is not open\n");
int n = 0; return FALSE;
char *p = NULL; }
for (; n < nFields; n++)
tot += fieldMax[n] + fs_len + (po->standard ? 2 : 0);
if (po->standard)
tot += fs_len * 2 + 2;
border = malloc(tot + 1);
if (!border)
{
perror("malloc");
exit(1);
}
p = border;
if (po->standard)
{
char *fs = po->fieldSep;
while (*fs++)
*p++ = '+';
}
for (j = 0; j < nFields; j++)
{
int len;
for (len = fieldMax[j] + (po->standard ? 2 : 0); len--; *p++ = '-'); msg[0] = '\0';
if (po->standard || (j + 1) < nFields)
{
char *fs = po->fieldSep;
while (*fs++) if (send(conn->sock, msg, 1, MSG_OOB) < 0)
*p++ = '+';
}
}
*p = '\0';
if (po->standard)
fprintf(fout, "%s\n", border);
}
if (po->standard)
fputs(po->fieldSep, fout);
for (j = 0; j < nFields; j++)
{ {
char *s = PQfname(res, j); sprintf(conn->errorMessage,
"PQrequestCancel() -- couldn't send OOB data: errno=%d\n%s\n",
if (po->html3) errno, strerror(errno));
{ return FALSE;
fprintf(fout, "<th align=%s>%s</th>",
fieldNotNum[j] ? "left" : "right", fieldNames[j]);
}
else
{
int n = strlen(s);
if (n > fieldMax[j])
fieldMax[j] = n;
if (po->standard)
fprintf(fout,
fieldNotNum[j] ? " %-*s " : " %*s ",
fieldMax[j], s);
else
fprintf(fout, fieldNotNum[j] ? "%-*s" : "%*s", fieldMax[j], s);
if (po->standard || (j + 1) < nFields)
fputs(po->fieldSep, fout);
}
} }
if (po->html3)
fputs("</tr>\n", fout); return TRUE;
else
fprintf(fout, "\n%s\n", border);
return border;
} }
static void /*
output_row(FILE *fout, PQprintOpt *po, const int nFields, char *fields[], * Attempt to read a Notice response message.
unsigned char fieldNotNum[], int fieldMax[], char *border, * This is possible in several places, so we break it out as a subroutine.
const int row_index) * Entry: 'N' flag character has already been consumed.
* Exit: returns 0 if successfully consumed Notice message.
* returns EOF if not enough data.
*/
static int
getNotice(PGconn *conn)
{ {
if (pqGets(conn->errorMessage, ERROR_MSG_LENGTH, conn))
return EOF;
/*
* Should we really be doing this? These notices
* are not important enough for us to presume to
* put them on stderr. Maybe the caller should
* decide whether to put them on stderr or not.
* BJH 96.12.27
*/
fprintf(stderr, "%s", conn->errorMessage);
return 0;
}
int field_index; /* for loop index */ /*
* Attempt to read a Notify response message.
if (po->html3) * This is possible in several places, so we break it out as a subroutine.
fputs("<tr>", fout); * Entry: 'A' flag character has already been consumed.
else if (po->standard) * Exit: returns 0 if successfully consumed Notify message.
fputs(po->fieldSep, fout); * returns EOF if not enough data.
for (field_index = 0; field_index < nFields; field_index++) */
{ static int
char *p = fields[row_index * nFields + field_index]; getNotify(PGconn *conn)
{
PGnotify tempNotify;
PGnotify *newNotify;
if (po->html3) if (pqGetInt(&(tempNotify.be_pid), 4, conn))
fprintf(fout, "<td align=%s>%s</td>", return EOF;
fieldNotNum[field_index] ? "left" : "right", p ? p : ""); if (pqGets(tempNotify.relname, NAMEDATALEN, conn))
else return EOF;
{ newNotify = (PGnotify *) malloc(sizeof(PGnotify));
fprintf(fout, memcpy(newNotify, &tempNotify, sizeof(PGnotify));
fieldNotNum[field_index] ? DLAddTail(conn->notifyList, DLNewElem(newNotify));
(po->standard ? " %-*s " : "%-*s") : return 0;
(po->standard ? " %*s " : "%*s"),
fieldMax[field_index],
p ? p : "");
if (po->standard || field_index + 1 < nFields)
fputs(po->fieldSep, fout);
}
if (p)
free(p);
}
if (po->html3)
fputs("</tr>", fout);
else if (po->standard)
fprintf(fout, "\n%s", border);
fputc('\n', fout);
} }
/*
* PQnotifies
* returns a PGnotify* structure of the latest async notification
* that has not yet been handled
*
* returns NULL, if there is currently
* no unhandled async notification from the backend
*
* the CALLER is responsible for FREE'ing the structure returned
*/
PGnotify *
PQnotifies(PGconn *conn)
{
Dlelem *e;
PGnotify *event;
if (!conn)
return NULL;
/* Parse any available data to see if we can extract NOTIFY messages. */
parseInput(conn);
/* RemHead returns NULL if list is empty */
e = DLRemHead(conn->notifyList);
if (!e)
return NULL;
event = (PGnotify *) DLE_VAL(e);
DLFreeElem(e);
return event;
}
/* /*
* PQprint() * PQgetline - gets a newline-terminated string from the backend.
* *
* Format results of a query for printing. * Chiefly here so that applications can use "COPY <rel> to stdout"
* and read the output string. Returns a null-terminated string in s.
* *
* PQprintOpt is a typedef (structure) that containes * PQgetline reads up to maxlen-1 characters (like fgets(3)) but strips
* various flags and options. consult libpq-fe.h for * the terminating \n (like gets(3)).
* details
* *
* Obsoletes PQprintTuples. * RETURNS:
* EOF if it is detected or invalid arguments are given
* 0 if EOL is reached (i.e., \n has been read)
* (this is required for backward-compatibility -- this
* routine used to always return EOF or 0, assuming that
* the line ended within maxlen bytes.)
* 1 in other cases (i.e., the buffer was filled before \n is reached)
*/ */
int
void PQgetline(PGconn *conn, char *s, int maxlen)
PQprint(FILE *fout,
PGresult *res,
PQprintOpt *po
)
{ {
int nFields; int result = 1; /* return value if buffer overflows */
nFields = PQnfields(res);
if (nFields > 0)
{ /* only print rows with at least 1 field. */
int i,
j;
int nTups;
int *fieldMax = NULL; /* in case we don't use them */
unsigned char *fieldNotNum = NULL;
char *border = NULL;
char **fields = NULL;
char **fieldNames;
int fieldMaxLen = 0;
int numFieldName;
int fs_len = strlen(po->fieldSep);
int total_line_length = 0;
int usePipe = 0;
char *pagerenv;
char buf[8192 * 2 + 1];
nTups = PQntuples(res);
if (!(fieldNames = (char **) calloc(nFields, sizeof(char *))))
{
perror("calloc");
exit(1);
}
if (!(fieldNotNum = (unsigned char *) calloc(nFields, 1)))
{
perror("calloc");
exit(1);
}
if (!(fieldMax = (int *) calloc(nFields, sizeof(int))))
{
perror("calloc");
exit(1);
}
for (numFieldName = 0;
po->fieldName && po->fieldName[numFieldName];
numFieldName++)
;
for (j = 0; j < nFields; j++)
{
int len;
char *s =
(j < numFieldName && po->fieldName[j][0]) ?
po->fieldName[j] : PQfname(res, j);
fieldNames[j] = s;
len = s ? strlen(s) : 0;
fieldMax[j] = len;
len += fs_len;
if (len > fieldMaxLen)
fieldMaxLen = len;
total_line_length += len;
}
total_line_length += nFields * strlen(po->fieldSep) + 1; if (!s || maxlen <= 0)
return EOF;
if (fout == NULL) if (!conn || conn->sock < 0)
fout = stdout; {
if (po->pager && fout == stdout && *s = '\0';
isatty(fileno(stdin)) && return EOF;
isatty(fileno(stdout))) }
{
/* try to pipe to the pager program if possible */
#ifdef TIOCGWINSZ
if (ioctl(fileno(stdout), TIOCGWINSZ, &screen_size) == -1 ||
screen_size.ws_col == 0 ||
screen_size.ws_row == 0)
{
#endif
screen_size.ws_row = 24;
screen_size.ws_col = 80;
#ifdef TIOCGWINSZ
}
#endif
pagerenv = getenv("PAGER");
if (pagerenv != NULL &&
pagerenv[0] != '\0' &&
!po->html3 &&
((po->expanded &&
nTups * (nFields + 1) >= screen_size.ws_row) ||
(!po->expanded &&
nTups * (total_line_length / screen_size.ws_col + 1) *
(1 + (po->standard != 0)) >=
screen_size.ws_row -
(po->header != 0) *
(total_line_length / screen_size.ws_col + 1) * 2
- (po->header != 0) * 2 /* row count and newline */
)))
{
fout = popen(pagerenv, "w");
if (fout)
{
usePipe = 1;
pqsignal(SIGPIPE, SIG_IGN);
}
else
fout = stdout;
}
}
if (!po->expanded && (po->align || po->html3)) /* Since this is a purely synchronous routine, we don't bother to
* maintain conn->inCursor; there is no need to back up.
*/
while (maxlen > 1)
{
if (conn->inStart < conn->inEnd)
{ {
if (!(fields = (char **) calloc(nFields * (nTups + 1), sizeof(char *)))) char c = conn->inBuffer[conn->inStart++];
if (c == '\n')
{ {
perror("calloc"); result = 0; /* success exit */
exit(1); break;
} }
*s++ = c;
maxlen--;
} }
else if (po->header && !po->html3) else
{ {
if (po->expanded) /* need to load more data */
if (pqWait(TRUE, FALSE, conn) ||
pqReadData(conn) < 0)
{ {
if (po->align) result = EOF;
fprintf(fout, "%-*s%s Value\n", break;
fieldMaxLen - fs_len, "Field", po->fieldSep);
else
fprintf(fout, "%s%sValue\n", "Field", po->fieldSep);
} }
else }
{ }
int len = 0; *s = '\0';
for (j = 0; j < nFields; j++) return result;
{ }
char *s = fieldNames[j];
fputs(s, fout); /*
len += strlen(s) + fs_len; * PQputline -- sends a string to the backend.
if ((j + 1) < nFields) *
fputs(po->fieldSep, fout); * Chiefly here so that applications can use "COPY <rel> from stdin".
} */
fputc('\n', fout); void
for (len -= fs_len; len--; fputc('-', fout)); PQputline(PGconn *conn, const char *s)
fputc('\n', fout); {
} if (conn && conn->sock >= 0)
} {
if (po->expanded && po->html3) (void) pqPuts(s, conn);
{ }
if (po->caption) }
fprintf(fout, "<centre><h2>%s</h2></centre>\n", po->caption);
else /*
fprintf(fout, * PQendcopy
"<centre><h2>" * After completing the data transfer portion of a copy in/out,
"Query retrieved %d rows * %d fields" * the application must call this routine to finish the command protocol.
"</h2></centre>\n", *
nTups, nFields); * RETURNS:
} * 0 on success
for (i = 0; i < nTups; i++) * 1 on failure
{ */
if (po->expanded) int
{ PQendcopy(PGconn *conn)
if (po->html3) {
fprintf(fout, PGresult *result;
"<table %s><caption align=high>%d</caption>\n",
po->tableOpt ? po->tableOpt : "", i); if (!conn)
else return 0;
fprintf(fout, "-- RECORD %d --\n", i);
} if (conn->asyncStatus != PGASYNC_COPY_IN &&
for (j = 0; j < nFields; j++) conn->asyncStatus != PGASYNC_COPY_OUT)
do_field(po, res, i, j, buf, fs_len, fields, nFields, {
fieldNames, fieldNotNum, sprintf(conn->errorMessage,
fieldMax, fieldMaxLen, fout); "PQendcopy() -- I don't think there's a copy in progress.");
if (po->html3 && po->expanded) return 1;
fputs("</table>\n", fout); }
}
if (!po->expanded && (po->align || po->html3)) (void) pqFlush(conn); /* make sure no data is waiting to be sent */
{
if (po->html3) /* Return to active duty */
{ conn->asyncStatus = PGASYNC_BUSY;
if (po->header)
{ /* Wait for the completion response */
if (po->caption) result = PQgetResult(conn);
fprintf(fout,
"<table %s><caption align=high>%s</caption>\n", /* Expecting a successful result */
po->tableOpt ? po->tableOpt : "", if (result->resultStatus == PGRES_COMMAND_OK)
po->caption); {
else PQclear(result);
fprintf(fout, return 0;
"<table %s><caption align=high>"
"Retrieved %d rows * %d fields"
"</caption>\n",
po->tableOpt ? po->tableOpt : "", nTups, nFields);
}
else
fprintf(fout, "<table %s>", po->tableOpt ? po->tableOpt : "");
}
if (po->header)
border = do_header(fout, po, nFields, fieldMax, fieldNames,
fieldNotNum, fs_len, res);
for (i = 0; i < nTups; i++)
output_row(fout, po, nFields, fields,
fieldNotNum, fieldMax, border, i);
free(fields);
if (border)
free(border);
}
if (po->header && !po->html3)
fprintf(fout, "(%d row%s)\n\n", PQntuples(res),
(PQntuples(res) == 1) ? "" : "s");
free(fieldMax);
free(fieldNotNum);
free(fieldNames);
if (usePipe)
{
pclose(fout);
pqsignal(SIGPIPE, SIG_DFL);
}
if (po->html3 && !po->expanded)
fputs("</table>\n", fout);
} }
/* Trouble.
* The worst case is that we've lost sync with the backend entirely
* due to application screwup of the copy in/out protocol.
* To recover, reset the connection (talk about using a sledgehammer...)
*/
PQclear(result);
fprintf(stderr, "PQendcopy: resetting connection\n");
PQreset(conn);
return 1;
} }
...@@ -1491,14 +1018,15 @@ PQprint(FILE *fout, ...@@ -1491,14 +1018,15 @@ PQprint(FILE *fout,
* for varlena structures.) * for varlena structures.)
* result_type : If the result is an integer, this must be 1, * result_type : If the result is an integer, this must be 1,
* otherwise this should be 0 * otherwise this should be 0
* args : pointer to a NULL terminated arg array. * args : pointer to an array of function arguments.
* (length, if integer, and result-pointer) * (each has length, if integer, and value/pointer)
* nargs : # of arguments in args array. * nargs : # of arguments in args array.
* *
* RETURNS * RETURNS
* NULL on failure. PQerrormsg will be set. * PGresult with status = PGRES_COMMAND_OK if successful.
* "G" if there is a return value. * *actual_result_len is > 0 if there is a return value, 0 if not.
* "V" if there is no return value. * PGresult with status = PGRES_FATAL_ERROR if backend returns an error.
* NULL on communications failure. conn->errorMessage will be set.
* ---------------- * ----------------
*/ */
...@@ -1511,116 +1039,147 @@ PQfn(PGconn *conn, ...@@ -1511,116 +1039,147 @@ PQfn(PGconn *conn,
PQArgBlock *args, PQArgBlock *args,
int nargs) int nargs)
{ {
FILE *pfin, bool needInput = false;
*pfout, ExecStatusType status = PGRES_FATAL_ERROR;
*pfdebug; char id;
int id;
int i; int i;
*actual_result_len = 0;
if (!conn) if (!conn)
return NULL; return NULL;
pfin = conn->Pfin; if (conn->sock < 0 || conn->asyncStatus != PGASYNC_IDLE)
pfout = conn->Pfout; {
pfdebug = conn->Pfdebug; sprintf(conn->errorMessage, "PQfn() -- connection in wrong state\n");
return NULL;
}
/* clear the error string */ /* clear the error string */
conn->errorMessage[0] = '\0'; conn->errorMessage[0] = '\0';
pqPuts("F ", pfout, pfdebug); /* function */ if (pqPuts("F ", conn)) /* function */
pqPutInt(fnid, 4, pfout, pfdebug); /* function id */ return NULL;
pqPutInt(nargs, 4, pfout, pfdebug); /* # of args */ if (pqPutInt(fnid, 4, conn)) /* function id */
return NULL;
if (pqPutInt(nargs, 4, conn)) /* # of args */
return NULL;
for (i = 0; i < nargs; ++i) for (i = 0; i < nargs; ++i)
{ /* len.int4 + contents */ { /* len.int4 + contents */
pqPutInt(args[i].len, 4, pfout, pfdebug); if (pqPutInt(args[i].len, 4, conn))
return NULL;
if (args[i].isint) if (args[i].isint)
{ {
pqPutInt(args[i].u.integer, 4, pfout, pfdebug); if (pqPutInt(args[i].u.integer, 4, conn))
return NULL;
} }
else else
{ {
pqPutnchar((char *) args[i].u.ptr, args[i].len, pfout, pfdebug); if (pqPutnchar((char *) args[i].u.ptr, args[i].len, conn))
return NULL;
} }
} }
pqFlush(pfout, pfdebug); if (pqFlush(conn))
return NULL;
while ((id = pqGetc(pfin, pfdebug)) != 'V') for (;;)
{ {
if (id == 'E') if (needInput)
{ {
pqGets(conn->errorMessage, ERROR_MSG_LENGTH, pfin, pfdebug); /* Wait for some data to arrive (or for the channel to close) */
} if (pqWait(TRUE, FALSE, conn) ||
else if (id == 'N') pqReadData(conn) < 0)
{ break;
/* print notice and go back to processing return
values */
if (pqGets(conn->errorMessage, ERROR_MSG_LENGTH,
pfin, pfdebug) == 1)
{
sprintf(conn->errorMessage,
"Notice return detected from backend, but "
"message cannot be read");
}
else
fprintf(stderr, "%s\n", conn->errorMessage);
continue;
} }
else /* Scan the message.
sprintf(conn->errorMessage, * If we run out of data, loop around to try again.
"PQfn: expected a 'V' from the backend. Got '%c' instead", */
id); conn->inCursor = conn->inStart;
return makeEmptyPGresult(conn, PGRES_FATAL_ERROR); needInput = true;
}
id = pqGetc(pfin, pfdebug); if (pqGetc(&id, conn))
for (;;) continue;
{
int c;
/* We should see V or E response to the command,
* but might get N and/or A notices first.
* We also need to swallow the final Z before returning.
*/
switch (id) switch (id)
{ {
case 'G': /* function returned properly */ case 'V': /* function result */
pqGetInt(actual_result_len, 4, pfin, pfdebug); if (pqGetc(&id, conn))
if (result_is_int) continue;
if (id == 'G')
{ {
pqGetInt(result_buf, 4, pfin, pfdebug); /* function returned nonempty value */
if (pqGetInt(actual_result_len, 4, conn))
continue;
if (result_is_int)
{
if (pqGetInt(result_buf, 4, conn))
continue;
}
else
{
if (pqGetnchar((char *) result_buf,
*actual_result_len,
conn))
continue;
}
if (pqGetc(&id, conn)) /* get the last '0' */
continue;
} }
else if (id == '0')
{ {
pqGetnchar((char *) result_buf, *actual_result_len, /* correctly finished function result message */
pfin, pfdebug); status = PGRES_COMMAND_OK;
} }
c = pqGetc(pfin, pfdebug); /* get the last '0' */ else {
return makeEmptyPGresult(conn, PGRES_COMMAND_OK); /* The backend violates the protocol. */
case 'E':
sprintf(conn->errorMessage,
"PQfn: returned an error");
return makeEmptyPGresult(conn, PGRES_FATAL_ERROR);
case 'N':
/* print notice and go back to processing return values */
if (pqGets(conn->errorMessage, ERROR_MSG_LENGTH, pfin, pfdebug)
== 1)
{
sprintf(conn->errorMessage, sprintf(conn->errorMessage,
"Notice return detected from backend, but message " "FATAL: PQfn: protocol error: id=%x\n", id);
"cannot be read"); conn->inStart = conn->inCursor;
return makeEmptyPGresult(conn, PGRES_FATAL_ERROR);
} }
else
fprintf(stderr, "%s\n", conn->errorMessage);
/* keep iterating */
break; break;
case '0': /* no return value */ case 'E': /* error return */
return makeEmptyPGresult(conn, PGRES_COMMAND_OK); if (pqGets(conn->errorMessage, ERROR_MSG_LENGTH, conn))
continue;
status = PGRES_FATAL_ERROR;
break;
case 'A': /* notify message */
/* handle notify and go back to processing return values */
if (getNotify(conn))
continue;
break;
case 'N': /* notice */
/* handle notice and go back to processing return values */
if (getNotice(conn))
continue;
break;
case 'Z': /* backend is ready for new query */
/* consume the message and exit */
conn->inStart = conn->inCursor;
return makeEmptyPGresult(conn, status);
default: default:
/* The backend violates the protocol. */ /* The backend violates the protocol. */
sprintf(conn->errorMessage, sprintf(conn->errorMessage,
"FATAL: PQfn: protocol error: id=%x\n", id); "FATAL: PQfn: protocol error: id=%x\n", id);
conn->inStart = conn->inCursor;
return makeEmptyPGresult(conn, PGRES_FATAL_ERROR); return makeEmptyPGresult(conn, PGRES_FATAL_ERROR);
} }
/* Completed this message, keep going */
conn->inStart = conn->inCursor;
needInput = false;
} }
/* we fall out of the loop only upon failing to read data */
return makeEmptyPGresult(conn, PGRES_FATAL_ERROR);
} }
/* ====== accessor funcs for PGresult ======== */ /* ====== accessor funcs for PGresult ======== */
ExecStatusType ExecStatusType
...@@ -1628,7 +1187,7 @@ PQresultStatus(PGresult *res) ...@@ -1628,7 +1187,7 @@ PQresultStatus(PGresult *res)
{ {
if (!res) if (!res)
{ {
fprintf(stderr, "PQresultStatus() -- pointer to PQresult is null"); fprintf(stderr, "PQresultStatus() -- pointer to PQresult is null\n");
return PGRES_NONFATAL_ERROR; return PGRES_NONFATAL_ERROR;
} }
...@@ -1640,8 +1199,8 @@ PQntuples(PGresult *res) ...@@ -1640,8 +1199,8 @@ PQntuples(PGresult *res)
{ {
if (!res) if (!res)
{ {
fprintf(stderr, "PQntuples() -- pointer to PQresult is null"); fprintf(stderr, "PQntuples() -- pointer to PQresult is null\n");
return (int) NULL; return 0;
} }
return res->ntups; return res->ntups;
} }
...@@ -1651,8 +1210,8 @@ PQnfields(PGresult *res) ...@@ -1651,8 +1210,8 @@ PQnfields(PGresult *res)
{ {
if (!res) if (!res)
{ {
fprintf(stderr, "PQnfields() -- pointer to PQresult is null"); fprintf(stderr, "PQnfields() -- pointer to PQresult is null\n");
return (int) NULL; return 0;
} }
return res->numAttributes; return res->numAttributes;
} }
...@@ -1665,14 +1224,14 @@ PQfname(PGresult *res, int field_num) ...@@ -1665,14 +1224,14 @@ PQfname(PGresult *res, int field_num)
{ {
if (!res) if (!res)
{ {
fprintf(stderr, "PQfname() -- pointer to PQresult is null"); fprintf(stderr, "PQfname() -- pointer to PQresult is null\n");
return NULL; return NULL;
} }
if (field_num > (res->numAttributes - 1)) if (field_num < 0 || field_num >= res->numAttributes)
{ {
fprintf(stderr, fprintf(stderr,
"PQfname: ERROR! name of field %d(of %d) is not available", "PQfname: ERROR! field number %d is out of range 0..%d\n",
field_num, res->numAttributes - 1); field_num, res->numAttributes - 1);
return NULL; return NULL;
} }
...@@ -1695,7 +1254,7 @@ PQfnumber(PGresult *res, const char *field_name) ...@@ -1695,7 +1254,7 @@ PQfnumber(PGresult *res, const char *field_name)
if (!res) if (!res)
{ {
fprintf(stderr, "PQfnumber() -- pointer to PQresult is null"); fprintf(stderr, "PQfnumber() -- pointer to PQresult is null\n");
return -1; return -1;
} }
...@@ -1732,15 +1291,16 @@ PQftype(PGresult *res, int field_num) ...@@ -1732,15 +1291,16 @@ PQftype(PGresult *res, int field_num)
{ {
if (!res) if (!res)
{ {
fprintf(stderr, "PQftype() -- pointer to PQresult is null"); fprintf(stderr, "PQftype() -- pointer to PQresult is null\n");
return InvalidOid; return InvalidOid;
} }
if (field_num > (res->numAttributes - 1)) if (field_num < 0 || field_num >= res->numAttributes)
{ {
fprintf(stderr, fprintf(stderr,
"PQftype: ERROR! type of field %d(of %d) is not available", "PQftype: ERROR! field number %d is out of range 0..%d\n",
field_num, res->numAttributes - 1); field_num, res->numAttributes - 1);
return InvalidOid;
} }
if (res->attDescs) if (res->attDescs)
{ {
...@@ -1750,20 +1310,21 @@ PQftype(PGresult *res, int field_num) ...@@ -1750,20 +1310,21 @@ PQftype(PGresult *res, int field_num)
return InvalidOid; return InvalidOid;
} }
int2 short
PQfsize(PGresult *res, int field_num) PQfsize(PGresult *res, int field_num)
{ {
if (!res) if (!res)
{ {
fprintf(stderr, "PQfsize() -- pointer to PQresult is null"); fprintf(stderr, "PQfsize() -- pointer to PQresult is null\n");
return (int2) NULL; return 0;
} }
if (field_num > (res->numAttributes - 1)) if (field_num < 0 || field_num >= res->numAttributes)
{ {
fprintf(stderr, fprintf(stderr,
"PQfsize: ERROR! size of field %d(of %d) is not available", "PQfsize: ERROR! field number %d is out of range 0..%d\n",
field_num, res->numAttributes - 1); field_num, res->numAttributes - 1);
return 0;
} }
if (res->attDescs) if (res->attDescs)
{ {
...@@ -1773,12 +1334,36 @@ PQfsize(PGresult *res, int field_num) ...@@ -1773,12 +1334,36 @@ PQfsize(PGresult *res, int field_num)
return 0; return 0;
} }
short
PQfmod(PGresult *res, int field_num)
{
if (!res)
{
fprintf(stderr, "PQfmod() -- pointer to PQresult is null\n");
return 0;
}
if (field_num < 0 || field_num >= res->numAttributes)
{
fprintf(stderr,
"PQfmod: ERROR! field number %d is out of range 0..%d\n",
field_num, res->numAttributes - 1);
return 0;
}
if (res->attDescs)
{
return res->attDescs[field_num].adtmod;
}
else
return 0;
}
char * char *
PQcmdStatus(PGresult *res) PQcmdStatus(PGresult *res)
{ {
if (!res) if (!res)
{ {
fprintf(stderr, "PQcmdStatus() -- pointer to PQresult is null"); fprintf(stderr, "PQcmdStatus() -- pointer to PQresult is null\n");
return NULL; return NULL;
} }
return res->cmdStatus; return res->cmdStatus;
...@@ -1789,21 +1374,20 @@ PQcmdStatus(PGresult *res) ...@@ -1789,21 +1374,20 @@ PQcmdStatus(PGresult *res)
if the last command was an INSERT, return the oid string if the last command was an INSERT, return the oid string
if not, return "" if not, return ""
*/ */
static char oidStatus[32] = {0};
const char * const char *
PQoidStatus(PGresult *res) PQoidStatus(PGresult *res)
{ {
static char oidStatus[32] = {0};
if (!res) if (!res)
{ {
fprintf(stderr, "PQoidStatus () -- pointer to PQresult is null"); fprintf(stderr, "PQoidStatus () -- pointer to PQresult is null\n");
return NULL; return NULL;
} }
oidStatus[0] = 0; oidStatus[0] = 0;
if (!res->cmdStatus)
return oidStatus;
if (strncmp(res->cmdStatus, "INSERT", 6) == 0) if (strncmp(res->cmdStatus, "INSERT ", 7) == 0)
{ {
char *p = res->cmdStatus + 7; char *p = res->cmdStatus + 7;
char *e; char *e;
...@@ -1825,13 +1409,10 @@ PQcmdTuples(PGresult *res) ...@@ -1825,13 +1409,10 @@ PQcmdTuples(PGresult *res)
{ {
if (!res) if (!res)
{ {
fprintf(stderr, "PQcmdTuples () -- pointer to PQresult is null"); fprintf(stderr, "PQcmdTuples () -- pointer to PQresult is null\n");
return NULL; return NULL;
} }
if (!res->cmdStatus)
return "";
if (strncmp(res->cmdStatus, "INSERT", 6) == 0 || if (strncmp(res->cmdStatus, "INSERT", 6) == 0 ||
strncmp(res->cmdStatus, "DELETE", 6) == 0 || strncmp(res->cmdStatus, "DELETE", 6) == 0 ||
strncmp(res->cmdStatus, "UPDATE", 6) == 0) strncmp(res->cmdStatus, "UPDATE", 6) == 0)
...@@ -1840,7 +1421,7 @@ PQcmdTuples(PGresult *res) ...@@ -1840,7 +1421,7 @@ PQcmdTuples(PGresult *res)
if (*p == 0) if (*p == 0)
{ {
fprintf(stderr, "PQcmdTuples (%s) -- short input from server", fprintf(stderr, "PQcmdTuples (%s) -- bad input from server\n",
res->cmdStatus); res->cmdStatus);
return NULL; return NULL;
} }
...@@ -1851,7 +1432,7 @@ PQcmdTuples(PGresult *res) ...@@ -1851,7 +1432,7 @@ PQcmdTuples(PGresult *res)
p++; /* INSERT: skip oid */ p++; /* INSERT: skip oid */
if (*p == 0) if (*p == 0)
{ {
fprintf(stderr, "PQcmdTuples (INSERT) -- there's no # of tuples"); fprintf(stderr, "PQcmdTuples (INSERT) -- there's no # of tuples\n");
return NULL; return NULL;
} }
p++; p++;
...@@ -1878,7 +1459,7 @@ PQgetvalue(PGresult *res, int tup_num, int field_num) ...@@ -1878,7 +1459,7 @@ PQgetvalue(PGresult *res, int tup_num, int field_num)
fprintf(stderr, "PQgetvalue: pointer to PQresult is null\n"); fprintf(stderr, "PQgetvalue: pointer to PQresult is null\n");
return NULL; return NULL;
} }
else if (tup_num > (res->ntups - 1)) if (tup_num < 0 || tup_num >= res->ntups)
{ {
fprintf(stderr, fprintf(stderr,
"PQgetvalue: There is no row %d in the query results. " "PQgetvalue: There is no row %d in the query results. "
...@@ -1886,7 +1467,7 @@ PQgetvalue(PGresult *res, int tup_num, int field_num) ...@@ -1886,7 +1467,7 @@ PQgetvalue(PGresult *res, int tup_num, int field_num)
tup_num, res->ntups - 1); tup_num, res->ntups - 1);
return NULL; return NULL;
} }
else if (field_num > (res->numAttributes - 1)) if (field_num < 0 || field_num >= res->numAttributes)
{ {
fprintf(stderr, fprintf(stderr,
"PQgetvalue: There is no field %d in the query results. " "PQgetvalue: There is no field %d in the query results. "
...@@ -1910,17 +1491,25 @@ PQgetlength(PGresult *res, int tup_num, int field_num) ...@@ -1910,17 +1491,25 @@ PQgetlength(PGresult *res, int tup_num, int field_num)
{ {
if (!res) if (!res)
{ {
fprintf(stderr, "PQgetlength() -- pointer to PQresult is null"); fprintf(stderr, "PQgetlength() -- pointer to PQresult is null\n");
return (int) NULL; return 0;
} }
if (tup_num > (res->ntups - 1) || if (tup_num < 0 || tup_num >= res->ntups)
field_num > (res->numAttributes - 1)) {
fprintf(stderr,
"PQgetlength: There is no row %d in the query results. "
"The highest numbered row is %d.\n",
tup_num, res->ntups - 1);
return 0;
}
if (field_num < 0 || field_num >= res->numAttributes)
{ {
fprintf(stderr, fprintf(stderr,
"PQgetlength: ERROR! field %d(of %d) of row %d(of %d) " "PQgetlength: There is no field %d in the query results. "
"is not available", "The highest numbered field is %d.\n",
field_num, res->numAttributes - 1, tup_num, res->ntups); field_num, res->numAttributes - 1);
return 0;
} }
if (res->tuples[tup_num][field_num].len != NULL_LEN) if (res->tuples[tup_num][field_num].len != NULL_LEN)
...@@ -1937,17 +1526,24 @@ PQgetisnull(PGresult *res, int tup_num, int field_num) ...@@ -1937,17 +1526,24 @@ PQgetisnull(PGresult *res, int tup_num, int field_num)
{ {
if (!res) if (!res)
{ {
fprintf(stderr, "PQgetisnull() -- pointer to PQresult is null"); fprintf(stderr, "PQgetisnull() -- pointer to PQresult is null\n");
return (int) NULL; return 1; /* pretend it is null */
} }
if (tup_num < 0 || tup_num >= res->ntups)
if (tup_num > (res->ntups - 1) || {
field_num > (res->numAttributes - 1)) fprintf(stderr,
"PQgetisnull: There is no row %d in the query results. "
"The highest numbered row is %d.\n",
tup_num, res->ntups - 1);
return 1; /* pretend it is null */
}
if (field_num < 0 || field_num >= res->numAttributes)
{ {
fprintf(stderr, fprintf(stderr,
"PQgetisnull: ERROR! field %d(of %d) of row %d(of %d) " "PQgetisnull: There is no field %d in the query results. "
"is not available", "The highest numbered field is %d.\n",
field_num, res->numAttributes - 1, tup_num, res->ntups); field_num, res->numAttributes - 1);
return 1; /* pretend it is null */
} }
if (res->tuples[tup_num][field_num].len == NULL_LEN) if (res->tuples[tup_num][field_num].len == NULL_LEN)
......
src/interfaces/libpq/fe-misc.c
View file @ edbd5139
...@@ -5,177 +5,496 @@ ...@@ -5,177 +5,496 @@
* *
* DESCRIPTION * DESCRIPTION
* miscellaneous useful functions * miscellaneous useful functions
* these routines are analogous to the ones in libpq/pqcomm.c *
* The communication routines here are analogous to the ones in
* backend/libpq/pqcomm.c and backend/libpq/pqcomprim.c, but operate
* in the considerably different environment of the frontend libpq.
* In particular, we work with a bare nonblock-mode socket, rather than
* a stdio stream, so that we can avoid unwanted blocking of the application.
*
* XXX: MOVE DEBUG PRINTOUT TO HIGHER LEVEL. As is, block and restart
* will cause repeat printouts.
*
* We must speak the same transmitted data representations as the backend
* routines. Note that this module supports *only* network byte order
* for transmitted ints, whereas the backend modules (as of this writing)
* still handle either network or little-endian byte order.
* *
* Copyright (c) 1994, Regents of the University of California * Copyright (c) 1994, Regents of the University of California
* *
* *
* IDENTIFICATION * IDENTIFICATION
* $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-misc.c,v 1.10 1998/02/26 04:45:09 momjian Exp $ * $Header: /cvsroot/pgsql/src/interfaces/libpq/fe-misc.c,v 1.11 1998/05/06 23:51:14 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h>
#include <time.h>
#if !defined(NO_UNISTD_H)
#include <unistd.h>
#endif
#include <sys/types.h> /* for fd_set stuff */
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#include "postgres.h" #include "postgres.h"
#include "libpq-fe.h" #include "libpq-fe.h"
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
/* pqGetc: /* pqGetc:
get a character from stream f get a character from the connection
if debug is set, also echo the character fetched All these routines return 0 on success, EOF on error.
Note that for the Get routines, EOF only means there is not enough
data in the buffer, not that there is necessarily a hard error.
*/ */
int int
pqGetc(FILE *fin, FILE *debug) pqGetc(char *result, PGconn *conn)
{ {
int c; if (conn->inCursor >= conn->inEnd)
return EOF;
c = getc(fin); *result = conn->inBuffer[conn->inCursor++];
if (debug && c != EOF) if (conn->Pfdebug)
fprintf(debug, "From backend> %c\n", c); fprintf(conn->Pfdebug, "From backend> %c\n", *result);
return c; return 0;
} }
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
/* pqPutnchar: /* pqPutBytes: local routine to write N bytes to the connection,
send a string of exactly len length into stream f with buffering
*/
static int
pqPutBytes(const char *s, int nbytes, PGconn *conn)
{
int avail = conn->outBufSize - conn->outCount;
while (nbytes > avail)
{
memcpy(conn->outBuffer + conn->outCount, s, avail);
conn->outCount += avail;
s += avail;
nbytes -= avail;
if (pqFlush(conn))
return EOF;
avail = conn->outBufSize;
}
returns 1 if there was an error, 0 otherwise. memcpy(conn->outBuffer + conn->outCount, s, nbytes);
conn->outCount += nbytes;
return 0;
}
/* --------------------------------------------------------------------- */
/* pqGets:
get a null-terminated string from the connection,
and store it in a buffer of size maxlen bytes.
If the incoming string is >= maxlen bytes, all of it is read,
but the excess characters are silently discarded.
*/ */
int int
pqPutnchar(const char *s, int len, FILE *f, FILE *debug) pqGets(char *s, int maxlen, PGconn *conn)
{
/* Copy conn data to locals for faster search loop */
char *inBuffer = conn->inBuffer;
int inCursor = conn->inCursor;
int inEnd = conn->inEnd;
int slen;
while (inCursor < inEnd && inBuffer[inCursor])
inCursor++;
if (inCursor >= inEnd)
return EOF;
slen = inCursor - conn->inCursor;
if (slen < maxlen)
strcpy(s, inBuffer + conn->inCursor);
else
{
strncpy(s, inBuffer + conn->inCursor, maxlen-1);
s[maxlen-1] = '\0';
}
conn->inCursor = ++inCursor;
if (conn->Pfdebug)
fprintf(conn->Pfdebug, "From backend> \"%s\"\n", s);
return 0;
}
/* --------------------------------------------------------------------- */
int
pqPuts(const char *s, PGconn *conn)
{ {
if (debug) if (pqPutBytes(s, strlen(s)+1, conn))
fprintf(debug, "To backend> %s\n", s); return EOF;
if (conn->Pfdebug)
fprintf(conn->Pfdebug, "To backend> %s\n", s);
return (pqPutNBytes(s, len, f) == EOF ? 1 : 0); return 0;
} }
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
/* pqGetnchar: /* pqGetnchar:
get a string of exactly len bytes in buffer s (which must be 1 byte get a string of exactly len bytes in buffer s (which must be 1 byte
longer) from stream f and terminate it with a '\0'. longer) and terminate it with a '\0'.
*/ */
int int
pqGetnchar(char *s, int len, FILE *f, FILE *debug) pqGetnchar(char *s, int len, PGconn *conn)
{ {
int status; if (len < 0 || len > conn->inEnd - conn->inCursor)
return EOF;
memcpy(s, conn->inBuffer + conn->inCursor, len);
s[len] = '\0';
status = pqGetNBytes(s, len, f); conn->inCursor += len;
if (debug) if (conn->Pfdebug)
fprintf(debug, "From backend (%d)> %s\n", len, s); fprintf(conn->Pfdebug, "From backend (%d)> %s\n", len, s);
return (status == EOF ? 1 : 0); return 0;
} }
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
/* pqGets: /* pqPutnchar:
get a string of up to length len from stream f send a string of exactly len bytes
The buffer should have a terminating null, but it's not sent.
*/ */
int int
pqGets(char *s, int len, FILE *f, FILE *debug) pqPutnchar(const char *s, int len, PGconn *conn)
{ {
int status; if (pqPutBytes(s, len, conn))
return EOF;
status = pqGetString(s, len, f);
if (debug) if (conn->Pfdebug)
fprintf(debug, "From backend> \"%s\"\n", s); fprintf(conn->Pfdebug, "To backend> %s\n", s);
return (status == EOF ? 1 : 0); return 0;
} }
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
/* pgPutInt /* pgGetInt
send an integer of 2 or 4 bytes to the file stream, compensate read a 2 or 4 byte integer and convert from network byte order
for host endianness. to local byte order
returns 0 if successful, 1 otherwise
*/ */
int int
pqPutInt(const int integer, int bytes, FILE *f, FILE *debug) pqGetInt(int *result, int bytes, PGconn *conn)
{ {
int retval = 0; uint16 tmp2;
uint32 tmp4;
switch (bytes) switch (bytes)
{ {
case 2: case 2:
retval = pqPutShort(integer, f); if (conn->inCursor + 2 > conn->inEnd)
return EOF;
memcpy(&tmp2, conn->inBuffer + conn->inCursor, 2);
conn->inCursor += 2;
*result = (int) ntohs(tmp2);
break; break;
case 4: case 4:
retval = pqPutLong(integer, f); if (conn->inCursor + 4 > conn->inEnd)
return EOF;
memcpy(&tmp4, conn->inBuffer + conn->inCursor, 4);
conn->inCursor += 4;
*result = (int) ntohl(tmp4);
break; break;
default: default:
fprintf(stderr, "** int size %d not supported\n", bytes); fprintf(stderr, "** int size %d not supported\n", bytes);
retval = 1; return EOF;
} }
if (debug) if (conn->Pfdebug)
fprintf(debug, "To backend (%d#)> %d\n", bytes, integer); fprintf(conn->Pfdebug, "From backend (#%d)> %d\n", bytes, *result);
return retval; return 0;
} }
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
/* pgGetInt /* pgPutInt
read a 2 or 4 byte integer from the stream and swab it around send an integer of 2 or 4 bytes, converting from host byte order
to compensate for different endianness to network byte order.
returns 0 if successful
*/ */
int int
pqGetInt(int *result, int bytes, FILE *f, FILE *debug) pqPutInt(int value, int bytes, PGconn *conn)
{ {
int retval = 0; uint16 tmp2;
uint32 tmp4;
switch (bytes) switch (bytes)
{ {
case 2: case 2:
retval = pqGetShort(result, f); tmp2 = htons((uint16) value);
if (pqPutBytes((const char*) &tmp2, 2, conn))
return EOF;
break; break;
case 4: case 4:
retval = pqGetLong(result, f); tmp4 = htonl((uint32) value);
if (pqPutBytes((const char*) &tmp4, 4, conn))
return EOF;
break; break;
default: default:
fprintf(stderr, "** int size %d not supported\n", bytes); fprintf(stderr, "** int size %d not supported\n", bytes);
retval = 1; return EOF;
} }
if (debug) if (conn->Pfdebug)
fprintf(debug, "From backend (#%d)> %d\n", bytes, *result); fprintf(conn->Pfdebug, "To backend (%d#)> %d\n", bytes, value);
return retval; return 0;
} }
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
/* pqReadReady: is select() saying the file is ready to read?
*/
static int
pqReadReady(PGconn *conn)
{
fd_set input_mask;
struct timeval timeout;
if (conn->sock < 0)
return 0;
FD_ZERO(&input_mask);
FD_SET(conn->sock, &input_mask);
timeout.tv_sec = 0;
timeout.tv_usec = 0;
if (select(conn->sock+1, &input_mask, (fd_set *) NULL, (fd_set *) NULL,
&timeout) < 0)
{
sprintf(conn->errorMessage,
"pqReadReady() -- select() failed: errno=%d\n%s\n",
errno, strerror(errno));
return 0;
}
return FD_ISSET(conn->sock, &input_mask);
}
/* --------------------------------------------------------------------- */
/* pqReadData: read more data, if any is available
* Possible return values:
* 1: successfully loaded at least one more byte
* 0: no data is presently available, but no error detected
* -1: error detected (including EOF = connection closure);
* conn->errorMessage set
* NOTE: callers must not assume that pointers or indexes into conn->inBuffer
* remain valid across this call!
*/
int int
pqPuts(const char *s, FILE *f, FILE *debug) pqReadData(PGconn *conn)
{ {
if (pqPutString(s, f) == EOF) int nread;
return 1;
if (conn->sock < 0)
{
strcpy(conn->errorMessage, "pqReadData() -- connection not open\n");
return -1;
}
fflush(f); /* Left-justify any data in the buffer to make room */
if (conn->inStart < conn->inEnd)
{
memmove(conn->inBuffer, conn->inBuffer + conn->inStart,
conn->inEnd - conn->inStart);
conn->inEnd -= conn->inStart;
conn->inCursor -= conn->inStart;
conn->inStart = 0;
}
else
{
conn->inStart = conn->inCursor = conn->inEnd = 0;
}
/* If the buffer is fairly full, enlarge it.
* We need to be able to enlarge the buffer in case a single message
* exceeds the initial buffer size. We enlarge before filling the
* buffer entirely so as to avoid asking the kernel for a partial packet.
* The magic constant here should be at least one TCP packet.
*/
if (conn->inBufSize - conn->inEnd < 2000)
{
int newSize = conn->inBufSize * 2;
char * newBuf = (char *) realloc(conn->inBuffer, newSize);
if (newBuf)
{
conn->inBuffer = newBuf;
conn->inBufSize = newSize;
}
}
if (debug) /* OK, try to read some data */
fprintf(debug, "To backend> %s\n", s); tryAgain:
nread = recv(conn->sock, conn->inBuffer + conn->inEnd,
conn->inBufSize - conn->inEnd, 0);
if (nread < 0)
{
if (errno == EINTR)
goto tryAgain;
sprintf(conn->errorMessage,
"pqReadData() -- read() failed: errno=%d\n%s\n",
errno, strerror(errno));
return -1;
}
if (nread > 0)
{
conn->inEnd += nread;
return 1;
}
return 0; /* A return value of 0 could mean just that no data is now available,
* or it could mean EOF --- that is, the server has closed the connection.
* Since we have the socket in nonblock mode, the only way to tell the
* difference is to see if select() is saying that the file is ready.
* Grumble. Fortunately, we don't expect this path to be taken much,
* since in normal practice we should not be trying to read data unless
* the file selected for reading already.
*/
if (! pqReadReady(conn))
return 0; /* definitely no data available */
/* Still not sure that it's EOF,
* because some data could have just arrived.
*/
tryAgain2:
nread = recv(conn->sock, conn->inBuffer + conn->inEnd,
conn->inBufSize - conn->inEnd, 0);
if (nread < 0)
{
if (errno == EINTR)
goto tryAgain2;
sprintf(conn->errorMessage,
"pqReadData() -- read() failed: errno=%d\n%s\n",
errno, strerror(errno));
return -1;
}
if (nread > 0)
{
conn->inEnd += nread;
return 1;
}
/* OK, we are getting a zero read even though select() says ready.
* This means the connection has been closed. Cope.
*/
sprintf(conn->errorMessage,
"pqReadData() -- backend closed the channel unexpectedly.\n"
"\tThis probably means the backend terminated abnormally"
" before or while processing the request.\n");
conn->status = CONNECTION_BAD; /* No more connection to
* backend */
close(conn->sock);
conn->sock = -1;
return -1;
} }
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
void /* pqFlush: send any data waiting in the output buffer
pqFlush(FILE *f, FILE *debug) */
int
pqFlush(PGconn *conn)
{ {
if (f) char * ptr = conn->outBuffer;
fflush(f); int len = conn->outCount;
if (conn->sock < 0)
{
strcpy(conn->errorMessage, "pqFlush() -- connection not open\n");
return EOF;
}
if (debug) while (len > 0)
fflush(debug); {
int sent = send(conn->sock, ptr, len, 0);
if (sent < 0)
{
/* Anything except EAGAIN or EWOULDBLOCK is trouble */
switch (errno)
{
#ifdef EAGAIN
case EAGAIN:
break;
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
case EWOULDBLOCK:
break;
#endif
default:
sprintf(conn->errorMessage,
"pqFlush() -- couldn't send data: errno=%d\n%s\n",
errno, strerror(errno));
return EOF;
}
}
else
{
ptr += sent;
len -= sent;
}
if (len > 0)
{
/* We didn't send it all, wait till we can send more */
if (pqWait(FALSE, TRUE, conn))
return EOF;
}
}
conn->outCount = 0;
if (conn->Pfdebug)
fflush(conn->Pfdebug);
return 0;
} }
/* --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- */
/* pqWait: wait until we can read or write the connection socket
*/
int
pqWait(int forRead, int forWrite, PGconn *conn)
{
fd_set input_mask;
fd_set output_mask;
if (conn->sock < 0)
{
strcpy(conn->errorMessage, "pqWait() -- connection not open\n");
return EOF;
}
/* loop in case select returns EINTR */
for (;;) {
FD_ZERO(&input_mask);
FD_ZERO(&output_mask);
if (forRead)
FD_SET(conn->sock, &input_mask);
if (forWrite)
FD_SET(conn->sock, &output_mask);
if (select(conn->sock+1, &input_mask, &output_mask, (fd_set *) NULL,
(struct timeval *) NULL) < 0)
{
if (errno == EINTR)
continue;
sprintf(conn->errorMessage,
"pqWait() -- select() failed: errno=%d\n%s\n",
errno, strerror(errno));
return EOF;
}
/* On nonerror return, assume we're done */
break;
}
return 0;
}
src/interfaces/libpq/libpq-fe.h
View file @ edbd5139
...@@ -6,7 +6,7 @@ ...@@ -6,7 +6,7 @@
* *
* Copyright (c) 1994, Regents of the University of California * Copyright (c) 1994, Regents of the University of California
* *
* $Id: libpq-fe.h,v 1.28 1998/03/20 04:02:57 momjian Exp $ * $Id: libpq-fe.h,v 1.29 1998/05/06 23:51:16 momjian Exp $
* *
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
*/ */
...@@ -28,6 +28,8 @@ extern "C" ...@@ -28,6 +28,8 @@ extern "C"
#include "libpq/pqcomm.h" #include "libpq/pqcomm.h"
#include "lib/dllist.h" #include "lib/dllist.h"
/* Application-visible enum types */
typedef enum typedef enum
{ {
CONNECTION_OK, CONNECTION_OK,
...@@ -41,14 +43,13 @@ extern "C" ...@@ -41,14 +43,13 @@ extern "C"
/* anything was executed properly by the backend */ /* anything was executed properly by the backend */
PGRES_TUPLES_OK, /* a query command that returns tuples */ PGRES_TUPLES_OK, /* a query command that returns tuples */
/* was executed properly by the backend, PGresult */ /* was executed properly by the backend, PGresult */
/* contains the resulttuples */ /* contains the result tuples */
PGRES_COPY_OUT, PGRES_COPY_OUT, /* Copy Out data transfer in progress */
PGRES_COPY_IN, PGRES_COPY_IN, /* Copy In data transfer in progress */
PGRES_BAD_RESPONSE, /* an unexpected response was recv'd from PGRES_BAD_RESPONSE, /* an unexpected response was recv'd from
* the backend */ * the backend */
PGRES_NONFATAL_ERROR, PGRES_NONFATAL_ERROR,
PGRES_FATAL_ERROR PGRES_FATAL_ERROR
} ExecStatusType; } ExecStatusType;
/* string descriptions of the ExecStatusTypes */ /* string descriptions of the ExecStatusTypes */
...@@ -63,29 +64,21 @@ extern "C" ...@@ -63,29 +64,21 @@ extern "C"
#define COMMAND_LENGTH 20 #define COMMAND_LENGTH 20
#define REMARK_LENGTH 80 #define REMARK_LENGTH 80
#define PORTAL_NAME_LENGTH 16 #define PORTAL_NAME_LENGTH 16
#define CMDSTATUS_LEN 40
/* ---------------- /* PGresult and the subsidiary types PGresAttDesc, PGresAttValue
* PQArgBlock -- * represent the result of a query (or more precisely, of a single SQL
* Information (pointer to array of this structure) required * command --- a query string given to PQexec can contain multiple commands).
* for the PQfn() call. * Note we assume that a single command can return at most one tuple group,
* ---------------- * hence there is no need for multiple descriptor sets.
*/ */
typedef struct
{
int len;
int isint;
union
{
int *ptr; /* can't use void (dec compiler barfs) */
int integer;
} u;
} PQArgBlock;
typedef struct pgresAttDesc typedef struct pgresAttDesc
{ {
char *name; /* type name */ char *name; /* type name */
Oid adtid; /* type id */ Oid adtid; /* type id */
short adtsize; /* type size */ short adtsize; /* type size */
short adtmod; /* type-specific modifier info */
} PGresAttDesc; } PGresAttDesc;
/* use char* for Attribute values, /* use char* for Attribute values,
...@@ -102,6 +95,25 @@ extern "C" ...@@ -102,6 +95,25 @@ extern "C"
char *value; /* actual value */ char *value; /* actual value */
} PGresAttValue; } PGresAttValue;
struct pg_conn; /* forward reference */
typedef struct pg_result
{
int ntups;
int numAttributes;
PGresAttDesc *attDescs;
PGresAttValue **tuples; /* each PGresTuple is an array of
* PGresAttValue's */
int tupArrSize; /* size of tuples array allocated */
ExecStatusType resultStatus;
char cmdStatus[CMDSTATUS_LEN]; /* cmd status from the
* last insert query */
int binary; /* binary tuple values if binary == 1,
* otherwise ASCII */
struct pg_conn *conn; /* connection we did the query on */
} PGresult;
/* PGnotify represents the occurrence of a NOTIFY message */
typedef struct pgNotify typedef struct pgNotify
{ {
char relname[NAMEDATALEN]; /* name of relation char relname[NAMEDATALEN]; /* name of relation
...@@ -109,6 +121,18 @@ extern "C" ...@@ -109,6 +121,18 @@ extern "C"
int be_pid; /* process id of backend */ int be_pid; /* process id of backend */
} PGnotify; } PGnotify;
/* PGAsyncStatusType is private to libpq, really shouldn't be seen by users */
typedef enum
{
PGASYNC_IDLE, /* nothing's happening, dude */
PGASYNC_BUSY, /* query in progress */
PGASYNC_READY, /* result ready for PQgetResult */
PGASYNC_COPY_IN, /* Copy In data transfer in progress */
PGASYNC_COPY_OUT /* Copy Out data transfer in progress */
} PGAsyncStatusType;
/* large-object-access data ... allocated only if large-object code is used.
* Really shouldn't be visible to users */
typedef struct pgLobjfuncs typedef struct pgLobjfuncs
{ {
Oid fn_lo_open; /* OID of backend function lo_open */ Oid fn_lo_open; /* OID of backend function lo_open */
...@@ -122,54 +146,62 @@ extern "C" ...@@ -122,54 +146,62 @@ extern "C"
Oid fn_lo_write;/* OID of backend function LOwrite */ Oid fn_lo_write;/* OID of backend function LOwrite */
} PGlobjfuncs; } PGlobjfuncs;
/* PGconn encapsulates a connection to the backend */ /* PGconn encapsulates a connection to the backend.
* XXX contents of this struct really shouldn't be visible to applications
*/
typedef struct pg_conn typedef struct pg_conn
{ {
/* Saved values of connection options */
char *pghost; /* the machine on which the server is char *pghost; /* the machine on which the server is
* running */ * running */
char *pgport; /* the server's communication port */
char *pgtty; /* tty on which the backend messages is char *pgtty; /* tty on which the backend messages is
* displayed */ * displayed (NOT ACTUALLY USED???) */
char *pgport; /* the communication port with the backend */
char *pgoptions; /* options to start the backend with */ char *pgoptions; /* options to start the backend with */
char *dbName; /* database name */ char *dbName; /* database name */
ConnStatusType status; char *pguser; /* Postgres username and password, if any */
char errorMessage[ERROR_MSG_LENGTH]; char *pgpass;
/* pipes for be/fe communication */
FILE *Pfin; /* Optional file to write trace info to */
FILE *Pfout;
FILE *Pfdebug; FILE *Pfdebug;
int sock; /* The socket */
/* Status indicators */
ConnStatusType status;
PGAsyncStatusType asyncStatus;
Dllist *notifyList; /* Notify msgs not yet handed to application */
/* Connection data */
int sock; /* Unix FD for socket, -1 if not connected */
SockAddr laddr; /* Local address */ SockAddr laddr; /* Local address */
SockAddr raddr; /* Remote address */ SockAddr raddr; /* Remote address */
char salt[2];
int asyncNotifyWaiting;
Dllist *notifyList;
char *pguser; /* Postgres username of user who is
* connected */
char *pgpass;
PGlobjfuncs *lobjfuncs; /* Backend function OID's for large object
* access */
} PGconn;
#define CMDSTATUS_LEN 40
/* PGresult encapsulates the result of a query */ /* Miscellaneous stuff */
/* unlike the old libpq, we assume that queries only return in one group */ char salt[2]; /* password salt received from backend */
typedef struct pg_result PGlobjfuncs *lobjfuncs; /* private state for large-object access fns */
{
int ntups; /* Buffer for data received from backend and not yet processed */
int numAttributes; char *inBuffer; /* currently allocated buffer */
PGresAttDesc *attDescs; int inBufSize; /* allocated size of buffer */
PGresAttValue **tuples; /* each PGresTuple is an array of int inStart; /* offset to first unconsumed data in buffer */
* PGresAttValue's */ int inCursor; /* next byte to tentatively consume */
int tupArrSize; /* size of tuples array allocated */ int inEnd; /* offset to first position after avail data */
ExecStatusType resultStatus;
char cmdStatus[CMDSTATUS_LEN]; /* cmd status from the /* Buffer for data not yet sent to backend */
* last insert query */ char *outBuffer; /* currently allocated buffer */
int binary; /* binary tuple values if binary == 1, int outBufSize; /* allocated size of buffer */
* otherwise ASCII */ int outCount; /* number of chars waiting in buffer */
PGconn *conn;
} PGresult; /* Status for asynchronous result construction */
PGresult *result; /* result being constructed */
PGresAttValue *curTuple; /* tuple currently being read */
/* Message space. Placed last for code-size reasons.
* errorMessage is the message last returned to the application.
* When asyncStatus=READY, asyncErrorMessage is the pending message
* that will be put in errorMessage by PQgetResult. */
char errorMessage[ERROR_MSG_LENGTH];
char asyncErrorMessage[ERROR_MSG_LENGTH];
} PGconn;
typedef char pqbool; typedef char pqbool;
...@@ -179,7 +211,9 @@ extern "C" ...@@ -179,7 +211,9 @@ extern "C"
* defined. Pqbool, on the other hand, is unlikely to be used. * defined. Pqbool, on the other hand, is unlikely to be used.
*/ */
struct _PQprintOpt /* Print options for PQprint() */
typedef struct _PQprintOpt
{ {
pqbool header; /* print output field headings and row pqbool header; /* print output field headings and row
* count */ * count */
...@@ -193,15 +227,28 @@ extern "C" ...@@ -193,15 +227,28 @@ extern "C"
char *caption; /* HTML <caption> */ char *caption; /* HTML <caption> */
char **fieldName; /* null terminated array of repalcement char **fieldName; /* null terminated array of repalcement
* field names */ * field names */
}; } PQprintOpt;
typedef struct _PQprintOpt PQprintOpt; /* ----------------
* PQArgBlock -- structure for PQfn() arguments
* ----------------
*/
typedef struct
{
int len;
int isint;
union
{
int *ptr; /* can't use void (dec compiler barfs) */
int integer;
} u;
} PQArgBlock;
/* ---------------- /* ----------------
* Structure for the conninfo parameter definitions of PQconnectdb() * Structure for the conninfo parameter definitions of PQconnectdb()
* ---------------- * ----------------
*/ */
struct _PQconninfoOption typedef struct _PQconninfoOption
{ {
char *keyword; /* The keyword of the option */ char *keyword; /* The keyword of the option */
char *environ; /* Fallback environment variable name */ char *environ; /* Fallback environment variable name */
...@@ -215,9 +262,7 @@ extern "C" ...@@ -215,9 +262,7 @@ extern "C"
/* "D" Debug options - don't */ /* "D" Debug options - don't */
/* create a field by default */ /* create a field by default */
int dispsize; /* Field size in characters for dialog */ int dispsize; /* Field size in characters for dialog */
}; } PQconninfoOption;
typedef struct _PQconninfoOption PQconninfoOption;
/* === in fe-connect.c === */ /* === in fe-connect.c === */
/* make a new client connection to the backend */ /* make a new client connection to the backend */
...@@ -235,6 +280,7 @@ extern "C" ...@@ -235,6 +280,7 @@ extern "C"
*/ */
extern void PQreset(PGconn *conn); extern void PQreset(PGconn *conn);
/* Accessor functions for PGconn objects */
extern char *PQdb(PGconn *conn); extern char *PQdb(PGconn *conn);
extern char *PQuser(PGconn *conn); extern char *PQuser(PGconn *conn);
extern char *PQhost(PGconn *conn); extern char *PQhost(PGconn *conn);
...@@ -243,14 +289,38 @@ extern "C" ...@@ -243,14 +289,38 @@ extern "C"
extern char *PQtty(PGconn *conn); extern char *PQtty(PGconn *conn);
extern ConnStatusType PQstatus(PGconn *conn); extern ConnStatusType PQstatus(PGconn *conn);
extern char *PQerrorMessage(PGconn *conn); extern char *PQerrorMessage(PGconn *conn);
extern int PQsocket(PGconn *conn);
/* Enable/disable tracing */
extern void PQtrace(PGconn *conn, FILE *debug_port); extern void PQtrace(PGconn *conn, FILE *debug_port);
extern void PQuntrace(PGconn *conn); extern void PQuntrace(PGconn *conn);
/* === in fe-exec.c === */ /* === in fe-exec.c === */
/* Simple synchronous query */
extern PGresult *PQexec(PGconn *conn, const char *query); extern PGresult *PQexec(PGconn *conn, const char *query);
extern PGnotify *PQnotifies(PGconn *conn);
/* Interface for multiple-result or asynchronous queries */
extern int PQsendQuery(PGconn *conn, const char *query);
extern PGresult *PQgetResult(PGconn *conn);
/* Routines for managing an asychronous query */
extern int PQisBusy(PGconn *conn);
extern void PQconsumeInput(PGconn *conn);
extern int PQrequestCancel(PGconn *conn);
/* Routines for copy in/out */
extern int PQgetline(PGconn *conn, char *string, int length); extern int PQgetline(PGconn *conn, char *string, int length);
extern int PQendcopy(PGconn *conn);
extern void PQputline(PGconn *conn, const char *string); extern void PQputline(PGconn *conn, const char *string);
extern int PQendcopy(PGconn *conn);
/* Not really meant for application use: */
extern PGresult *PQfn(PGconn *conn,
int fnid,
int *result_buf,
int *result_len,
int result_is_int,
PQArgBlock *args,
int nargs);
extern void PQclearAsyncResult(PGconn *conn);
/* Accessor functions for PGresult objects */
extern ExecStatusType PQresultStatus(PGresult *res); extern ExecStatusType PQresultStatus(PGresult *res);
extern int PQntuples(PGresult *res); extern int PQntuples(PGresult *res);
extern int PQnfields(PGresult *res); extern int PQnfields(PGresult *res);
...@@ -258,84 +328,84 @@ extern "C" ...@@ -258,84 +328,84 @@ extern "C"
extern int PQfnumber(PGresult *res, const char *field_name); extern int PQfnumber(PGresult *res, const char *field_name);
extern Oid PQftype(PGresult *res, int field_num); extern Oid PQftype(PGresult *res, int field_num);
extern short PQfsize(PGresult *res, int field_num); extern short PQfsize(PGresult *res, int field_num);
extern short PQfmod(PGresult *res, int field_num);
extern char *PQcmdStatus(PGresult *res); extern char *PQcmdStatus(PGresult *res);
extern const char *PQoidStatus(PGresult *res); extern const char *PQoidStatus(PGresult *res);
extern const char *PQcmdTuples(PGresult *res); extern const char *PQcmdTuples(PGresult *res);
extern char *PQgetvalue(PGresult *res, int tup_num, int field_num); extern char *PQgetvalue(PGresult *res, int tup_num, int field_num);
extern int PQgetlength(PGresult *res, int tup_num, int field_num); extern int PQgetlength(PGresult *res, int tup_num, int field_num);
extern int PQgetisnull(PGresult *res, int tup_num, int field_num); extern int PQgetisnull(PGresult *res, int tup_num, int field_num);
/* Delete a PGresult */
extern void PQclear(PGresult *res); extern void PQclear(PGresult *res);
/* PQdisplayTuples() is a better version of PQprintTuples() */
/* === in fe-print.c === */
extern void PQprint(FILE *fout, /* output stream */
PGresult *res,
PQprintOpt *ps /* option structure */
);
/* PQdisplayTuples() is a better version of PQprintTuples(),
* but both are obsoleted by PQprint().
*/
extern void PQdisplayTuples(PGresult *res, extern void PQdisplayTuples(PGresult *res,
FILE *fp, /* where to send the FILE *fp, /* where to send the
* output */ * output */
int fillAlign, /* pad the fields with int fillAlign, /* pad the fields with
* spaces */ * spaces */
const char *fieldSep, /* field separator */ const char *fieldSep, /* field separator */
int printHeader, /* display headers? */ int printHeader, /* display headers? */
int quiet); int quiet);
extern void PQprintTuples(PGresult *res, extern void PQprintTuples(PGresult *res,
FILE *fout, /* output stream */ FILE *fout, /* output stream */
int printAttName, /* print attribute names int printAttName, /* print attribute names
* or not */ * or not */
int terseOutput, /* delimiter bars or int terseOutput, /* delimiter bars or
* not? */ * not? */
int width /* width of column, if int width /* width of column, if
* 0, use variable width */ * 0, use variable width */
); );
extern void PQprint(FILE *fout, /* output stream */
PGresult *res,
PQprintOpt *ps /* option structure */
);
extern PGnotify *PQnotifies(PGconn *conn);
extern PGresult *PQfn(PGconn *conn,
int fnid,
int *result_buf,
int *result_len,
int result_is_int,
PQArgBlock *args,
int nargs);
/* === in fe-auth.c === */ /* === in fe-auth.c === */
extern MsgType fe_getauthsvc(char *PQerrormsg); extern MsgType fe_getauthsvc(char *PQerrormsg);
extern void fe_setauthsvc(const char *name, char *PQerrormsg); extern void fe_setauthsvc(const char *name, char *PQerrormsg);
extern char *fe_getauthname(char *PQerrormsg); extern char *fe_getauthname(char *PQerrormsg);
/* === in fe-misc.c === */ /* === in fe-misc.c === */
/* pqGets and pqPuts gets and sends strings to the file stream /* "Get" and "Put" routines return 0 if successful, EOF if not.
returns 0 if successful * Note that for Get, EOF merely means the buffer is exhausted,
if debug is non-null, debugging output is sent to that stream * not that there is necessarily any error.
*/ */
extern int pqGets(char *s, int maxlen, FILE *stream, FILE *debug); extern int pqGetc(char *result, PGconn *conn);
extern int pqGetnchar(char *s, int maxlen, FILE *stream, FILE *debug); extern int pqGets(char *s, int maxlen, PGconn *conn);
extern int pqPutnchar(const char *s, int maxlen, FILE *stream, FILE *debug); extern int pqPuts(const char *s, PGconn *conn);
extern int pqPuts(const char *s, FILE *stream, FILE *debug); extern int pqGetnchar(char *s, int len, PGconn *conn);
extern int pqGetc(FILE *stream, FILE *debug); extern int pqPutnchar(const char *s, int len, PGconn *conn);
/* get a n-byte integer from the stream into result */ extern int pqGetInt(int *result, int bytes, PGconn *conn);
/* returns 0 if successful */ extern int pqPutInt(int value, int bytes, PGconn *conn);
extern int pqGetInt(int *result, int bytes, FILE *stream, FILE *debug); extern int pqReadData(PGconn *conn);
/* put a n-byte integer into the stream */ extern int pqFlush(PGconn *conn);
/* returns 0 if successful */ extern int pqWait(int forRead, int forWrite, PGconn *conn);
extern int pqPutInt(const int n, int bytes, FILE *stream, FILE *debug);
extern void pqFlush(FILE *stream, FILE *debug);
/* === in fe-lobj.c === */ /* === in fe-lobj.c === */
int lo_open(PGconn *conn, Oid lobjId, int mode); extern int lo_open(PGconn *conn, Oid lobjId, int mode);
int lo_close(PGconn *conn, int fd); extern int lo_close(PGconn *conn, int fd);
int lo_read(PGconn *conn, int fd, char *buf, int len); extern int lo_read(PGconn *conn, int fd, char *buf, int len);
int lo_write(PGconn *conn, int fd, char *buf, int len); extern int lo_write(PGconn *conn, int fd, char *buf, int len);
int lo_lseek(PGconn *conn, int fd, int offset, int whence); extern int lo_lseek(PGconn *conn, int fd, int offset, int whence);
Oid lo_creat(PGconn *conn, int mode); extern Oid lo_creat(PGconn *conn, int mode);
int lo_tell(PGconn *conn, int fd); extern int lo_tell(PGconn *conn, int fd);
int lo_unlink(PGconn *conn, Oid lobjId); extern int lo_unlink(PGconn *conn, Oid lobjId);
Oid lo_import(PGconn *conn, char *filename); extern Oid lo_import(PGconn *conn, char *filename);
int lo_export(PGconn *conn, Oid lobjId, char *filename); extern int lo_export(PGconn *conn, Oid lobjId, char *filename);
/* max length of message to send */ /* max length of message to send */
#define MAX_MESSAGE_LEN 8193 #define MAX_MESSAGE_LEN 8193
/* maximum number of fields in a tuple */ /* maximum number of fields in a tuple */
#define BYTELEN 8
#define MAX_FIELDS 512 #define MAX_FIELDS 512
/* bits in a byte */
#define BYTELEN 8
/* fall back options if they are not specified by arguments or defined /* fall back options if they are not specified by arguments or defined
by environment variables */ by environment variables */
#define DefaultHost "localhost" #define DefaultHost "localhost"
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment