database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-27 12:41:57 +03:00
Code Activity

Add pginterface into main tree, called pgeasy.

Browse Source
This commit is contained in:
Bruce Momjian
1999-10-11 17:47:02 +00:00
parent 6da92d94bc
commit 676404d5dc
19 changed files with 144 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
contrib/README
View File

@ -50,14 +50,6 @@ mSQL-interface -
noupdate -
trigger to prevent updates on single columns
plpgsql -
Postgres procedural language
by Jan Wieck <jwieck@debis.com>
pginterface -
A crude C/4GL
by Bruce Momjian <root@candle.pha.pa.us>
soundex -
Prototype for soundex function

2
contrib/findoidjoins/README
View File

@ -6,7 +6,7 @@ and the tables they join to. CAUTION: it is ver-r-r-y slow on a large
database, or even a not-so-large one. We don't really recommend running
it on anything but an empty database.
It requires pgsql/contrib/pginterface to be compiled first.
Uses pgeasy library.
Run on an empty database, it returns the system join relationships (shown
below for 6.5). Note that unexpected matches may indicate bogus entries

32
contrib/pginterface/Makefile
View File

@ -1,32 +0,0 @@
#
# Makefile
#
#
PGINTERFACE = pginterface.o halt.o
TARGET = pginsert pgwordcount pgnulltest
CFLAGS = -g -Wall -I. -I../../src/interfaces/libpq -I/usr/local/pgsql/include
LDFLAGS = -L/usr/local/pgsql/lib -lpq
all : $(TARGET)
pginsert: $(PGINTERFACE) pginsert.c
gcc -o $@ $(CFLAGS) $@.c $(PGINTERFACE) $(LDFLAGS)
pgwordcount: $(PGINTERFACE) pgwordcount.c
gcc -o $@ $(CFLAGS) $@.c $(PGINTERFACE) $(LDFLAGS)
pgnulltest: $(PGINTERFACE) pgnulltest.c
gcc -o $@ $(CFLAGS) $@.c $(PGINTERFACE) $(LDFLAGS)
pginterface.o: pginterface.c
gcc -c $(CFLAGS) pginterface.c
halt.o: halt.c
gcc -c $(CFLAGS) halt.c
clean:
rm -f *.o $(TARGET) log core
install:
install -s -o bin -g bin $(TARGET) /usr/local/pgsql/bin

15
contrib/pginterface/README
View File

@ -1,15 +0,0 @@
Pginterface 2.0
Attached is a copy of the Postgres support routines I wrote to allow me
to more cleanly interface to the libpg library, more like a 4gl SQL
interface.
You can create a library of pginterface.c and halt.c, and just include
pginterface.h in your source code.
I am willing to maintain this if people find problems or want additional
functionality.
Bruce Momjian (root@candle.pha.pa.us)

60
contrib/pginterface/halt.c
View File

@ -1,60 +0,0 @@
/*
**
** halt.c
**
** This is used to print out error messages and exit
*/
#include <varargs.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
/*-------------------------------------------------------------------------
**
** halt - print error message, and call clean up routine or exit
**
**------------------------------------------------------------------------*/
/*VARARGS*/
void
halt(va_alist)
va_dcl
{
va_list arg_ptr;
char *format,
*pstr;
void (*sig_func) ();
va_start(arg_ptr);
format = va_arg(arg_ptr, char *);
if (strncmp(format, "PERROR", 6) != 0)
vfprintf(stderr, format, arg_ptr);
else
{
for (pstr = format + 6; *pstr == ' ' || *pstr == ':'; pstr++)
;
vfprintf(stderr, pstr, arg_ptr);
perror("");
}
va_end(arg_ptr);
fflush(stderr);
/* call one clean up function if defined */
if ((sig_func = signal(SIGTERM, SIG_DFL)) !=SIG_DFL &&
sig_func !=SIG_IGN)
(*sig_func) (0);
else if ((sig_func = signal(SIGHUP, SIG_DFL)) !=SIG_DFL &&
sig_func !=SIG_IGN)
(*sig_func) (0);
else if ((sig_func = signal(SIGINT, SIG_DFL)) !=SIG_DFL &&
sig_func !=SIG_IGN)
(*sig_func) (0);
else if ((sig_func = signal(SIGQUIT, SIG_DFL)) !=SIG_DFL &&
sig_func !=SIG_IGN)
(*sig_func) (0);
exit(1);
}

6
contrib/pginterface/halt.h
View File

@ -1,6 +0,0 @@
/*
** halt.h
**
*/
void halt();

101
contrib/pginterface/pginsert.c
View File

@ -1,101 +0,0 @@
/*
* insert.c
*
*/
#include <stdio.h>
#include <time.h>
#include <libpq-fe.h>
#include "halt.h"
#include "pginterface.h"
int
main(int argc, char **argv)
{
char query[4000];
int row = 1;
int aint;
float afloat;
double adouble;
char achar[11],
achar16[17],
abpchar[11],
avarchar[51],
atext[51];
time_t aabstime;
if (argc != 2)
halt("Usage: %s database\n", argv[0]);
connectdb(argv[1], NULL, NULL, NULL, NULL);
on_error_continue();
doquery("DROP TABLE testfetch");
on_error_stop();
doquery("\
CREATE TABLE testfetch( \
aint int4, \
afloat float4, \
adouble float8, \
achar char, \
achar16 char16, \
abpchar char(10), \
avarchar varchar(50), \
atext text, \
aabstime abstime) \
");
while (1)
{
sprintf(query, "INSERT INTO testfetch VALUES ( \
%d, \
2322.12, \
'923121.0323'::float8, \
'A', \
'Betty', \
'Charley', \
'Doug', \
'Ernie', \
'now' )", row);
doquery(query);
doquery("BEGIN WORK");
doquery("DECLARE c_testfetch BINARY CURSOR FOR \
SELECT * FROM testfetch");
doquery("FETCH ALL IN c_testfetch");
while (fetch(
&aint,
&afloat,
&adouble,
achar,
achar16,
abpchar,
avarchar,
atext,
&aabstime) != END_OF_TUPLES)
printf("int %d\nfloat %f\ndouble %f\nchar %s\nchar16 %s\n\
bpchar %s\nvarchar %s\ntext %s\nabstime %s",
aint,
afloat,
adouble,
achar,
achar16,
abpchar,
avarchar,
atext,
ctime(&aabstime));
doquery("CLOSE c_testfetch");
doquery("COMMIT WORK");
printf("--- %-d rows inserted so far\n", row);
row++;
}
disconnectdb();
return 0;
}

71
contrib/pginterface/pginterface.3
View File

@ -1,71 +0,0 @@
.\" This is -*-nroff-*-
.\" XXX standard disclaimer belongs here....
.\" $Header: /cvsroot/pgsql/contrib/pginterface/Attic/pginterface.3,v 1.1 1998/09/11 05:14:08 momjian Exp $
.TH PGINTERFACE INTRO 08/08/98 PostgreSQL PostgreSQL
.SH DESCRIPTION
Pginterface allows you to cleanly interface to the libpq library,
more like a 4gl SQL interface.
.PP
It consists of set of simplified C functions that encapsulate the
functionality of libpq.
The functions are:
.nf
PGresult *doquery(char *query);
PGconn *connectdb();
void disconnectdb();
int fetch(void *param,...);
int fetchwithnulls(void *param,...);
void reset_fetch();
void on_error_continue();
void on_error_stop();
PGresult *get_result();
void set_result(PGresult *newres);
void unset_result(PGresult *oldres);
.fi
.PP
Many functions return a structure or value, so you can do more work
with the result if required.
.PP
You basically connect to the database with
.BR connectdb ,
issue your query with
.BR doquery ,
fetch the results with
.BR fetch ,
and finish with
.BR disconnectdb .
.PP
For
.IR select
queries,
.BR fetch
allows you to pass pointers as parameters, and on return the variables
are filled with data from the binary cursor you opened. These binary
cursors can not be used if you are running the
.BR pginterface
client on a system with a different architecture than the database
server. If you pass a NULL pointer parameter, the column is skipped.
.BR fetchwithnulls
allows you to retieve the
.IR null
status of the field by passing an
.IR int*
after each result pointer, which returns true or false if the field is null.
You can always use libpq functions on the PGresult pointer returned by
.BR doquery .
.BR reset_fetch
starts the fetch back at the beginning.
.PP
.BR get_result ,
.BR set_result ,
and
.BR unset_result
allow you to handle multiple result sets at the same time.
.PP
There are a variety of demonstration programs in the
.BR pginterface
source directory.

287
contrib/pginterface/pginterface.c
View File

@ -1,287 +0,0 @@
/*
* pginterface.c
*
*/
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <libpq-fe.h>
#include "halt.h"
#include "pginterface.h"
#define NUL '\0'
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
/* GLOBAL VARIABLES */
static PGconn *conn;
static PGresult *res = NULL;
#define ON_ERROR_STOP 0
#define ON_ERROR_CONTINUE 1
static int on_error_state = ON_ERROR_STOP;
static in_result_block = FALSE;
static was_get_unset_result = FALSE;
/* LOCAL VARIABLES */
static int tuple;
/*
**
** connectdb - returns PGconn structure
**
*/
PGconn *
connectdb(char *dbName,
char *pghost,
char *pgport,
char *pgoptions,
char *pgtty)
{
/* make a connection to the database */
conn = PQsetdb(pghost, pgport, pgoptions, pgtty, dbName);
if (PQstatus(conn) == CONNECTION_BAD)
halt("Connection to database '%s' failed.\n%s\n", dbName,
PQerrorMessage(conn));
return conn;
}
/*
**
** disconnectdb
**
*/
void
disconnectdb()
{
PQfinish(conn);
}
/*
**
** doquery - returns PGresult structure
**
*/
PGresult *
doquery(char *query)
{
if (res != NULL && in_result_block == FALSE && was_get_unset_result == FALSE)
PQclear(res);
was_get_unset_result = FALSE;
res = PQexec(conn, query);
if (on_error_state == ON_ERROR_STOP &&
(res == NULL ||
PQresultStatus(res) == PGRES_BAD_RESPONSE ||
PQresultStatus(res) == PGRES_NONFATAL_ERROR ||
PQresultStatus(res) == PGRES_FATAL_ERROR))
{
if (res != NULL)
fprintf(stderr, "query error: %s\n", PQcmdStatus(res));
else
fprintf(stderr, "connection error: %s\n", PQerrorMessage(conn));
PQfinish(conn);
halt("failed request: %s\n", query);
}
tuple = 0;
return res;
}
/*
**
** fetch - returns tuple number (starts at 0), or the value END_OF_TUPLES
** NULL pointers are skipped
**
*/
int
fetch(void *param,...)
{
va_list ap;
int arg,
num_fields;
num_fields = PQnfields(res);
if (tuple >= PQntuples(res))
return END_OF_TUPLES;
va_start(ap, param);
for (arg = 0; arg < num_fields; arg++)
{
if (param != NULL)
{
if (PQfsize(res, arg) == -1)
{
memcpy(param, PQgetvalue(res, tuple, arg), PQgetlength(res, tuple, arg));
((char *) param)[PQgetlength(res, tuple, arg)] = NUL;
}
else
memcpy(param, PQgetvalue(res, tuple, arg), PQfsize(res, arg));
}
param = va_arg(ap, char *);
}
va_end(ap);
return tuple++;
}
/*
**
** fetchwithnulls - returns tuple number (starts at 0),
** or the value END_OF_TUPLES
** Returns TRUE or FALSE into null indicator variables
** NULL pointers are skipped
*/
int
fetchwithnulls(void *param,...)
{
va_list ap;
int arg,
num_fields;
num_fields = PQnfields(res);
if (tuple >= PQntuples(res))
return END_OF_TUPLES;
va_start(ap, param);
for (arg = 0; arg < num_fields; arg++)
{
if (param != NULL)
{
if (PQfsize(res, arg) == -1)
{
memcpy(param, PQgetvalue(res, tuple, arg), PQgetlength(res, tuple, arg));
((char *) param)[PQgetlength(res, tuple, arg)] = NUL;
}
else
memcpy(param, PQgetvalue(res, tuple, arg), PQfsize(res, arg));
}
param = va_arg(ap, char *);
if (PQgetisnull(res, tuple, arg) != 0)
*(int *) param = 1;
else
*(int *) param = 0;
param = va_arg(ap, char *);
}
va_end(ap);
return tuple++;
}
/*
**
** on_error_stop
**
*/
void
on_error_stop()
{
on_error_state = ON_ERROR_STOP;
}
/*
**
** on_error_continue
**
*/
void
on_error_continue()
{
on_error_state = ON_ERROR_CONTINUE;
}
/*
**
** get_result
**
*/
PGresult *
get_result()
{
char *cmdstatus = PQcmdStatus(res);
was_get_unset_result = TRUE;
/* we have to store the fetch location somewhere */
cmdstatus[0] = NUL;
memcpy(&cmdstatus[1], &tuple, sizeof(tuple));
return res;
}
/*
**
** set_result
**
*/
void
set_result(PGresult *newres)
{
char *cmdstatus = PQcmdStatus(res);
if (newres == NULL)
halt("set_result called with null result pointer\n");
if (res != NULL && was_get_unset_result == FALSE)
if (in_result_block == FALSE)
PQclear(res);
else
{
cmdstatus[0] = NUL;
memcpy(&cmdstatus[1], &tuple, sizeof(tuple));
}
in_result_block = TRUE;
was_get_unset_result = FALSE;
cmdstatus = PQcmdStatus(newres);
memcpy(&tuple, &cmdstatus[1], sizeof(tuple));
res = newres;
}
/*
**
** unset_result
**
*/
void
unset_result(PGresult *oldres)
{
char *cmdstatus = PQcmdStatus(oldres);
if (oldres == NULL)
halt("unset_result called with null result pointer\n");
if (in_result_block == FALSE)
halt("Unset of result without being set.\n");
was_get_unset_result = TRUE;
cmdstatus[0] = NUL;
memcpy(&cmdstatus[1], &tuple, sizeof(tuple));
in_result_block = FALSE;
}
/*
**
** reset_fetch
**
*/
void
reset_fetch()
{
tuple = 0;
}

18
contrib/pginterface/pginterface.h
View File

@ -1,18 +0,0 @@
/*
* pglib.h
*
*/
PGresult *doquery(char *query);
PGconn *connectdb();
void disconnectdb();
int fetch(void *param,...);
int fetchwithnulls(void *param,...);
void on_error_continue();
void on_error_stop();
PGresult *get_result();
void set_result(PGresult *newres);
void unset_result(PGresult *oldres);
void reset_fetch();
#define END_OF_TUPLES (-1)

142
contrib/pginterface/pgnulltest.c
View File

@ -1,142 +0,0 @@
/*
* pgnulltest.c
*
*/
#define TEST_NON_NULLS
#include <stdio.h>
#include <time.h>
#include <halt.h>
#include <libpq-fe.h>
#include <pginterface.h>
int
main(int argc, char **argv)
{
char query[4000];
int row = 1;
int aint;
float afloat;
double adouble;
char achar[11],
achar16[17],
abpchar[11],
avarchar[51],
atext[51];
time_t aabstime;
int aint_null,
afloat_null,
adouble_null,
achar_null,
achar16_null,
abpchar_null,
avarchar_null,
atext_null,
aabstime_null;
if (argc != 2)
halt("Usage: %s database\n", argv[0]);
connectdb(argv[1], NULL, NULL, NULL, NULL);
on_error_continue();
doquery("DROP TABLE testfetch");
on_error_stop();
doquery("\
CREATE TABLE testfetch( \
aint int4, \
afloat float4, \
adouble float8, \
achar char, \
achar16 char16, \
abpchar char(10), \
avarchar varchar(50), \
atext text, \
aabstime abstime) \
");
#ifdef TEST_NON_NULLS
sprintf(query, "INSERT INTO testfetch VALUES ( \
0, \
0, \
0, \
'', \
'', \
'', \
'', \
'', \
'');");
#else
sprintf(query, "INSERT INTO testfetch VALUES ( \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL, \
NULL);");
#endif
doquery(query);
doquery("BEGIN WORK");
doquery("DECLARE c_testfetch BINARY CURSOR FOR \
SELECT * FROM testfetch");
doquery("FETCH ALL IN c_testfetch");
if (fetchwithnulls(
&aint,
&aint_null,
&afloat,
&afloat_null,
&adouble,
&adouble_null,
achar,
&achar_null,
achar16,
&achar16_null,
abpchar,
&abpchar_null,
avarchar,
&avarchar_null,
atext,
&atext_null,
&aabstime,
&aabstime_null) != END_OF_TUPLES)
printf("int %d\nfloat %f\ndouble %f\nchar %s\nchar16 %s\n\
bpchar %s\nvarchar %s\ntext %s\nabstime %s\n",
aint,
afloat,
adouble,
achar,
achar16,
abpchar,
avarchar,
atext,
ctime(&aabstime));
printf("NULL:\nint %d\nfloat %d\ndouble %d\nchar %d\nchar16 %d\n\
bpchar %d\nvarchar %d\ntext %d\nabstime %d\n",
aint_null,
afloat_null,
adouble_null,
achar_null,
achar16_null,
abpchar_null,
avarchar_null,
atext_null,
aabstime_null);
doquery("CLOSE c_testfetch");
doquery("COMMIT WORK");
printf("--- %-d rows inserted so far\n", row);
row++;
disconnectdb();
return 0;
}

70
contrib/pginterface/pgwordcount.c
View File

@ -1,70 +0,0 @@
/*
* wordcount.c
*
*/
#include <stdio.h>
#include "halt.h"
#include <libpq-fe.h>
#include "pginterface.h"
int
main(int argc, char **argv)
{
char query[4000];
int row = 0;
int count;
char line[4000];
if (argc != 2)
halt("Usage: %s database\n", argv[0]);
connectdb(argv[1], NULL, NULL, NULL, NULL);
on_error_continue();
doquery("DROP TABLE words");
on_error_stop();
doquery("\
CREATE TABLE words( \
matches int4, \
word text ) \
");
doquery("\
CREATE INDEX i_words_1 ON words USING btree ( \
word text_ops )\
");
while (1)
{
if (scanf("%s", line) != 1)
break;
doquery("BEGIN WORK");
sprintf(query, "\
DECLARE c_words BINARY CURSOR FOR \
SELECT count(*) \
FROM words \
WHERE word = '%s'", line);
doquery(query);
doquery("FETCH ALL IN c_words");
while (fetch(&count) == END_OF_TUPLES)
count = 0;
doquery("CLOSE c_words");
doquery("COMMIT WORK");
if (count == 0)
sprintf(query, "\
INSERT INTO words \
VALUES (1, '%s')", line);
else
sprintf(query, "\
UPDATE words \
SET matches = matches + 1 \
WHERE word = '%s'", line);
doquery(query);
row++;
}
disconnectdb();
return 0;
}