Changeset 530


Ignore:
Timestamp:
Nov 13, 2015, 11:49:45 AM (4 years ago)
Author:
darcy
Message:

More re-organization. Still passes all tests.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/module/pgmodule.c

    r528 r530  
    5353static const char *PyPgVersion = TOSTRING(PYGRESQL_VERSION);
    5454
    55 #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
     55#ifndef IS_PY3K
     56# if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
    5657typedef int Py_ssize_t;
    5758#define PY_SSIZE_T_MAX INT_MAX
    5859#define PY_SSIZE_T_MIN INT_MIN
     60#endif
    5961#endif
    6062
     
    153155static PyTypeObject connType;
    154156
    155 /* pg connection object */
    156 
     157/* forward static declarations */
     158static void notice_receiver(void *, const PGresult *);
     159
     160/* --------------------------------------------------------------------- */
     161/* Object declarations */
     162/* --------------------------------------------------------------------- */
    157163typedef struct
    158164{
     
    163169}       connObject;
    164170#define is_connObject(v) (PyType(v) == &connType)
    165 
    166 static PyObject *
    167 connNew(void)
    168 {
    169         connObject      *pgobj;
    170 
    171         if (!(pgobj = PyObject_NEW(connObject, &connType)))
    172                 return NULL;
    173 
    174         pgobj->valid = 1;
    175         pgobj->cnx = NULL;
    176         pgobj->notice_receiver = NULL;
    177 
    178         return (PyObject *) pgobj;
    179 }
    180 
    181 /* pg notice result object */
    182 
    183 typedef struct
    184 {
    185         PyObject_HEAD
    186         connObject      *pgcnx;         /* parent connection object */
    187         PGresult        const *res;     /* an error or warning */
    188 }       pgnoticeobject;
    189 #define is_pgnoticeobject(v) (PyType(v) == &noticeType)
    190 
    191 /* pg query object */
    192 
    193 typedef struct
    194 {
    195         PyObject_HEAD
    196         PGresult        *result;                /* result content */
    197         int                     result_type;    /* type of previous result */
    198         long            current_pos;    /* current position in last result */
    199         long            num_rows;               /* number of (affected) rows */
    200 }       pgqueryobject;
    201 #define is_pgqueryobject(v) (PyType(v) == &queryType)
    202 
    203 /* pg source object */
    204171
    205172typedef struct
     
    214181        int                     max_row;                /* number of rows in the result */
    215182        int                     num_fields;             /* number of fields in each row */
    216 }       pgsourceobject;
    217 #define is_pgsourceobject(v) (PyType(v) == &sourceType)
     183}       sourceObject;
     184#define is_sourceObject(v) (PyType(v) == &sourceType)
     185
     186typedef struct
     187{
     188        PyObject_HEAD
     189        connObject      *pgcnx;         /* parent connection object */
     190        PGresult        const *res;     /* an error or warning */
     191}       noticeObject;
     192#define is_noticeObject(v) (PyType(v) == &noticeType)
     193
     194typedef struct
     195{
     196        PyObject_HEAD
     197        PGresult        *result;                /* result content */
     198        int                     result_type;    /* type of previous result */
     199        long            current_pos;    /* current position in last result */
     200        long            num_rows;               /* number of (affected) rows */
     201}       queryObject;
     202#define is_queryObject(v) (PyType(v) == &queryType)
    218203
    219204#ifdef LARGE_OBJECTS
    220 /* pg large object */
    221 
    222205typedef struct
    223206{
     
    226209        Oid                     lo_oid;                 /* large object oid */
    227210        int                     lo_fd;                  /* large object fd */
    228 }       pglargeobject;
    229 #define is_pglargeobject(v) (PyType(v) == &largeType)
     211}       largeObject;
     212#define is_largeObject(v) (PyType(v) == &largeType)
    230213#endif /* LARGE_OBJECTS */
    231214
     215
    232216/* --------------------------------------------------------------------- */
    233 /* INTERNAL FUNCTIONS */
     217/* Internal Functions */
     218/* --------------------------------------------------------------------- */
     219/* shared functions for converting PG types to Python types */
     220static int *
     221get_type_array(PGresult *result, int nfields)
     222{
     223        int *typ;
     224        int j;
     225
     226        if (!(typ = malloc(sizeof(int) * nfields)))
     227        {
     228                PyErr_SetString(PyExc_MemoryError, "memory error in getresult().");
     229                return NULL;
     230        }
     231
     232        for (j = 0; j < nfields; j++)
     233        {
     234                switch (PQftype(result, j))
     235                {
     236                        case INT2OID:
     237                        case INT4OID:
     238                        case OIDOID:
     239                                typ[j] = 1;
     240                                break;
     241
     242                        case INT8OID:
     243                                typ[j] = 2;
     244                                break;
     245
     246                        case FLOAT4OID:
     247                        case FLOAT8OID:
     248                                typ[j] = 3;
     249                                break;
     250
     251                        case NUMERICOID:
     252                                typ[j] = 4;
     253                                break;
     254
     255                        case CASHOID:
     256                                typ[j] = 5;
     257                                break;
     258
     259                        default:
     260                                typ[j] = 6;
     261                                break;
     262                }
     263        }
     264
     265        return typ;
     266}
     267
     268/* internal wrapper for the notice receiver callback */
     269static void notice_receiver(void *arg, const PGresult *res)
     270{
     271        PyGILState_STATE gstate = PyGILState_Ensure();
     272        connObject *self = (connObject*) arg;
     273        PyObject *proc = self->notice_receiver;
     274        if (proc && PyCallable_Check(proc))
     275        {
     276                noticeObject *notice = PyObject_NEW(noticeObject, &noticeType);
     277                PyObject *args, *ret;
     278                if (notice)
     279                {
     280                        notice->pgcnx = arg;
     281                        notice->res = res;
     282                }
     283                else
     284                {
     285                        Py_INCREF(Py_None);
     286                        notice = (noticeObject *)(void *)Py_None;
     287                }
     288                args = Py_BuildValue("(O)", notice);
     289                ret = PyObject_CallObject(proc, args);
     290                Py_XDECREF(ret);
     291                Py_DECREF(args);
     292        }
     293        PyGILState_Release(gstate);
     294}
    234295
    235296/* sets database error with sqlstate attribute */
     
    271332}
    272333
    273 
    274334/* checks connection validity */
    275335static int
     
    282342        }
    283343        return 1;
    284 }
    285 
    286 #ifdef LARGE_OBJECTS
    287 /* checks large object validity */
    288 static int
    289 check_lo_obj(pglargeobject *self, int level)
    290 {
    291         if (!check_cnx_obj(self->pgcnx))
    292                 return 0;
    293 
    294         if (!self->lo_oid)
    295         {
    296                 set_dberror(IntegrityError, "object is not valid (null oid).", NULL);
    297                 return 0;
    298         }
    299 
    300         if (level & CHECK_OPEN)
    301         {
    302                 if (self->lo_fd < 0)
    303                 {
    304                         PyErr_SetString(PyExc_IOError, "object is not opened.");
    305                         return 0;
    306                 }
    307         }
    308 
    309         if (level & CHECK_CLOSE)
    310         {
    311                 if (self->lo_fd >= 0)
    312                 {
    313                         PyErr_SetString(PyExc_IOError, "object is already opened.");
    314                         return 0;
    315                 }
    316         }
    317 
    318         return 1;
    319 }
    320 #endif /* LARGE_OBJECTS */
    321 
    322 /* checks source object validity */
    323 static int
    324 check_source_obj(pgsourceobject *self, int level)
    325 {
    326         if (!self->valid)
    327         {
    328                 set_dberror(OperationalError, "object has been closed", NULL);
    329                 return 0;
    330         }
    331 
    332         if ((level & CHECK_RESULT) && !self->result)
    333         {
    334                 set_dberror(DatabaseError, "no result.", NULL);
    335                 return 0;
    336         }
    337 
    338         if ((level & CHECK_DQL) && self->result_type != RESULT_DQL)
    339         {
    340                 set_dberror(DatabaseError,
    341                         "last query did not return tuples.", self->result);
    342                 return 0;
    343         }
    344 
    345         if ((level & CHECK_CNX) && !check_cnx_obj(self->pgcnx))
    346                 return 0;
    347 
    348         return 1;
    349 }
    350 
    351 /* shared functions for converting PG types to Python types */
    352 int *
    353 get_type_array(PGresult *result, int nfields)
    354 {
    355         int *typ;
    356         int j;
    357 
    358         if (!(typ = malloc(sizeof(int) * nfields)))
    359         {
    360                 PyErr_SetString(PyExc_MemoryError, "memory error in getresult().");
    361                 return NULL;
    362         }
    363 
    364         for (j = 0; j < nfields; j++)
    365         {
    366                 switch (PQftype(result, j))
    367                 {
    368                         case INT2OID:
    369                         case INT4OID:
    370                         case OIDOID:
    371                                 typ[j] = 1;
    372                                 break;
    373 
    374                         case INT8OID:
    375                                 typ[j] = 2;
    376                                 break;
    377 
    378                         case FLOAT4OID:
    379                         case FLOAT8OID:
    380                                 typ[j] = 3;
    381                                 break;
    382 
    383                         case NUMERICOID:
    384                                 typ[j] = 4;
    385                                 break;
    386 
    387                         case CASHOID:
    388                                 typ[j] = 5;
    389                                 break;
    390 
    391                         default:
    392                                 typ[j] = 6;
    393                                 break;
    394                 }
    395         }
    396 
    397         return typ;
    398344}
    399345
     
    404350 * and because using PQprint() and tp_print is not recommended any more.
    405351 */
    406 
    407352static PyObject *
    408353format_result(const PGresult *res)
     
    569514
    570515/* --------------------------------------------------------------------- */
    571 /* PG SOURCE OBJECT IMPLEMENTATION */
     516/* large objects                                                         */
     517/* --------------------------------------------------------------------- */
     518#ifdef LARGE_OBJECTS
     519
     520/* checks large object validity */
     521static int
     522check_lo_obj(largeObject *self, int level)
     523{
     524        if (!check_cnx_obj(self->pgcnx))
     525                return 0;
     526
     527        if (!self->lo_oid)
     528        {
     529                set_dberror(IntegrityError, "object is not valid (null oid).", NULL);
     530                return 0;
     531        }
     532
     533        if (level & CHECK_OPEN)
     534        {
     535                if (self->lo_fd < 0)
     536                {
     537                        PyErr_SetString(PyExc_IOError, "object is not opened.");
     538                        return 0;
     539                }
     540        }
     541
     542        if (level & CHECK_CLOSE)
     543        {
     544                if (self->lo_fd >= 0)
     545                {
     546                        PyErr_SetString(PyExc_IOError, "object is already opened.");
     547                        return 0;
     548                }
     549        }
     550
     551        return 1;
     552}
    572553
    573554/* constructor (internal use only) */
    574 static pgsourceobject *
    575 sourceNew(connObject *pgcnx)
    576 {
    577         pgsourceobject *npgobj;
    578 
    579         /* allocates new query object */
    580         if (!(npgobj = PyObject_NEW(pgsourceobject, &sourceType)))
    581                 return NULL;
    582 
    583         /* initializes internal parameters */
    584         Py_XINCREF(pgcnx);
    585         npgobj->pgcnx = pgcnx;
    586         npgobj->result = NULL;
    587         npgobj->valid = 1;
    588         npgobj->arraysize = PG_ARRAYSIZE;
    589 
    590         return npgobj;
    591 }
    592 
    593 /* destructor */
    594 static void
    595 sourceDelete(pgsourceobject *self)
    596 {
    597         if (self->result)
    598                 PQclear(self->result);
    599 
    600         Py_XDECREF(self->pgcnx);
    601         PyObject_Del(self);
    602 }
    603 
    604 /* closes object */
    605 static char sourceClose__doc__[] =
    606 "close() -- close query object without deleting it. "
    607 "All instances of the query object can no longer be used after this call.";
    608 
    609 static PyObject *
    610 pgsource_close(pgsourceobject *self, PyObject *args)
    611 {
    612         /* checks args */
    613         if (!PyArg_ParseTuple(args, ""))
    614         {
    615                 PyErr_SetString(PyExc_TypeError, "method close() takes no parameter.");
    616                 return NULL;
    617         }
    618 
    619         /* frees result if necessary and invalidates object */
    620         if (self->result)
    621         {
    622                 PQclear(self->result);
    623                 self->result_type = RESULT_EMPTY;
    624                 self->result = NULL;
    625         }
    626 
    627         self->valid = 0;
    628 
    629         /* return None */
    630         Py_INCREF(Py_None);
    631         return Py_None;
    632 }
    633 
    634 /* database query */
    635 static char sourceExecute__doc__[] =
    636 "execute(sql) -- execute a SQL statement (string).\n "
    637 "On success, this call returns the number of affected rows, "
    638 "or None for DQL (SELECT, ...) statements.\n"
    639 "The fetch (fetch(), fetchone() and fetchall()) methods can be used "
    640 "to get result rows.";
    641 
    642 static PyObject *
    643 pgsource_execute(pgsourceobject *self, PyObject *args)
    644 {
    645         char            *query;
    646 
    647         /* checks validity */
    648         if (!check_source_obj(self, CHECK_CNX))
    649                 return NULL;
    650 
    651         /* make sure that the connection object is valid */
    652         if (!self->pgcnx->cnx)
    653                 return NULL;
    654 
    655         /* get query args */
    656         if (!PyArg_ParseTuple(args, "s", &query))
    657         {
    658                 PyErr_SetString(PyExc_TypeError, "execute(sql), with sql (string).");
    659                 return NULL;
    660         }
    661 
    662         /* frees previous result */
    663         if (self->result)
    664         {
    665                 PQclear(self->result);
    666                 self->result = NULL;
    667         }
    668         self->max_row = 0;
    669         self->current_row = 0;
    670         self->num_fields = 0;
    671 
    672         /* gets result */
    673         Py_BEGIN_ALLOW_THREADS
    674         self->result = PQexec(self->pgcnx->cnx, query);
    675         Py_END_ALLOW_THREADS
    676 
    677         /* checks result validity */
    678         if (!self->result)
    679         {
    680                 PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->pgcnx->cnx));
    681                 return NULL;
    682         }
    683 
    684         /* checks result status */
    685         switch (PQresultStatus(self->result))
    686         {
    687                 long    num_rows;
    688                 char   *temp;
    689 
    690                 /* query succeeded */
    691                 case PGRES_TUPLES_OK:   /* DQL: returns None (DB-SIG compliant) */
    692                         self->result_type = RESULT_DQL;
    693                         self->max_row = PQntuples(self->result);
    694                         self->num_fields = PQnfields(self->result);
    695                         Py_INCREF(Py_None);
    696                         return Py_None;
    697                 case PGRES_COMMAND_OK:  /* other requests */
    698                 case PGRES_COPY_OUT:
    699                 case PGRES_COPY_IN:
    700                         self->result_type = RESULT_DDL;
    701                         temp = PQcmdTuples(self->result);
    702                         num_rows = -1;
    703                         if (temp[0])
    704                         {
    705                                 self->result_type = RESULT_DML;
    706                                 num_rows = atol(temp);
    707                         }
    708                         return PyLong_FromLong(num_rows);
    709 
    710                 /* query failed */
    711                 case PGRES_EMPTY_QUERY:
    712                         PyErr_SetString(PyExc_ValueError, "empty query.");
    713                         break;
    714                 case PGRES_BAD_RESPONSE:
    715                 case PGRES_FATAL_ERROR:
    716                 case PGRES_NONFATAL_ERROR:
    717                         set_dberror(ProgrammingError,
    718                                 PQerrorMessage(self->pgcnx->cnx), self->result);
    719                         break;
    720                 default:
    721                         set_dberror(InternalError, "internal error: "
    722                                 "unknown result status.", self->result);
    723                         break;
    724         }
    725 
    726         /* frees result and returns error */
    727         PQclear(self->result);
    728         self->result = NULL;
    729         self->result_type = RESULT_EMPTY;
    730         return NULL;
    731 }
    732 
    733 /* gets oid status for last query (valid for INSERTs, 0 for other) */
    734 static char sourceOidstatus__doc__[] =
    735 "oidstatus() -- return oid of last inserted row (if available).";
    736 
    737 static PyObject *
    738 pgsource_oidstatus(pgsourceobject *self, PyObject *args)
    739 {
    740         Oid                     oid;
    741 
    742         /* checks validity */
    743         if (!check_source_obj(self, CHECK_RESULT))
    744                 return NULL;
    745 
    746         /* checks args */
    747         if (args && !PyArg_ParseTuple(args, ""))
    748         {
    749                 PyErr_SetString(PyExc_TypeError,
    750                         "method oidstatus() takes no parameters.");
    751                 return NULL;
    752         }
    753 
    754         /* retrieves oid status */
    755         if ((oid = PQoidValue(self->result)) == InvalidOid)
    756         {
    757                 Py_INCREF(Py_None);
    758                 return Py_None;
    759         }
    760 
    761         return PyLong_FromLong(oid);
    762 }
    763 
    764 /* fetches rows from last result */
    765 static char sourceFetch__doc__[] =
    766 "fetch(num) -- return the next num rows from the last result in a list. "
    767 "If num parameter is omitted arraysize attribute value is used. "
    768 "If size equals -1, all rows are fetched.";
    769 
    770 static PyObject *
    771 pgsource_fetch(pgsourceobject *self, PyObject *args)
    772 {
    773         PyObject   *rowtuple,
    774                            *reslist,
    775                            *str;
    776         int                     i,
    777                                 j;
    778         long            size;
    779 
    780         /* checks validity */
    781         if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
    782                 return NULL;
    783 
    784         /* checks args */
    785         size = self->arraysize;
    786         if (!PyArg_ParseTuple(args, "|l", &size))
    787         {
    788                 PyErr_SetString(PyExc_TypeError,
    789                         "fetch(num), with num (integer, optional).");
    790                 return NULL;
    791         }
    792 
    793         /* seeks last line */
    794         /* limit size to be within the amount of data we actually have */
    795         if (size == -1 || (self->max_row - self->current_row) < size)
    796                 size = self->max_row - self->current_row;
    797 
    798         /* allocate list for result */
    799         if (!(reslist = PyList_New(0)))
    800                 return NULL;
    801 
    802         /* builds result */
    803         for (i = 0; i < size; i++)
    804         {
    805                 if (!(rowtuple = PyTuple_New(self->num_fields)))
    806                 {
    807                         Py_DECREF(reslist);
    808                         return NULL;
    809                 }
    810 
    811                 for (j = 0; j < self->num_fields; j++)
    812                 {
    813                         if (PQgetisnull(self->result, self->current_row, j))
    814                         {
    815                                 Py_INCREF(Py_None);
    816                                 str = Py_None;
    817                         }
    818                         else
    819                                 str = PyBytes_FromString(PQgetvalue(self->result, self->current_row, j));
    820 
    821                         PyTuple_SET_ITEM(rowtuple, j, str);
    822                 }
    823 
    824                 PyList_Append(reslist, rowtuple);
    825                 Py_DECREF(rowtuple);
    826                 self->current_row++;
    827         }
    828 
    829         return reslist;
    830 }
    831 
    832 /* changes current row (internal wrapper for all "move" methods) */
    833 static PyObject *
    834 pgsource_move(pgsourceobject *self, PyObject *args, int move)
    835 {
    836         /* checks validity */
    837         if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
    838                 return NULL;
    839 
    840         /* checks args */
    841         if (!PyArg_ParseTuple(args, ""))
    842         {
    843                 char            errbuf[256];
    844                 PyOS_snprintf(errbuf, sizeof(errbuf),
    845                         "method %s() takes no parameter.", __movename[move]);
    846                 PyErr_SetString(PyExc_TypeError, errbuf);
    847                 return NULL;
    848         }
    849 
    850         /* changes the current row */
    851         switch (move)
    852         {
    853                 case QUERY_MOVEFIRST:
    854                         self->current_row = 0;
    855                         break;
    856                 case QUERY_MOVELAST:
    857                         self->current_row = self->max_row - 1;
    858                         break;
    859                 case QUERY_MOVENEXT:
    860                         if (self->current_row != self->max_row)
    861                                 self->current_row++;
    862                         break;
    863                 case QUERY_MOVEPREV:
    864                         if (self->current_row > 0)
    865                                 self->current_row--;
    866                         break;
    867         }
    868 
    869         Py_INCREF(Py_None);
    870         return Py_None;
    871 }
    872 
    873 /* move to first result row */
    874 static char sourceMovefirst__doc__[] =
    875 "movefirst() -- move to first result row.";
    876 
    877 static PyObject *
    878 pgsource_movefirst(pgsourceobject *self, PyObject *args)
    879 {
    880         return pgsource_move(self, args, QUERY_MOVEFIRST);
    881 }
    882 
    883 /* move to last result row */
    884 static char sourceMovelast__doc__[] =
    885 "movelast() -- move to last valid result row.";
    886 
    887 static PyObject *
    888 pgsource_movelast(pgsourceobject *self, PyObject *args)
    889 {
    890         return pgsource_move(self, args, QUERY_MOVELAST);
    891 }
    892 
    893 /* move to next result row */
    894 static char sourceMovenext__doc__[] =
    895 "movenext() -- move to next result row.";
    896 
    897 static PyObject *
    898 pgsource_movenext(pgsourceobject *self, PyObject *args)
    899 {
    900         return pgsource_move(self, args, QUERY_MOVENEXT);
    901 }
    902 
    903 /* move to previous result row */
    904 static char sourceMoveprev__doc__[] =
    905 "moveprev() -- move to previous result row.";
    906 
    907 static PyObject *
    908 pgsource_moveprev(pgsourceobject *self, PyObject *args)
    909 {
    910         return pgsource_move(self, args, QUERY_MOVEPREV);
    911 }
    912 
    913 /* finds field number from string/integer (internal use only) */
    914 static int
    915 pgsource_fieldindex(pgsourceobject *self, PyObject *param, const char *usage)
    916 {
    917         int                     num;
    918 
    919         /* checks validity */
    920         if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
    921                 return -1;
    922 
    923         /* gets field number */
    924         if (PyBytes_Check(param))
    925                 num = PQfnumber(self->result, PyBytes_AsString(param));
    926         else if (PyLong_Check(param))
    927                 num = PyLong_AsLong(param);
    928         else
    929         {
    930                 PyErr_SetString(PyExc_TypeError, usage);
    931                 return -1;
    932         }
    933 
    934         /* checks field validity */
    935         if (num < 0 || num >= self->num_fields)
    936         {
    937                 PyErr_SetString(PyExc_ValueError, "Unknown field.");
    938                 return -1;
    939         }
    940 
    941         return num;
    942 }
    943 
    944 /* builds field information from position (internal use only) */
    945 static PyObject *
    946 pgsource_buildinfo(pgsourceobject *self, int num)
    947 {
    948         PyObject *result;
    949 
    950         /* allocates tuple */
    951         result = PyTuple_New(3);
    952         if (!result)
    953                 return NULL;
    954 
    955         /* affects field information */
    956         PyTuple_SET_ITEM(result, 0, PyLong_FromLong(num));
    957         PyTuple_SET_ITEM(result, 1,
    958                 PyBytes_FromString(PQfname(self->result, num)));
    959         PyTuple_SET_ITEM(result, 2,
    960                 PyLong_FromLong(PQftype(self->result, num)));
    961 
    962         return result;
    963 }
    964 
    965 /* lists fields info */
    966 static char sourceListinfo__doc__[] =
    967 "listinfo() -- return information for all fields "
    968 "(position, name, type oid).";
    969 
    970 static PyObject *
    971 pgsource_listinfo(pgsourceobject *self, PyObject *args)
    972 {
    973         int                     i;
    974         PyObject   *result,
    975                            *info;
    976 
    977         /* checks validity */
    978         if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
    979                 return NULL;
    980 
    981         /* gets args */
    982         if (!PyArg_ParseTuple(args, ""))
    983         {
    984                 PyErr_SetString(PyExc_TypeError,
    985                         "method listinfo() takes no parameter.");
    986                 return NULL;
    987         }
    988 
    989         /* builds result */
    990         if (!(result = PyTuple_New(self->num_fields)))
    991                 return NULL;
    992 
    993         for (i = 0; i < self->num_fields; i++)
    994         {
    995                 info = pgsource_buildinfo(self, i);
    996                 if (!info)
    997                 {
    998                         Py_DECREF(result);
    999                         return NULL;
    1000                 }
    1001                 PyTuple_SET_ITEM(result, i, info);
    1002         }
    1003 
    1004         /* returns result */
    1005         return result;
    1006 };
    1007 
    1008 /* list fields information for last result */
    1009 static char sourceFieldinfo__doc__[] =
    1010 "fieldinfo(string|integer) -- return specified field information "
    1011 "(position, name, type oid).";
    1012 
    1013 static PyObject *
    1014 pgsource_fieldinfo(pgsourceobject *self, PyObject *args)
    1015 {
    1016         static const char short_usage[] =
    1017         "fieldinfo(desc), with desc (string|integer).";
    1018         int                     num;
    1019         PyObject   *param;
    1020 
    1021         /* gets args */
    1022         if (!PyArg_ParseTuple(args, "O", &param))
    1023         {
    1024                 PyErr_SetString(PyExc_TypeError, short_usage);
    1025                 return NULL;
    1026         }
    1027 
    1028         /* checks args and validity */
    1029         if ((num = pgsource_fieldindex(self, param, short_usage)) == -1)
    1030                 return NULL;
    1031 
    1032         /* returns result */
    1033         return pgsource_buildinfo(self, num);
    1034 };
    1035 
    1036 /* retrieve field value */
    1037 static char sourceField__doc__[] =
    1038 "field(string|integer) -- return specified field value.";
    1039 
    1040 static PyObject *
    1041 pgsource_field(pgsourceobject *self, PyObject *args)
    1042 {
    1043         static const char short_usage[] =
    1044         "field(desc), with desc (string|integer).";
    1045         int                     num;
    1046         PyObject   *param;
    1047 
    1048         /* gets args */
    1049         if (!PyArg_ParseTuple(args, "O", &param))
    1050         {
    1051                 PyErr_SetString(PyExc_TypeError, short_usage);
    1052                 return NULL;
    1053         }
    1054 
    1055         /* checks args and validity */
    1056         if ((num = pgsource_fieldindex(self, param, short_usage)) == -1)
    1057                 return NULL;
    1058 
    1059         return PyBytes_FromString(PQgetvalue(self->result,
    1060                                                                         self->current_row, num));
    1061 }
    1062 
    1063 /* query object methods */
    1064 static PyMethodDef pgsource_methods[] = {
    1065         {"close", (PyCFunction) pgsource_close, METH_VARARGS,
    1066                         sourceClose__doc__},
    1067         {"execute", (PyCFunction) pgsource_execute, METH_VARARGS,
    1068                         sourceExecute__doc__},
    1069         {"oidstatus", (PyCFunction) pgsource_oidstatus, METH_VARARGS,
    1070                         sourceOidstatus__doc__},
    1071         {"fetch", (PyCFunction) pgsource_fetch, METH_VARARGS,
    1072                         sourceFetch__doc__},
    1073         {"movefirst", (PyCFunction) pgsource_movefirst, METH_VARARGS,
    1074                         sourceMovefirst__doc__},
    1075         {"movelast", (PyCFunction) pgsource_movelast, METH_VARARGS,
    1076                         sourceMovelast__doc__},
    1077         {"movenext", (PyCFunction) pgsource_movenext, METH_VARARGS,
    1078                         sourceMovenext__doc__},
    1079         {"moveprev", (PyCFunction) pgsource_moveprev, METH_VARARGS,
    1080                         sourceMoveprev__doc__},
    1081         {"field", (PyCFunction) pgsource_field, METH_VARARGS,
    1082                         sourceField__doc__},
    1083         {"fieldinfo", (PyCFunction) pgsource_fieldinfo, METH_VARARGS,
    1084                         sourceFieldinfo__doc__},
    1085         {"listinfo", (PyCFunction) pgsource_listinfo, METH_VARARGS,
    1086                         sourceListinfo__doc__},
    1087         {NULL, NULL}
    1088 };
    1089 
    1090 /* gets query object attributes */
    1091 static PyObject *
    1092 sourceGetattr(pgsourceobject *self, char *name)
    1093 {
    1094         /* pg connection object */
    1095         if (!strcmp(name, "pgcnx"))
    1096         {
    1097                 if (check_source_obj(self, 0))
    1098                 {
    1099                         Py_INCREF(self->pgcnx);
    1100                         return (PyObject *) (self->pgcnx);
    1101                 }
    1102                 Py_INCREF(Py_None);
    1103                 return Py_None;
    1104         }
    1105 
    1106         /* arraysize */
    1107         if (!strcmp(name, "arraysize"))
    1108                 return PyLong_FromLong(self->arraysize);
    1109 
    1110         /* resulttype */
    1111         if (!strcmp(name, "resulttype"))
    1112                 return PyLong_FromLong(self->result_type);
    1113 
    1114         /* ntuples */
    1115         if (!strcmp(name, "ntuples"))
    1116                 return PyLong_FromLong(self->max_row);
    1117 
    1118         /* nfields */
    1119         if (!strcmp(name, "nfields"))
    1120                 return PyLong_FromLong(self->num_fields);
    1121 
    1122         /* attributes list */
    1123         if (!strcmp(name, "__members__"))
    1124         {
    1125                 PyObject *list = PyList_New(5);
    1126 
    1127                 PyList_SET_ITEM(list, 0, PyBytes_FromString("pgcnx"));
    1128                 PyList_SET_ITEM(list, 1, PyBytes_FromString("arraysize"));
    1129                 PyList_SET_ITEM(list, 2, PyBytes_FromString("resulttype"));
    1130                 PyList_SET_ITEM(list, 3, PyBytes_FromString("ntuples"));
    1131                 PyList_SET_ITEM(list, 4, PyBytes_FromString("nfields"));
    1132 
    1133                 return list;
    1134         }
    1135 
    1136         /* module name */
    1137         if (!strcmp(name, "__module__"))
    1138                 return PyBytes_FromString(MODULE_NAME);
    1139 
    1140         /* class name */
    1141         if (!strcmp(name, "__class__"))
    1142                 return PyBytes_FromString("pgsource");
    1143 
    1144         /* seeks name in methods (fallback) */
    1145         return Py_FindMethod(pgsource_methods, (PyObject *) self, name);
    1146 }
    1147 
    1148 /* sets query object attributes */
    1149 static int
    1150 sourceSetattr(pgsourceobject *self, char *name, PyObject *v)
    1151 {
    1152         /* arraysize */
    1153         if (!strcmp(name, "arraysize"))
    1154         {
    1155                 if (!PyLong_Check(v))
    1156                 {
    1157                         PyErr_SetString(PyExc_TypeError, "arraysize must be integer.");
    1158                         return -1;
    1159                 }
    1160 
    1161                 self->arraysize = PyLong_AsLong(v);
    1162                 return 0;
    1163         }
    1164 
    1165         /* unknown attribute */
    1166         PyErr_SetString(PyExc_TypeError, "not a writable attribute.");
    1167         return -1;
    1168 }
    1169 
    1170 static PyObject *
    1171 sourceRepr(pgsourceobject *self)
    1172 {
    1173         return PyBytes_FromString("<pg source object>");
    1174 }
    1175 
    1176 /* returns source object as string in human readable format */
    1177 
    1178 static PyObject *
    1179 sourceStr(pgsourceobject *self)
    1180 {
    1181         switch (self->result_type)
    1182         {
    1183                 case RESULT_DQL:
    1184                         return format_result(self->result);
    1185                 case RESULT_DDL:
    1186                 case RESULT_DML:
    1187                         return PyBytes_FromString(PQcmdStatus(self->result));
    1188                 case RESULT_EMPTY:
    1189                 default:
    1190                         return PyBytes_FromString("(empty PostgreSQL source object)");
    1191         }
    1192 }
    1193 
    1194 /* query type definition */
    1195 static PyTypeObject sourceType = {
    1196         PyObject_HEAD_INIT(NULL)
    1197         0,                                                              /* ob_size */
    1198         "pgsourceobject",                               /* tp_name */
    1199         sizeof(pgsourceobject),                 /* tp_basicsize */
    1200         0,                                                              /* tp_itemsize */
    1201         /* methods */
    1202         (destructor) sourceDelete,              /* tp_dealloc */
    1203         0,                                                              /* tp_print */
    1204         (getattrfunc) sourceGetattr,    /* tp_getattr */
    1205         (setattrfunc) sourceSetattr,    /* tp_setattr */
    1206         0,                                                              /* tp_compare */
    1207         (reprfunc) sourceRepr,                  /* tp_repr */
    1208         0,                                                              /* tp_as_number */
    1209         0,                                                              /* tp_as_sequence */
    1210         0,                                                              /* tp_as_mapping */
    1211         0,                                                              /* tp_hash */
    1212         0,                                                              /* tp_call */
    1213         (reprfunc) sourceStr,                   /* tp_str */
    1214 };
    1215 
    1216 /* --------------------------------------------------------------------- */
    1217 /* PG "LARGE" OBJECT IMPLEMENTATION */
    1218 
    1219 #ifdef LARGE_OBJECTS
    1220 
    1221 /* constructor (internal use only) */
    1222 static pglargeobject *
    1223 pglarge_new(connObject *pgcnx, Oid oid)
    1224 {
    1225         pglargeobject *npglo;
    1226 
    1227         if (!(npglo = PyObject_NEW(pglargeobject, &largeType)))
     555static largeObject *
     556largeNew(connObject *pgcnx, Oid oid)
     557{
     558        largeObject *npglo;
     559
     560        if (!(npglo = PyObject_NEW(largeObject, &largeType)))
    1228561                return NULL;
    1229562
     
    1238571/* destructor */
    1239572static void
    1240 pglarge_dealloc(pglargeobject *self)
     573pglarge_dealloc(largeObject *self)
    1241574{
    1242575        if (self->lo_fd >= 0 && check_cnx_obj(self->pgcnx))
     
    1253586
    1254587static PyObject *
    1255 pglarge_open(pglargeobject *self, PyObject *args)
     588largeOpen(largeObject *self, PyObject *args)
    1256589{
    1257590        int                     mode,
     
    1287620
    1288621static PyObject *
    1289 pglarge_close(pglargeobject *self, PyObject *args)
     622largeClose(largeObject *self, PyObject *args)
    1290623{
    1291624        /* checks args */
     
    1320653
    1321654static PyObject *
    1322 pglarge_read(pglargeobject *self, PyObject *args)
     655largeRead(largeObject *self, PyObject *args)
    1323656{
    1324657        int                     size;
     
    1363696
    1364697static PyObject *
    1365 pglarge_write(pglargeobject *self, PyObject *args)
     698largeWrite(largeObject *self, PyObject *args)
    1366699{
    1367700        char       *buffer;
     
    1401734
    1402735static PyObject *
    1403 pglarge_lseek(pglargeobject *self, PyObject *args)
     736largeSeek(largeObject *self, PyObject *args)
    1404737{
    1405738        /* offset and whence are initialized to keep compiler happy */
     
    1437770
    1438771static PyObject *
    1439 pglarge_size(pglargeobject *self, PyObject *args)
     772largeSize(largeObject *self, PyObject *args)
    1440773{
    1441774        int                     start,
     
    1486819
    1487820static PyObject *
    1488 pglarge_tell(pglargeobject *self, PyObject *args)
     821largeTell(largeObject *self, PyObject *args)
    1489822{
    1490823        int                     start;
     
    1519852
    1520853static PyObject *
    1521 pglarge_export(pglargeobject *self, PyObject *args)
     854largeExport(largeObject *self, PyObject *args)
    1522855{
    1523856        char *name;
     
    1552885
    1553886static PyObject *
    1554 pglarge_unlink(pglargeobject *self, PyObject *args)
     887largeUnlink(largeObject *self, PyObject *args)
    1555888{
    1556889        /* checks args */
     
    1580913
    1581914/* large object methods */
    1582 static struct PyMethodDef pglarge_methods[] = {
    1583         {"open", (PyCFunction) pglarge_open, METH_VARARGS, largeOpen__doc__},
    1584         {"close", (PyCFunction) pglarge_close, METH_VARARGS, largeClose__doc__},
    1585         {"read", (PyCFunction) pglarge_read, METH_VARARGS, largeRead__doc__},
    1586         {"write", (PyCFunction) pglarge_write, METH_VARARGS, largeWrite__doc__},
    1587         {"seek", (PyCFunction) pglarge_lseek, METH_VARARGS, largeSeek__doc__},
    1588         {"size", (PyCFunction) pglarge_size, METH_VARARGS, largeSize__doc__},
    1589         {"tell", (PyCFunction) pglarge_tell, METH_VARARGS, largeTell__doc__},
    1590         {"export", (PyCFunction) pglarge_export, METH_VARARGS, largeExport__doc__},
    1591         {"unlink", (PyCFunction) pglarge_unlink, METH_VARARGS, largeUnlink__doc__},
     915static struct PyMethodDef largeMethods[] = {
     916        {"open", (PyCFunction) largeOpen, METH_VARARGS, largeOpen__doc__},
     917        {"close", (PyCFunction) largeClose, METH_VARARGS, largeClose__doc__},
     918        {"read", (PyCFunction) largeRead, METH_VARARGS, largeRead__doc__},
     919        {"write", (PyCFunction) largeWrite, METH_VARARGS, largeWrite__doc__},
     920        {"seek", (PyCFunction) largeSeek, METH_VARARGS, largeSeek__doc__},
     921        {"size", (PyCFunction) largeSize, METH_VARARGS, largeSize__doc__},
     922        {"tell", (PyCFunction) largeTell, METH_VARARGS, largeTell__doc__},
     923        {"export",(PyCFunction) largeExport,METH_VARARGS,largeExport__doc__},
     924        {"unlink",(PyCFunction) largeUnlink,METH_VARARGS,largeUnlink__doc__},
    1592925        {NULL, NULL}
    1593926};
     
    1595928/* get attribute */
    1596929static PyObject *
    1597 pglarge_getattr(pglargeobject *self, char *name)
     930pglarge_getattr(largeObject *self, char *name)
    1598931{
    1599932        /* list postgreSQL large object fields */
     
    1650983
    1651984        /* seeks name in methods (fallback) */
    1652         return Py_FindMethod(pglarge_methods, (PyObject *) self, name);
     985        return Py_FindMethod(largeMethods, (PyObject *) self, name);
    1653986}
    1654987
    1655988/* prints query object in human readable format */
    1656989static int
    1657 pglarge_print(pglargeobject *self, FILE *fp, int flags)
     990pglarge_print(largeObject *self, FILE *fp, int flags)
    1658991{
    1659992        char            print_buffer[128];
     
    16691002static PyTypeObject largeType = {
    16701003        PyObject_HEAD_INIT(NULL)
    1671         0,                                                      /* ob_size */
    1672         "pglarge",                                      /* tp_name */
    1673         sizeof(pglargeobject),          /* tp_basicsize */
    1674         0,                                                      /* tp_itemsize */
     1004        0,                                                              /* ob_size */
     1005        "PGlargeObject",                                /* tp_name */
     1006        sizeof(largeObject),                    /* tp_basicsize */
     1007        0,                                                              /* tp_itemsize */
    16751008
    16761009        /* methods */
    1677         (destructor) pglarge_dealloc,           /* tp_dealloc */
    1678         (printfunc) pglarge_print,      /* tp_print */
    1679         (getattrfunc) pglarge_getattr,          /* tp_getattr */
    1680         0,                                                      /* tp_setattr */
    1681         0,                                                      /* tp_compare */
    1682         0,                                                      /* tp_repr */
    1683         0,                                                      /* tp_as_number */
    1684         0,                                                      /* tp_as_sequence */
    1685         0,                                                      /* tp_as_mapping */
    1686         0,                                                      /* tp_hash */
     1010        (destructor) pglarge_dealloc,   /* tp_dealloc */
     1011        (printfunc) pglarge_print,              /* tp_print */
     1012        (getattrfunc) pglarge_getattr,  /* tp_getattr */
     1013        0,                                                              /* tp_setattr */
     1014        0,                                                              /* tp_compare */
     1015        0,                                                              /* tp_repr */
     1016        0,                                                              /* tp_as_number */
     1017        0,                                                              /* tp_as_sequence */
     1018        0,                                                              /* tp_as_mapping */
     1019        0,                                                              /* tp_hash */
    16871020};
    16881021#endif /* LARGE_OBJECTS */
    16891022
    1690 
    16911023/* --------------------------------------------------------------------- */
    1692 /* PG QUERY OBJECT IMPLEMENTATION */
    1693 
    1694 /* connects to a database */
    1695 static char pgConnect__doc__[] =
    1696 "connect(dbname, host, port, opt, tty) -- connect to a PostgreSQL database "
    1697 "using specified parameters (optionals, keywords aware).";
    1698 
    1699 static PyObject *
    1700 pgconnect(connObject *self, PyObject *args, PyObject *dict)
    1701 {
    1702         static const char *kwlist[] = {"dbname", "host", "port", "opt",
    1703         "tty", "user", "passwd", NULL};
    1704 
    1705         char       *pghost,
    1706                            *pgopt,
    1707                            *pgtty,
    1708                            *pgdbname,
    1709                            *pguser,
    1710                            *pgpasswd;
    1711         int                     pgport;
    1712         char            port_buffer[20];
    1713         connObject   *npgobj;
    1714 
    1715         pghost = pgopt = pgtty = pgdbname = pguser = pgpasswd = NULL;
    1716         pgport = -1;
    1717 
    1718         /*
    1719          * parses standard arguments With the right compiler warnings, this
    1720          * will issue a diagnostic. There is really no way around it.  If I
    1721          * don't declare kwlist as const char *kwlist[] then it complains when
    1722          * I try to assign all those constant strings to it.
    1723          */
    1724         if (!PyArg_ParseTupleAndKeywords(args, dict, "|zzizzzz", (char **) kwlist,
    1725                 &pgdbname, &pghost, &pgport, &pgopt, &pgtty, &pguser, &pgpasswd))
    1726                 return NULL;
    1727 
    1728 #ifdef DEFAULT_VARS
    1729         /* handles defaults variables (for uninitialised vars) */
    1730         if ((!pghost) && (pg_default_host != Py_None))
    1731                 pghost = PyBytes_AsString(pg_default_host);
    1732 
    1733         if ((pgport == -1) && (pg_default_port != Py_None))
    1734                 pgport = PyLong_AsLong(pg_default_port);
    1735 
    1736         if ((!pgopt) && (pg_default_opt != Py_None))
    1737                 pgopt = PyBytes_AsString(pg_default_opt);
    1738 
    1739         if ((!pgtty) && (pg_default_tty != Py_None))
    1740                 pgtty = PyBytes_AsString(pg_default_tty);
    1741 
    1742         if ((!pgdbname) && (pg_default_base != Py_None))
    1743                 pgdbname = PyBytes_AsString(pg_default_base);
    1744 
    1745         if ((!pguser) && (pg_default_user != Py_None))
    1746                 pguser = PyBytes_AsString(pg_default_user);
    1747 
    1748         if ((!pgpasswd) && (pg_default_passwd != Py_None))
    1749                 pgpasswd = PyBytes_AsString(pg_default_passwd);
    1750 #endif /* DEFAULT_VARS */
    1751 
    1752         if (!(npgobj = (connObject *) connNew()))
    1753                 return NULL;
    1754 
    1755         if (pgport != -1)
    1756         {
    1757                 memset(port_buffer, 0, sizeof(port_buffer));
    1758                 sprintf(port_buffer, "%d", pgport);
    1759         }
    1760 
    1761 #ifdef PQsetdbLoginIsThreadSafe
    1762         Py_BEGIN_ALLOW_THREADS
    1763 #endif
    1764         npgobj->cnx = PQsetdbLogin(pghost, pgport == -1 ? NULL : port_buffer,
    1765                 pgopt, pgtty, pgdbname, pguser, pgpasswd);
    1766 #ifdef PQsetdbLoginIsThreadSafe
    1767         Py_END_ALLOW_THREADS
    1768 #endif
    1769 
    1770         if (PQstatus(npgobj->cnx) == CONNECTION_BAD)
    1771         {
    1772                 set_dberror(InternalError, PQerrorMessage(npgobj->cnx), NULL);
    1773                 Py_XDECREF(npgobj);
    1774                 return NULL;
    1775         }
    1776 
    1777         return (PyObject *) npgobj;
    1778 }
    1779 
    1780 /* internal wrapper for the notice receiver callback */
    1781 void notice_receiver(void *arg, const PGresult *res)
    1782 {
    1783         PyGILState_STATE gstate = PyGILState_Ensure();
    1784         connObject *self = (connObject*) arg;
    1785         PyObject *proc = self->notice_receiver;
    1786         if (proc && PyCallable_Check(proc))
    1787         {
    1788                 pgnoticeobject *notice = PyObject_NEW(pgnoticeobject, &noticeType);
    1789                 PyObject *args, *ret;
    1790                 if (notice)
    1791                 {
    1792                         notice->pgcnx = arg;
    1793                         notice->res = res;
    1794                 }
    1795                 else
    1796                 {
    1797                         Py_INCREF(Py_None);
    1798                         notice = (pgnoticeobject *)(void *)Py_None;
    1799                 }
    1800                 args = Py_BuildValue("(O)", notice);
    1801                 ret = PyObject_CallObject(proc, args);
    1802                 Py_XDECREF(ret);
    1803                 Py_DECREF(args);
    1804         }
    1805         PyGILState_Release(gstate);
    1806 }
    1807 
    1808 /* connObject methods */
    1809 
    1810 /* destructor */
     1024/* connection object */
     1025/* --------------------------------------------------------------------- */
    18111026static void
    18121027connDelete(connObject *self)
     
    18251040}
    18261041
    1827 /* close without deleting */
    1828 static char connClose__doc__[] =
    1829 "close() -- close connection. All instances of the connection object and "
    1830 "derived objects (queries and large objects) can no longer be used after "
    1831 "this call.";
    1832 
    1833 static PyObject *
    1834 pg_close(connObject *self, PyObject *args)
    1835 {
    1836         /* gets args */
    1837         if (!PyArg_ParseTuple(args, ""))
    1838         {
    1839                 PyErr_SetString(PyExc_TypeError, "close().");
    1840                 return NULL;
    1841         }
    1842 
    1843         /* connection object cannot already be closed */
    1844         if (!self->cnx)
    1845         {
    1846                 set_dberror(InternalError, "Connection already closed", NULL);
    1847                 return NULL;
    1848         }
    1849 
    1850         Py_BEGIN_ALLOW_THREADS
    1851         PQfinish(self->cnx);
    1852         Py_END_ALLOW_THREADS
    1853 
    1854         self->cnx = NULL;
    1855         Py_INCREF(Py_None);
    1856         return Py_None;
    1857 }
    1858 
    1859 static void
    1860 pgquery_dealloc(pgqueryobject *self)
    1861 {
    1862         if (self->result)
    1863                 PQclear(self->result);
    1864 
    1865         PyObject_Del(self);
    1866 }
    1867 
    1868 /* resets connection */
    1869 static char connReset__doc__[] =
    1870 "reset() -- reset connection with current parameters. All derived queries "
    1871 "and large objects derived from this connection will not be usable after "
    1872 "this call.";
    1873 
    1874 static PyObject *
    1875 pg_reset(connObject *self, PyObject *args)
    1876 {
    1877         if (!self->cnx)
    1878         {
    1879                 PyErr_SetString(PyExc_TypeError, "Connection is not valid.");
    1880                 return NULL;
    1881         }
    1882 
    1883         /* checks args */
    1884         if (!PyArg_ParseTuple(args, ""))
    1885         {
    1886                 PyErr_SetString(PyExc_TypeError,
    1887                         "method reset() takes no parameters.");
    1888                 return NULL;
    1889         }
    1890 
    1891         /* resets the connection */
    1892         PQreset(self->cnx);
    1893         Py_INCREF(Py_None);
    1894         return Py_None;
    1895 }
    1896 
    1897 /* cancels current command */
    1898 static char connCancel__doc__[] =
    1899 "cancel() -- abandon processing of the current command.";
    1900 
    1901 static PyObject *
    1902 pg_cancel(connObject *self, PyObject *args)
    1903 {
    1904         if (!self->cnx)
    1905         {
    1906                 PyErr_SetString(PyExc_TypeError, "Connection is not valid.");
    1907                 return NULL;
    1908         }
    1909 
    1910         /* checks args */
    1911         if (!PyArg_ParseTuple(args, ""))
    1912         {
    1913                 PyErr_SetString(PyExc_TypeError,
    1914                         "method cancel() takes no parameters.");
    1915                 return NULL;
    1916         }
    1917 
    1918         /* request that the server abandon processing of the current command */
    1919         return PyLong_FromLong((long) PQrequestCancel(self->cnx));
    1920 }
    1921 
    1922 /* get connection socket */
    1923 static char connFileno__doc__[] =
    1924 "fileno() -- return database connection socket file handle.";
    1925 
    1926 static PyObject *
    1927 pg_fileno(connObject *self, PyObject *args)
    1928 {
    1929         if (!self->cnx)
    1930         {
    1931                 PyErr_SetString(PyExc_TypeError, "Connection is not valid.");
    1932                 return NULL;
    1933         }
    1934 
    1935         /* checks args */
    1936         if (!PyArg_ParseTuple(args, ""))
    1937         {
    1938                 PyErr_SetString(PyExc_TypeError,
    1939                         "method fileno() takes no parameters.");
    1940                 return NULL;
    1941         }
    1942 
    1943 #ifdef NO_PQSOCKET
    1944         return PyLong_FromLong((long) self->cnx->sock);
    1945 #else
    1946         return PyLong_FromLong((long) PQsocket(self->cnx));
    1947 #endif
    1948 }
    1949 
    1950 /* set notice receiver callback function */
    1951 static char connSset_notice_receiver__doc__[] =
    1952 "set_notice_receiver() -- set the current notice receiver.";
    1953 
    1954 static PyObject *
    1955 pg_set_notice_receiver(connObject * self, PyObject * args)
    1956 {
    1957         PyObject *ret = NULL;
    1958         PyObject *proc;
    1959 
    1960         if (PyArg_ParseTuple(args, "O", &proc))
    1961         {
    1962                 if (PyCallable_Check(proc))
    1963                 {
    1964                         Py_XINCREF(proc);
    1965                         self->notice_receiver = proc;
    1966                         PQsetNoticeReceiver(self->cnx, notice_receiver, self);
    1967                         Py_INCREF(Py_None); ret = Py_None;
    1968                 }
    1969                 else
    1970                         PyErr_SetString(PyExc_TypeError, "notice receiver must be callable");
    1971         }
    1972         return ret;
    1973 }
    1974 
    1975 /* get notice receiver callback function */
    1976 static char connGet_notice_receiver__doc__[] =
    1977 "get_notice_receiver() -- get the current notice receiver.";
    1978 
    1979 static PyObject *
    1980 pg_get_notice_receiver(connObject * self, PyObject * args)
    1981 {
    1982         PyObject *ret = NULL;
    1983 
    1984         if (PyArg_ParseTuple(args, ""))
    1985         {
    1986                 ret = self->notice_receiver;
    1987                 if (!ret)
    1988                         ret = Py_None;
    1989                 Py_INCREF(ret);
    1990         }
    1991         else
    1992         {
    1993                 PyErr_SetString(PyExc_TypeError,
    1994                         "method get_notice_receiver() takes no parameters.");
    1995         }
    1996         return ret;
    1997 }
    1998 
    1999 /* get number of rows */
    2000 static char queryNtuples__doc__[] =
    2001 "ntuples() -- returns number of tuples returned by query.";
    2002 
    2003 static PyObject *
    2004 pgquery_ntuples(pgqueryobject *self, PyObject *args)
    2005 {
    2006         /* checks args */
    2007         if (!PyArg_ParseTuple(args, ""))
    2008         {
    2009                 PyErr_SetString(PyExc_TypeError,
    2010                         "method ntuples() takes no parameters.");
    2011                 return NULL;
    2012         }
    2013 
    2014         return PyLong_FromLong((long) PQntuples(self->result));
    2015 }
    2016 
    2017 /* list fields names from query result */
    2018 static char queryListfields__doc__[] =
    2019 "listfields() -- Lists field names from result.";
    2020 
    2021 static PyObject *
    2022 pgquery_listfields(pgqueryobject *self, PyObject *args)
    2023 {
    2024         int                     i,
    2025                                 n;
    2026         char       *name;
    2027         PyObject   *fieldstuple,
    2028                            *str;
    2029 
    2030         /* checks args */
    2031         if (!PyArg_ParseTuple(args, ""))
    2032         {
    2033                 PyErr_SetString(PyExc_TypeError,
    2034                         "method listfields() takes no parameters.");
    2035                 return NULL;
    2036         }
    2037 
    2038         /* builds tuple */
    2039         n = PQnfields(self->result);
    2040         fieldstuple = PyTuple_New(n);
    2041 
    2042         for (i = 0; i < n; i++)
    2043         {
    2044                 name = PQfname(self->result, i);
    2045                 str = PyBytes_FromString(name);
    2046                 PyTuple_SET_ITEM(fieldstuple, i, str);
    2047         }
    2048 
    2049         return fieldstuple;
    2050 }
    2051 
    2052 /* get field name from last result */
    2053 static char queryFieldname__doc__[] =
    2054 "fieldname() -- returns name of field from result from its position.";
    2055 
    2056 static PyObject *
    2057 pgquery_fieldname(pgqueryobject *self, PyObject *args)
    2058 {
    2059         int             i;
    2060         char   *name;
    2061 
    2062         /* gets args */
    2063         if (!PyArg_ParseTuple(args, "i", &i))
    2064         {
    2065                 PyErr_SetString(PyExc_TypeError,
    2066                         "fieldname(number), with number(integer).");
    2067                 return NULL;
    2068         }
    2069 
    2070         /* checks number validity */
    2071         if (i >= PQnfields(self->result))
    2072         {
    2073                 PyErr_SetString(PyExc_ValueError, "invalid field number.");
    2074                 return NULL;
    2075         }
    2076 
    2077         /* gets fields name and builds object */
    2078         name = PQfname(self->result, i);
    2079         return PyBytes_FromString(name);
    2080 }
    2081 
    2082 /* gets fields number from name in last result */
    2083 static char queryFieldnum__doc__[] =
    2084 "fieldnum() -- returns position in query for field from its name.";
    2085 
    2086 static PyObject *
    2087 pgquery_fieldnum(pgqueryobject *self, PyObject *args)
    2088 {
    2089         int             num;
    2090         char   *name;
    2091 
    2092         /* gets args */
    2093         if (!PyArg_ParseTuple(args, "s", &name))
    2094         {
    2095                 PyErr_SetString(PyExc_TypeError, "fieldnum(name), with name (string).");
    2096                 return NULL;
    2097         }
    2098 
    2099         /* gets field number */
    2100         if ((num = PQfnumber(self->result, name)) == -1)
    2101         {
    2102                 PyErr_SetString(PyExc_ValueError, "Unknown field.");
    2103                 return NULL;
    2104         }
    2105 
    2106         return PyLong_FromLong(num);
    2107 }
    2108 
    2109 /* retrieves last result */
    2110 static char queryGetresult__doc__[] =
    2111 "getresult() -- Gets the result of a query.  The result is returned "
    2112 "as a list of rows, each one a tuple of fields in the order returned "
    2113 "by the server.";
    2114 
    2115 static PyObject *
    2116 pgquery_getresult(pgqueryobject *self, PyObject *args)
    2117 {
    2118         PyObject   *rowtuple,
    2119                            *reslist,
    2120                            *val;
    2121         int                     i,
    2122                                 j,
    2123                                 m,
    2124                                 n,
    2125                            *typ;
    2126 
    2127         /* checks args (args == NULL for an internal call) */
    2128         if (args && !PyArg_ParseTuple(args, ""))
    2129         {
    2130                 PyErr_SetString(PyExc_TypeError,
    2131                         "method getresult() takes no parameters.");
    2132                 return NULL;
    2133         }
    2134 
    2135         /* stores result in tuple */
    2136         m = PQntuples(self->result);
    2137         n = PQnfields(self->result);
    2138         reslist = PyList_New(m);
    2139 
    2140         typ = get_type_array(self->result, n);
    2141 
    2142         for (i = 0; i < m; i++)
    2143         {
    2144                 if (!(rowtuple = PyTuple_New(n)))
    2145                 {
    2146                         Py_DECREF(reslist);
    2147                         reslist = NULL;
    2148                         goto exit;
    2149                 }
    2150 
    2151                 for (j = 0; j < n; j++)
    2152                 {
    2153                         int                     k;
    2154                         char       *s = PQgetvalue(self->result, i, j);
    2155                         char            cashbuf[64];
    2156                         PyObject   *tmp_obj;
    2157 
    2158                         if (PQgetisnull(self->result, i, j))
    2159                         {
    2160                                 Py_INCREF(Py_None);
    2161                                 val = Py_None;
    2162                         }
    2163                         else
    2164                                 switch (typ[j])
    2165                                 {
    2166                                         case 1:  /* int2/4 */
    2167                                                 val = PyLong_FromString(s, NULL, 10);
    2168                                                 break;
    2169 
    2170                                         case 2:  /* int8 */
    2171                                                 val = PyLong_FromString(s, NULL, 10);
    2172                                                 break;
    2173 
    2174                                         case 3:  /* float/double */
    2175                                                 tmp_obj = PyBytes_FromString(s);
    2176                                                 val = PyFloat_FromString(tmp_obj, NULL);
    2177                                                 Py_DECREF(tmp_obj);
    2178                                                 break;
    2179 
    2180                                         case 5:  /* money */
    2181                                                 for (k = 0;
    2182                                                          *s && k < sizeof(cashbuf) / sizeof(cashbuf[0]) - 1;
    2183                                                          s++)
    2184                                                 {
    2185                                                         if (isdigit(*s))
    2186                                                                 cashbuf[k++] = *s;
    2187                                                         else if (*s == *decimal_point)
    2188                                                                 cashbuf[k++] = '.';
    2189                                                         else if (*s == '(' || *s == '-')
    2190                                                                 cashbuf[k++] = '-';
    2191                                                 }
    2192                                                 cashbuf[k] = 0;
    2193                                                 s = cashbuf;
    2194 
    2195                                         /* FALLTHROUGH */ /* no break */
    2196                                         case 4:  /* numeric */
    2197                                                 if (decimal)
    2198                                                 {
    2199                                                         tmp_obj = Py_BuildValue("(s)", s);
    2200                                                         val = PyEval_CallObject(decimal, tmp_obj);
    2201                                                 }
    2202                                                 else
    2203                                                 {
    2204                                                         tmp_obj = PyBytes_FromString(s);
    2205                                                         val = PyFloat_FromString(tmp_obj, NULL);
    2206                                                 }
    2207                                                 Py_DECREF(tmp_obj);
    2208                                                 break;
    2209 
    2210                                         default:
    2211                                                 val = PyBytes_FromString(s);
    2212                                                 break;
    2213                                 }
    2214 
    2215                         if (!val)
    2216                         {
    2217                                 Py_DECREF(reslist);
    2218                                 Py_DECREF(rowtuple);
    2219                                 reslist = NULL;
    2220                                 goto exit;
    2221                         }
    2222 
    2223                         PyTuple_SET_ITEM(rowtuple, j, val);
    2224                 }
    2225 
    2226                 PyList_SET_ITEM(reslist, i, rowtuple);
    2227         }
    2228 
    2229 exit:
    2230         free(typ);
    2231 
    2232         /* returns list */
    2233         return reslist;
    2234 }
    2235 
    2236 /* retrieves last result as a list of dictionaries*/
    2237 static char queryDictresult__doc__[] =
    2238 "dictresult() -- Gets the result of a query.  The result is returned "
    2239 "as a list of rows, each one a dictionary with the field names used "
    2240 "as the labels.";
    2241 
    2242 static PyObject *
    2243 pgquery_dictresult(pgqueryobject *self, PyObject *args)
    2244 {
    2245         PyObject   *dict,
    2246                            *reslist,
    2247                            *val;
    2248         int                     i,
    2249                                 j,
    2250                                 m,
    2251                                 n,
    2252                            *typ;
    2253 
    2254         /* checks args (args == NULL for an internal call) */
    2255         if (args && !PyArg_ParseTuple(args, ""))
    2256         {
    2257                 PyErr_SetString(PyExc_TypeError,
    2258                         "method dictresult() takes no parameters.");
    2259                 return NULL;
    2260         }
    2261 
    2262         /* stores result in list */
    2263         m = PQntuples(self->result);
    2264         n = PQnfields(self->result);
    2265         reslist = PyList_New(m);
    2266 
    2267         typ = get_type_array(self->result, n);
    2268 
    2269         for (i = 0; i < m; i++)
    2270         {
    2271                 if (!(dict = PyDict_New()))
    2272                 {
    2273                         Py_DECREF(reslist);
    2274                         reslist = NULL;
    2275                         goto exit;
    2276                 }
    2277 
    2278                 for (j = 0; j < n; j++)
    2279                 {
    2280                         int                     k;
    2281                         char       *s = PQgetvalue(self->result, i, j);
    2282                         char            cashbuf[64];
    2283                         PyObject   *tmp_obj;
    2284 
    2285                         if (PQgetisnull(self->result, i, j))
    2286                         {
    2287                                 Py_INCREF(Py_None);
    2288                                 val = Py_None;
    2289                         }
    2290                         else
    2291                                 switch (typ[j])
    2292                                 {
    2293                                         case 1:  /* int2/4 */
    2294                                                 val = PyLong_FromString(s, NULL, 10);
    2295                                                 break;
    2296 
    2297                                         case 2:  /* int8 */
    2298                                                 val = PyLong_FromString(s, NULL, 10);
    2299                                                 break;
    2300 
    2301                                         case 3:  /* float/double */
    2302                                                 tmp_obj = PyBytes_FromString(s);
    2303                                                 val = PyFloat_FromString(tmp_obj, NULL);
    2304                                                 Py_DECREF(tmp_obj);
    2305                                                 break;
    2306 
    2307                                         case 5:  /* money */
    2308                                                 for (k = 0;
    2309                                                          *s && k < sizeof(cashbuf) / sizeof(cashbuf[0]) - 1;
    2310                                                          s++)
    2311                                                 {
    2312                                                         if (isdigit(*s))
    2313                                                                 cashbuf[k++] = *s;
    2314                                                         else if (*s == *decimal_point)
    2315                                                                 cashbuf[k++] = '.';
    2316                                                         else if (*s == '(' || *s == '-')
    2317                                                                 cashbuf[k++] = '-';
    2318                                                 }
    2319                                                 cashbuf[k] = 0;
    2320                                                 s = cashbuf;
    2321 
    2322                                         /* FALLTHROUGH */ /* no break */
    2323                                         case 4:  /* numeric */
    2324                                                 if (decimal)
    2325                                                 {
    2326                                                         tmp_obj = Py_BuildValue("(s)", s);
    2327                                                         val = PyEval_CallObject(decimal, tmp_obj);
    2328                                                 }
    2329                                                 else
    2330                                                 {
    2331                                                         tmp_obj = PyBytes_FromString(s);
    2332                                                         val = PyFloat_FromString(tmp_obj, NULL);
    2333                                                 }
    2334                                                 Py_DECREF(tmp_obj);
    2335                                                 break;
    2336 
    2337                                         default:
    2338                                                 val = PyBytes_FromString(s);
    2339                                                 break;
    2340                                 }
    2341 
    2342                         if (!val)
    2343                         {
    2344                                 Py_DECREF(dict);
    2345                                 Py_DECREF(reslist);
    2346                                 reslist = NULL;
    2347                                 goto exit;
    2348                         }
    2349 
    2350                         PyDict_SetItemString(dict, PQfname(self->result, j), val);
    2351                         Py_DECREF(val);
    2352                 }
    2353 
    2354                 PyList_SET_ITEM(reslist, i, dict);
    2355         }
    2356 
    2357 exit:
    2358         free(typ);
    2359 
    2360         /* returns list */
    2361         return reslist;
    2362 }
    2363 
    2364 /* retrieves last result as named tuples */
    2365 static char queryNamedresult__doc__[] =
    2366 "namedresult() -- Gets the result of a query.  The result is returned "
    2367 "as a list of rows, each one a tuple of fields in the order returned "
    2368 "by the server.";
    2369 
    2370 static PyObject *
    2371 pgquery_namedresult(pgqueryobject *self, PyObject *args)
    2372 {
    2373         PyObject   *arglist,
    2374                            *ret;
    2375 
    2376         /* checks args (args == NULL for an internal call) */
    2377         if (args && !PyArg_ParseTuple(args, ""))
    2378         {
    2379                 PyErr_SetString(PyExc_TypeError,
    2380                         "method namedresult() takes no parameters.");
    2381                 return NULL;
    2382         }
    2383 
    2384         if (!namedresult)
    2385         {
    2386                 PyErr_SetString(PyExc_TypeError,
    2387                         "named tuples are not supported.");
    2388                 return NULL;
    2389         }
    2390 
    2391         arglist = Py_BuildValue("(O)", self);
    2392         ret = PyObject_CallObject(namedresult, arglist);
    2393         Py_DECREF(arglist);
    2394 
    2395         if (ret == NULL)
    2396                 return NULL;
    2397 
    2398         return ret;
    2399 }
    2400 
    2401 /* gets asynchronous notify */
    2402 static char connGetnotify__doc__[] =
    2403 "getnotify() -- get database notify for this connection.";
    2404 
    2405 static PyObject *
    2406 pg_getnotify(connObject *self, PyObject *args)
    2407 {
    2408         PGnotify   *notify;
    2409 
    2410         if (!self->cnx)
    2411         {
    2412                 PyErr_SetString(PyExc_TypeError, "Connection is not valid.");
    2413                 return NULL;
    2414         }
    2415 
    2416         /* checks args */
    2417         if (!PyArg_ParseTuple(args, ""))
    2418         {
    2419                 PyErr_SetString(PyExc_TypeError,
    2420                         "method getnotify() takes no parameters.");
    2421                 return NULL;
    2422         }
    2423 
    2424         /* checks for NOTIFY messages */
    2425         PQconsumeInput(self->cnx);
    2426 
    2427         if (!(notify = PQnotifies(self->cnx)))
    2428         {
    2429                 Py_INCREF(Py_None);
    2430                 return Py_None;
    2431         }
    2432         else
    2433         {
    2434                 PyObject   *notify_result,
    2435                                    *temp;
    2436 
    2437                 if (!(temp = PyBytes_FromString(notify->relname)))
    2438                         return NULL;
    2439 
    2440                 if (!(notify_result = PyTuple_New(3)))
    2441                         return NULL;
    2442 
    2443                 PyTuple_SET_ITEM(notify_result, 0, temp);
    2444 
    2445                 if (!(temp = PyLong_FromLong(notify->be_pid)))
    2446                 {
    2447                         Py_DECREF(notify_result);
    2448                         return NULL;
    2449                 }
    2450 
    2451                 PyTuple_SET_ITEM(notify_result, 1, temp);
    2452 
    2453                 /* extra exists even in old versions that did not support it */
    2454                 if (!(temp = PyBytes_FromString(notify->extra)))
    2455                 {
    2456                         Py_DECREF(notify_result);
    2457                         return NULL;
    2458                 }
    2459 
    2460                 PyTuple_SET_ITEM(notify_result, 2, temp);
    2461 
    2462                 PQfreemem(notify);
    2463 
    2464                 return notify_result;
    2465         }
    2466 }
    2467 
    24681042/* source creation */
    24691043static char connSource__doc__[] =
     
    24711045
    24721046static PyObject *
    2473 pg_source(connObject *self, PyObject *args)
    2474 {
     1047connSource(connObject *self, PyObject *args)
     1048{
     1049        sourceObject *npgobj;
     1050
    24751051        /* checks validity */
    24761052        if (!check_cnx_obj(self))
     
    24841060        }
    24851061
    2486         /* allocate new pg query object */
    2487         return (PyObject *) sourceNew(self);
     1062        /* allocates new query object */
     1063        if (!(npgobj = PyObject_NEW(sourceObject, &sourceType)))
     1064                return NULL;
     1065
     1066        /* initializes internal parameters */
     1067        Py_XINCREF(self);
     1068        npgobj->pgcnx = self;
     1069        npgobj->result = NULL;
     1070        npgobj->valid = 1;
     1071        npgobj->arraysize = PG_ARRAYSIZE;
     1072
     1073        return (PyObject *) npgobj;
    24881074}
    24891075
     
    24941080
    24951081static PyObject *
    2496 pg_query(connObject *self, PyObject *args)
     1082connQuery(connObject *self, PyObject *args)
    24971083{
    24981084        char            *query;
    24991085        PyObject        *oargs = NULL;
    25001086        PGresult        *result;
    2501         pgqueryobject *npgobj;
     1087        queryObject *npgobj;
    25021088        int                     status,
    25031089                                nparms = 0;
     
    26931279        }
    26941280
    2695         if (!(npgobj = PyObject_NEW(pgqueryobject, &queryType)))
     1281        if (!(npgobj = PyObject_NEW(queryObject, &queryType)))
    26961282                return NULL;
    26971283
     
    27021288
    27031289#ifdef DIRECT_ACCESS
    2704 static char connPutline__doc__[] =
     1290static char connPutLine__doc__[] =
    27051291"putline() -- sends a line directly to the backend";
    27061292
    27071293/* direct acces function : putline */
    27081294static PyObject *
    2709 pg_putline(connObject *self, PyObject *args)
     1295connPutLine(connObject *self, PyObject *args)
    27101296{
    27111297        char *line;
     
    27351321
    27361322/* direct access function : getline */
    2737 static char connGetline__doc__[] =
     1323static char connGetLine__doc__[] =
    27381324"getline() -- gets a line directly from the backend.";
    27391325
    27401326static PyObject *
    2741 pg_getline(connObject *self, PyObject *args)
     1327connGetLine(connObject *self, PyObject *args)
    27421328{
    27431329        char            line[MAX_BUFFER_SIZE];
     
    27781364
    27791365/* direct access function : end copy */
    2780 static char connEndcopy__doc__[] =
     1366static char connEndCopy__doc__[] =
    27811367"endcopy() -- synchronizes client and server";
    27821368
    27831369static PyObject *
    2784 pg_endcopy(connObject *self, PyObject *args)
     1370connEndCopy(connObject *self, PyObject *args)
    27851371{
    27861372        if (!self->cnx)
     
    28101396
    28111397static PyObject *
    2812 pgquery_repr(pgqueryobject *self)
     1398pgquery_repr(queryObject *self)
    28131399{
    28141400        return PyBytes_FromString("<pg query result>");
     
    28161402
    28171403static PyObject *
    2818 pgquery_str(pgqueryobject *self)
     1404pgquery_str(queryObject *self)
    28191405{
    28201406        return format_result(self->result);
     
    28221408
    28231409/* insert table */
    2824 static char connInserttable__doc__[] =
     1410static char connInsertTable__doc__[] =
    28251411"inserttable(string, list) -- insert list in table. The fields in the "
    28261412"list must be in the same order as in the table.";
    28271413
    28281414static PyObject *
    2829 pg_inserttable(connObject *self, PyObject *args)
     1415connInsertTable(connObject *self, PyObject *args)
    28301416{
    28311417        PGresult        *result;
     
    30511637
    30521638static PyObject *
    3053 pg_transaction(connObject *self, PyObject *args)
     1639connTransaction(connObject *self, PyObject *args)
    30541640{
    30551641        if (!self->cnx)
     
    30751661
    30761662static PyObject *
    3077 pg_parameter(connObject *self, PyObject *args)
     1663connParameter(connObject *self, PyObject *args)
    30781664{
    30791665        const char *name;
     
    31051691
    31061692/* escape literal */
    3107 static char connEscape_literal__doc__[] =
    3108 "pg_escape_literal(str) -- escape a literal constant for use within SQL.";
    3109 
    3110 static PyObject *
    3111 pg_escape_literal(connObject *self, PyObject *args)
     1693static char connEscapeLiteral__doc__[] =
     1694"connEscapeLiteral(str) -- escape a literal constant for use within SQL.";
     1695
     1696static PyObject *
     1697connEscapeLiteral(connObject *self, PyObject *args)
    31121698{
    31131699        char *str; /* our string argument */
     
    31281714
    31291715/* escape identifier */
    3130 static char connEscape_identifier__doc__[] =
    3131 "pg_escape_identifier(str) -- escape an identifier for use within SQL.";
    3132 
    3133 static PyObject *
    3134 pg_escape_identifier(connObject *self, PyObject *args)
     1716static char connEscapeIdentifier__doc__[] =
     1717"connEscapeIdentifier(str) -- escape an identifier for use within SQL.";
     1718
     1719static PyObject *
     1720connEscapeIdentifier(connObject *self, PyObject *args)
    31351721{
    31361722        char *str; /* our string argument */
     
    31531739
    31541740/* escape string */
    3155 static char connEscape_string__doc__[] =
    3156 "pg_escape_string(str) -- escape a string for use within SQL.";
    3157 
    3158 static PyObject *
    3159 pg_escape_string(connObject *self, PyObject *args)
     1741static char connEscapeString__doc__[] =
     1742"connEscapeString(str) -- escape a string for use within SQL.";
     1743
     1744static PyObject *
     1745connEscapeString(connObject *self, PyObject *args)
    31601746{
    31611747        char *from; /* our string argument */
     
    31851771
    31861772/* escape bytea */
    3187 static char connEscape_bytea__doc__[] =
    3188 "pg_escape_bytea(data) -- escape binary data for use within SQL as type bytea.";
    3189 
    3190 static PyObject *
    3191 pg_escape_bytea(connObject *self, PyObject *args)
     1773static char connEscapeBytea__doc__[] =
     1774"connEscapeBytea(data) -- escape binary data for use within SQL as type bytea.";
     1775
     1776static PyObject *
     1777connEscapeBytea(connObject *self, PyObject *args)
    31921778{
    31931779        unsigned char *from; /* our string argument */
     
    32101796#ifdef LARGE_OBJECTS
    32111797/* creates large object */
    3212 static char connLocreate__doc__[] =
     1798static char connCreateLO__doc__[] =
    32131799"locreate() -- creates a new large object in the database.";
    32141800
    32151801static PyObject *
    3216 pg_locreate(connObject *self, PyObject *args)
     1802connCreateLO(connObject *self, PyObject *args)
    32171803{
    32181804        int                     mode;
     
    32391825        }
    32401826
    3241         return (PyObject *) pglarge_new(self, lo_oid);
     1827        return (PyObject *) largeNew(self, lo_oid);
    32421828}
    32431829
    32441830/* init from already known oid */
    3245 static char connGetlo__doc__[] =
     1831static char connGetLO__doc__[] =
    32461832"getlo(long) -- create a large object instance for the specified oid.";
    32471833
    32481834static PyObject *
    3249 pg_getlo(connObject *self, PyObject *args)
     1835connGetLO(connObject *self, PyObject *args)
    32501836{
    32511837        int                     lo_oid;
     
    32691855
    32701856        /* creates object */
    3271         return (PyObject *) pglarge_new(self, lo_oid);
     1857        return (PyObject *) largeNew(self, lo_oid);
    32721858}
    32731859
    32741860/* import unix file */
    3275 static char connLoimport__doc__[] =
     1861static char connImportLO__doc__[] =
    32761862"loimport(string) -- create a new large object from specified file.";
    32771863
    32781864static PyObject *
    3279 pg_loimport(connObject *self, PyObject *args)
     1865connImportLO(connObject *self, PyObject *args)
    32801866{
    32811867        char   *name;
     
    33011887        }
    33021888
    3303         return (PyObject *) pglarge_new(self, lo_oid);
     1889        return (PyObject *) largeNew(self, lo_oid);
    33041890}
    33051891#endif /* LARGE_OBJECTS */
    33061892
     1893/* resets connection */
     1894static char connReset__doc__[] =
     1895"reset() -- reset connection with current parameters. All derived queries "
     1896"and large objects derived from this connection will not be usable after "
     1897"this call.";
     1898
     1899static PyObject *
     1900connReset(connObject *self, PyObject *args)
     1901{
     1902        if (!self->cnx)
     1903        {
     1904                PyErr_SetString(PyExc_TypeError, "Connection is not valid.");
     1905                return NULL;
     1906        }
     1907
     1908        /* checks args */
     1909        if (!PyArg_ParseTuple(args, ""))
     1910        {
     1911                PyErr_SetString(PyExc_TypeError,
     1912                        "method reset() takes no parameters.");
     1913                return NULL;
     1914        }
     1915
     1916        /* resets the connection */
     1917        PQreset(self->cnx);
     1918        Py_INCREF(Py_None);
     1919        return Py_None;
     1920}
     1921
     1922/* cancels current command */
     1923static char connCancel__doc__[] =
     1924"cancel() -- abandon processing of the current command.";
     1925
     1926static PyObject *
     1927connCancel(connObject *self, PyObject *args)
     1928{
     1929        if (!self->cnx)
     1930        {
     1931                PyErr_SetString(PyExc_TypeError, "Connection is not valid.");
     1932                return NULL;
     1933        }
     1934
     1935        /* checks args */
     1936        if (!PyArg_ParseTuple(args, ""))
     1937        {
     1938                PyErr_SetString(PyExc_TypeError,
     1939                        "method cancel() takes no parameters.");
     1940                return NULL;
     1941        }
     1942
     1943        /* request that the server abandon processing of the current command */
     1944        return PyLong_FromLong((long) PQrequestCancel(self->cnx));
     1945}
     1946
     1947/* get connection socket */
     1948static char connFileno__doc__[] =
     1949"fileno() -- return database connection socket file handle.";
     1950
     1951static PyObject *
     1952connFileno(connObject *self, PyObject *args)
     1953{
     1954        if (!self->cnx)
     1955        {
     1956                PyErr_SetString(PyExc_TypeError, "Connection is not valid.");
     1957                return NULL;
     1958        }
     1959
     1960        /* checks args */
     1961        if (!PyArg_ParseTuple(args, ""))
     1962        {
     1963                PyErr_SetString(PyExc_TypeError,
     1964                        "method fileno() takes no parameters.");
     1965                return NULL;
     1966        }
     1967
     1968#ifdef NO_PQSOCKET
     1969        return PyLong_FromLong((long) self->cnx->sock);
     1970#else
     1971        return PyLong_FromLong((long) PQsocket(self->cnx));
     1972#endif
     1973}
     1974
     1975/* set notice receiver callback function */
     1976static char connSetNoticeReceiver__doc__[] =
     1977"set_notice_receiver() -- set the current notice receiver.";
     1978
     1979static PyObject *
     1980connSetNoticeReceiver(connObject * self, PyObject * args)
     1981{
     1982        PyObject *ret = NULL;
     1983        PyObject *proc;
     1984
     1985        if (PyArg_ParseTuple(args, "O", &proc))
     1986        {
     1987                if (PyCallable_Check(proc))
     1988                {
     1989                        Py_XINCREF(proc);
     1990                        self->notice_receiver = proc;
     1991                        PQsetNoticeReceiver(self->cnx, notice_receiver, self);
     1992                        Py_INCREF(Py_None); ret = Py_None;
     1993                }
     1994                else
     1995                        PyErr_SetString(PyExc_TypeError, "notice receiver must be callable");
     1996        }
     1997        return ret;
     1998}
     1999
     2000/* get notice receiver callback function */
     2001static char connGetNoticeReceiver__doc__[] =
     2002"get_notice_receiver() -- get the current notice receiver.";
     2003
     2004static PyObject *
     2005connGetNoticeReceiver(connObject * self, PyObject * args)
     2006{
     2007        PyObject *ret = NULL;
     2008
     2009        if (PyArg_ParseTuple(args, ""))
     2010        {
     2011                ret = self->notice_receiver;
     2012                if (!ret)
     2013                        ret = Py_None;
     2014                Py_INCREF(ret);
     2015        }
     2016        else
     2017        {
     2018                PyErr_SetString(PyExc_TypeError,
     2019                        "method get_notice_receiver() takes no parameters.");
     2020        }
     2021        return ret;
     2022}
     2023
     2024/* close without deleting */
     2025static char connClose__doc__[] =
     2026"close() -- close connection. All instances of the connection object and "
     2027"derived objects (queries and large objects) can no longer be used after "
     2028"this call.";
     2029
     2030static PyObject *
     2031connClose(connObject *self, PyObject *args)
     2032{
     2033        /* gets args */
     2034        if (!PyArg_ParseTuple(args, ""))
     2035        {
     2036                PyErr_SetString(PyExc_TypeError, "close().");
     2037                return NULL;
     2038        }
     2039
     2040        /* connection object cannot already be closed */
     2041        if (!self->cnx)
     2042        {
     2043                set_dberror(InternalError, "Connection already closed", NULL);
     2044                return NULL;
     2045        }
     2046
     2047        Py_BEGIN_ALLOW_THREADS
     2048        PQfinish(self->cnx);
     2049        Py_END_ALLOW_THREADS
     2050
     2051        self->cnx = NULL;
     2052        Py_INCREF(Py_None);
     2053        return Py_None;
     2054}
     2055
     2056/* gets asynchronous notify */
     2057static char connGetNotify__doc__[] =
     2058"getnotify() -- get database notify for this connection.";
     2059
     2060static PyObject *
     2061connGetNotify(connObject *self, PyObject *args)
     2062{
     2063        PGnotify   *notify;
     2064
     2065        if (!self->cnx)
     2066        {
     2067                PyErr_SetString(PyExc_TypeError, "Connection is not valid.");
     2068                return NULL;
     2069        }
     2070
     2071        /* checks args */
     2072        if (!PyArg_ParseTuple(args, ""))
     2073        {
     2074                PyErr_SetString(PyExc_TypeError,
     2075                        "method getnotify() takes no parameters.");
     2076                return NULL;
     2077        }
     2078
     2079        /* checks for NOTIFY messages */
     2080        PQconsumeInput(self->cnx);
     2081
     2082        if (!(notify = PQnotifies(self->cnx)))
     2083        {
     2084                Py_INCREF(Py_None);
     2085                return Py_None;
     2086        }
     2087        else
     2088        {
     2089                PyObject   *notify_result,
     2090                                   *temp;
     2091
     2092                if (!(temp = PyBytes_FromString(notify->relname)))
     2093                        return NULL;
     2094
     2095                if (!(notify_result = PyTuple_New(3)))
     2096                        return NULL;
     2097
     2098                PyTuple_SET_ITEM(notify_result, 0, temp);
     2099
     2100                if (!(temp = PyLong_FromLong(notify->be_pid)))
     2101                {
     2102                        Py_DECREF(notify_result);
     2103                        return NULL;
     2104                }
     2105
     2106                PyTuple_SET_ITEM(notify_result, 1, temp);
     2107
     2108                /* extra exists even in old versions that did not support it */
     2109                if (!(temp = PyBytes_FromString(notify->extra)))
     2110                {
     2111                        Py_DECREF(notify_result);
     2112                        return NULL;
     2113                }
     2114
     2115                PyTuple_SET_ITEM(notify_result, 2, temp);
     2116
     2117                PQfreemem(notify);
     2118
     2119                return notify_result;
     2120        }
     2121}
    33072122
    33082123/* connection object methods */
    3309 static struct PyMethodDef pgobj_methods[] = {
    3310         {"source", (PyCFunction) pg_source, METH_VARARGS, connSource__doc__},
    3311         {"query", (PyCFunction) pg_query, METH_VARARGS, connQuery__doc__},
    3312         {"reset", (PyCFunction) pg_reset, METH_VARARGS, connReset__doc__},
    3313         {"cancel", (PyCFunction) pg_cancel, METH_VARARGS, connCancel__doc__},
    3314         {"close", (PyCFunction) pg_close, METH_VARARGS, connClose__doc__},
    3315         {"fileno", (PyCFunction) pg_fileno, METH_VARARGS, connFileno__doc__},
    3316         {"get_notice_receiver", (PyCFunction) pg_get_notice_receiver, METH_VARARGS,
    3317                         connGet_notice_receiver__doc__},
    3318         {"set_notice_receiver", (PyCFunction) pg_set_notice_receiver, METH_VARARGS,
    3319                         connSset_notice_receiver__doc__},
    3320         {"getnotify", (PyCFunction) pg_getnotify, METH_VARARGS,
    3321                         connGetnotify__doc__},
    3322         {"inserttable", (PyCFunction) pg_inserttable, METH_VARARGS,
    3323                         connInserttable__doc__},
    3324         {"transaction", (PyCFunction) pg_transaction, METH_VARARGS,
     2124static struct PyMethodDef connMethods[] = {
     2125        {"source", (PyCFunction) connSource, METH_VARARGS, connSource__doc__},
     2126        {"query", (PyCFunction) connQuery, METH_VARARGS, connQuery__doc__},
     2127        {"reset", (PyCFunction) connReset, METH_VARARGS, connReset__doc__},
     2128        {"cancel", (PyCFunction) connCancel, METH_VARARGS, connCancel__doc__},
     2129        {"close", (PyCFunction) connClose, METH_VARARGS, connClose__doc__},
     2130        {"fileno", (PyCFunction) connFileno, METH_VARARGS, connFileno__doc__},
     2131        {"get_notice_receiver", (PyCFunction) connGetNoticeReceiver, METH_VARARGS,
     2132                        connGetNoticeReceiver__doc__},
     2133        {"set_notice_receiver", (PyCFunction) connSetNoticeReceiver, METH_VARARGS,
     2134                        connSetNoticeReceiver__doc__},
     2135        {"getnotify", (PyCFunction) connGetNotify, METH_VARARGS,
     2136                        connGetNotify__doc__},
     2137        {"inserttable", (PyCFunction) connInsertTable, METH_VARARGS,
     2138                        connInsertTable__doc__},
     2139        {"transaction", (PyCFunction) connTransaction, METH_VARARGS,
    33252140                        connTransaction__doc__},
    3326         {"parameter", (PyCFunction) pg_parameter, METH_VARARGS,
     2141        {"parameter", (PyCFunction) connParameter, METH_VARARGS,
    33272142                        connParameter__doc__},
    33282143
    33292144#ifdef ESCAPING_FUNCS
    3330         {"escape_literal", (PyCFunction) pg_escape_literal, METH_VARARGS,
    3331                         connEscape_literal__doc__},
    3332         {"escape_identifier", (PyCFunction) pg_escape_identifier, METH_VARARGS,
    3333                         connEscape_identifier__doc__},
     2145        {"escape_literal", (PyCFunction) connEscapeLiteral, METH_VARARGS,
     2146                        connEscapeLiteral__doc__},
     2147        {"escape_identifier", (PyCFunction) connEscapeIdentifier, METH_VARARGS,
     2148                        connEscapeIdentifier__doc__},
    33342149#endif  /* ESCAPING_FUNCS */
    3335         {"escape_string", (PyCFunction) pg_escape_string, METH_VARARGS,
    3336                         connEscape_string__doc__},
    3337         {"escape_bytea", (PyCFunction) pg_escape_bytea, METH_VARARGS,
    3338                         connEscape_bytea__doc__},
     2150        {"escape_string", (PyCFunction) connEscapeString, METH_VARARGS,
     2151                        connEscapeString__doc__},
     2152        {"escape_bytea", (PyCFunction) connEscapeBytea, METH_VARARGS,
     2153                        connEscapeBytea__doc__},
    33392154
    33402155#ifdef DIRECT_ACCESS
    3341         {"putline", (PyCFunction) pg_putline, 1, connPutline__doc__},
    3342         {"getline", (PyCFunction) pg_getline, 1, connGetline__doc__},
    3343         {"endcopy", (PyCFunction) pg_endcopy, 1, connEndcopy__doc__},
     2156        {"putline", (PyCFunction) connPutLine, 1, connPutLine__doc__},
     2157        {"getline", (PyCFunction) connGetLine, 1, connGetLine__doc__},
     2158        {"endcopy", (PyCFunction) connEndCopy, 1, connEndCopy__doc__},
    33442159#endif /* DIRECT_ACCESS */
    33452160
    33462161#ifdef LARGE_OBJECTS
    3347         {"locreate", (PyCFunction) pg_locreate, 1, connLocreate__doc__},
    3348         {"getlo", (PyCFunction) pg_getlo, 1, connGetlo__doc__},
    3349         {"loimport", (PyCFunction) pg_loimport, 1, connLoimport__doc__},
     2162        {"locreate", (PyCFunction) connCreateLO, 1, connCreateLO__doc__},
     2163        {"getlo", (PyCFunction) connGetLO, 1, connGetLO__doc__},
     2164        {"loimport", (PyCFunction) connImportLO, 1, connImportLO__doc__},
    33502165#endif /* LARGE_OBJECTS */
    33512166
     
    33532168};
    33542169
    3355 /* get attribute */
    33562170static PyObject *
    33572171connGetattr(connObject *self, char *name)
     
    34432257        }
    34442258
    3445         return Py_FindMethod(pgobj_methods, (PyObject *) self, name);
     2259        return Py_FindMethod(connMethods, (PyObject *) self, name);
    34462260}
    34472261
     
    34502264        PyObject_HEAD_INIT(NULL)
    34512265        0,                                                      /* ob_size */
    3452         "connObject",                                   /* tp_name */
     2266        "PGconnObject",                         /* tp_name */
    34532267        sizeof(connObject),                     /* tp_basicsize */
    34542268        0,                                                      /* tp_itemsize */
     
    34662280};
    34672281
     2282/* --------------------------------------------------------------------- */
     2283/* source object */
     2284/* --------------------------------------------------------------------- */
     2285/* checks source object validity */
     2286static int
     2287check_source_obj(sourceObject *self, int level)
     2288{
     2289        if (!self->valid)
     2290        {
     2291                set_dberror(OperationalError, "object has been closed", NULL);
     2292                return 0;
     2293        }
     2294
     2295        if ((level & CHECK_RESULT) && !self->result)
     2296        {
     2297                set_dberror(DatabaseError, "no result.", NULL);
     2298                return 0;
     2299        }
     2300
     2301        if ((level & CHECK_DQL) && self->result_type != RESULT_DQL)
     2302        {
     2303                set_dberror(DatabaseError,
     2304                        "last query did not return tuples.", self->result);
     2305                return 0;
     2306        }
     2307
     2308        if ((level & CHECK_CNX) && !check_cnx_obj(self->pgcnx))
     2309                return 0;
     2310
     2311        return 1;
     2312}
     2313
     2314/* destructor */
     2315static void
     2316pgsource_dealloc(sourceObject *self)
     2317{
     2318        if (self->result)
     2319                PQclear(self->result);
     2320
     2321        Py_XDECREF(self->pgcnx);
     2322        PyObject_Del(self);
     2323}
     2324
     2325/* closes object */
     2326static char sourceClose__doc__[] =
     2327"close() -- close query object without deleting it. "
     2328"All instances of the query object can no longer be used after this call.";
     2329
     2330static PyObject *
     2331sourceClose(sourceObject *self, PyObject *args)
     2332{
     2333        /* checks args */
     2334        if (!PyArg_ParseTuple(args, ""))
     2335        {
     2336                PyErr_SetString(PyExc_TypeError, "method close() takes no parameter.");
     2337                return NULL;
     2338        }
     2339
     2340        /* frees result if necessary and invalidates object */
     2341        if (self->result)
     2342        {
     2343                PQclear(self->result);
     2344                self->result_type = RESULT_EMPTY;
     2345                self->result = NULL;
     2346        }
     2347
     2348        self->valid = 0;
     2349
     2350        /* return None */
     2351        Py_INCREF(Py_None);
     2352        return Py_None;
     2353}
     2354
     2355/* database query */
     2356static char sourceExecute__doc__[] =
     2357"execute(sql) -- execute a SQL statement (string).\n "
     2358"On success, this call returns the number of affected rows, "
     2359"or None for DQL (SELECT, ...) statements.\n"
     2360"The fetch (fetch(), fetchone() and fetchall()) methods can be used "
     2361"to get result rows.";
     2362
     2363static PyObject *
     2364sourceExecute(sourceObject *self, PyObject *args)
     2365{
     2366        char            *query;
     2367
     2368        /* checks validity */
     2369        if (!check_source_obj(self, CHECK_CNX))
     2370                return NULL;
     2371
     2372        /* make sure that the connection object is valid */
     2373        if (!self->pgcnx->cnx)
     2374                return NULL;
     2375
     2376        /* get query args */
     2377        if (!PyArg_ParseTuple(args, "s", &query))
     2378        {
     2379                PyErr_SetString(PyExc_TypeError, "execute(sql), with sql (string).");
     2380                return NULL;
     2381        }
     2382
     2383        /* frees previous result */
     2384        if (self->result)
     2385        {
     2386                PQclear(self->result);
     2387                self->result = NULL;
     2388        }
     2389        self->max_row = 0;
     2390        self->current_row = 0;
     2391        self->num_fields = 0;
     2392
     2393        /* gets result */
     2394        Py_BEGIN_ALLOW_THREADS
     2395        self->result = PQexec(self->pgcnx->cnx, query);
     2396        Py_END_ALLOW_THREADS
     2397
     2398        /* checks result validity */
     2399        if (!self->result)
     2400        {
     2401                PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->pgcnx->cnx));
     2402                return NULL;
     2403        }
     2404
     2405        /* checks result status */
     2406        switch (PQresultStatus(self->result))
     2407        {
     2408                long    num_rows;
     2409                char   *temp;
     2410
     2411                /* query succeeded */
     2412                case PGRES_TUPLES_OK:   /* DQL: returns None (DB-SIG compliant) */
     2413                        self->result_type = RESULT_DQL;
     2414                        self->max_row = PQntuples(self->result);
     2415                        self->num_fields = PQnfields(self->result);
     2416                        Py_INCREF(Py_None);
     2417                        return Py_None;
     2418                case PGRES_COMMAND_OK:  /* other requests */
     2419                case PGRES_COPY_OUT:
     2420                case PGRES_COPY_IN:
     2421                        self->result_type = RESULT_DDL;
     2422                        temp = PQcmdTuples(self->result);
     2423                        num_rows = -1;
     2424                        if (temp[0])
     2425                        {
     2426                                self->result_type = RESULT_DML;
     2427                                num_rows = atol(temp);
     2428                        }
     2429                        return PyLong_FromLong(num_rows);
     2430
     2431                /* query failed */
     2432                case PGRES_EMPTY_QUERY:
     2433                        PyErr_SetString(PyExc_ValueError, "empty query.");
     2434                        break;
     2435                case PGRES_BAD_RESPONSE:
     2436                case PGRES_FATAL_ERROR:
     2437                case PGRES_NONFATAL_ERROR:
     2438                        set_dberror(ProgrammingError,
     2439                                PQerrorMessage(self->pgcnx->cnx), self->result);
     2440                        break;
     2441                default:
     2442                        set_dberror(InternalError, "internal error: "
     2443                                "unknown result status.", self->result);
     2444                        break;
     2445        }
     2446
     2447        /* frees result and returns error */
     2448        PQclear(self->result);
     2449        self->result = NULL;
     2450        self->result_type = RESULT_EMPTY;
     2451        return NULL;
     2452}
     2453
     2454/* gets oid status for last query (valid for INSERTs, 0 for other) */
     2455static char sourceStatusOID__doc__[] =
     2456"oidstatus() -- return oid of last inserted row (if available).";
     2457
     2458static PyObject *
     2459sourceStatusOID(sourceObject *self, PyObject *args)
     2460{
     2461        Oid                     oid;
     2462
     2463        /* checks validity */
     2464        if (!check_source_obj(self, CHECK_RESULT))
     2465                return NULL;
     2466
     2467        /* checks args */
     2468        if (args && !PyArg_ParseTuple(args, ""))
     2469        {
     2470                PyErr_SetString(PyExc_TypeError,
     2471                        "method oidstatus() takes no parameters.");
     2472                return NULL;
     2473        }
     2474
     2475        /* retrieves oid status */
     2476        if ((oid = PQoidValue(self->result)) == InvalidOid)
     2477        {
     2478                Py_INCREF(Py_None);
     2479                return Py_None;
     2480        }
     2481
     2482        return PyLong_FromLong(oid);
     2483}
     2484
     2485/* fetches rows from last result */
     2486static char sourceFetch__doc__[] =
     2487"fetch(num) -- return the next num rows from the last result in a list. "
     2488"If num parameter is omitted arraysize attribute value is used. "
     2489"If size equals -1, all rows are fetched.";
     2490
     2491static PyObject *
     2492sourceFetch(sourceObject *self, PyObject *args)
     2493{
     2494        PyObject   *rowtuple,
     2495                           *reslist,
     2496                           *str;
     2497        int                     i,
     2498                                j;
     2499        long            size;
     2500
     2501        /* checks validity */
     2502        if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
     2503                return NULL;
     2504
     2505        /* checks args */
     2506        size = self->arraysize;
     2507        if (!PyArg_ParseTuple(args, "|l", &size))
     2508        {
     2509                PyErr_SetString(PyExc_TypeError,
     2510                        "fetch(num), with num (integer, optional).");
     2511                return NULL;
     2512        }
     2513
     2514        /* seeks last line */
     2515        /* limit size to be within the amount of data we actually have */
     2516        if (size == -1 || (self->max_row - self->current_row) < size)
     2517                size = self->max_row - self->current_row;
     2518
     2519        /* allocate list for result */
     2520        if (!(reslist = PyList_New(0)))
     2521                return NULL;
     2522
     2523        /* builds result */
     2524        for (i = 0; i < size; i++)
     2525        {
     2526                if (!(rowtuple = PyTuple_New(self->num_fields)))
     2527                {
     2528                        Py_DECREF(reslist);
     2529                        return NULL;
     2530                }
     2531
     2532                for (j = 0; j < self->num_fields; j++)
     2533                {
     2534                        if (PQgetisnull(self->result, self->current_row, j))
     2535                        {
     2536                                Py_INCREF(Py_None);
     2537                                str = Py_None;
     2538                        }
     2539                        else
     2540                                str = PyBytes_FromString(PQgetvalue(self->result, self->current_row, j));
     2541
     2542                        PyTuple_SET_ITEM(rowtuple, j, str);
     2543                }
     2544
     2545                PyList_Append(reslist, rowtuple);
     2546                Py_DECREF(rowtuple);
     2547                self->current_row++;
     2548        }
     2549
     2550        return reslist;
     2551}
     2552
     2553/* changes current row (internal wrapper for all "move" methods) */
     2554static PyObject *
     2555pgsource_move(sourceObject *self, PyObject *args, int move)
     2556{
     2557        /* checks validity */
     2558        if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
     2559                return NULL;
     2560
     2561        /* checks args */
     2562        if (!PyArg_ParseTuple(args, ""))
     2563        {
     2564                char            errbuf[256];
     2565                PyOS_snprintf(errbuf, sizeof(errbuf),
     2566                        "method %s() takes no parameter.", __movename[move]);
     2567                PyErr_SetString(PyExc_TypeError, errbuf);
     2568                return NULL;
     2569        }
     2570
     2571        /* changes the current row */
     2572        switch (move)
     2573        {
     2574                case QUERY_MOVEFIRST:
     2575                        self->current_row = 0;
     2576                        break;
     2577                case QUERY_MOVELAST:
     2578                        self->current_row = self->max_row - 1;
     2579                        break;
     2580                case QUERY_MOVENEXT:
     2581                        if (self->current_row != self->max_row)
     2582                                self->current_row++;
     2583                        break;
     2584                case QUERY_MOVEPREV:
     2585                        if (self->current_row > 0)
     2586                                self->current_row--;
     2587                        break;
     2588        }
     2589
     2590        Py_INCREF(Py_None);
     2591        return Py_None;
     2592}
     2593
     2594/* move to first result row */
     2595static char sourceMoveFirst__doc__[] =
     2596"movefirst() -- move to first result row.";
     2597
     2598static PyObject *
     2599sourceMoveFirst(sourceObject *self, PyObject *args)
     2600{
     2601        return pgsource_move(self, args, QUERY_MOVEFIRST);
     2602}
     2603
     2604/* move to last result row */
     2605static char sourceMoveLast__doc__[] =
     2606"movelast() -- move to last valid result row.";
     2607
     2608static PyObject *
     2609sourceMoveLast(sourceObject *self, PyObject *args)
     2610{
     2611        return pgsource_move(self, args, QUERY_MOVELAST);
     2612}
     2613
     2614/* move to next result row */
     2615static char sourceMoveNext__doc__[] =
     2616"movenext() -- move to next result row.";
     2617
     2618static PyObject *
     2619sourceMoveNext(sourceObject *self, PyObject *args)
     2620{
     2621        return pgsource_move(self, args, QUERY_MOVENEXT);
     2622}
     2623
     2624/* move to previous result row */
     2625static char sourceMovePrev__doc__[] =
     2626"moveprev() -- move to previous result row.";
     2627
     2628static PyObject *
     2629sourceMovePrev(sourceObject *self, PyObject *args)
     2630{
     2631        return pgsource_move(self, args, QUERY_MOVEPREV);
     2632}
     2633
     2634/* finds field number from string/integer (internal use only) */
     2635static int
     2636sourceFieldindex(sourceObject *self, PyObject *param, const char *usage)
     2637{
     2638        int                     num;
     2639
     2640        /* checks validity */
     2641        if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
     2642                return -1;
     2643
     2644        /* gets field number */
     2645        if (PyBytes_Check(param))
     2646                num = PQfnumber(self->result, PyBytes_AsString(param));
     2647        else if (PyLong_Check(param))
     2648                num = PyLong_AsLong(param);
     2649        else
     2650        {
     2651                PyErr_SetString(PyExc_TypeError, usage);
     2652                return -1;
     2653        }
     2654
     2655        /* checks field validity */
     2656        if (num < 0 || num >= self->num_fields)
     2657        {
     2658                PyErr_SetString(PyExc_ValueError, "Unknown field.");
     2659                return -1;
     2660        }
     2661
     2662        return num;
     2663}
     2664
     2665/* builds field information from position (internal use only) */
     2666static PyObject *
     2667pgsource_buildinfo(sourceObject *self, int num)
     2668{
     2669        PyObject *result;
     2670
     2671        /* allocates tuple */
     2672        result = PyTuple_New(3);
     2673        if (!result)
     2674                return NULL;
     2675
     2676        /* affects field information */
     2677        PyTuple_SET_ITEM(result, 0, PyLong_FromLong(num));
     2678        PyTuple_SET_ITEM(result, 1,
     2679                PyBytes_FromString(PQfname(self->result, num)));
     2680        PyTuple_SET_ITEM(result, 2,
     2681                PyLong_FromLong(PQftype(self->result, num)));
     2682
     2683        return result;
     2684}
     2685
     2686/* lists fields info */
     2687static char sourceListInfo__doc__[] =
     2688"listinfo() -- return information for all fields "
     2689"(position, name, type oid).";
     2690
     2691static PyObject *
     2692sourceListInfo(sourceObject *self, PyObject *args)
     2693{
     2694        int                     i;
     2695        PyObject   *result,
     2696                           *info;
     2697
     2698        /* checks validity */
     2699        if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
     2700                return NULL;
     2701
     2702        /* gets args */
     2703        if (!PyArg_ParseTuple(args, ""))
     2704        {
     2705                PyErr_SetString(PyExc_TypeError,
     2706                        "method listinfo() takes no parameter.");
     2707                return NULL;
     2708        }
     2709
     2710        /* builds result */
     2711        if (!(result = PyTuple_New(self->num_fields)))
     2712                return NULL;
     2713
     2714        for (i = 0; i < self->num_fields; i++)
     2715        {
     2716                info = pgsource_buildinfo(self, i);
     2717                if (!info)
     2718                {
     2719                        Py_DECREF(result);
     2720                        return NULL;
     2721                }
     2722                PyTuple_SET_ITEM(result, i, info);
     2723        }
     2724
     2725        /* returns result */
     2726        return result;
     2727};
     2728
     2729/* list fields information for last result */
     2730static char sourceFieldInfo__doc__[] =
     2731"fieldinfo(string|integer) -- return specified field information "
     2732"(position, name, type oid).";
     2733
     2734static PyObject *
     2735sourceFieldInfo(sourceObject *self, PyObject *args)
     2736{
     2737        static const char short_usage[] =
     2738        "fieldinfo(desc), with desc (string|integer).";
     2739        int                     num;
     2740        PyObject   *param;
     2741
     2742        /* gets args */
     2743        if (!PyArg_ParseTuple(args, "O", &param))
     2744        {
     2745                PyErr_SetString(PyExc_TypeError, short_usage);
     2746                return NULL;
     2747        }
     2748
     2749        /* checks args and validity */
     2750        if ((num = sourceFieldindex(self, param, short_usage)) == -1)
     2751                return NULL;
     2752
     2753        /* returns result */
     2754        return pgsource_buildinfo(self, num);
     2755};
     2756
     2757/* retrieve field value */
     2758static char sourceField__doc__[] =
     2759"field(string|integer) -- return specified field value.";
     2760
     2761static PyObject *
     2762sourceField(sourceObject *self, PyObject *args)
     2763{
     2764        static const char short_usage[] =
     2765        "field(desc), with desc (string|integer).";
     2766        int                     num;
     2767        PyObject   *param;
     2768
     2769        /* gets args */
     2770        if (!PyArg_ParseTuple(args, "O", &param))
     2771        {
     2772                PyErr_SetString(PyExc_TypeError, short_usage);
     2773                return NULL;
     2774        }
     2775
     2776        /* checks args and validity */
     2777        if ((num = sourceFieldindex(self, param, short_usage)) == -1)
     2778                return NULL;
     2779
     2780        return PyBytes_FromString(PQgetvalue(self->result,
     2781                                                                        self->current_row, num));
     2782}
     2783
     2784/* query object methods */
     2785static PyMethodDef sourceMethods[] = {
     2786        {"close", (PyCFunction) sourceClose, METH_VARARGS,
     2787                        sourceClose__doc__},
     2788        {"execute", (PyCFunction) sourceExecute, METH_VARARGS,
     2789                        sourceExecute__doc__},
     2790        {"oidstatus", (PyCFunction) sourceStatusOID, METH_VARARGS,
     2791                        sourceStatusOID__doc__},
     2792        {"fetch", (PyCFunction) sourceFetch, METH_VARARGS,
     2793                        sourceFetch__doc__},
     2794        {"movefirst", (PyCFunction) sourceMoveFirst, METH_VARARGS,
     2795                        sourceMoveFirst__doc__},
     2796        {"movelast", (PyCFunction) sourceMoveLast, METH_VARARGS,
     2797                        sourceMoveLast__doc__},
     2798        {"movenext", (PyCFunction) sourceMoveNext, METH_VARARGS,
     2799                        sourceMoveNext__doc__},
     2800        {"moveprev", (PyCFunction) sourceMovePrev, METH_VARARGS,
     2801                        sourceMovePrev__doc__},
     2802        {"field", (PyCFunction) sourceField, METH_VARARGS,
     2803                        sourceField__doc__},
     2804        {"fieldinfo", (PyCFunction) sourceFieldInfo, METH_VARARGS,
     2805                        sourceFieldInfo__doc__},
     2806        {"listinfo", (PyCFunction) sourceListInfo, METH_VARARGS,
     2807                        sourceListInfo__doc__},
     2808        {NULL, NULL}
     2809};
     2810
     2811/* gets query object attributes */
     2812static PyObject *
     2813pgsource_getattr(sourceObject *self, char *name)
     2814{
     2815        /* pg connection object */
     2816        if (!strcmp(name, "pgcnx"))
     2817        {
     2818                if (check_source_obj(self, 0))
     2819                {
     2820                        Py_INCREF(self->pgcnx);
     2821                        return (PyObject *) (self->pgcnx);
     2822                }
     2823                Py_INCREF(Py_None);
     2824                return Py_None;
     2825        }
     2826
     2827        /* arraysize */
     2828        if (!strcmp(name, "arraysize"))
     2829                return PyLong_FromLong(self->arraysize);
     2830
     2831        /* resulttype */
     2832        if (!strcmp(name, "resulttype"))
     2833                return PyLong_FromLong(self->result_type);
     2834
     2835        /* ntuples */
     2836        if (!strcmp(name, "ntuples"))
     2837                return PyLong_FromLong(self->max_row);
     2838
     2839        /* nfields */
     2840        if (!strcmp(name, "nfields"))
     2841                return PyLong_FromLong(self->num_fields);
     2842
     2843        /* attributes list */
     2844        if (!strcmp(name, "__members__"))
     2845        {
     2846                PyObject *list = PyList_New(5);
     2847
     2848                PyList_SET_ITEM(list, 0, PyBytes_FromString("pgcnx"));
     2849                PyList_SET_ITEM(list, 1, PyBytes_FromString("arraysize"));
     2850                PyList_SET_ITEM(list, 2, PyBytes_FromString("resulttype"));
     2851                PyList_SET_ITEM(list, 3, PyBytes_FromString("ntuples"));
     2852                PyList_SET_ITEM(list, 4, PyBytes_FromString("nfields"));
     2853
     2854                return list;
     2855        }
     2856
     2857        /* module name */
     2858        if (!strcmp(name, "__module__"))
     2859                return PyBytes_FromString(MODULE_NAME);
     2860
     2861        /* class name */
     2862        if (!strcmp(name, "__class__"))
     2863                return PyBytes_FromString("pgsource");
     2864
     2865        /* seeks name in methods (fallback) */
     2866        return Py_FindMethod(sourceMethods, (PyObject *) self, name);
     2867}
     2868
     2869/* sets query object attributes */
     2870static int
     2871pgsource_setattr(sourceObject *self, char *name, PyObject *v)
     2872{
     2873        /* arraysize */
     2874        if (!strcmp(name, "arraysize"))
     2875        {
     2876                if (!PyLong_Check(v))
     2877                {
     2878                        PyErr_SetString(PyExc_TypeError, "arraysize must be integer.");
     2879                        return -1;
     2880                }
     2881
     2882                self->arraysize = PyLong_AsLong(v);
     2883                return 0;
     2884        }
     2885
     2886        /* unknown attribute */
     2887        PyErr_SetString(PyExc_TypeError, "not a writable attribute.");
     2888        return -1;
     2889}
     2890
     2891static PyObject *
     2892pgsource_repr(sourceObject *self)
     2893{
     2894        return PyBytes_FromString("<pg source object>");
     2895}
     2896
     2897/* returns source object as string in human readable format */
     2898
     2899static PyObject *
     2900pgsource_str(sourceObject *self)
     2901{
     2902        switch (self->result_type)
     2903        {
     2904                case RESULT_DQL:
     2905                        return format_result(self->result);
     2906                case RESULT_DDL:
     2907                case RESULT_DML:
     2908                        return PyBytes_FromString(PQcmdStatus(self->result));
     2909                case RESULT_EMPTY:
     2910                default:
     2911                        return PyBytes_FromString("(empty PostgreSQL source object)");
     2912        }
     2913}
     2914
     2915/* query type definition */
     2916static PyTypeObject sourceType = {
     2917        PyObject_HEAD_INIT(NULL)
     2918        0,                                                              /* ob_size */
     2919        "PGsourceObject",                               /* tp_name */
     2920        sizeof(sourceObject),                   /* tp_basicsize */
     2921        0,                                                              /* tp_itemsize */
     2922        /* methods */
     2923        (destructor) pgsource_dealloc,  /* tp_dealloc */
     2924        0,                                                              /* tp_print */
     2925        (getattrfunc) pgsource_getattr, /* tp_getattr */
     2926        (setattrfunc) pgsource_setattr, /* tp_setattr */
     2927        0,                                                              /* tp_compare */
     2928        (reprfunc) pgsource_repr,               /* tp_repr */
     2929        0,                                                              /* tp_as_number */
     2930        0,                                                              /* tp_as_sequence */
     2931        0,                                                              /* tp_as_mapping */
     2932        0,                                                              /* tp_hash */
     2933        0,                                                              /* tp_call */
     2934        (reprfunc) pgsource_str,                /* tp_str */
     2935};
     2936
     2937/* connects to a database */
     2938static char connect__doc__[] =
     2939"connect(dbname, host, port, opt, tty) -- connect to a PostgreSQL database "
     2940"using specified parameters (optionals, keywords aware).";
     2941
     2942static PyObject *
     2943pgConnect(PyObject *self, PyObject *args, PyObject *dict)
     2944{
     2945        static const char *kwlist[] = {"dbname", "host", "port", "opt",
     2946        "tty", "user", "passwd", NULL};
     2947
     2948        char       *pghost,
     2949                           *pgopt,
     2950                           *pgtty,
     2951                           *pgdbname,
     2952                           *pguser,
     2953                           *pgpasswd;
     2954        int                     pgport;
     2955        char            port_buffer[20];
     2956        connObject   *npgobj;
     2957
     2958        pghost = pgopt = pgtty = pgdbname = pguser = pgpasswd = NULL;
     2959        pgport = -1;
     2960
     2961        /*
     2962         * parses standard arguments With the right compiler warnings, this
     2963         * will issue a diagnostic. There is really no way around it.  If I
     2964         * don't declare kwlist as const char *kwlist[] then it complains when
     2965         * I try to assign all those constant strings to it.
     2966         */
     2967        if (!PyArg_ParseTupleAndKeywords(args, dict, "|zzizzzz", (char **) kwlist,
     2968                &pgdbname, &pghost, &pgport, &pgopt, &pgtty, &pguser, &pgpasswd))
     2969                return NULL;
     2970
     2971#ifdef DEFAULT_VARS
     2972        /* handles defaults variables (for uninitialised vars) */
     2973        if ((!pghost) && (pg_default_host != Py_None))
     2974                pghost = PyBytes_AsString(pg_default_host);
     2975
     2976        if ((pgport == -1) && (pg_default_port != Py_None))
     2977                pgport = PyLong_AsLong(pg_default_port);
     2978
     2979        if ((!pgopt) && (pg_default_opt != Py_None))
     2980                pgopt = PyBytes_AsString(pg_default_opt);
     2981
     2982        if ((!pgtty) && (pg_default_tty != Py_None))
     2983                pgtty = PyBytes_AsString(pg_default_tty);
     2984
     2985        if ((!pgdbname) && (pg_default_base != Py_None))
     2986                pgdbname = PyBytes_AsString(pg_default_base);
     2987
     2988        if ((!pguser) && (pg_default_user != Py_None))
     2989                pguser = PyBytes_AsString(pg_default_user);
     2990
     2991        if ((!pgpasswd) && (pg_default_passwd != Py_None))
     2992                pgpasswd = PyBytes_AsString(pg_default_passwd);
     2993#endif /* DEFAULT_VARS */
     2994
     2995        if (!(npgobj = PyObject_NEW(connObject, &connType)))
     2996        {
     2997                set_dberror(InternalError, "Can't create new connection object", NULL);
     2998                return NULL;
     2999        }
     3000
     3001        npgobj->valid = 1;
     3002        npgobj->cnx = NULL;
     3003        npgobj->notice_receiver = NULL;
     3004
     3005        if (pgport != -1)
     3006        {
     3007                memset(port_buffer, 0, sizeof(port_buffer));
     3008                sprintf(port_buffer, "%d", pgport);
     3009        }
     3010
     3011#ifdef PQsetdbLoginIsThreadSafe
     3012        Py_BEGIN_ALLOW_THREADS
     3013#endif
     3014        npgobj->cnx = PQsetdbLogin(pghost, pgport == -1 ? NULL : port_buffer,
     3015                pgopt, pgtty, pgdbname, pguser, pgpasswd);
     3016#ifdef PQsetdbLoginIsThreadSafe
     3017        Py_END_ALLOW_THREADS
     3018#endif
     3019
     3020        if (PQstatus(npgobj->cnx) == CONNECTION_BAD)
     3021        {
     3022                set_dberror(InternalError, PQerrorMessage(npgobj->cnx), NULL);
     3023                Py_XDECREF(npgobj);
     3024                return NULL;
     3025        }
     3026
     3027        return (PyObject *) npgobj;
     3028}
     3029
     3030static void
     3031pgquery_dealloc(queryObject *self)
     3032{
     3033        if (self->result)
     3034                PQclear(self->result);
     3035
     3036        PyObject_Del(self);
     3037}
     3038
     3039/* get number of rows */
     3040static char pgquery_ntuples__doc__[] =
     3041"ntuples() -- returns number of tuples returned by query.";
     3042
     3043static PyObject *
     3044pgquery_ntuples(queryObject *self, PyObject *args)
     3045{
     3046        /* checks args */
     3047        if (!PyArg_ParseTuple(args, ""))
     3048        {
     3049                PyErr_SetString(PyExc_TypeError,
     3050                        "method ntuples() takes no parameters.");
     3051                return NULL;
     3052        }
     3053
     3054        return PyLong_FromLong((long) PQntuples(self->result));
     3055}
     3056
     3057/* list fields names from query result */
     3058static char pgquery_listfields__doc__[] =
     3059"listfields() -- Lists field names from result.";
     3060
     3061static PyObject *
     3062pgquery_listfields(queryObject *self, PyObject *args)
     3063{
     3064        int                     i,
     3065                                n;
     3066        char       *name;
     3067        PyObject   *fieldstuple,
     3068                           *str;
     3069
     3070        /* checks args */
     3071        if (!PyArg_ParseTuple(args, ""))
     3072        {
     3073                PyErr_SetString(PyExc_TypeError,
     3074                        "method listfields() takes no parameters.");
     3075                return NULL;
     3076        }
     3077
     3078        /* builds tuple */
     3079        n = PQnfields(self->result);
     3080        fieldstuple = PyTuple_New(n);
     3081
     3082        for (i = 0; i < n; i++)
     3083        {
     3084                name = PQfname(self->result, i);
     3085                str = PyBytes_FromString(name);
     3086                PyTuple_SET_ITEM(fieldstuple, i, str);
     3087        }
     3088
     3089        return fieldstuple;
     3090}
     3091
     3092/* get field name from last result */
     3093static char pgquery_fieldname__doc__[] =
     3094"fieldname() -- returns name of field from result from its position.";
     3095
     3096static PyObject *
     3097pgquery_fieldname(queryObject *self, PyObject *args)
     3098{
     3099        int             i;
     3100        char   *name;
     3101
     3102        /* gets args */
     3103        if (!PyArg_ParseTuple(args, "i", &i))
     3104        {
     3105                PyErr_SetString(PyExc_TypeError,
     3106                        "fieldname(number), with number(integer).");
     3107                return NULL;
     3108        }
     3109
     3110        /* checks number validity */
     3111        if (i >= PQnfields(self->result))
     3112        {
     3113                PyErr_SetString(PyExc_ValueError, "invalid field number.");
     3114                return NULL;
     3115        }
     3116
     3117        /* gets fields name and builds object */
     3118        name = PQfname(self->result, i);
     3119        return PyBytes_FromString(name);
     3120}
     3121
     3122/* gets fields number from name in last result */
     3123static char pgquery_fieldnum__doc__[] =
     3124"fieldnum() -- returns position in query for field from its name.";
     3125
     3126static PyObject *
     3127pgquery_fieldnum(queryObject *self, PyObject *args)
     3128{
     3129        int             num;
     3130        char   *name;
     3131
     3132        /* gets args */
     3133        if (!PyArg_ParseTuple(args, "s", &name))
     3134        {
     3135                PyErr_SetString(PyExc_TypeError, "fieldnum(name), with name (string).");
     3136                return NULL;
     3137        }
     3138
     3139        /* gets field number */
     3140        if ((num = PQfnumber(self->result, name)) == -1)
     3141        {
     3142                PyErr_SetString(PyExc_ValueError, "Unknown field.");
     3143                return NULL;
     3144        }
     3145
     3146        return PyLong_FromLong(num);
     3147}
     3148
     3149/* retrieves last result */
     3150static char pgquery_getresult__doc__[] =
     3151"getresult() -- Gets the result of a query.  The result is returned "
     3152"as a list of rows, each one a tuple of fields in the order returned "
     3153"by the server.";
     3154
     3155static PyObject *
     3156pgquery_getresult(queryObject *self, PyObject *args)
     3157{
     3158        PyObject   *rowtuple,
     3159                           *reslist,
     3160                           *val;
     3161        int                     i,
     3162                                j,
     3163                                m,
     3164                                n,
     3165                           *typ;
     3166
     3167        /* checks args (args == NULL for an internal call) */
     3168        if (args && !PyArg_ParseTuple(args, ""))
     3169        {
     3170                PyErr_SetString(PyExc_TypeError,
     3171                        "method getresult() takes no parameters.");
     3172                return NULL;
     3173        }
     3174
     3175        /* stores result in tuple */
     3176        m = PQntuples(self->result);
     3177        n = PQnfields(self->result);
     3178        reslist = PyList_New(m);
     3179
     3180        typ = get_type_array(self->result, n);
     3181
     3182        for (i = 0; i < m; i++)
     3183        {
     3184                if (!(rowtuple = PyTuple_New(n)))
     3185                {
     3186                        Py_DECREF(reslist);
     3187                        reslist = NULL;
     3188                        goto exit;
     3189                }
     3190
     3191                for (j = 0; j < n; j++)
     3192                {
     3193                        int                     k;
     3194                        char       *s = PQgetvalue(self->result, i, j);
     3195                        char            cashbuf[64];
     3196                        PyObject   *tmp_obj;
     3197
     3198                        if (PQgetisnull(self->result, i, j))
     3199                        {
     3200                                Py_INCREF(Py_None);
     3201                                val = Py_None;
     3202                        }
     3203                        else
     3204                                switch (typ[j])
     3205                                {
     3206                                        case 1:  /* int2/4 */
     3207                                                val = PyLong_FromString(s, NULL, 10);
     3208                                                break;
     3209
     3210                                        case 2:  /* int8 */
     3211                                                val = PyLong_FromString(s, NULL, 10);
     3212                                                break;
     3213
     3214                                        case 3:  /* float/double */
     3215                                                tmp_obj = PyBytes_FromString(s);
     3216                                                val = PyFloat_FromString(tmp_obj, NULL);
     3217                                                Py_DECREF(tmp_obj);
     3218                                                break;
     3219
     3220                                        case 5:  /* money */
     3221                                                for (k = 0;
     3222                                                         *s && k < sizeof(cashbuf) / sizeof(cashbuf[0]) - 1;
     3223                                                         s++)
     3224                                                {
     3225                                                        if (isdigit(*s))
     3226                                                                cashbuf[k++] = *s;
     3227                                                        else if (*s == *decimal_point)
     3228                                                                cashbuf[k++] = '.';
     3229                                                        else if (*s == '(' || *s == '-')
     3230                                                                cashbuf[k++] = '-';
     3231                                                }
     3232                                                cashbuf[k] = 0;
     3233                                                s = cashbuf;
     3234
     3235                                        /* FALLTHROUGH */ /* no break */
     3236                                        case 4:  /* numeric */
     3237                                                if (decimal)
     3238                                                {
     3239                                                        tmp_obj = Py_BuildValue("(s)", s);
     3240                                                        val = PyEval_CallObject(decimal, tmp_obj);
     3241                                                }
     3242                                                else
     3243                                                {
     3244                                                        tmp_obj = PyBytes_FromString(s);
     3245                                                        val = PyFloat_FromString(tmp_obj, NULL);
     3246                                                }
     3247                                                Py_DECREF(tmp_obj);
     3248                                                break;
     3249
     3250                                        default:
     3251                                                val = PyBytes_FromString(s);
     3252                                                break;
     3253                                }
     3254
     3255                        if (!val)
     3256                        {
     3257                                Py_DECREF(reslist);
     3258                                Py_DECREF(rowtuple);
     3259                                reslist = NULL;
     3260                                goto exit;
     3261                        }
     3262
     3263                        PyTuple_SET_ITEM(rowtuple, j, val);
     3264                }
     3265
     3266                PyList_SET_ITEM(reslist, i, rowtuple);
     3267        }
     3268
     3269exit:
     3270        free(typ);
     3271
     3272        /* returns list */
     3273        return reslist;
     3274}
     3275
     3276/* retrieves last result as a list of dictionaries*/
     3277static char pgquery_dictresult__doc__[] =
     3278"dictresult() -- Gets the result of a query.  The result is returned "
     3279"as a list of rows, each one a dictionary with the field names used "
     3280"as the labels.";
     3281
     3282static PyObject *
     3283pgquery_dictresult(queryObject *self, PyObject *args)
     3284{
     3285        PyObject   *dict,
     3286                           *reslist,
     3287                           *val;
     3288        int                     i,
     3289                                j,
     3290                                m,
     3291                                n,
     3292                           *typ;
     3293
     3294        /* checks args (args == NULL for an internal call) */
     3295        if (args && !PyArg_ParseTuple(args, ""))
     3296        {
     3297                PyErr_SetString(PyExc_TypeError,
     3298                        "method dictresult() takes no parameters.");
     3299                return NULL;
     3300        }
     3301
     3302        /* stores result in list */
     3303        m = PQntuples(self->result);
     3304        n = PQnfields(self->result);
     3305        reslist = PyList_New(m);
     3306
     3307        typ = get_type_array(self->result, n);
     3308
     3309        for (i = 0; i < m; i++)
     3310        {
     3311                if (!(dict = PyDict_New()))
     3312                {
     3313                        Py_DECREF(reslist);
     3314                        reslist = NULL;
     3315                        goto exit;
     3316                }
     3317
     3318                for (j = 0; j < n; j++)
     3319                {
     3320                        int                     k;
     3321                        char       *s = PQgetvalue(self->result, i, j);
     3322                        char            cashbuf[64];
     3323                        PyObject   *tmp_obj;
     3324
     3325                        if (PQgetisnull(self->result, i, j))
     3326                        {
     3327                                Py_INCREF(Py_None);
     3328                                val = Py_None;
     3329                        }
     3330                        else
     3331                                switch (typ[j])
     3332                                {
     3333                                        case 1:  /* int2/4 */
     3334                                                val = PyLong_FromString(s, NULL, 10);
     3335                                                break;
     3336
     3337                                        case 2:  /* int8 */
     3338                                                val = PyLong_FromString(s, NULL, 10);
     3339                                                break;
     3340
     3341                                        case 3:  /* float/double */
     3342                                                tmp_obj = PyBytes_FromString(s);
     3343                                                val = PyFloat_FromString(tmp_obj, NULL);
     3344                                                Py_DECREF(tmp_obj);
     3345                                                break;
     3346
     3347                                        case 5:  /* money */
     3348                                                for (k = 0;
     3349                                                         *s && k < sizeof(cashbuf) / sizeof(cashbuf[0]) - 1;
     3350                                                         s++)
     3351                                                {
     3352                                                        if (isdigit(*s))
     3353                                                                cashbuf[k++] = *s;
     3354                                                        else if (*s == *decimal_point)
     3355                                                                cashbuf[k++] = '.';
     3356                                                        else if (*s == '(' || *s == '-')
     3357                                                                cashbuf[k++] = '-';
     3358                                                }
     3359                                                cashbuf[k] = 0;
     3360                                                s = cashbuf;
     3361
     3362                                        /* FALLTHROUGH */ /* no break */
     3363                                        case 4:  /* numeric */
     3364                                                if (decimal)
     3365                                                {
     3366                                                        tmp_obj = Py_BuildValue("(s)", s);
     3367                                                        val = PyEval_CallObject(decimal, tmp_obj);
     3368                                                }
     3369                                                else
     3370                                                {
     3371                                                        tmp_obj = PyBytes_FromString(s);
     3372                                                        val = PyFloat_FromString(tmp_obj, NULL);
     3373                                                }
     3374                                                Py_DECREF(tmp_obj);
     3375                                                break;
     3376
     3377                                        default:
     3378                                                val = PyBytes_FromString(s);
     3379                                                break;
     3380                                }
     3381
     3382                        if (!val)
     3383                        {
     3384                                Py_DECREF(dict);
     3385                                Py_DECREF(reslist);
     3386                                reslist = NULL;
     3387                                goto exit;
     3388                        }
     3389
     3390                        PyDict_SetItemString(dict, PQfname(self->result, j), val);
     3391                        Py_DECREF(val);
     3392                }
     3393
     3394                PyList_SET_ITEM(reslist, i, dict);
     3395        }
     3396
     3397exit:
     3398        free(typ);
     3399
     3400        /* returns list */
     3401        return reslist;
     3402}
     3403
     3404/* retrieves last result as named tuples */
     3405static char pgquery_namedresult__doc__[] =
     3406"namedresult() -- Gets the result of a query.  The result is returned "
     3407"as a list of rows, each one a tuple of fields in the order returned "
     3408"by the server.";
     3409
     3410static PyObject *
     3411pgquery_namedresult(queryObject *self, PyObject *args)
     3412{
     3413        PyObject   *arglist,
     3414                           *ret;
     3415
     3416        /* checks args (args == NULL for an internal call) */
     3417        if (args && !PyArg_ParseTuple(args, ""))
     3418        {
     3419                PyErr_SetString(PyExc_TypeError,
     3420                        "method namedresult() takes no parameters.");
     3421                return NULL;
     3422        }
     3423
     3424        if (!namedresult)
     3425        {
     3426                PyErr_SetString(PyExc_TypeError,
     3427                        "named tuples are not supported.");
     3428                return NULL;
     3429        }
     3430
     3431        arglist = Py_BuildValue("(O)", self);
     3432        ret = PyObject_CallObject(namedresult, arglist);
     3433        Py_DECREF(arglist);
     3434
     3435        if (ret == NULL)
     3436                return NULL;
     3437
     3438        return ret;
     3439}
     3440
    34683441
    34693442/* get attribute */
    34703443static PyObject *
    3471 pgnotice_getattr(pgnoticeobject *self, char *name)
     3444pgnotice_getattr(noticeObject *self, char *name)
    34723445{
    34733446        PGresult const *res = self->res;
     
    35373510
    35383511        PyErr_Format(PyExc_AttributeError,
    3539                 "'pgnoticeobject' has no attribute %s", name);
     3512                "'noticeObject' has no attribute %s", name);
    35403513        return NULL;
    35413514}
    35423515
    35433516static PyObject *
    3544 pgnotice_str(pgnoticeobject *self)
     3517pgnotice_str(noticeObject *self)
    35453518{
    35463519        return pgnotice_getattr(self, "message");
     
    35503523static PyTypeObject noticeType = {
    35513524        PyObject_HEAD_INIT(NULL)
    3552         0,                                                      /* ob_size */
    3553         "pgnoticeobject",                       /* tp_name */
    3554         sizeof(pgnoticeobject),         /* tp_basicsize */
    3555         0,                                                      /* tp_itemsize */
     3525        0,                                                              /* ob_size */
     3526        "PGnoticeObject",                               /* tp_name */
     3527        sizeof(noticeObject),                   /* tp_basicsize */
     3528        0,                                                              /* tp_itemsize */
    35563529        /* methods */
    35573530        0,                                                              /* tp_dealloc */
     
    35713544
    35723545/* query object methods */
    3573 static struct PyMethodDef pgquery_methods[] = {
     3546static struct PyMethodDef queryMethods[] = {
    35743547        {"getresult", (PyCFunction) pgquery_getresult, METH_VARARGS,
    3575                         queryGetresult__doc__},
     3548                        pgquery_getresult__doc__},
    35763549        {"dictresult", (PyCFunction) pgquery_dictresult, METH_VARARGS,
    3577                         queryDictresult__doc__},
     3550                        pgquery_dictresult__doc__},
    35783551        {"namedresult", (PyCFunction) pgquery_namedresult, METH_VARARGS,
    3579                         queryNamedresult__doc__},
     3552                        pgquery_namedresult__doc__},
    35803553        {"fieldname", (PyCFunction) pgquery_fieldname, METH_VARARGS,
    3581                          queryFieldname__doc__},
     3554                         pgquery_fieldname__doc__},
    35823555        {"fieldnum", (PyCFunction) pgquery_fieldnum, METH_VARARGS,
    3583                         queryFieldnum__doc__},
     3556                        pgquery_fieldnum__doc__},
    35843557        {"listfields", (PyCFunction) pgquery_listfields, METH_VARARGS,
    3585                         queryListfields__doc__},
     3558                        pgquery_listfields__doc__},
    35863559        {"ntuples", (PyCFunction) pgquery_ntuples, METH_VARARGS,
    3587                         queryNtuples__doc__},
     3560                        pgquery_ntuples__doc__},
    35883561        {NULL, NULL}
    35893562};
     
    35913564/* gets query object attributes */
    35923565static PyObject *
    3593 pgquery_getattr(pgqueryobject *self, char *name)
     3566pgquery_getattr(queryObject *self, char *name)
    35943567{
    35953568        /* list postgreSQL connection fields */
    3596         return Py_FindMethod(pgquery_methods, (PyObject *) self, name);
     3569        return Py_FindMethod(queryMethods, (PyObject *) self, name);
    35973570}
    35983571
     
    36013574        PyObject_HEAD_INIT(NULL)
    36023575        0,                                                              /* ob_size */
    3603         "pgqueryobject",                                /* tp_name */
    3604         sizeof(pgqueryobject),                  /* tp_basicsize */
     3576        "PGqueryObject",                                /* tp_name */
     3577        sizeof(queryObject),                    /* tp_basicsize */
    36053578        0,                                                              /* tp_itemsize */
    36063579        /* methods */
     
    36253598
    36263599/* escape string */
    3627 static char pgEscape_string__doc__[] =
    3628 "escape_string(str) -- escape a string for use within SQL.";
    3629 
    3630 static PyObject *
    3631 escape_string(PyObject *self, PyObject *args)
     3600static char pgEscapeString__doc__[] =
     3601"pgEscapeString(str) -- escape a string for use within SQL.";
     3602
     3603static PyObject *
     3604pgEscapeString(PyObject *self, PyObject *args)
    36323605{
    36333606        char *from; /* our string argument */
     
    36563629
    36573630/* escape bytea */
    3658 static char pgEscape_bytea__doc__[] =
    3659 "escape_bytea(data) -- escape binary data for use within SQL as type bytea.";
    3660 
    3661 static PyObject *
    3662 escape_bytea(PyObject *self, PyObject *args)
     3631static char pgEscapeBytea__doc__[] =
     3632"pgEscapeBytea(data) -- escape binary data for use within SQL as type bytea.";
     3633
     3634static PyObject *
     3635pgEscapeBytea(PyObject *self, PyObject *args)
    36633636{
    36643637        unsigned char *from; /* our string argument */
     
    36803653
    36813654/* unescape bytea */
    3682 static char pgUnescape_bytea__doc__[] =
    3683 "unescape_bytea(str) -- unescape bytea data that has been retrieved as text.";
     3655static char pgUnescapeBytea__doc__[] =
     3656"pgUnescapeBytea(str) -- unescape bytea data that has been retrieved as text.";
    36843657
    36853658static PyObject
    3686 *unescape_bytea(PyObject *self, PyObject *args)
     3659*pgUnescapeBytea(PyObject *self, PyObject *args)
    36873660{
    36883661        unsigned char *from; /* our string argument */
     
    37033676
    37043677/* set decimal point */
    3705 static char pgSet_decimal_point__doc__[] =
    3706 "set_decimal_point() -- set decimal point to be used for money values.";
    3707 
    3708 static PyObject *
    3709 set_decimal_point(PyObject *self, PyObject * args)
     3678static char pgSetDecimalPoint__doc__[] =
     3679"pgSetDecimalPoint() -- set decimal point to be used for money values.";
     3680
     3681static PyObject *
     3682pgSetDecimalPoint(PyObject *self, PyObject * args)
    37103683{
    37113684        PyObject *ret = NULL;
     
    37213694
    37223695/* get decimal point */
    3723 static char pgGet_decimal_point__doc__[] =
    3724 "get_decimal_point() -- get decimal point to be used for money values.";
    3725 
    3726 static PyObject *
    3727 get_decimal_point(PyObject *self, PyObject * args)
     3696static char pgGetDecimalPoint__doc__[] =
     3697"pgGetDecimalPoint() -- get decimal point to be used for money values.";
     3698
     3699static PyObject *
     3700pgGetDecimalPoint(PyObject *self, PyObject * args)
    37283701{
    37293702        PyObject *ret = NULL;
     
    37363709        {
    37373710                PyErr_SetString(PyExc_TypeError,
    3738                         " get_decimal_point() takes no parameter");
     3711                        " pgGetDecimalPoint() takes no parameter");
    37393712        }
    37403713
     
    37443717
    37453718/* set decimal */
    3746 static char pgSet_decimal__doc__[] =
     3719static char pgSetDecimal__doc__[] =
    37473720"set_decimal(cls) -- set a decimal type to be used for numeric values.";
    37483721
    37493722static PyObject *
    3750 set_decimal(PyObject *self, PyObject *args)
     3723pgSetDecimal(PyObject *self, PyObject *args)
    37513724{
    37523725        PyObject *ret = NULL;
     
    37723745
    37733746/* set named result */
    3774 static char pgSet_namedresult__doc__[] =
     3747static char pgSetNamedresult__doc__[] =
    37753748"set_namedresult(cls) -- set a function to be used for getting named results.";
    37763749
    37773750static PyObject *
    3778 set_namedresult(PyObject *self, PyObject *args)
     3751pgSetNamedresult(PyObject *self, PyObject *args)
    37793752{
    37803753        PyObject *ret = NULL;
     
    37973770
    37983771/* gets default host */
    3799 static char pgGetdefhost__doc__[] =
     3772static char pgGetDefHost__doc__[] =
    38003773"get_defhost() -- return default database host.";
    38013774
    38023775static PyObject *
    3803 pggetdefhost(PyObject *self, PyObject *args)
     3776pgGetDefHost(PyObject *self, PyObject *args)
    38043777{
    38053778        /* checks args */
     
    38163789
    38173790/* sets default host */
    3818 static char pgSetdefhost__doc__[] =
     3791static char pgSetDefHost__doc__[] =
    38193792"set_defhost(string) -- set default database host. Return previous value.";
    38203793
    38213794static PyObject *
    3822 pgsetdefhost(PyObject *self, PyObject *args)
     3795pgSetDefHost(PyObject *self, PyObject *args)
    38233796{
    38243797        char       *temp = NULL;
     
    38483821
    38493822/* gets default base */
    3850 static char pgGetdefbase__doc__[] =
     3823static char pgGetDefBase__doc__[] =
    38513824"get_defbase() -- return default database name.";
    38523825
    38533826static PyObject *
    3854 pggetdefbase(PyObject *self, PyObject *args)
     3827pgGetDefBase(PyObject *self, PyObject *args)
    38553828{
    38563829        /* checks args */
     
    38673840
    38683841/* sets default base */
    3869 static char pgSetdefbase__doc__[] =
     3842static char pgSetDefBase__doc__[] =
    38703843"set_defbase(string) -- set default database name. Return previous value";
    38713844
    38723845static PyObject *
    3873 pgsetdefbase(PyObject *self, PyObject *args)
     3846pgSetDefBase(PyObject *self, PyObject *args)
    38743847{
    38753848        char       *temp = NULL;
     
    38993872
    39003873/* gets default options */
    3901 static char pgGetdefopt__doc__[] =
     3874static char pgGetDefOpt__doc__[] =
    39023875"get_defopt() -- return default database options.";
    39033876
    39043877static PyObject *
    3905 pggetdefopt(PyObject *self, PyObject *args)
     3878pgGetDefOpt(PyObject *self, PyObject *args)
    39063879{
    39073880        /* checks args */
     
    39183891
    39193892/* sets default opt */
    3920 static char pgSetdefopt__doc__[] =
     3893static char pgSetDefOpt__doc__[] =
    39213894"set_defopt(string) -- set default database options. Return previous value.";
    39223895
    39233896static PyObject *
    3924 pgsetdefopt(PyObject *self, PyObject *args)
     3897pgSetDefOpt(PyObject *self, PyObject *args)
    39253898{
    39263899        char       *temp = NULL;
     
    39503923
    39513924/* gets default tty */
    3952 static char pgGetdeftty__doc__[] =
     3925static char pgGetDefTTY__doc__[] =
    39533926"get_deftty() -- return default database debug terminal.";
    39543927
    39553928static PyObject *
    3956 pggetdeftty(PyObject *self, PyObject *args)
     3929pgGetDefTTY(PyObject *self, PyObject *args)
    39573930{
    39583931        /* checks args */
     
    39693942
    39703943/* sets default tty */
    3971 static char pgSetdeftty__doc__[] =
     3944static char pgSetDefTTY__doc__[] =
    39723945"set_deftty(string) -- set default database debug terminal. "
    39733946"Return previous value.";
    39743947
    39753948static PyObject *
    3976 pgsetdeftty(PyObject *self, PyObject *args)
     3949pgSetDefTTY(PyObject *self, PyObject *args)
    39773950{
    39783951        char       *temp = NULL;
     
    40023975
    40033976/* gets default username */
    4004 static char pgGetdefuser__doc__[] =
     3977static char pgGetDefUser__doc__[] =
    40053978"get_defuser() -- return default database username.";
    40063979
    40073980static PyObject *
    4008 pggetdefuser(PyObject *self, PyObject *args)
     3981pgGetDefUser(PyObject *self, PyObject *args)
    40093982{
    40103983        /* checks args */
     
    40223995
    40233996/* sets default username */
    4024 static char pgSetdefuser__doc__[] =
     3997
     3998static char pgSetDefUser__doc__[] =
    40253999"set_defuser() -- set default database username. Return previous value.";
    40264000
    40274001static PyObject *
    4028 pgsetdefuser(PyObject *self, PyObject *args)
     4002pgSetDefUser(PyObject *self, PyObject *args)
    40294003{
    40304004        char       *temp = NULL;
     
    40544028
    40554029/* sets default password */
    4056 static char pgSetdefpasswd__doc__[] =
     4030static char pgSetDefPassword__doc__[] =
    40574031"set_defpasswd() -- set default database password.";
    40584032
    40594033static PyObject *
    4060 pgsetdefpasswd(PyObject *self, PyObject *args)
     4034pgSetDefPassword(PyObject *self, PyObject *args)
    40614035{
    40624036        char       *temp = NULL;
     
    40834057
    40844058/* gets default port */
    4085 static char pgGetdefport__doc__[] =
     4059static char pgGetDefPort__doc__[] =
    40864060"get_defport() -- return default database port.";
    40874061
    40884062static PyObject *
    4089 pggetdefport(PyObject *self, PyObject *args)
     4063pgGetDefPort(PyObject *self, PyObject *args)
    40904064{
    40914065        /* checks args */
     
    41024076
    41034077/* sets default port */
    4104 static char pgSetdefport__doc__[] =
     4078static char pgSetDefPort__doc__[] =
    41054079"set_defport(integer) -- set default database port. Return previous value.";
    41064080
    41074081static PyObject *
    4108 pgsetdefport(PyObject *self, PyObject *args)
     4082pgSetDefPort(PyObject *self, PyObject *args)
    41094083{
    41104084        long int        port = -2;
     
    41364110/* List of functions defined in the module */
    41374111
    4138 static struct PyMethodDef pg_methods[] = {
    4139         {"connect", (PyCFunction) pgconnect, METH_VARARGS|METH_KEYWORDS,
    4140                         pgConnect__doc__},
    4141         {"escape_string", (PyCFunction) escape_string, METH_VARARGS,
    4142                         pgEscape_string__doc__},
    4143         {"escape_bytea", (PyCFunction) escape_bytea, METH_VARARGS,
    4144                         pgEscape_bytea__doc__},
    4145         {"unescape_bytea", (PyCFunction) unescape_bytea, METH_VARARGS,
    4146                         pgUnescape_bytea__doc__},
    4147         {"set_decimal_point", (PyCFunction) set_decimal_point, METH_VARARGS,
    4148                         pgSet_decimal_point__doc__},
    4149         {"get_decimal_point", (PyCFunction) get_decimal_point, METH_VARARGS,
    4150                         pgGet_decimal_point__doc__},
    4151         {"set_decimal", (PyCFunction) set_decimal, METH_VARARGS,
    4152                         pgSet_decimal__doc__},
    4153         {"set_namedresult", (PyCFunction) set_namedresult, METH_VARARGS,
    4154                         pgSet_namedresult__doc__},
     4112static struct PyMethodDef pgMethods[] = {
     4113        {"connect", (PyCFunction) pgConnect, METH_VARARGS|METH_KEYWORDS,
     4114                        connect__doc__},
     4115        {"escape_string", (PyCFunction) pgEscapeString, METH_VARARGS,
     4116                        pgEscapeString__doc__},
     4117        {"escape_bytea", (PyCFunction) pgEscapeBytea, METH_VARARGS,
     4118                        pgEscapeBytea__doc__},
     4119        {"unescape_bytea", (PyCFunction) pgUnescapeBytea, METH_VARARGS,
     4120                        pgUnescapeBytea__doc__},
     4121        {"set_decimalpoint", (PyCFunction) pgSetDecimalPoint, METH_VARARGS,
     4122                        pgSetDecimalPoint__doc__},
     4123        {"get_decimalpoint", (PyCFunction) pgGetDecimalPoint, METH_VARARGS,
     4124                        pgGetDecimalPoint__doc__},
     4125        {"set_decimal", (PyCFunction) pgSetDecimal, METH_VARARGS,
     4126                        pgSetDecimal__doc__},
     4127        {"set_namedresult", (PyCFunction) pgSetNamedresult, METH_VARARGS,
     4128                        pgSetNamedresult__doc__},
    41554129
    41564130#ifdef DEFAULT_VARS
    4157         {"get_defhost", pggetdefhost, METH_VARARGS, pgGetdefhost__doc__},
    4158         {"set_defhost", pgsetdefhost, METH_VARARGS, pgSetdefhost__doc__},
    4159         {"get_defbase", pggetdefbase, METH_VARARGS, pgGetdefbase__doc__},
    4160         {"set_defbase", pgsetdefbase, METH_VARARGS, pgSetdefbase__doc__},
    4161         {"get_defopt", pggetdefopt, METH_VARARGS, pgGetdefopt__doc__},
    4162         {"set_defopt", pgsetdefopt, METH_VARARGS, pgSetdefopt__doc__},
    4163         {"get_deftty", pggetdeftty, METH_VARARGS, pgGetdeftty__doc__},
    4164         {"set_deftty", pgsetdeftty, METH_VARARGS, pgSetdeftty__doc__},
    4165         {"get_defport", pggetdefport, METH_VARARGS, pgGetdefport__doc__},
    4166         {"set_defport", pgsetdefport, METH_VARARGS, pgSetdefport__doc__},
    4167         {"get_defuser", pggetdefuser, METH_VARARGS, pgGetdefuser__doc__},
    4168         {"set_defuser", pgsetdefuser, METH_VARARGS, pgSetdefuser__doc__},
    4169         {"set_defpasswd", pgsetdefpasswd, METH_VARARGS, pgSetdefpasswd__doc__},
     4131        {"get_defhost", pgGetDefHost, METH_VARARGS, pgGetDefHost__doc__},
     4132        {"set_defhost", pgSetDefHost, METH_VARARGS, pgSetDefHost__doc__},
     4133        {"get_defbase", pgGetDefBase, METH_VARARGS, pgGetDefBase__doc__},
     4134        {"set_defbase", pgSetDefBase, METH_VARARGS, pgSetDefBase__doc__},
     4135        {"get_defopt", pgGetDefOpt, METH_VARARGS, pgGetDefOpt__doc__},
     4136        {"set_defopt", pgSetDefOpt, METH_VARARGS, pgSetDefOpt__doc__},
     4137        {"get_deftty", pgGetDefTTY, METH_VARARGS, pgGetDefTTY__doc__},
     4138        {"set_deftty", pgSetDefTTY, METH_VARARGS, pgSetDefTTY__doc__},
     4139        {"get_defport", pgGetDefPort, METH_VARARGS, pgGetDefPort__doc__},
     4140        {"set_defport", pgSetDefPort, METH_VARARGS, pgSetDefPort__doc__},
     4141        {"get_defuser", pgGetDefUser, METH_VARARGS, pgGetDefUser__doc__},
     4142        {"set_defuser", pgSetDefUser, METH_VARARGS, pgSetDefUser__doc__},
     4143        {"set_defpasswd", pgSetDefPassword, METH_VARARGS, pgSetDefPassword__doc__},
    41704144#endif /* DEFAULT_VARS */
    41714145        {NULL, NULL} /* sentinel */
     
    41904164
    41914165        /* Create the module and add the functions */
    4192         mod = Py_InitModule4("_pg", pg_methods, pg__doc__, NULL, PYTHON_API_VERSION);
     4166        mod = Py_InitModule4("_pg", pgMethods, pg__doc__, NULL, PYTHON_API_VERSION);
    41934167        dict = PyModule_GetDict(mod);
    41944168
Note: See TracChangeset for help on using the changeset viewer.