Honestly, the programming examples on the official PostgreSQL website aren’t that bad. I just thought that I could write my own, and show people how I like to use the libpq API in C (and for Google purposes, Cee).

Initializing and Connecting

The first thing you’ll need is the libpq-fe.h header, to allow you to use all the goodies that libpq has to offer:

#include libpq-fe.h

Connecting to the database server is done via the PQconnectdb() function, with the configuration being passed as a string. Of course, this is a terribly nasty way of doing things in my humble opinion, but I’m sure there are alternatives if you look for them.

PGconn *psql;
psql = PQconnectdb("hostaddr = '127.0.0.1' port = '' dbname = 'fwaggle' user = 'fwaggle' password = 'password' connect_timeout = '10'");
/* init connection */
if (!psql) {
fprintf(stderr, "libpq error: PQconnectdb returned NULL.\n\n");
exit(0);
}
if (PQstatus(psql) != CONNECTION_OK) {
fprintf(stderr, "libpq error: PQstatus(psql) != CONNECTION_OK\n\n");
exit(0);
}

As you can see, everything’s done for you with a single function call, and we simply check to see if we’re connected by 1) checking if the pointer was NULL and 2) checking PQstatus()‘s return value. If you’re not writing CGI and you’re writing a long-term daemon of some sort, you probably want to include multiple PQstatus() calls in your application.

Cleanup

I wouldn’t be a good little hacker if I didn’t show you how to cleanup after yourself, would I? Thankfully, it’s trivial:

PQfinish(psql);

Queries

Queries aren’t handled the greatest with libpq, so I much prefer to write my own wrapper function for them using variable argument lists (va_arg) if it’s available:

PGresult *pq_query(const char *format, ...) {
va_list argv;
char *ptrQuery;
PGresult *result;
va_start(argv, format);
vasprintf(ptrQuery, format, argv);
va_end(argv);
if (!ptrQuery)
return(0);
result = PQexec(psql, ptrQuery);
free(ptrQuery);
return(result);
}

Then, it’s simply a matter of calling pq_query() with sprintf() style arguments:

#define WORD "this is a test"
PGresult *result;
result = db_query("SELECT now(), md5('%s');", WORD);

Doing something with the data set that result will (hopefully) point to generally requires some kind of loop, unless you’re only expecting a single row. Even though the above SQL will only ever return one row, we’ll still use a loop just in case. In this case, we’re introducing the PQntuples() function, which returns the number of tuples (rows) for a given result set.

I’m not sure if it’s necessary (RTFM, as they say) but I like to check for a NULL result set anyway. We’ll also introduce the PQgetvalue() function, for grabbing values from rows:

int i, j;
if (!result || !(j = PQntuples(result))) {
fprintf(stderr, "libpq error: no rows returned or bad result set\n\n");
PQfinish(psql);
exit(0);
}
for (i = 0; i j; i++) {
printf("Time: %s\n", PQgetvalue(result, i, 0);
printf("MD5: %s\n", PQgetvalue(result, i, 1);
}
PQclear(result);

In case you didn’t figure it out, the arguments for PQgetvalue() are: “result set”, “row”, “column”. Everything starts at 0.

Sanitizing Data

When dealing with any kind of data that comes from user land – whether it be user input, environment variables, whatever – it’s always a good idea to sanitize the data to ensure no one meddles with your SQL queries. libpq provides the PQescapeString() function, but it’s invocation isn’t the cleanest, so again, I like to wrap it in a wrapper function and toast lightly:

char * pq_escape (char *input) {
int len;
char *output;
len = strlen(input);
if (len 1)
return(NULL);
output = malloc((len * 2) + 1);
if (!output)
return(NULL);
PQescapeString(output, input, len);
return(output);
}

Of course, the return value is a pointer to a dynamically allocated variable, which you’ll need to free on your own when you’re done with it. But nonetheless, we can use this wrapper function to easily escape user-provided data:

char *data_safe;
if (argc > 1) {
data_safe = pq_escape(argv[1]);
result = pq_query("SELECT MD5('%s');", data_safe);
if (!result || PQntuples(result) 1) {
fprintf(stderr, "libpq error: no results returned or NULL resultset pointer.\n\n");
PQfinish(psql);
exit(0);
}
printf("data: %s (data safe: %s)\n", argv[0]);
printf("MD5: %s\n", PQgetvalue(result, 0, 0));
PQclear(result);
}

Putting it all together:

Putting the whole mess together, you should have a fully compilable, executable program that takes next to no time to execute and does a couple of measly features:

/*
** libpq example
** fwaggle@hungryhacker.com
** http://www.hungryhacker.com/
*/
#include stdio.h
#include stdarg.h
#include libpq-fe.h
&nsbp;
#define WORD "this is a test"
PGconn *psql;
&nsbp;
PGresult *pq_query(const char *format, ...)
{
va_list argv;
char *ptrQuery;
PGresult *result;
va_start(argv, format);
vasprintf(ptrQuery, format, argv);
va_end(argv);
if (!ptrQuery)
return(0);
result = PQexec(psql, ptrQuery);
free(ptrQuery);
return(result);
}
&nsbp;
char * pq_escape (char *input)
{
int len;
char *output;
len = strlen(input);
if (len 1)
return(NULL);
output = malloc((len * 2) + 1);
if (!output)
return(NULL);
PQescapeString(output, input, len);
return(output);
}
&nsbp;
int main (int argc, char **argv)
{
char *data_safe;
int i, j;
PGresult *result;
psql = PQconnectdb("hostaddr = '127.0.0.1' port = '' dbname = 'fwaggle' user = 'fwaggle' password = 'password' connect_timeout = '10'");
&nsbp;
/* init connection */
if (!psql)
{
fprintf(stderr, "libpq error: PQconnectdb returned NULL.\n\n");
exit(0);
}
if (PQstatus(psql) != CONNECTION_OK)
{
fprintf(stderr, "libpq error: PQstatus(psql) != CONNECTION_OK\n\n");
exit(0);
}
result = pq_query("SELECT now(), md5('%s');", WORD);
if (!result || !(j = PQntuples(result)))
{
fprintf(stderr, "libpq error: no rows returned or bad result set\n\n");
PQfinish(psql);
exit(0);
}
for (i = 0; i j; i++)
{
printf("Time: %s\n", PQgetvalue(result, i, 0));
printf("MD5: %s\n", PQgetvalue(result, i, 1));
}
PQclear(result);
if (argc > 1)
{
data_safe = pq_escape(argv[1]);
result = pq_query("SELECT MD5('%s');", data_safe);
if (!result || PQntuples(result) 1)
{
fprintf(stderr, "libpq error: no results returned or NULL resultset pointer.\n\n");
PQfinish(psql);
exit(0);
}
printf("data: %s (data safe: %s)\n", argv[0]);
printf("MD5: %s\n", PQgetvalue(result, 0, 0));
PQclear(result);
}
PQfinish(psql);
}

Compiling

On my system, I have to play some Makefile games to get libpq to compile in, I’ve seen some Redhat systems that are worse though. Basically, find where libpq-fe.h and the libpq libraries are, and modify your gcc command to suit:

fwaggle@diglett:~$ gcc -I/usr/local/include -L/usr/local/lib -o test_psql -lpq test_psql.c

If it doesn’t work, and barfs on PQconnectdb(), try leaving the hostaddr blank, as that will often cause libpq to connect via a UNIX domain socket, as opposed to TCP/IP (in case your PostgreSQL server isn’t listening on a TCP/IP port). That worked for me:

fwaggle@diglett:~$ ./test_psql Time: 2005-09-21 02:00:28.213502+01 MD5: 54b0c58c7ce9f2a8b551351102ee0938 fwaggle@diglett:~$

Enjoy, and if you have any questions, leave a comment.

This text is supposed to explain the brainfuck language and its elegance. I hope to wake your interest in esoteric programming languages, such as intercal, dis, malbolge and befunge.

I will continue to use the word ‘brainfuck‘ and not something like ‘brainf*ck’. If you are too sensitive to stand foul language, then please ignore this article, though I would find that extremely ridiculous.

What is brainfuck?

Brainfuck is a programming language with only 8 commands, each one symbol, that is Turing-complete. It was originally implemented and designed for Amiga OS 2.0 by Urban Mueller.

A brainfuck program has an array of 30000 elements (lets call it A for simplicity), all with an initial value of 0 and a pointer (we’ll call it P) pointing to the first element of A.

Commands

As previously mentioned, brainfuck only uses 8 commands. These are: ‘+’, ‘-’, ‘>’, ‘<’, ‘[', ']‘, ‘.’, ‘,’. In case that was unreadable: +-><[].,

Let’s examine them more closely, what does each one of them do?

• the ‘+’ command increments the element of A currently pointed at by P
• the ‘-’ command decrements the element of A currently pointed at by P
• the ‘>’ command increments P
• the ‘<’ command decrements P
• the ‘[' command starts a loop, which is looped until the element of A currently pointed at by P is 0.
• the ']‘ command ends the execution block of a previously started loop.
• the ‘.’ command prints out the ascii character of the element of A currently pointed at by P.
• the ‘,’ command reads a character and saves its ascii value to the element of A currently pointed at by P.

It may be easier to understand this in comparison to the C language.

Command | C-Equivalent --------+------------- + | a[p]++ - | a[p]-- > | p++ < | p-- [ | while(a[p]) { ] | } . | putchar(a[p]) , | a[p] = getchar()

Taking apart the ‘hello world’ program

Let’s take a look at the original brainfuck code of the ‘hello world’ program first:

>+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.[-]>++++++++[<++++>-]<. >+++++++++++[<+++++>-]<.>++++++++[<+++>-]<.+++.------.--------.[-]>++++++++[<++++ >-]<+.[-]++++++++++.

We know that a ‘.’ will print out a character, so we can assume that >+++++++++[<++++++++>-]<. prints ‘H’. The ascii value of ‘H’ is 72, so how do we get 72 into a[p] without writing 72 ‘+’s? We run a loop. So, first we set P to 1 and then a[1] to 9. Now we go into a loop. In the body of the loop we decrement P and add 8 to a[0]. Then we increment P again and subtract one from a[1].

At the beginning we have a[0] = 0 and a[1] = 9. After going through the loop the first time, we have a[0] = 8 and a[1] = 8. After going through the loop the second time, we have a[0] = 16 and a[1] = 7. This continues 9 times, so what this results in, basically is a[0] = 9 * 8.

Let’s take a look at ‘[-]‘ now. So, what does this do and how does it work?

Assuming a[p] = 5, what would ‘while(a[p]) a[p]–;’ do? It would loop until a[p] is 0 … that’s it. It’s a simple way to reset a[p].

To help you understand how this works, here’s the code in C:

/* Begin C code */ #include <stdio.h> long a[30000]; int p = 0; int main(void) { /* Print 'H' */ p++; /* > */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ while(a[p]) { /* [ */ p--; /* < */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ p++; /* > */ a[p]--; /* - */ } /* ] */ p--; /* < */ putchar(a[p]); /* . */ /* Print 'e' */ p++; /* > */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ while(a[p]) { /* [ */ p--; /* < */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ p++; /* > */ a[p]--; /* - */ } /* ] */ p--; /* < */ a[p]++; /* + */ putchar(a[p]); /* . */ /* Print 'l' */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ putchar(a[p]); /* . */ /* Print 'l' */ putchar(a[p]); /* . */ /* Print 'o' */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ putchar(a[p]); /* . */ /* Print ' ' */ while(a[p]) { /* [ */ a[p]--; /* - */ } /* ] */ p++; /* > */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ while(a[p]) { /* [ */ p--; /* < */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ p++; /* > */ a[p]--; /* - */ } /* ] */ p--; /* < */ putchar(a[p]); /* . */ /* Print 'W' */ p++; /* > */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ while(a[p]) { /* [ */ p--; /* < */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ p++; /* > */ a[p]--; /* - */ } /* ] */ p--; /* < */ putchar(a[p]); /* . */ /* Print 'o' */ p++; /* > */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ while(a[p]) { /* [ */ p--; /* < */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ p++; /* > */ a[p]--; /* - */ } /* ] */ p--; /* < */ putchar(a[p]); /* . */ /* Print 'r' */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ putchar(a[p]); /* . */ /* Print 'l' */ a[p]--; /* - */ a[p]--; /* - */ a[p]--; /* - */ a[p]--; /* - */ a[p]--; /* - */ a[p]--; /* - */ putchar(a[p]); /* . */ /* Print 'd' */ a[p]--; /* - */ a[p]--; /* - */ a[p]--; /* - */ a[p]--; /* - */ a[p]--; /* - */ a[p]--; /* - */ a[p]--; /* - */ a[p]--; /* - */ putchar(a[p]); /* . */ /* Print '!' */ while(a[p]) { /* [ */ a[p]--; /* - */ } /* ] */ p++; /* > */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ while(a[p]) { /* [ */ p--; /* < */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ p++; /* > */ a[p]--; /* - */ } /* ] */ p--; /* < */ a[p]++; /* + */ putchar(a[p]); /* . */ /* Newline */ while(a[p]) { /* [ */ a[p]--; /* - */ } /* ] */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ a[p]++; /* + */ putchar(a[p]); /* . */ return 0; } /* End C code */

Notes on efficiency in brainfuck

If you’re aiming for efficiency, brainfuck is definitely not the programming language you’ll want to use. To make brainfuck code as efficient as possible, you should translate it to C using, for example, bfc, which optimizes the code. Then you should definitely compile the C code with optimization flags ofyour compiler, eg. -O2 for gcc. It will still probably be faster to just write int main(void) { printf(“Hello World!\n”); return 0; }though

Also, obviously it will be faster to just decrement a[p] by 3 instead of using [-] and then setting up the value again, just 3 less, when you for example just printed ‘m’ and now wish to print ‘j’.

Running through a loop less often will probably be faster, so instead of having’>++++++++[<++++>-]‘ you should use ‘>++++[<++++++++>-]‘, though I must admit Ihaven’t timed these possibilities or tested results.

Last program

Note: I wrote this brainfuck program rather quickly so it may not be the mostefficient or shortest way to write it … this is left as an exercise for thereader (as substitute for my laziness) Well, here it is:

>++++++++[<+++++++++>-]<++.>+++++++[<++++++>-]<+.--.+.[-]>++++[<++++++++>-]<. >++++[<++++++++>-]<+.>+++++[<+++++++++>-]<.+.+++++.>++[<------>-]<.---.>++[<+ +++++>-]<+.[-]>++++[<++++++++>-]<.>++++[<++++++++>-]<++.>++++++[<++++++++>-]< .>++++[<---->-]<-.++++++++.+++++.[-]>++++[<++++++++>-]<.[-]>++++++++[<+++++++ ++>-]<--.>+++++[<+++++++++>-]<++.>+++[<------>-]<.++++++++.------.>++[<++++++ >-]<+.[-]>++[<+++++>-]<.

What is so elegant about brainfuck?

Brainfuck just simply is the most elegant programming language around. It only has 8 commands, only 6 being necessary for it to be turing-complete. If you don’t find that makes it elegant … well, that’s your opinion then, I suppose. Many people enjoy writing their own interpreters and/or compilers/translaters to other programming languages for brainfuck. Brainfuck is just a lot of fun and it’s a lifetime experience coding programs in it

Also you can impress colleagues by the cryptic look of its code.

Well, that’s it for this article … hope you enjoyed it.

Resources

• http://www.catseye.mb.ca/esoteric/bf/ – the current brainfuck site
• http://freshmeat.net – has various brainfuck compilers/interpreters
• http://www.muppetlabs.com/~breadbox/bf/ – a great site about brainfuck
• http://home.wxs.nl/~faase009/Ha_bf_Turing.html – brainfuck in relation to turing-completeness and URM.
• http://obiwan.uvi.edu/computing/turing/ture.htm – paper on the turing machine
• http://www.ionet.net/~timtroyr/funhouse/beer/beer_a_c.html#brainfuck – 99 bottles of beer on the wall in brainfuck
• http://cydathria.com/bf/brainfuck.html – Guide on programming in brainfuck

Markus Kliegl <markus.kliegl@t-online.de>, December 2000