Merge in D'Arcy Cain's python interface (PyGreSQL 2.0)

1 files changed, 1778 insertions, 0 deletions

diff --git a/src/interfaces/python/pgmodule.c b/src/interfaces/python/pgmodule.c
new file mode 100644
index 00000000000..1dbadb1fc08
--- /dev/null
+++ b/src/interfaces/python/pgmodule.c
@@ -0,0 +1,1778 @@
+/*
+ * PyGres, version 2.0 A Python interface for PostgreSQL database. Written by
+ * D'Arcy J.M. Cain, (darcy@druid.net).  Based heavily on code written by
+ * Pascal Andre, andre@chimay.via.ecp.fr. Copyright (c) 1995, Pascal Andre
+ * (andre@via.ecp.fr).
+ * 
+ * Permission to use, copy, modify, and distribute this software and its
+ * documentation for any purpose, without fee, and without a written
+ * agreement is hereby granted, provided that the above copyright notice and
+ * this paragraph and the following two paragraphs appear in all copies or in
+ * any new file that contains a substantial portion of this file.
+ * 
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
+ * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
+ * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE
+ * AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE
+ * AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
+ * ENHANCEMENTS, OR MODIFICATIONS.
+ * 
+ * Further modifications copyright 1997 by D'Arcy J.M. Cain (darcy@druid.net)
+ * subject to the same terms and conditions as above.
+ * 
+ */
+
+#include <Python.h>
+#include <libpq-fe.h>
+#include <libpq/libpq-fs.h>
+#include <stdio.h>
+
+static PyObject *PGError;
+
+/* taken from fileobject.c */
+#define BUF(v) PyString_AS_STRING((PyStringObject *)(v))
+
+#define CHECK_OPEN        1
+#define CHECK_CLOSE       2
+
+#define MAX_BUFFER_SIZE   8192	/* maximum transaction size */
+
+#ifndef NO_DIRECT
+#define DIRECT_ACCESS     1		/* enables direct access functions */
+#endif							/* NO_DIRECT */
+
+#ifndef NO_LARGE
+#define LARGE_OBJECTS     1		/* enables large objects support */
+#endif							/* NO_LARGE */
+
+#ifndef NO_DEF_VAR
+#define DEFAULT_VARS      1		/* enables default variables use */
+#endif							/* NO_DEF_VAR */
+
+/* --------------------------------------------------------------------- */
+
+/* MODULE GLOBAL VARIABLES */
+
+#ifdef DEFAULT_VARS
+
+PyObject       *pg_default_host;	/* default database host */
+PyObject       *pg_default_base;	/* default database name */
+PyObject       *pg_default_opt;		/* default connection options */
+PyObject       *pg_default_tty;		/* default debug tty */
+PyObject       *pg_default_port;	/* default connection port */
+
+#endif							/* DEFAULT_VARS */
+
+/* --------------------------------------------------------------------- */
+
+/* OBJECTS DECLARATION */
+
+/* pg connection object */
+
+typedef struct
+{
+	PyObject_HEAD
+	int             valid;			/* validity flag */
+	PGconn         *cnx;			/* PostGres connection handle */
+}               pgobject;
+
+staticforward PyTypeObject PgType;
+
+#define is_pgobject(v) ((v)->ob_type == &PgType)
+
+/* pg query object */
+
+typedef struct
+{
+	PyObject_HEAD
+	PGresult       *last_result;	/* last result content */
+}               pgqueryobject;
+
+staticforward PyTypeObject PgQueryType;
+
+#define is_pgqueryobject(v) ((v)->ob_type == &PgQueryType)
+
+#ifdef LARGE_OBJECTS
+/* pg large object */
+
+typedef struct
+{
+	PyObject_HEAD
+	pgobject * pgcnx;
+	Oid             lo_oid;
+	int             lo_fd;
+}               pglargeobject;
+
+staticforward PyTypeObject PglargeType;
+
+#define is_pglargeobject(v) ((v)->ob_type == &PglargeType)
+#endif							/* LARGE_OBJECTS */
+
+/* --------------------------------------------------------------------- */
+
+/* INTERNAL FUNCTIONS */
+
+#ifdef LARGE_OBJECTS
+/* validity check (large object) */
+static int
+check_lo(pglargeobject * self, int level)
+{
+	if (!self->lo_oid)
+	{
+		PyErr_SetString(PGError, "object is not valid (null oid).");
+		return 0;
+	}
+
+	if (level & CHECK_OPEN)
+	{
+		if (self->lo_fd < 0)
+		{
+			PyErr_SetString(PyExc_IOError, "object is not opened.");
+			return 0;
+		}
+	}
+
+	if (level & CHECK_CLOSE)
+	{
+		if (self->lo_fd >= 0)
+		{
+			PyErr_SetString(PyExc_IOError, "object is already opened.");
+			return 0;
+		}
+	}
+
+	return 1;
+}
+
+#endif							/* LARGE_OBJECTS */
+
+/* --------------------------------------------------------------------- */
+
+#ifdef LARGE_OBJECTS
+/* PG CONNECTION OBJECT IMPLEMENTATION */
+
+/* pglargeobject initialisation (from pgobject) */
+
+/* creates large object */
+static PyObject  *
+pg_locreate(pgobject * self, PyObject * args)
+{
+	int             mode;
+	pglargeobject  *npglo;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "i", &mode))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"locreate(mode), with mode (integer).");
+		return NULL;
+	}
+
+	if ((npglo = PyObject_NEW(pglargeobject, &PglargeType)) == NULL)
+		return NULL;
+
+	npglo->pgcnx = self;
+	Py_XINCREF(self);
+	npglo->lo_fd = -1;
+	npglo->lo_oid = lo_creat(self->cnx, mode);
+
+	/* checks result validity */
+	if (npglo->lo_oid == 0)
+	{
+		PyErr_SetString(PGError, "can't create large object.");
+		Py_XDECREF(npglo);
+		return NULL;
+	}
+
+	return (PyObject *) npglo;
+}
+
+/* init from already known oid */
+static PyObject *
+pg_getlo(pgobject * self, PyObject * args)
+{
+	int             lo_oid;
+	pglargeobject  *npglo;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "i", &lo_oid))
+	{
+		PyErr_SetString(PyExc_TypeError, "loopen(oid), with oid (integer).");
+		return NULL;
+	}
+
+	if (!lo_oid)
+	{
+		PyErr_SetString(PyExc_ValueError, "the object oid can't be null.");
+		return NULL;
+	}
+
+	/* creates object */
+	if ((npglo = PyObject_NEW(pglargeobject, &PglargeType)) == NULL)
+		return NULL;
+
+	npglo->pgcnx = self;
+	Py_XINCREF(self);
+	npglo->lo_fd = -1;
+	npglo->lo_oid = lo_oid;
+
+	return (PyObject *) npglo;
+}
+
+/* import unix file */
+static PyObject *
+pg_loimport(pgobject * self, PyObject * args)
+{
+	char           *name;
+	pglargeobject  *npglo;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "s", &name))
+	{
+		PyErr_SetString(PyExc_TypeError, "loimport(name), with name (string).");
+		return NULL;
+	}
+
+	if ((npglo = PyObject_NEW(pglargeobject, &PglargeType)) == NULL)
+		return NULL;
+
+	npglo->pgcnx = self;
+	Py_XINCREF(self);
+	npglo->lo_fd = -1;
+	npglo->lo_oid = lo_import(self->cnx, name);
+
+	/* checks result validity */
+	if (npglo->lo_oid == 0)
+	{
+		PyErr_SetString(PGError, "can't create large object.");
+		Py_XDECREF(npglo);
+		return NULL;
+	}
+
+	return (PyObject *) npglo;
+}
+
+/* pglargeobject methods */
+
+/* destructor */
+static void
+pglarge_dealloc(pglargeobject * self)
+{
+	if (self->lo_fd >= 0 && self->pgcnx->valid == 1)
+		lo_close(self->pgcnx->cnx, self->lo_fd);
+
+	Py_XDECREF(self->pgcnx);
+	PyMem_DEL(self);
+}
+
+/* opens large object */
+static PyObject *
+pglarge_open(pglargeobject * self, PyObject * args)
+{
+	int             mode, fd;
+
+	/* check validity */
+	if (!check_lo(self, CHECK_CLOSE))
+		return NULL;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "i", &mode))
+	{
+		PyErr_SetString(PyExc_TypeError, "open(mode), with mode(integer).");
+		return NULL;
+	}
+
+	/* opens large object */
+	if ((fd = lo_open(self->pgcnx->cnx, self->lo_oid, mode)) < 0)
+	{
+		PyErr_SetString(PyExc_IOError, "can't open large object.");
+		return NULL;
+	}
+	self->lo_fd = fd;
+
+	/* no error : returns Py_None */
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* close large object */
+static PyObject *
+pglarge_close(pglargeobject * self, PyObject * args)
+{
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method close() takes no parameters.");
+		return NULL;
+	}
+
+	/* checks validity */
+	if (!check_lo(self, CHECK_OPEN))
+		return NULL;
+
+	/* closes large object */
+	if (lo_close(self->pgcnx->cnx, self->lo_fd))
+	{
+		PyErr_SetString(PyExc_IOError, "error while closing large object fd.");
+		return NULL;
+	}
+	self->lo_fd = -1;
+
+	/* no error : returns Py_None */
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* reads from large object */
+static PyObject *
+pglarge_read(pglargeobject * self, PyObject * args)
+{
+	int             size;
+	PyObject       *buffer;
+
+	/* checks validity */
+	if (!check_lo(self, CHECK_OPEN))
+		return NULL;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "i", &size))
+	{
+		PyErr_SetString(PyExc_TypeError, "read(size), wih size (integer).");
+		return NULL;
+	}
+
+	if (size <= 0)
+	{
+		PyErr_SetString(PyExc_ValueError, "size must be positive.");
+		return NULL;
+	}
+
+	/* allocate buffer and runs read */
+	buffer = PyString_FromStringAndSize((char *) NULL, size);
+
+	if ((size = lo_read(self->pgcnx->cnx, self->lo_fd, BUF(buffer), size)) < 0)
+	{
+		PyErr_SetString(PyExc_IOError, "error while reading.");
+		Py_XDECREF(buffer);
+		return NULL;
+	}
+
+	/* resize buffer and returns it */
+	_PyString_Resize(&buffer, size);
+	return buffer;
+}
+
+/* write to large object */
+static PyObject *
+pglarge_write(pglargeobject * self, PyObject * args)
+{
+	PyObject       *buffer;
+	int             size;
+
+	/* checks validity */
+	if (!check_lo(self, CHECK_OPEN))
+		return NULL;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "s", &buffer))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"write(buffer), with buffer (sized string).");
+		return NULL;
+	}
+
+	/* sends query */
+	if ((size = lo_write(self->pgcnx->cnx, self->lo_fd, (char *) BUF(buffer),
+					PyString_Size(buffer))) <  PyString_Size(buffer))
+	{
+		PyErr_SetString(PyExc_IOError, "buffer truncated during write.");
+		return NULL;
+	}
+
+	/* no error : returns Py_None */
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* go to position in large object */
+static PyObject *
+pglarge_lseek(pglargeobject * self, PyObject * args)
+{
+	int             ret, offset, whence;
+
+	/* checks validity */
+	if (!check_lo(self, CHECK_OPEN))
+		return NULL;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "ii", offset, whence))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"lseek(offset, whence), with offset and whence (integers).");
+		return NULL;
+	}
+
+	/* sends query */
+	if ((ret = lo_lseek(self->pgcnx->cnx, self->lo_fd, offset, whence)) == -1)
+	{
+		PyErr_SetString(PyExc_IOError, "error while moving cursor.");
+		return NULL;
+	}
+
+	/* returns position */
+	return PyInt_FromLong(ret);
+}
+
+/* gets large object size */
+static PyObject *
+pglarge_size(pglargeobject * self, PyObject * args)
+{
+	int             start, end;
+
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method size() takes no parameters.");
+		return NULL;
+	}
+
+	/* checks validity */
+	if (!check_lo(self, CHECK_OPEN))
+		return NULL;
+
+	/* gets current position */
+	if ((start = lo_tell(self->pgcnx->cnx, self->lo_fd)) == -1)
+	{
+		PyErr_SetString(PyExc_IOError, "error while getting current position.");
+		return NULL;
+	}
+
+	/* gets end position */
+	if ((end = lo_lseek(self->pgcnx->cnx, self->lo_fd, 0, SEEK_END)) == -1)
+	{
+		PyErr_SetString(PyExc_IOError, "error while getting end position.");
+		return NULL;
+	}
+
+	/* move back to start position */
+	if ((start = lo_lseek(self->pgcnx->cnx,self->lo_fd,start,SEEK_SET)) == -1)
+	{
+		PyErr_SetString(PyExc_IOError,
+				"error while moving back to first position.");
+		return NULL;
+	}
+
+	/* returns size */
+	return PyInt_FromLong(end);
+}
+
+/* gets large object cursor position */
+static PyObject *
+pglarge_tell(pglargeobject * self, PyObject * args)
+{
+	int             start;
+
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method tell() takes no parameters.");
+		return NULL;
+	}
+
+	/* checks validity */
+	if (!check_lo(self, CHECK_OPEN))
+		return NULL;
+
+	/* gets current position */
+	if ((start = lo_tell(self->pgcnx->cnx, self->lo_fd)) == -1)
+	{
+		PyErr_SetString(PyExc_IOError, "error while getting position.");
+		return NULL;
+	}
+
+	/* returns size */
+	return PyInt_FromLong(start);
+}
+
+/* exports large object as unix file */
+static PyObject *
+pglarge_export(pglargeobject * self, PyObject * args)
+{
+	char           *name;
+
+	/* checks validity */
+	if (!check_lo(self, CHECK_CLOSE))
+		return NULL;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "s", &name))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"export(filename), with filename (string).");
+		return NULL;
+	}
+
+	/* runs command */
+	if (!lo_export(self->pgcnx->cnx, self->lo_oid, name))
+	{
+		PyErr_SetString(PyExc_IOError, "error while exporting large object.");
+		return NULL;
+	}
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* deletes a large object */
+static PyObject *
+pglarge_unlink(pglargeobject * self, PyObject * args)
+{
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method unlink() takes no parameters.");
+		return NULL;
+	}
+
+	/* checks validity */
+	if (!check_lo(self, CHECK_CLOSE))
+		return NULL;
+
+	/* deletes the object, invalidate it on success */
+	if (!lo_unlink(self->pgcnx->cnx, self->lo_oid))
+	{
+		PyErr_SetString(PyExc_IOError, "error while unlinking large object");
+		return NULL;
+	}
+	self->lo_oid = 0;
+
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* large object methods */
+static struct PyMethodDef pglarge_methods[] = {
+	{"open",	(PyCFunction) pglarge_open, 1},	/* opens large object */
+	{"close",	(PyCFunction) pglarge_close, 1},/* closes large object */
+	{"read",	(PyCFunction) pglarge_read, 1},	/* reads from large object */
+	{"write",	(PyCFunction) pglarge_write, 1},/* writes to large object */
+	{"seek",	(PyCFunction) pglarge_lseek, 1},/* seeks position */
+	{"size",	(PyCFunction) pglarge_size, 1},	/* gives object size */
+	{"tell",	(PyCFunction) pglarge_tell, 1},	/* gives position in lobj */
+	{"export",	(PyCFunction) pglarge_export, 1},/* exports to unix file */
+	{"unlink",	(PyCFunction) pglarge_unlink, 1},/* deletes a large object */
+	{NULL, NULL}								/* sentinel */
+};
+
+/* get attribute */
+static PyObject *
+pglarge_getattr(pglargeobject * self, char *name)
+{
+	/* list postgreSQL large object fields */
+
+	/* associated pg connection object */
+	if (!strcmp(name, "pgcnx"))
+	{
+		if (check_lo(self, 0))
+		{
+			Py_INCREF(self->pgcnx);
+			return (PyObject *) (self->pgcnx);
+		}
+
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
+
+	/* large object oid */
+	if (!strcmp(name, "oid"))
+	{
+		if (check_lo(self, 0))
+			return PyInt_FromLong(self->lo_oid);
+
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
+
+	/* error (status) message */
+	if (!strcmp(name, "error"))
+		return PyString_FromString(PQerrorMessage(self->pgcnx->cnx));
+
+	/* attributes list */
+	if (!strcmp(name, "__members__"))
+	{
+		PyObject       *list = PyList_New(3);
+
+		if (list)
+		{
+			PyList_SetItem(list, 0, PyString_FromString("oid"));
+			PyList_SetItem(list, 1, PyString_FromString("pgcnx"));
+			PyList_SetItem(list, 2, PyString_FromString("error"));
+		}
+
+		return list;
+	}
+
+	return Py_FindMethod(pglarge_methods, (PyObject *) self, name);
+}
+
+/* object type definition */
+staticforward PyTypeObject PglargeType = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,								/* ob_size */
+	"pglarge",						/* tp_name */
+	sizeof(pglargeobject),			/* tp_basicsize */
+	0,								/* tp_itemsize */
+
+	/* methods */
+	(destructor) pglarge_dealloc,	/* tp_dealloc */
+	0,								/* tp_print */
+	(getattrfunc) pglarge_getattr,	/* tp_getattr */
+	0,								/* tp_setattr */
+	0,								/* tp_compare */
+	0,								/* tp_repr */
+	0,								/* tp_as_number */
+	0,								/* tp_as_sequence */
+	0,								/* tp_as_mapping */
+	0,								/* tp_hash */
+};
+
+#endif							/* LARGE_OBJECTS */
+
+/* --------------------------------------------------------------------- */
+
+/* PG CONNECTION OBJECT IMPLEMENTATION */
+
+/* pgobject initialisation (from module) */
+
+static PyObject *
+pgconnect(pgobject * self, PyObject * args, PyObject * dict)
+{
+	char           *pghost, *pgopt, *pgtty, *pgdbname;
+	int             pgport;
+	char            port_buffer[20];
+	PyObject       *temp;
+	pgobject       *npgobj;
+	PGconn         *test_cnx;
+
+	pghost = pgopt = pgtty = pgdbname = NULL;
+	pgport = -1;
+
+	/* parses standard arguments */
+	if (!PyArg_ParseTuple(args, "|zzlzz",
+					&pgdbname, &pghost, &pgport, &pgopt, &pgtty))
+	{
+		PyErr_Clear();
+
+		if (!PyArg_ParseTuple(args, ""))
+		{
+			PyErr_SetString(PyExc_TypeError,
+						"connect(dbname, host, port, opt, tty), "
+							"with args (opt., strings or None).");
+			return NULL;
+		}
+	}
+
+	/* looks for keywords arguments */
+	if (PyMapping_Check(dict))
+	{
+		/* server host */
+		if (PyMapping_HasKeyString(dict, "host"))
+		{
+			if ((temp = PyMapping_GetItemString(dict, "host")) != NULL)
+			{
+				if (pghost)
+				{
+					PyErr_SetString(PyExc_SyntaxError,
+								"Duplicate argument definition.");
+					return NULL;
+				}
+
+				if (!PyString_Check(temp))
+				{
+					PyErr_SetString(PyExc_TypeError,
+								 "'Host' argument must be a string.");
+					return NULL;
+				}
+
+				pghost = PyString_AsString(temp);
+			}
+		}
+
+		/* server port */
+		if (PyMapping_HasKeyString(dict, "port"))
+		{
+			if ((temp = PyMapping_GetItemString(dict, "port")) != NULL)
+			{
+				if (pgport != -1)
+				{
+					PyErr_SetString(PyExc_SyntaxError,
+								"Duplicate argument definition.");
+					return NULL;
+				}
+
+				if (!PyInt_Check(temp))
+				{
+					PyErr_SetString(PyExc_TypeError,
+								"'Port' argument must be an integer.");
+					return NULL;
+				}
+
+				pgport = PyInt_AsLong(temp);
+			}
+		}
+
+		/* connection options */
+		if (PyMapping_HasKeyString(dict, "opt"))
+		{
+			if ((temp = PyMapping_GetItemString(dict, "opt")) != NULL)
+			{
+				if (pgtty)
+				{
+					PyErr_SetString(PyExc_SyntaxError,
+								"Duplicate argument definition.");
+					return NULL;
+				}
+
+				if (!PyString_Check(temp))
+				{
+					PyErr_SetString(PyExc_TypeError,
+								"'opt' argument must be a string.");
+					return NULL;
+				}
+
+				pgopt = PyString_AsString(temp);
+			}
+		}
+
+		/* debug terminal */
+		if (PyMapping_HasKeyString(dict, "tty"))
+		{
+			if ((temp = PyMapping_GetItemString(dict, "tty")) != NULL)
+			{
+				if (pgtty)
+				{
+					PyErr_SetString(PyExc_SyntaxError,
+							"Duplicate argument definition.");
+					return NULL;
+				}
+
+				if (!PyString_Check(temp))
+				{
+					PyErr_SetString(PyExc_TypeError,
+							"'tty' argument must be a string.");
+					return NULL;
+				}
+
+				pgtty = PyString_AsString(temp);
+			}
+		}
+
+		/* database name */
+		if (PyMapping_HasKeyString(dict, "dbname"))
+		{
+			if ((temp = PyMapping_GetItemString(dict, "dbname")) != NULL)
+			{
+				if (pgdbname)
+				{
+					PyErr_SetString(PyExc_SyntaxError,
+							"Duplicate argument definition.");
+					return NULL;
+				}
+
+				if (!PyString_Check(temp))
+				{
+					PyErr_SetString(PyExc_TypeError,
+							"'dbname' argument must be a string.");
+					return NULL;
+				}
+
+				pgdbname = PyString_AsString(temp);
+			}
+		}
+	}
+
+#ifdef DEFAULT_VARS
+	/* handles defaults variables (for unintialised vars) */
+	if ((!pghost) && (pg_default_host != Py_None))
+		pghost = PyString_AsString(pg_default_host);
+
+	if ((pgport == -1) && (pg_default_port != Py_None))
+		pgport = PyInt_AsLong(pg_default_port);
+
+	if ((!pgopt) && (pg_default_opt != Py_None))
+		pgopt = PyString_AsString(pg_default_opt);
+
+	if ((!pgtty) && (pg_default_tty != Py_None))
+		pgtty = PyString_AsString(pg_default_tty);
+
+	if ((!pgdbname) && (pg_default_base != Py_None))
+		pgdbname = PyString_AsString(pg_default_base);
+#endif							/* DEFAULT_VARS */
+
+	if ((npgobj = PyObject_NEW(pgobject, &PgType)) == NULL)
+		return NULL;
+
+	if (pgport != -1)
+	{
+		bzero(port_buffer, sizeof(port_buffer));
+		sprintf(port_buffer, "%d", pgport);
+		npgobj->cnx = PQsetdb(pghost, port_buffer, pgopt, pgtty, pgdbname);
+	}
+	else
+		npgobj->cnx = PQsetdb(pghost, NULL, pgopt, pgtty, pgdbname);
+
+	if (PQstatus(npgobj->cnx) == CONNECTION_BAD)
+	{
+		PyErr_SetString(PGError, PQerrorMessage(npgobj->cnx));
+		Py_XDECREF(npgobj);
+		return NULL;
+	}
+
+	return (PyObject *) npgobj;
+}
+
+/* pgobject methods */
+
+/* destructor */
+static void
+pg_dealloc(pgobject * self)
+{
+	PQfinish(self->cnx);
+	PyMem_DEL(self);
+}
+
+static void
+pg_querydealloc(pgqueryobject * self)
+{
+	if (self->last_result)
+		PQclear(self->last_result);
+
+	PyMem_DEL(self);
+}
+
+/* resets connection */
+static PyObject *
+pg_reset(pgobject * self, PyObject * args)
+{
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method reset() takes no parameters.");
+		return NULL;
+	}
+
+	/* resets the connection */
+	PQreset(self->cnx);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* list fields names from query result */
+static PyObject *
+pg_listfields(pgqueryobject * self, PyObject * args)
+{
+	int             i, n;
+	char           *name;
+	PyObject       *fieldstuple, *str;
+
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method listfields() takes no parameters.");
+		return NULL;
+	}
+
+	/* builds tuple */
+	n = PQnfields(self->last_result);
+	fieldstuple = PyTuple_New(n);
+
+	for (i = 0; i < n; i++)
+	{
+		name = PQfname(self->last_result, i);
+		str = PyString_FromString(name);
+		PyTuple_SetItem(fieldstuple, i, str);
+	}
+
+	return fieldstuple;
+}
+
+/* get field name from last result */
+static PyObject *
+pg_fieldname(pgqueryobject * self, PyObject * args)
+{
+	int             i;
+	char           *name;
+
+	/* gets args */
+	if (!PyArg_ParseTuple(args, "i", &i))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"fieldname(number), with number(integer).");
+		return NULL;
+	}
+
+	/* checks number validity */
+	if (i >= PQnfields(self->last_result))
+	{
+		PyErr_SetString(PyExc_ValueError, "invalid field number.");
+		return NULL;
+	}
+
+	/* gets fields name and builds object */
+	name = PQfname(self->last_result, i);
+	return PyString_FromString(name);
+}
+
+/* gets fields number from name in last result */
+static PyObject *
+pg_fieldnum(pgqueryobject * self, PyObject * args)
+{
+	char           *name;
+	int             num;
+
+	/* gets args */
+	if (!PyArg_ParseTuple(args, "s", &name))
+	{
+		PyErr_SetString(PyExc_TypeError, "fieldnum(name), with name (string).");
+		return NULL;
+	}
+
+	/* gets field number */
+	if ((num = PQfnumber(self->last_result, name)) == -1)
+	{
+		PyErr_SetString(PyExc_ValueError, "Unknown field.");
+		return NULL;
+	}
+
+	return PyInt_FromLong(num);
+}
+
+/* retrieves last result */
+static PyObject *
+pg_getresult(pgqueryobject * self, PyObject * args)
+{
+	PyObject       *rowtuple, *reslist, *str;
+	int             i, j, m, n;
+
+	/* checks args (args == NULL for an internal call) */
+	if ((args != NULL) && (!PyArg_ParseTuple(args, "")))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method getresult() takes no parameters.");
+		return NULL;
+	}
+
+	/* stores result in tuple */
+	reslist = PyList_New(0);
+	m = PQntuples(self->last_result);
+	n = PQnfields(self->last_result);
+
+	for (i = 0; i < m; i++)
+	{
+		rowtuple = PyTuple_New(n);
+		for (j = 0; j < n; j++)
+		{
+			str = PyString_FromString(PQgetvalue(self->last_result, i, j));
+			PyTuple_SetItem(rowtuple, j, str);
+		}
+
+		PyList_Append(reslist, rowtuple);
+		Py_XDECREF(rowtuple);
+	}
+
+	/* returns list */
+	return reslist;
+}
+
+/* getq asynchronous notify */
+static PyObject *
+pg_getnotify(pgobject * self, PyObject * args)
+{
+	PGnotify       *notify;
+	PGresult       *result;
+	PyObject       *notify_result, *temp;
+
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method getnotify() takes no parameters.");
+		return NULL;
+	}
+
+	/* gets notify and builds result */
+	/* notifies only come back as result of a query, so I send an empty query */
+	result = PQexec(self->cnx, " ");
+
+	if ((notify = PQnotifies(self->cnx)) != NULL)
+	{
+		notify_result = PyTuple_New(2);
+		temp = PyString_FromString(notify->relname);
+		PyTuple_SetItem(notify_result, 0, temp);
+		temp = PyInt_FromLong(notify->be_pid);
+		PyTuple_SetItem(notify_result, 1, temp);
+		free(notify);
+	}
+	else
+	{
+		Py_INCREF(Py_None);
+		notify_result = Py_None;
+	}
+
+	PQclear(result);
+
+	/* returns result */
+	return notify_result;
+}
+
+/* database query */
+static PyObject *
+pg_query(pgobject * self, PyObject * args)
+{
+	char           *query;
+	PGresult       *result;
+	PyObject       *rowtuple, *reslist, *str;
+	pgqueryobject  *npgobj;
+	int             i, j, m, n, status;
+
+	/* get query args */
+	if (!PyArg_ParseTuple(args, "s", &query))
+	{
+		PyErr_SetString(PyExc_TypeError, "query(sql), with sql (string).");
+		return NULL;
+	}
+
+	/* gets result */
+	result = PQexec(self->cnx, query);
+
+	/* checks result validity */
+	if (!result)
+	{
+		PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->cnx));
+		return NULL;
+	}
+
+	/* checks result status */
+	if ((status = PQresultStatus(result)) != PGRES_TUPLES_OK)
+	{
+		PQclear(result);
+
+		switch (status)
+		{
+			case PGRES_EMPTY_QUERY:
+				PyErr_SetString(PyExc_ValueError, "empty query.");
+				break;
+			case PGRES_BAD_RESPONSE:
+				PyErr_SetString(PGError,
+						"unexpected responsed received from server.");
+				break;
+			case PGRES_FATAL_ERROR:
+				PyErr_SetString(PGError,
+					"server fatal error.  "
+							"Please report to your db administrator.");
+				break;
+			case PGRES_NONFATAL_ERROR:
+				PyErr_SetString(PGError, "server (non fatal) error.");
+				break;
+			case PGRES_COMMAND_OK:	/* no data will be received */
+			case PGRES_COPY_OUT:
+			case PGRES_COPY_IN:
+				Py_INCREF(Py_None);
+				return Py_None;
+			default:
+				PyErr_SetString(PGError, "internal error: "
+											"unknown result status.");
+				break;
+		}
+
+		return NULL;			/* error detected on query */
+	}
+
+	if ((npgobj = PyObject_NEW(pgqueryobject, &PgQueryType)) == NULL)
+		return NULL;
+
+	/* stores result and returns object */
+	npgobj->last_result = result;
+	return (PyObject *) npgobj;
+}
+
+#ifdef DIRECT_ACCESS
+/* direct acces function : putline */
+static PyObject *
+pg_putline(pgobject * self, PyObject * args)
+{
+	char           *line;
+
+	/* reads args */
+	if (!PyArg_ParseTuple(args, "s", &line))
+	{
+		PyErr_SetString(PyExc_TypeError, "putline(line), with line (string).");
+		return NULL;
+	}
+
+	/* sends line to backend */
+	PQputline(self->cnx, line);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* direct access function : getline */
+static PyObject *
+pg_getline(pgobject * self, PyObject * args)
+{
+	char           *line;
+	PyObject       *str;
+	int             ret;
+
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method getline() takes no parameters.");
+		return NULL;
+	}
+
+	/* allocate buffer */
+	if ((line = malloc(MAX_BUFFER_SIZE)) == NULL)
+	{
+		PyErr_SetString(PyExc_MemoryError, "can't allocate getline buffer");
+		return NULL;
+	}
+
+	/* gets line */
+	switch (PQgetline(self->cnx, line, MAX_BUFFER_SIZE))
+	{
+		case 0:
+			str = PyString_FromString(line);
+			break;
+		case 1:
+			PyErr_SetString(PyExc_MemoryError, "buffer overflow");
+			str = NULL;
+			break;
+		case EOF:
+			Py_INCREF(Py_None);
+			str = Py_None;
+			break;
+	}
+
+	free(line);
+	return str;
+}
+
+/* direct access function : end copy */
+static PyObject *
+pg_endcopy(pgobject * self, PyObject * args)
+{
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method endcopy() takes no parameters.");
+		return NULL;
+	}
+
+	/* ends direct copy */
+	PQendcopy(self->cnx);
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+#endif							/* DIRECT_ACCESS */
+
+
+static PyObject *
+pg_print(pgqueryobject *self, FILE *fp, int flags)
+{
+	PQprintOpt		op;
+
+	memset(&op, 0, sizeof(op));
+	op.align = 1; 
+	op.header = 1;
+	op.fieldSep = "|";
+	op.pager = 1;
+	PQprint(fp, self->last_result, &op);
+	return 0;
+}
+
+/* insert table */
+static PyObject *
+pg_inserttable(pgobject * self, PyObject * args)
+{
+	PGresult       *result;
+	char           *table, *buffer, *temp;
+	char            temp_buffer[256];
+	PyObject       *list, *sublist, *item;
+	PyObject       *(*getitem) (PyObject *, int);
+	PyObject       *(*getsubitem) (PyObject *, int);
+	int             i, j;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "sO:filter", &table, &list))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"tableinsert(table, content), with table (string) "
+				   "and content (list).");
+		return NULL;
+	}
+
+	/* checks list type */
+	if (PyTuple_Check(list))
+		getitem = PyTuple_GetItem;
+	else if (PyList_Check(list))
+		getitem = PyList_GetItem;
+	else
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"second arg must be some kind of array.");
+		return NULL;
+	}
+
+	/* checks sublists type */
+	for (i = 0; sublist = getitem(list, i); i++)
+	{
+		if (!PyTuple_Check(sublist) && !PyList_Check(sublist))
+		{
+			PyErr_SetString(PyExc_TypeError,
+					"second arg must contain some kind of arrays.");
+			return NULL;
+		}
+	}
+
+	/* allocate buffer */
+	if (!(buffer = (char *) malloc(MAX_BUFFER_SIZE)))
+	{
+		PyErr_SetString(PyExc_MemoryError, "can't allocate insert buffer.");
+		return NULL;
+	}
+
+	/* starts query */
+	sprintf(buffer, "copy %s from stdin", table);
+
+	if (!(result = PQexec(self->cnx, buffer)))
+	{
+		free(buffer);
+		PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->cnx));
+		return NULL;
+	}
+
+	PQclear(result);
+
+	/* feeds table */
+	for (i = 0; sublist = getitem(list, i); i++)
+	{
+		if (PyTuple_Check(sublist))
+			getsubitem = PyTuple_GetItem;
+		else
+			getsubitem = PyList_GetItem;
+
+		/* builds insert line */
+		buffer[0] = 0;
+
+		for (j = 0; item = getsubitem(sublist, j); j++)
+		{
+			/* converts item to string */
+			if (PyString_Check(item))
+				PyArg_ParseTuple(item, "s", &temp);
+			else if (PyInt_Check(item))
+			{
+				int             k;
+
+				PyArg_ParseTuple(item, "i", &k);
+				sprintf(temp_buffer, "%d", k);
+				temp = temp_buffer;
+			}
+			else if (PyLong_Check(item))
+			{
+				long            k;
+
+				PyArg_ParseTuple(item, "l", &k);
+				sprintf(temp_buffer, "%ld", k);
+				temp = temp_buffer;
+			}
+			else if (PyFloat_Check(item))
+			{
+				double          k;
+
+				PyArg_ParseTuple(item, "d", &k);
+				sprintf(temp_buffer, "%g", k);
+				temp = temp_buffer;
+			}
+			else
+			{
+				free(buffer);
+				PyErr_SetString(PyExc_ValueError,
+						"items must be strings, integers, "
+						   "longs or double (real).");
+				return NULL;
+			}
+
+			/* concats buffer */
+			if (strlen(buffer))
+				strncat(buffer, "\t", MAX_BUFFER_SIZE - strlen(buffer));
+
+			strncat(buffer, temp, MAX_BUFFER_SIZE - strlen(buffer));
+		}
+
+		strncat(buffer, "\n", MAX_BUFFER_SIZE - strlen(buffer));
+
+		/* sends data */
+		PQputline(self->cnx, buffer);
+	}
+
+	/* ends query */
+	PQputline(self->cnx, ".\n");
+	PQendcopy(self->cnx);
+	free(buffer);
+
+	/* no error : returns nothing */
+	Py_INCREF(Py_None);
+	return Py_None;
+}
+
+/* connection object methods */
+static struct PyMethodDef pgobj_methods[] = {
+	{"query",		(PyCFunction) pg_query, 1},			/* query method */
+	{"reset",		(PyCFunction) pg_reset, 1},			/* connection reset */
+	{"getnotify",	(PyCFunction) pg_getnotify, 1},		/* checks for notify */
+	{"inserttable",	(PyCFunction) pg_inserttable, 1},	/* table insert */
+
+#ifdef DIRECT_ACCESS
+	{"putline",		(PyCFunction) pg_putline, 1},	/* direct access: putline */
+	{"getline",		(PyCFunction) pg_getline, 1},	/* direct access: getline */
+	{"endcopy",		(PyCFunction) pg_endcopy, 1},	/* direct access: endcopy */
+#endif							/* DIRECT_ACCESS */
+
+#ifdef LARGE_OBJECTS
+	{"locreate",	(PyCFunction) pg_locreate, 1},	/* creates large object */
+	{"getlo",		(PyCFunction) pg_getlo, 1},		/* get lo from oid */
+	{"loimport",	(PyCFunction) pg_loimport, 1},	/* imports lo from file */
+#endif							/* LARGE_OBJECTS */
+
+	{NULL, NULL}				/* sentinel */
+};
+
+/* get attribute */
+static PyObject *
+pg_getattr(pgobject * self, char *name)
+{
+	/* list postgreSQL connection fields */
+
+	/* postmaster host */
+	if (!strcmp(name, "host"))
+		return PyString_FromString(PQhost(self->cnx));
+
+	/* postmaster port */
+	if (!strcmp(name, "port"))
+		return PyInt_FromLong(atol(PQport(self->cnx)));
+
+	/* selected database */
+	if (!strcmp(name, "db"))
+		return PyString_FromString(PQdb(self->cnx));
+
+	/* selected options */
+	if (!strcmp(name, "options"))
+		return PyString_FromString(PQoptions(self->cnx));
+
+	/* selected postgres tty */
+	if (!strcmp(name, "tty"))
+		return PyString_FromString(PQtty(self->cnx));
+
+	/* error (status) message */
+	if (!strcmp(name, "error"))
+		return PyString_FromString(PQerrorMessage(self->cnx));
+
+	/* connection status : 1 - OK, 0 - BAD */
+	if (!strcmp(name, "status"))
+		return PyInt_FromLong(PQstatus(self->cnx) == CONNECTION_OK ? 1 : 0);
+
+	/* provided user name */
+	if (!strcmp(name, "user"))
+		return PyString_FromString(fe_getauthname("<unknown user>"));
+
+	/* attributes list */
+	if (!strcmp(name, "__members__"))
+	{
+		PyObject       *list = PyList_New(8);
+
+		if (list)
+		{
+			PyList_SetItem(list, 0, PyString_FromString("host"));
+			PyList_SetItem(list, 1, PyString_FromString("port"));
+			PyList_SetItem(list, 2, PyString_FromString("db"));
+			PyList_SetItem(list, 3, PyString_FromString("options"));
+			PyList_SetItem(list, 4, PyString_FromString("tty"));
+			PyList_SetItem(list, 5, PyString_FromString("error"));
+			PyList_SetItem(list, 6, PyString_FromString("status"));
+			PyList_SetItem(list, 7, PyString_FromString("user"));
+		}
+
+		return list;
+	}
+
+	return Py_FindMethod(pgobj_methods, (PyObject *) self, name);
+}
+
+/* object type definition */
+staticforward PyTypeObject PgType = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,							/* ob_size */
+	"pgobject",					/* tp_name */
+	sizeof(pgobject),			/* tp_basicsize */
+	0,							/* tp_itemsize */
+	/* methods */
+	(destructor) pg_dealloc,	/* tp_dealloc */
+	0,							/* tp_print */
+	(getattrfunc) pg_getattr,	/* tp_getattr */
+	0,							/* tp_setattr */
+	0,							/* tp_compare */
+	0,							/* tp_repr */
+	0,							/* tp_as_number */
+	0,							/* tp_as_sequence */
+	0,							/* tp_as_mapping */
+	0,							/* tp_hash */
+};
+
+
+/* query object methods */
+static struct PyMethodDef pgquery_methods[] = {
+	{"getresult",	(PyCFunction) pg_getresult, 1},		/* get last result */
+	{"fieldname",	(PyCFunction) pg_fieldname, 1},		/* get field name */
+	{"fieldnum",	(PyCFunction) pg_fieldnum, 1},		/* get field number */
+	{"listfields",	(PyCFunction) pg_listfields, 1},	/* list fields names */
+	{NULL, NULL}				/* sentinel */
+};
+
+static PyObject *
+pg_querygetattr(pgqueryobject * self, char *name)
+{
+	/* list postgreSQL connection fields */
+	return Py_FindMethod(pgquery_methods, (PyObject *) self, name);
+}
+
+/* query type definition */
+staticforward PyTypeObject PgQueryType = {
+	PyObject_HEAD_INIT(&PyType_Type)
+	0,							/* ob_size */
+	"pgqueryobject",			/* tp_name */
+	sizeof(pgqueryobject),		/* tp_basicsize */
+	0,							/* tp_itemsize */
+	/* methods */
+	(destructor) pg_querydealloc,/* tp_dealloc */
+	(printfunc) pg_print,		/* tp_print */
+	(getattrfunc) pg_querygetattr,/* tp_getattr */
+	0,							/* tp_setattr */
+	0,							/* tp_compare */
+	0,							/* tp_repr */
+	0,							/* tp_as_number */
+	0,							/* tp_as_sequence */
+	0,							/* tp_as_mapping */
+	0,							/* tp_hash */
+};
+
+
+
+/* --------------------------------------------------------------------- */
+
+/* MODULE FUNCTIONS */
+
+#ifdef DEFAULT_VARS
+
+/* gets default host */
+PyObject       *
+pggetdefhost(PyObject *self, PyObject *args)
+{
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method get_defhost() takes no parameter.");
+		return NULL;
+	}
+
+	Py_XINCREF(pg_default_host);
+	return pg_default_host;
+}
+
+/* sets default host */
+PyObject       *
+pgsetdefhost(PyObject * self, PyObject *args)
+{
+	char           *temp = NULL;
+	PyObject       *old;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "z", &temp))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"set_defhost(name), with name (string/None).");
+		return NULL;
+	}
+
+	/* adjusts value */
+	old = pg_default_host;
+
+	if (temp)
+		pg_default_host = PyString_FromString(temp);
+	else
+	{
+		Py_INCREF(Py_None);
+		pg_default_host = Py_None;
+	}
+
+	return old;
+}
+
+/* gets default base */
+PyObject       *
+pggetdefbase(PyObject * self, PyObject *args)
+{
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method get_defbase() takes no parameter.");
+		return NULL;
+	}
+
+	Py_XINCREF(pg_default_base);
+	return pg_default_base;
+}
+
+/* sets default base */
+PyObject       *
+pgsetdefbase(PyObject * self, PyObject *args)
+{
+	char           *temp = NULL;
+	PyObject       *old;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "z", &temp))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"set_defbase(name), with name (string/None).");
+		return NULL;
+	}
+
+	/* adjusts value */
+	old = pg_default_base;
+
+	if (temp)
+		pg_default_base = PyString_FromString(temp);
+	else
+	{
+		Py_INCREF(Py_None);
+		pg_default_base = Py_None;
+	}
+
+	return old;
+}
+
+/* gets default options */
+PyObject       *
+pggetdefopt(PyObject * self, PyObject *args)
+{
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method get_defopt() takes no parameter.");
+		return NULL;
+	}
+
+	Py_XINCREF(pg_default_opt);
+	return pg_default_opt;
+}
+
+/* sets default opt */
+PyObject       *
+pgsetdefopt(PyObject * self, PyObject *args)
+{
+	char           *temp = NULL;
+	PyObject       *old;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "z", &temp))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"set_defopt(name), with name (string/None).");
+		return NULL;
+	}
+
+	/* adjusts value */
+	old = pg_default_opt;
+
+	if (temp)
+		pg_default_opt = PyString_FromString(temp);
+	else
+	{
+		Py_INCREF(Py_None);
+		pg_default_opt = Py_None;
+	}
+
+	return old;
+}
+
+/* gets default tty */
+PyObject       *
+pggetdeftty(PyObject * self, PyObject *args)
+{
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method get_deftty() takes no parameter.");
+		return NULL;
+	}
+
+	Py_XINCREF(pg_default_tty);
+	return pg_default_tty;
+}
+
+/* sets default tty */
+PyObject       *
+pgsetdeftty(PyObject * self, PyObject *args)
+{
+	char           *temp = NULL;
+	PyObject       *old;
+
+	/* gets arguments */
+	if (!PyArg_ParseTuple(args, "z", &temp))
+	{
+		PyErr_SetString(PyExc_TypeError,
+				"set_deftty(name), with name (string/None).");
+		return NULL;
+	}
+
+	/* adjusts value */
+	old = pg_default_tty;
+
+	if (temp)
+		pg_default_tty = PyString_FromString(temp);
+	else
+	{
+		Py_INCREF(Py_None);
+		pg_default_tty = Py_None;
+	}
+
+	return old;
+}
+
+/* gets default port */
+PyObject       *
+pggetdefport(PyObject * self, PyObject *args)
+{
+	char           *temp;
+
+	/* checks args */
+	if (!PyArg_ParseTuple(args, ""))
+	{
+		PyErr_SetString(PyExc_SyntaxError,
+				"method get_defport() takes no parameter.");
+		return NULL;
+	}
+
+	Py_XINCREF(pg_default_port);
+	return pg_default_port;
+}
+
+/* sets default port */
+PyObject       *
+pgsetdefport(PyObject * self, PyObject *args)
+{
+	long int        port = -2;
+	char            buffer[64], *temp;
+	PyObject       *old;
+
+	/* gets arguments */
+	if ((!PyArg_ParseTuple(args, "l", &port)) || (port < -1))
+	{
+		PyErr_SetString(PyExc_TypeError, "set_defport(port), with port "
+				   "(positive integer/-1).");
+		return NULL;
+	}
+
+	/* adjusts value */
+	old = pg_default_port;
+
+	if (port != -1)
+		pg_default_port = PyLong_FromLong(port);
+	else
+	{
+		Py_INCREF(Py_None);
+		pg_default_port = Py_None;
+	}
+
+	return old;
+}
+
+#endif							/* DEFAULT_VARS */
+
+/* List of functions defined in the module */
+
+static struct PyMethodDef pg_methods[] = {
+	{"connect", (PyCFunction) pgconnect, 3},/* connect to a postgres database */
+#ifdef DEFAULT_VARS
+	{"get_defhost",	pggetdefhost, 1},		/* gets default host */
+	{"set_defhost",	pgsetdefhost, 1},		/* sets default host */
+	{"get_defbase",	pggetdefbase, 1},		/* gets default base */
+	{"set_defbase",	pgsetdefbase, 1},		/* sets default base */
+	{"get_defopt",	pggetdefopt, 1},		/* gets default options */
+	{"set_defopt",	pgsetdefopt, 1},		/* sets default options */
+	{"get_deftty",	pggetdeftty, 1},		/* gets default debug tty */
+	{"set_deftty",	pgsetdeftty, 1},		/* sets default debug tty */
+	{"get_defport",	pggetdefport, 1},		/* gets default port */
+	{"set_defport",	pgsetdefport, 1},		/* sets default port */
+#endif							/* DEFAULT_VARS */
+	{NULL, NULL}				/* sentinel */
+};
+
+static char pg__doc__[] = "Python interface to PostgreSQL DB"; 
+
+/* Initialization function for the module */
+void
+initpg(void)
+{
+	PyObject       *mod, *dict;
+
+	/* Create the module and add the functions */
+	mod = Py_InitModule4("pg", pg_methods, pg__doc__, NULL, PYTHON_API_VERSION);
+	dict = PyModule_GetDict(mod);
+
+	/* Add some symbolic constants to the module */
+	PGError = PyString_FromString("pg.error");
+	PyDict_SetItemString(dict, "error", PGError);
+
+	/* create mode for large objects */
+	PyDict_SetItemString(dict, "INV_READ", PyInt_FromLong(INV_READ));
+	PyDict_SetItemString(dict, "INV_WRITE", PyInt_FromLong(INV_WRITE));
+	PyDict_SetItemString(dict, "INV_ARCHIVE", PyInt_FromLong(INV_ARCHIVE));
+
+#ifdef LARGE_OBJECTS
+	/* position flags for lo_lseek */
+	PyDict_SetItemString(dict, "SEEK_SET", PyInt_FromLong(SEEK_SET));
+	PyDict_SetItemString(dict, "SEEK_CUR", PyInt_FromLong(SEEK_CUR));
+	PyDict_SetItemString(dict, "SEEK_END", PyInt_FromLong(SEEK_END));
+#endif							/* LARGE_OBJECTS */
+
+#ifdef DEFAULT_VARS
+	/* prepares default values */
+	Py_INCREF(Py_None); pg_default_host = Py_None;
+	Py_INCREF(Py_None); pg_default_base = Py_None;
+	Py_INCREF(Py_None); pg_default_opt = Py_None;
+	Py_INCREF(Py_None); pg_default_port = Py_None;
+	Py_INCREF(Py_None); pg_default_tty = Py_None;
+#endif							/* DEFAULT_VARS */
+
+	/* Check for errors */
+	if (PyErr_Occurred())
+		Py_FatalError("can't initialize module pg");
+}