database/postgres
database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-05-06 19:59:18 +03:00
Code

Bring the libpq example programs into the 21st century.

Browse Source
This commit is contained in:
Tom Lane 2003-06-22 00:29:29 +00:00
parent 21e0b7b8f2
commit e92dc1e199
8 changed files with 532 additions and 560 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

632
doc/src/sgml/libpq.sgml
View File

@ -1,5 +1,5 @@
<!-- <!--
$Header: /cvsroot/pgsql/doc/src/sgml/libpq.sgml,v 1.125 2003/06/21 21:51:30 tgl Exp $ $Header: /cvsroot/pgsql/doc/src/sgml/libpq.sgml,v 1.126 2003/06/22 00:29:29 tgl Exp $
--> -->
<chapter id="libpq"> <chapter id="libpq">
@ -3431,6 +3431,12 @@ testlibpq.o(.text+0xa4): undefined reference to `PQerrorMessage'
<sect1 id="libpq-example"> <sect1 id="libpq-example">
<title>Example Programs</title> <title>Example Programs</title>
<para>
These examples and others can be found in the
directory <filename>src/test/examples</filename> in the source code
distribution.
</para>
<example id="libpq-example-1"> <example id="libpq-example-1">
<title><application>libpq</application> Example Program 1</title> <title><application>libpq</application> Example Program 1</title>
@ -3438,128 +3444,121 @@ testlibpq.o(.text+0xa4): undefined reference to `PQerrorMessage'
/* /*
* testlibpq.c * testlibpq.c
* *
* Test the C version of libpq, the <productname>PostgreSQL</> frontend * Test the C version of LIBPQ, the POSTGRES frontend library.
* library.
*/ */
#include &lt;stdio.h&gt; #include &lt;stdio.h&gt;
#include &lt;libpq-fe.h&gt; #include &lt;stdlib.h&gt;
#include "libpq-fe.h"
void static void
exit_nicely(PGconn *conn) exit_nicely(PGconn *conn)
{ {
PQfinish(conn); PQfinish(conn);
exit(1); exit(1);
} }
main() int
main(int argc, char **argv)
{ {
char *pghost, const char *conninfo;
*pgport, PGconn *conn;
*pgoptions, PGresult *res;
*pgtty; int nFields;
char *dbName; int i,
int nFields; j;
int i,
j;
/* FILE *debug; */ /*
* If the user supplies a parameter on the command line, use it as
* the conninfo string; otherwise default to setting dbname=template1
* and using environment variables or defaults for all other connection
* parameters.
*/
if (argc &gt; 1)
conninfo = argv[1];
else
conninfo = "dbname = template1";
PGconn *conn; /* Make a connection to the database */
PGresult *res; conn = PQconnectdb(conninfo);
/* /* Check to see that the backend connection was successfully made */
* begin, by setting the parameters for a backend connection if the if (PQstatus(conn) != CONNECTION_OK)
* parameters are null, then the system will try to use reasonable {
* defaults by looking up environment variables or, failing that, fprintf(stderr, "Connection to database '%s' failed.\n", PQdb(conn));
* using hardwired constants fprintf(stderr, "%s", PQerrorMessage(conn));
*/ exit_nicely(conn);
pghost = NULL; /* host name of the backend server */ }
pgport = NULL; /* port of the backend server */
pgoptions = NULL; /* special options to start up the backend
* server */
pgtty = NULL; /* unused */
dbName = "template1";
/* make a connection to the database */ /*
conn = PQsetdb(pghost, pgport, pgoptions, pgtty, dbName); * Our test case here involves using a cursor, for which we must be
* inside a transaction block. We could do the whole thing with a
* single PQexec() of "select * from pg_database", but that's too
* trivial to make a good example.
*/
/* /* Start a transaction block */
* check to see that the backend connection was successfully made res = PQexec(conn, "BEGIN");
*/ if (PQresultStatus(res) != PGRES_COMMAND_OK)
if (PQstatus(conn) == CONNECTION_BAD) {
{ fprintf(stderr, "BEGIN command failed: %s", PQerrorMessage(conn));
fprintf(stderr, "Connection to database '%s' failed.\n", dbName); PQclear(res);
fprintf(stderr, "%s", PQerrorMessage(conn)); exit_nicely(conn);
exit_nicely(conn); }
}
/* debug = fopen("/tmp/trace.out","w"); */ /*
/* PQtrace(conn, debug); */ * Should PQclear PGresult whenever it is no longer needed to avoid
* memory leaks
*/
PQclear(res);
/* start a transaction block */ /*
res = PQexec(conn, "BEGIN"); * Fetch rows from pg_database, the system catalog of databases
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK) */
{ res = PQexec(conn, "DECLARE myportal CURSOR FOR select * from pg_database");
fprintf(stderr, "BEGIN command failed\n"); if (PQresultStatus(res) != PGRES_COMMAND_OK)
PQclear(res); {
exit_nicely(conn); fprintf(stderr, "DECLARE CURSOR failed: %s", PQerrorMessage(conn));
} PQclear(res);
exit_nicely(conn);
}
PQclear(res);
/* res = PQexec(conn, "FETCH ALL in myportal");
* should PQclear PGresult whenever it is no longer needed to avoid if (PQresultStatus(res) != PGRES_TUPLES_OK)
* memory leaks {
*/ fprintf(stderr, "FETCH ALL failed: %s", PQerrorMessage(conn));
PQclear(res); PQclear(res);
exit_nicely(conn);
}
/* /* first, print out the attribute names */
* fetch rows from the pg_database, the system catalog of nFields = PQnfields(res);
* databases for (i = 0; i &lt; nFields; i++)
*/ printf("%-15s", PQfname(res, i));
res = PQexec(conn, "DECLARE mycursor CURSOR FOR SELECT * FROM pg_database"); printf("\n\n");
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
fprintf(stderr, "DECLARE CURSOR command failed\n");
PQclear(res);
exit_nicely(conn);
}
PQclear(res);
res = PQexec(conn, "FETCH ALL in mycursor");
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK)
{
fprintf(stderr, "FETCH ALL command didn't return tuples properly\n");
PQclear(res);
exit_nicely(conn);
}
/* first, print out the attribute names */ /* next, print out the rows */
nFields = PQnfields(res); for (i = 0; i &lt; PQntuples(res); i++)
for (i = 0; i &lt; nFields; i++) {
printf("%-15s", PQfname(res, i)); for (j = 0; j &lt; nFields; j++)
printf("\n\n"); printf("%-15s", PQgetvalue(res, i, j));
printf("\n");
}
/* next, print out the rows */ PQclear(res);
for (i = 0; i &lt; PQntuples(res); i++)
{
for (j = 0; j &lt; nFields; j++)
printf("%-15s", PQgetvalue(res, i, j));
printf("\n");
}
PQclear(res);
/* close the cursor */ /* close the portal ... we don't bother to check for errors ... */
res = PQexec(conn, "CLOSE mycursor"); res = PQexec(conn, "CLOSE myportal");
PQclear(res); PQclear(res);
/* commit the transaction */ /* end the transaction */
res = PQexec(conn, "COMMIT"); res = PQexec(conn, "END");
PQclear(res); PQclear(res);
/* close the connection to the database and cleanup */ /* close the connection to the database and cleanup */
PQfinish(conn); PQfinish(conn);
/* fclose(debug); */
return 0;
return 0;
} }
</programlisting> </programlisting>
</example> </example>
@ -3570,116 +3569,133 @@ main()
<programlisting> <programlisting>
/* /*
* testlibpq2.c * testlibpq2.c
* Test of the asynchronous notification interface * Test of the asynchronous notification interface
* *
* Start this program, then from psql in another window do * Start this program, then from psql in another window do
* NOTIFY TBL2; * NOTIFY TBL2;
* Repeat four times to get this program to exit.
* *
* Or, if you want to get fancy, try this: * Or, if you want to get fancy, try this:
* Populate a database with the following: * populate a database with the following commands
* (provided in src/test/examples/testlibpq2.sql):
* *
* CREATE TABLE TBL1 (i int4); * CREATE TABLE TBL1 (i int4);
* *
* CREATE TABLE TBL2 (i int4); * CREATE TABLE TBL2 (i int4);
* *
* CREATE RULE r1 AS ON INSERT TO TBL1 DO * CREATE RULE r1 AS ON INSERT TO TBL1 DO
* (INSERT INTO TBL2 values (new.i); NOTIFY TBL2); * (INSERT INTO TBL2 VALUES (new.i); NOTIFY TBL2);
* *
* and do * and do this four times:
*
* INSERT INTO TBL1 values (10);
* *
* INSERT INTO TBL1 VALUES (10);
*/ */
#include &lt;stdio.h&gt; #include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;errno.h&gt;
#include &lt;sys/time.h&gt;
#include "libpq-fe.h" #include "libpq-fe.h"
void static void
exit_nicely(PGconn *conn) exit_nicely(PGconn *conn)
{ {
PQfinish(conn); PQfinish(conn);
exit(1); exit(1);
} }
main() int
main(int argc, char **argv)
{ {
char *pghost, const char *conninfo;
*pgport, PGconn *conn;
*pgoptions, PGresult *res;
*pgtty; PGnotify *notify;
char *dbName; int nnotifies;
int nFields;
int i,
j;
PGconn *conn; /*
PGresult *res; * If the user supplies a parameter on the command line, use it as
PGnotify *notify; * the conninfo string; otherwise default to setting dbname=template1
* and using environment variables or defaults for all other connection
* parameters.
*/
if (argc &gt; 1)
conninfo = argv[1];
else
conninfo = "dbname = template1";
/* /* Make a connection to the database */
* begin, by setting the parameters for a backend connection if the conn = PQconnectdb(conninfo);
* parameters are null, then the system will try to use reasonable
* defaults by looking up environment variables or, failing that,
* using hardwired constants
*/
pghost = NULL; /* host name of the backend server */
pgport = NULL; /* port of the backend server */
pgoptions = NULL; /* special options to start up the backend
* server */
pgtty = NULL; /* unused */
dbName = getenv("USER"); /* change this to the name of your test
* database */
/* make a connection to the database */ /* Check to see that the backend connection was successfully made */
conn = PQsetdb(pghost, pgport, pgoptions, pgtty, dbName); if (PQstatus(conn) != CONNECTION_OK)
{
fprintf(stderr, "Connection to database '%s' failed.\n", PQdb(conn));
fprintf(stderr, "%s", PQerrorMessage(conn));
exit_nicely(conn);
}
/* /*
* check to see that the backend connection was successfully made * Issue LISTEN command to enable notifications from the rule's NOTIFY.
*/ */
if (PQstatus(conn) == CONNECTION_BAD) res = PQexec(conn, "LISTEN TBL2");
{ if (PQresultStatus(res) != PGRES_COMMAND_OK)
fprintf(stderr, "Connection to database '%s' failed.\n", dbName); {
fprintf(stderr, "%s", PQerrorMessage(conn)); fprintf(stderr, "LISTEN command failed: %s", PQerrorMessage(conn));
exit_nicely(conn); PQclear(res);
} exit_nicely(conn);
}
res = PQexec(conn, "LISTEN TBL2"); /*
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK) * should PQclear PGresult whenever it is no longer needed to avoid
{ * memory leaks
fprintf(stderr, "LISTEN command failed\n"); */
PQclear(res); PQclear(res);
exit_nicely(conn);
}
/* /* Quit after four notifies are received. */
* should PQclear PGresult whenever it is no longer needed to avoid nnotifies = 0;
* memory leaks while (nnotifies &lt; 4)
*/ {
PQclear(res); /*
* Sleep until something happens on the connection. We use select(2)
* to wait for input, but you could also use poll() or similar
* facilities.
*/
int sock;
fd_set input_mask;
while (1) sock = PQsocket(conn);
{
/* if (sock &lt; 0)
* wait a little bit between checks; waiting with select() break; /* shouldn't happen */
* would be more efficient.
*/
sleep(1);
/* collect any asynchronous backend messages */
PQconsumeInput(conn);
/* check for asynchronous notify messages */
while ((notify = PQnotifies(conn)) != NULL)
{
fprintf(stderr,
"ASYNC NOTIFY of '%s' from backend pid '%d' received\n",
notify-&gt;relname, notify-&gt;be_pid);
PQfreemem(notify);
}
}
/* close the connection to the database and cleanup */ FD_ZERO(&amp;input_mask);
PQfinish(conn); FD_SET(sock, &amp;input_mask);
return 0; if (select(sock + 1, &amp;input_mask, NULL, NULL, NULL) &lt; 0)
{
fprintf(stderr, "select() failed: %s\n", strerror(errno));
exit_nicely(conn);
}
/* Now check for input */
PQconsumeInput(conn);
while ((notify = PQnotifies(conn)) != NULL)
{
fprintf(stderr,
"ASYNC NOTIFY of '%s' received from backend pid %d\n",
notify-&gt;relname, notify-&gt;be_pid);
PQfreemem(notify);
nnotifies++;
}
}
fprintf(stderr, "Done.\n");
/* close the connection to the database and cleanup */
PQfinish(conn);
return 0;
} }
</programlisting> </programlisting>
</example> </example>
@ -3689,176 +3705,158 @@ main()
<programlisting> <programlisting>
/* /*
* testlibpq3.c Test the C version of Libpq, the <productname>PostgreSQL</> frontend * testlibpq3.c
* library. tests the binary cursor interface * Test out-of-line parameters and binary I/O.
* *
* Before running this, populate a database with the following commands
* (provided in src/test/examples/testlibpq3.sql):
* *
* CREATE TABLE test1 (i int4, t text, b bytea);
* *
* populate a database by doing the following: * INSERT INTO test1 values (1, 'joe''s place', '\\000\\001\\002\\003\\004');
* INSERT INTO test1 values (2, 'ho there', '\\004\\003\\002\\001\\000');
* *
* CREATE TABLE test1 (i int4, d real, p polygon); * The expected output is:
*
* INSERT INTO test1 values (1, 3.567, polygon '(3.0, 4.0, 1.0, 2.0)');
*
* INSERT INTO test1 values (2, 89.05, polygon '(4.0, 3.0, 2.0, 1.0)');
*
* the expected output is:
*
* tuple 0: got i = (4 bytes) 1, d = (4 bytes) 3.567000, p = (4
* bytes) 2 points boundbox = (hi=3.000000/4.000000, lo =
* 1.000000,2.000000) tuple 1: got i = (4 bytes) 2, d = (4 bytes)
* 89.050003, p = (4 bytes) 2 points boundbox =
* (hi=4.000000/3.000000, lo = 2.000000,1.000000)
* *
* tuple 0: got
* i = (4 bytes) 1
* t = (11 bytes) 'joe's place'
* b = (5 bytes) \000\001\002\003\004
* *
*/ */
#include &lt;stdio.h&gt; #include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;sys/types.h&gt;
#include "libpq-fe.h" #include "libpq-fe.h"
#include "utils/geo_decls.h" /* for the POLYGON type */
void /* for ntohl/htonl */
#include &lt;netinet/in.h&gt;
#include &lt;arpa/inet.h&gt;
static void
exit_nicely(PGconn *conn) exit_nicely(PGconn *conn)
{ {
PQfinish(conn); PQfinish(conn);
exit(1); exit(1);
} }
main() int
main(int argc, char **argv)
{ {
char *pghost, const char *conninfo;
*pgport, PGconn *conn;
*pgoptions, PGresult *res;
*pgtty; const char *paramValues[1];
char *dbName; int i,
int nFields; j;
int i, int i_fnum,
j; t_fnum,
int i_fnum, b_fnum;
d_fnum,
p_fnum;
PGconn *conn;
PGresult *res;
/* /*
* begin, by setting the parameters for a backend connection if the * If the user supplies a parameter on the command line, use it as
* parameters are null, then the system will try to use reasonable * the conninfo string; otherwise default to setting dbname=template1
* defaults by looking up environment variables or, failing that, * and using environment variables or defaults for all other connection
* using hardwired constants * parameters.
*/ */
pghost = NULL; /* host name of the backend server */ if (argc &gt; 1)
pgport = NULL; /* port of the backend server */ conninfo = argv[1];
pgoptions = NULL; /* special options to start up the backend else
* server */ conninfo = "dbname = template1";
pgtty = NULL; /* unused */
dbName = getenv("USER"); /* change this to the name of your test /* Make a connection to the database */
* database */ conn = PQconnectdb(conninfo);
/* make a connection to the database */ /* Check to see that the backend connection was successfully made */
conn = PQsetdb(pghost, pgport, pgoptions, pgtty, dbName); if (PQstatus(conn) != CONNECTION_OK)
{
fprintf(stderr, "Connection to database '%s' failed.\n", PQdb(conn));
fprintf(stderr, "%s", PQerrorMessage(conn));
exit_nicely(conn);
}
/* /*
* check to see that the backend connection was successfully made * The point of this program is to illustrate use of PQexecParams()
*/ * with out-of-line parameters, as well as binary transmission of
if (PQstatus(conn) == CONNECTION_BAD) * results. By using out-of-line parameters we can avoid a lot of
{ * tedious mucking about with quoting and escaping. Notice how we
fprintf(stderr, "Connection to database '%s' failed.\n", dbName); * don't have to do anything special with the quote mark in the
fprintf(stderr, "%s", PQerrorMessage(conn)); * parameter value.
exit_nicely(conn); */
}
/* start a transaction block */ /* Here is our out-of-line parameter value */
res = PQexec(conn, "BEGIN"); paramValues[0] = "joe's place";
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK)
{
fprintf(stderr, "BEGIN command failed\n");
PQclear(res);
exit_nicely(conn);
}
/* res = PQexecParams(conn,
* should PQclear PGresult whenever it is no longer needed to avoid "SELECT * FROM test1 WHERE t = $1",
* memory leaks 1, /* one param */
*/ NULL, /* let the backend deduce param type */
PQclear(res); paramValues,
NULL, /* don't need param lengths since text */
NULL, /* default to all text params */
1); /* ask for binary results */
/* if (PQresultStatus(res) != PGRES_TUPLES_OK)
* fetch rows from the pg_database, the system catalog of {
* databases fprintf(stderr, "SELECT failed: %s", PQerrorMessage(conn));
*/ PQclear(res);
res = PQexec(conn, "DECLARE mycursor BINARY CURSOR FOR SELECT * FROM test1"); exit_nicely(conn);
if (!res || PQresultStatus(res) != PGRES_COMMAND_OK) }
{
fprintf(stderr, "DECLARE CURSOR command failed\n");
PQclear(res);
exit_nicely(conn);
}
PQclear(res);
res = PQexec(conn, "FETCH ALL in mycursor"); /* Use PQfnumber to avoid assumptions about field order in result */
if (!res || PQresultStatus(res) != PGRES_TUPLES_OK) i_fnum = PQfnumber(res, "i");
{ t_fnum = PQfnumber(res, "t");
fprintf(stderr, "FETCH ALL command didn't return tuples properly\n"); b_fnum = PQfnumber(res, "b");
PQclear(res);
exit_nicely(conn);
}
i_fnum = PQfnumber(res, "i"); for (i = 0; i &lt; PQntuples(res); i++)
d_fnum = PQfnumber(res, "d"); {
p_fnum = PQfnumber(res, "p"); char *iptr;
char *tptr;
char *bptr;
int blen;
int ival;
for (i = 0; i &lt; 3; i++) /* Get the field values (we ignore possibility they are null!) */
{ iptr = PQgetvalue(res, i, i_fnum);
printf("type[%d] = %d, size[%d] = %d\n", tptr = PQgetvalue(res, i, t_fnum);
i, PQftype(res, i), bptr = PQgetvalue(res, i, b_fnum);
i, PQfsize(res, i));
}
for (i = 0; i &lt; PQntuples(res); i++)
{
int *ival;
float *dval;
int plen;
POLYGON *pval;
/* we hard-wire this to the 3 fields we know about */ /*
ival = (int *) PQgetvalue(res, i, i_fnum); * The binary representation of INT4 is in network byte order,
dval = (float *) PQgetvalue(res, i, d_fnum); * which we'd better coerce to the local byte order.
plen = PQgetlength(res, i, p_fnum); */
ival = ntohl(*((uint32_t *) iptr));
/* /*
* plen doesn't include the length field so need to * The binary representation of TEXT is, well, text, and since
* increment by VARHDSZ * libpq was nice enough to append a zero byte to it, it'll work
*/ * just fine as a C string.
pval = (POLYGON *) malloc(plen + VARHDRSZ); *
pval-&gt;size = plen; * The binary representation of BYTEA is a bunch of bytes, which
memmove((char *) &amp;pval-&gt;npts, PQgetvalue(res, i, p_fnum), plen); * could include embedded nulls so we have to pay attention to
printf("tuple %d: got\n", i); * field length.
printf(" i = (%d bytes) %d,\n", */
PQgetlength(res, i, i_fnum), *ival); blen = PQgetlength(res, i, b_fnum);
printf(" d = (%d bytes) %f,\n",
PQgetlength(res, i, d_fnum), *dval);
printf(" p = (%d bytes) %d points \tboundbox = (hi=%f/%f, lo = %f,%f)\n",
PQgetlength(res, i, d_fnum),
pval-&gt;npts,
pval-&gt;boundbox.xh,
pval-&gt;boundbox.yh,
pval-&gt;boundbox.xl,
pval-&gt;boundbox.yl);
}
PQclear(res);
/* close the cursor */ printf("tuple %d: got\n", i);
res = PQexec(conn, "CLOSE mycursor"); printf(" i = (%d bytes) %d\n",
PQclear(res); PQgetlength(res, i, i_fnum), ival);
printf(" t = (%d bytes) '%s'\n",
PQgetlength(res, i, t_fnum), tptr);
printf(" b = (%d bytes) ", blen);
for (j = 0; j &lt; blen; j++)
printf("\\%03o", bptr[j]);
printf("\n\n");
}
/* commit the transaction */ PQclear(res);
res = PQexec(conn, "COMMIT");
PQclear(res);
/* close the connection to the database and cleanup */ /* close the connection to the database and cleanup */
PQfinish(conn); PQfinish(conn);
return 0; return 0;
} }
</programlisting> </programlisting>
</example> </example>

3
src/test/examples/Makefile
View File

@ -7,10 +7,9 @@ top_builddir = ../../..
include $(top_builddir)/src/Makefile.global include $(top_builddir)/src/Makefile.global
override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS) override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS)
LIBS += $(libpq) LDFLAGS += $(libpq)
# PROGS= testlibpq0 testlibpq1 testlibpq2 testlibpq3 testlibpq4 testlo
PROGS = testlibpq testlibpq2 testlibpq3 testlibpq4 testlo PROGS = testlibpq testlibpq2 testlibpq3 testlibpq4 testlo
all: $(PROGS) all: $(PROGS)

80
src/test/examples/testlibpq.c
View File

@ -1,10 +1,10 @@
/* /*
* testlibpq.c * testlibpq.c
*
* Test the C version of LIBPQ, the POSTGRES frontend library. * Test the C version of LIBPQ, the POSTGRES frontend library.
*
*
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include "libpq-fe.h" #include "libpq-fe.h"
static void static void
@ -15,76 +15,66 @@ exit_nicely(PGconn *conn)
} }
int int
main() main(int argc, char **argv)
{ {
char *pghost, const char *conninfo;
*pgport, PGconn *conn;
*pgoptions, PGresult *res;
*pgtty;
char *dbName;
int nFields; int nFields;
int i, int i,
j; j;
#ifdef DEBUG
FILE *debug;
#endif /* DEBUG */
PGconn *conn;
PGresult *res;
/* /*
* begin, by setting the parameters for a backend connection if the * If the user supplies a parameter on the command line, use it as
* parameters are null, then the system will try to use reasonable * the conninfo string; otherwise default to setting dbname=template1
* defaults by looking up environment variables or, failing that, * and using environment variables or defaults for all other connection
* using hardwired constants * parameters.
*/ */
pghost = NULL; /* host name of the backend server */ if (argc > 1)
pgport = NULL; /* port of the backend server */ conninfo = argv[1];
pgoptions = NULL; /* special options to start up the backend else
* server */ conninfo = "dbname = template1";
pgtty = NULL; /* debugging tty for the backend server */
dbName = "template1";
/* make a connection to the database */ /* Make a connection to the database */
conn = PQsetdb(pghost, pgport, pgoptions, pgtty, dbName); conn = PQconnectdb(conninfo);
/* 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_OK)
{ {
fprintf(stderr, "Connection to database '%s' failed.\n", dbName); fprintf(stderr, "Connection to database '%s' failed.\n", PQdb(conn));
fprintf(stderr, "%s", PQerrorMessage(conn)); fprintf(stderr, "%s", PQerrorMessage(conn));
exit_nicely(conn); exit_nicely(conn);
} }
#ifdef DEBUG /*
debug = fopen("/tmp/trace.out", "w"); * Our test case here involves using a cursor, for which we must be
PQtrace(conn, debug); * inside a transaction block. We could do the whole thing with a
#endif /* DEBUG */ * single PQexec() of "select * from pg_database", but that's too
* trivial to make a good example.
*/
/* 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 failed\n"); fprintf(stderr, "BEGIN command failed: %s", PQerrorMessage(conn));
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
/* /*
* should PQclear PGresult whenever it is no longer needed to avoid * Should PQclear PGresult whenever it is no longer needed to avoid
* memory leaks * memory leaks
*/ */
PQclear(res); PQclear(res);
/* /*
* fetch instances from the pg_database, the system catalog of * Fetch rows from pg_database, the system catalog of databases
* 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 failed\n"); fprintf(stderr, "DECLARE CURSOR failed: %s", PQerrorMessage(conn));
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
@ -93,7 +83,7 @@ main()
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 properly\n"); fprintf(stderr, "FETCH ALL failed: %s", PQerrorMessage(conn));
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
@ -104,7 +94,7 @@ main()
printf("%-15s", PQfname(res, i)); printf("%-15s", PQfname(res, i));
printf("\n\n"); printf("\n\n");
/* next, print out the instances */ /* next, print out the rows */
for (i = 0; i < PQntuples(res); i++) for (i = 0; i < PQntuples(res); i++)
{ {
for (j = 0; j < nFields; j++) for (j = 0; j < nFields; j++)
@ -114,7 +104,7 @@ main()
PQclear(res); PQclear(res);
/* close the portal */ /* close the portal ... we don't bother to check for errors ... */
res = PQexec(conn, "CLOSE myportal"); res = PQexec(conn, "CLOSE myportal");
PQclear(res); PQclear(res);
@ -125,9 +115,5 @@ main()
/* close the connection to the database and cleanup */ /* close the connection to the database and cleanup */
PQfinish(conn); PQfinish(conn);
#ifdef DEBUG
fclose(debug);
#endif /* DEBUG */
return 0; return 0;
} }

127
src/test/examples/testlibpq2.c
View File

@ -2,24 +2,30 @@
* testlibpq2.c * testlibpq2.c
* Test of the asynchronous notification interface * Test of the asynchronous notification interface
* *
populate a database with the following: * Start this program, then from psql in another window do
* NOTIFY TBL2;
CREATE TABLE TBL1 (i int4); * Repeat four times to get this program to exit.
CREATE TABLE TBL2 (i int4);
CREATE RULE r1 AS ON INSERT TO TBL1 DO [INSERT INTO TBL2 values (new.i); NOTIFY TBL2];
* Then start up this program
* After the program has begun, do
INSERT INTO TBL1 values (10);
* *
* Or, if you want to get fancy, try this:
* populate a database with the following commands
* (provided in src/test/examples/testlibpq2.sql):
* *
* CREATE TABLE TBL1 (i int4);
*
* CREATE TABLE TBL2 (i int4);
*
* CREATE RULE r1 AS ON INSERT TO TBL1 DO
* (INSERT INTO TBL2 VALUES (new.i); NOTIFY TBL2);
*
* and do this four times:
*
* INSERT INTO TBL1 VALUES (10);
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/time.h>
#include "libpq-fe.h" #include "libpq-fe.h"
static void static void
@ -30,51 +36,43 @@ exit_nicely(PGconn *conn)
} }
int int
main() main(int argc, char **argv)
{ {
char *pghost, const char *conninfo;
*pgport,
*pgoptions,
*pgtty;
char *dbName;
/*
* int nFields; int i, j;
*/
PGconn *conn; PGconn *conn;
PGresult *res; PGresult *res;
PGnotify *notify; PGnotify *notify;
int nnotifies;
/* /*
* begin, by setting the parameters for a backend connection if the * If the user supplies a parameter on the command line, use it as
* parameters are null, then the system will try to use reasonable * the conninfo string; otherwise default to setting dbname=template1
* defaults by looking up environment variables or, failing that, * and using environment variables or defaults for all other connection
* using hardwired constants * parameters.
*/ */
pghost = NULL; /* host name of the backend server */ if (argc > 1)
pgport = NULL; /* port of the backend server */ conninfo = argv[1];
pgoptions = NULL; /* special options to start up the backend else
* server */ conninfo = "dbname = template1";
pgtty = NULL; /* debugging tty for the backend server */
dbName = getenv("USER"); /* change this to the name of your test
* database */
/* make a connection to the database */ /* Make a connection to the database */
conn = PQsetdb(pghost, pgport, pgoptions, pgtty, dbName); conn = PQconnectdb(conninfo);
/* 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_OK)
{ {
fprintf(stderr, "Connection to database '%s' failed.\n", dbName); fprintf(stderr, "Connection to database '%s' failed.\n", PQdb(conn));
fprintf(stderr, "%s", PQerrorMessage(conn)); fprintf(stderr, "%s", PQerrorMessage(conn));
exit_nicely(conn); exit_nicely(conn);
} }
/*
* Issue LISTEN command to enable notifications from the rule's NOTIFY.
*/
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 failed\n"); fprintf(stderr, "LISTEN command failed: %s", PQerrorMessage(conn));
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
@ -85,27 +83,48 @@ main()
*/ */
PQclear(res); PQclear(res);
while (1) /* Quit after four notifies are received. */
nnotifies = 0;
while (nnotifies < 4)
{ {
/* async notification only come back as a result of a query */ /*
/* we can send empty queries */ * Sleep until something happens on the connection. We use select(2)
res = PQexec(conn, " "); * to wait for input, but you could also use poll() or similar
/* printf("res->status = %s\n", PQresStatus(PQresultStatus(res))); */ * facilities.
/* check for asynchronous returns */ */
notify = PQnotifies(conn); int sock;
if (notify) fd_set input_mask;
sock = PQsocket(conn);
if (sock < 0)
break; /* shouldn't happen */
FD_ZERO(&input_mask);
FD_SET(sock, &input_mask);
if (select(sock + 1, &input_mask, NULL, NULL, NULL) < 0)
{
fprintf(stderr, "select() failed: %s\n", strerror(errno));
exit_nicely(conn);
}
/* Now check for input */
PQconsumeInput(conn);
while ((notify = PQnotifies(conn)) != NULL)
{ {
fprintf(stderr, fprintf(stderr,
"ASYNC NOTIFY of '%s' from backend pid '%d' received\n", "ASYNC NOTIFY of '%s' received from backend pid %d\n",
notify->relname, notify->be_pid); notify->relname, notify->be_pid);
PQfreemem(notify); PQfreemem(notify);
break; nnotifies++;
} }
PQclear(res);
} }
fprintf(stderr, "Done.\n");
/* close the connection to the database and cleanup */ /* close the connection to the database and cleanup */
PQfinish(conn); PQfinish(conn);
return 0; /* Though PQfinish(conn1) has called
* exit(1) */ return 0;
} }

3
src/test/examples/testlibpq2.sql
View File

@ -2,4 +2,5 @@ CREATE TABLE TBL1 (i int4);
CREATE TABLE TBL2 (i int4); CREATE TABLE TBL2 (i int4);
CREATE RULE r1 AS ON INSERT TO TBL1 DO [INSERT INTO TBL2 values (new.i); NOTIFY TBL2]; CREATE RULE r1 AS ON INSERT TO TBL1 DO
(INSERT INTO TBL2 VALUES (new.i); NOTIFY TBL2);

235
src/test/examples/testlibpq3.c
View File

@ -1,34 +1,33 @@
/* /*
* testlibpq3.c * testlibpq3.c
* Test the C version of LIBPQ, the POSTGRES frontend library. * Test out-of-line parameters and binary I/O.
* tests the binary cursor interface
* *
* Before running this, populate a database with the following commands
* (provided in src/test/examples/testlibpq3.sql):
* *
* CREATE TABLE test1 (i int4, t text, b bytea);
* *
populate a database by doing the following: * INSERT INTO test1 values (1, 'joe''s place', '\\000\\001\\002\\003\\004');
* INSERT INTO test1 values (2, 'ho there', '\\004\\003\\002\\001\\000');
CREATE TABLE test1 (i int4, d float4, p polygon); *
* The expected output is:
INSERT INTO test1 values (1, 3.567, '(3.0, 4.0, 1.0, 2.0)'::polygon); *
* tuple 0: got
INSERT INTO test1 values (2, 89.05, '(4.0, 3.0, 2.0, 1.0)'::polygon); * i = (4 bytes) 1
* t = (11 bytes) 'joe's place'
the expected output is: * b = (5 bytes) \000\001\002\003\004
tuple 0: got
i = (4 bytes) 1,
d = (4 bytes) 3.567000,
p = (4 bytes) 2 points boundbox = (hi=3.000000/4.000000, lo = 1.000000,2.000000)
tuple 1: got
i = (4 bytes) 2,
d = (4 bytes) 89.050003,
p = (4 bytes) 2 points boundbox = (hi=4.000000/3.000000, lo = 2.000000,1.000000)
* *
*/ */
#include "postgres.h" /* -> "c.h" -> int16, in access/attnum.h */ #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include "libpq-fe.h" #include "libpq-fe.h"
#include "utils/geo_decls.h" /* for the POLYGON type */
/* for ntohl/htonl */
#include <netinet/in.h>
#include <arpa/inet.h>
static void static void
exit_nicely(PGconn *conn) exit_nicely(PGconn *conn)
@ -38,146 +37,118 @@ exit_nicely(PGconn *conn)
} }
int int
main() main(int argc, char **argv)
{ {
char *pghost, const char *conninfo;
*pgport,
*pgoptions,
*pgtty;
char *dbName;
/*
* int nFields; int i, j;
*/
int i;
int i_fnum,
d_fnum,
p_fnum;
PGconn *conn; PGconn *conn;
PGresult *res; PGresult *res;
const char *paramValues[1];
int i,
j;
int i_fnum,
t_fnum,
b_fnum;
/* /*
* begin, by setting the parameters for a backend connection if the * If the user supplies a parameter on the command line, use it as
* parameters are null, then the system will try to use reasonable * the conninfo string; otherwise default to setting dbname=template1
* defaults by looking up environment variables or, failing that, * and using environment variables or defaults for all other connection
* using hardwired constants * parameters.
*/ */
pghost = NULL; /* host name of the backend server */ if (argc > 1)
pgport = NULL; /* port of the backend server */ conninfo = argv[1];
pgoptions = NULL; /* special options to start up the backend else
* server */ conninfo = "dbname = template1";
pgtty = NULL; /* debugging tty for the backend server */
dbName = getenv("USER"); /* change this to the name of your test /* Make a connection to the database */
* database */ conn = PQconnectdb(conninfo);
/* make a connection to the database */ /* Check to see that the backend connection was successfully made */
conn = PQsetdb(pghost, pgport, pgoptions, pgtty, dbName); if (PQstatus(conn) != CONNECTION_OK)
/* check to see that the backend connection was successfully made */
if (PQstatus(conn) == CONNECTION_BAD)
{ {
fprintf(stderr, "Connection to database '%s' failed.\n", dbName); fprintf(stderr, "Connection to database '%s' failed.\n", PQdb(conn));
fprintf(stderr, "%s", PQerrorMessage(conn)); fprintf(stderr, "%s", PQerrorMessage(conn));
exit_nicely(conn); exit_nicely(conn);
} }
/* start a transaction block */ /*
res = PQexec(conn, "BEGIN"); * The point of this program is to illustrate use of PQexecParams()
if (PQresultStatus(res) != PGRES_COMMAND_OK) * with out-of-line parameters, as well as binary transmission of
* results. By using out-of-line parameters we can avoid a lot of
* tedious mucking about with quoting and escaping. Notice how we
* don't have to do anything special with the quote mark in the
* parameter value.
*/
/* Here is our out-of-line parameter value */
paramValues[0] = "joe's place";
res = PQexecParams(conn,
"SELECT * FROM test1 WHERE t = $1",
1, /* one param */
NULL, /* let the backend deduce param type */
paramValues,
NULL, /* don't need param lengths since text */
NULL, /* default to all text params */
1); /* ask for binary results */
if (PQresultStatus(res) != PGRES_TUPLES_OK)
{ {
fprintf(stderr, "BEGIN command failed\n"); fprintf(stderr, "SELECT failed: %s", PQerrorMessage(conn));
PQclear(res); PQclear(res);
exit_nicely(conn); exit_nicely(conn);
} }
/* /* Use PQfnumber to avoid assumptions about field order in result */
* should PQclear PGresult whenever it is no longer needed to avoid
* memory leaks
*/
PQclear(res);
/*
* fetch instances from the pg_database, the system catalog of
* databases
*/
res = PQexec(conn, "DECLARE mycursor BINARY CURSOR FOR select * from test1");
if (res == NULL ||
PQresultStatus(res) != PGRES_COMMAND_OK)
{
fprintf(stderr, "DECLARE CURSOR command failed\n");
if (res)
PQclear(res);
exit_nicely(conn);
}
PQclear(res);
res = PQexec(conn, "FETCH ALL in mycursor");
if (res == NULL ||
PQresultStatus(res) != PGRES_TUPLES_OK)
{
fprintf(stderr, "FETCH ALL command didn't return tuples properly\n");
if (res)
PQclear(res);
exit_nicely(conn);
}
i_fnum = PQfnumber(res, "i"); i_fnum = PQfnumber(res, "i");
d_fnum = PQfnumber(res, "d"); t_fnum = PQfnumber(res, "t");
p_fnum = PQfnumber(res, "p"); b_fnum = PQfnumber(res, "b");
for (i = 0; i < 3; i++)
{
printf("type[%d] = %d, size[%d] = %d\n",
i, PQftype(res, i),
i, PQfsize(res, i));
}
for (i = 0; i < PQntuples(res); i++) for (i = 0; i < PQntuples(res); i++)
{ {
int *ival; char *iptr;
float *dval; char *tptr;
int plen; char *bptr;
POLYGON *pval; int blen;
int ival;
/* we hard-wire this to the 3 fields we know about */ /* Get the field values (we ignore possibility they are null!) */
ival = (int *) PQgetvalue(res, i, i_fnum); iptr = PQgetvalue(res, i, i_fnum);
dval = (float *) PQgetvalue(res, i, d_fnum); tptr = PQgetvalue(res, i, t_fnum);
plen = PQgetlength(res, i, p_fnum); bptr = PQgetvalue(res, i, b_fnum);
/* /*
* plen doesn't include the length field so need to increment by * The binary representation of INT4 is in network byte order,
* VARHDSZ * which we'd better coerce to the local byte order.
*/ */
pval = (POLYGON *) malloc(plen + VARHDRSZ); ival = ntohl(*((uint32_t *) iptr));
pval->size = plen;
memmove((char *) &pval->npts, PQgetvalue(res, i, p_fnum), plen); /*
* The binary representation of TEXT is, well, text, and since
* libpq was nice enough to append a zero byte to it, it'll work
* just fine as a C string.
*
* The binary representation of BYTEA is a bunch of bytes, which
* could include embedded nulls so we have to pay attention to
* field length.
*/
blen = PQgetlength(res, i, b_fnum);
printf("tuple %d: got\n", i); printf("tuple %d: got\n", i);
printf(" i = (%d bytes) %d,\n", printf(" i = (%d bytes) %d\n",
PQgetlength(res, i, i_fnum), *ival); PQgetlength(res, i, i_fnum), ival);
printf(" d = (%d bytes) %f,\n", printf(" t = (%d bytes) '%s'\n",
PQgetlength(res, i, d_fnum), *dval); PQgetlength(res, i, t_fnum), tptr);
printf(" p = (%d bytes) %d points \tboundbox = (hi=%f/%f, lo = %f,%f)\n", printf(" b = (%d bytes) ", blen);
PQgetlength(res, i, d_fnum), for (j = 0; j < blen; j++)
pval->npts, printf("\\%03o", bptr[j]);
pval->boundbox.high.x, printf("\n\n");
pval->boundbox.high.y,
pval->boundbox.low.x,
pval->boundbox.low.y);
} }
PQclear(res); PQclear(res);
/* close the portal */
res = PQexec(conn, "CLOSE mycursor");
PQclear(res);
/* end the transaction */
res = PQexec(conn, "END");
PQclear(res);
/* close the connection to the database and cleanup */ /* close the connection to the database and cleanup */
PQfinish(conn); PQfinish(conn);
return 0; /* Though PQfinish(conn1) has called
* exit(1) */ return 0;
} }

8
src/test/examples/testlibpq3.sql
View File

@ -1,6 +1,4 @@
CREATE TABLE test1 (i int4, d float4, p polygon); CREATE TABLE test1 (i int4, t text, b bytea);
INSERT INTO test1 values (1, 3.567, '(3.0, 4.0, 1.0, 2.0)'::polygon);
INSERT INTO test1 values (2, 89.05, '(4.0, 3.0, 2.0, 1.0)'::polygon);
INSERT INTO test1 values (1, 'joe''s place', '\\000\\001\\002\\003\\004');
INSERT INTO test1 values (2, 'ho there', '\\004\\003\\002\\001\\000');

4
src/test/examples/testlibpq4.c
View File

@ -1,11 +1,11 @@
/* /*
* testlibpq4.c * testlibpq4.c
* this test programs shows to use LIBPQ to make multiple backend * this test program shows to use LIBPQ to make multiple backend
* connections * connections
* *
*
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include "libpq-fe.h" #include "libpq-fe.h"
static void static void