Changeset 526


Ignore:
Timestamp:
Nov 8, 2015, 8:31:08 PM (4 years ago)
Author:
darcy
Message:

Moving closer to Python 3.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/module/pgmodule.c

    r492 r526  
    2323 * ENHANCEMENTS, OR MODIFICATIONS.
    2424 *
    25  * Further modifications copyright 1997, 1998, 1999 by D'Arcy J.M. Cain
    26  * (darcy@druid.net) subject to the same terms and conditions as above.
     25 * Further modifications copyright 1997 to 2015 by D'Arcy J.M. Cain
     26 * (darcy@PyGreSQL.org) subject to the same terms and conditions as above.
    2727 *
    2828 */
     
    3030/* Note: This should be linked against the same C runtime lib as Python */
    3131#include <Python.h>
     32#if PY_MAJOR_VERSION >= 3
     33#define IS_PY3K
     34#endif
     35
     36#ifndef IS_PY3K
     37#define PyLong_FromLong PyInt_FromLong
     38#endif
    3239
    3340#include <libpq-fe.h>
     
    5764
    5865/* taken from fileobject.c */
    59 #define BUF(v) PyString_AS_STRING((PyStringObject *)(v))
     66#define BUF(v) PyBytes_AS_STRING((PyBytesObject *)(v))
    6067
    6168/* default values */
     
    115122#endif  /* DEFAULT_VARS */
    116123
    117 DL_EXPORT(void) init_pg(void);
     124(void) init_pg(void);
    118125int *get_type_array(PGresult *result, int nfields);
    119126
     
    136143}       pgobject;
    137144
    138 staticforward PyTypeObject PgType;
    139 
    140 #define is_pgobject(v) ((v)->ob_type == &PgType)
     145static PyTypeObject PgType;
     146
     147#define is_pgobject(v) (PyType(v) == &PgType)
    141148
    142149static PyObject *
     
    164171}       pgnoticeobject;
    165172
    166 staticforward PyTypeObject PgNoticeType;
    167 
    168 #define is_pgnoticeobject(v) ((v)->ob_type == &PgNoticeType)
     173static PyTypeObject PgNoticeType;
     174
     175#define is_pgnoticeobject(v) (PyType(v) == &PgNoticeType)
    169176
    170177/* pg query object */
     
    179186}       pgqueryobject;
    180187
    181 staticforward PyTypeObject PgQueryType;
    182 
    183 #define is_pgqueryobject(v) ((v)->ob_type == &PgQueryType)
     188static PyTypeObject PgQueryType;
     189
     190#define is_pgqueryobject(v) (PyType(v) == &PgQueryType)
    184191
    185192/* pg source object */
     
    198205}       pgsourceobject;
    199206
    200 staticforward PyTypeObject PgSourceType;
    201 
    202 #define is_pgsourceobject(v) ((v)->ob_type == &PgSourceType)
    203 
     207static PyTypeObject PgSourceType;
     208
     209#define is_pgsourceobject(v) (PyType(v) == &PgSourceType)
    204210
    205211#ifdef LARGE_OBJECTS
     
    214220}       pglargeobject;
    215221
    216 staticforward PyTypeObject PglargeType;
    217 
    218 #define is_pglargeobject(v) ((v)->ob_type == &PglargeType)
     222static PyTypeObject PglargeType;
     223
     224#define is_pglargeobject(v) (PyType(v) == &PglargeType)
    219225#endif /* LARGE_OBJECTS */
    220226
     
    230236        PyObject *str;
    231237
    232         if (!(str = PyString_FromString(msg)))
     238        if (!(str = PyBytes_FromString(msg)))
    233239                err = NULL;
    234240        else
     
    242248                {
    243249                        char *sqlstate = PQresultErrorField(result, PG_DIAG_SQLSTATE);
    244                         str = sqlstate ? PyString_FromStringAndSize(sqlstate, 5) : NULL;
     250                        str = sqlstate ? PyBytes_FromStringAndSize(sqlstate, 5) : NULL;
    245251                }
    246252                else
     
    533539                                sprintf(p, "(%d row%s)", m, m == 1 ? "" : "s");
    534540                                /* return the result */
    535                                 result = PyString_FromString(buffer);
     541                                result = PyBytes_FromString(buffer);
    536542                                free(buffer);
    537543                                return result;
     
    554560        }
    555561        else
    556                 return PyString_FromString("(nothing selected)");
     562                return PyBytes_FromString("(nothing selected)");
    557563}
    558564
     
    698704                                num_rows = atol(temp);
    699705                        }
    700                         return PyInt_FromLong(num_rows);
     706                        return PyLong_FromLong(num_rows);
    701707
    702708                /* query failed */
     
    751757        }
    752758
    753         return PyInt_FromLong(oid);
     759        return PyLong_FromLong(oid);
    754760}
    755761
     
    809815                        }
    810816                        else
    811                                 str = PyString_FromString(PQgetvalue(self->result, self->current_row, j));
     817                                str = PyBytes_FromString(PQgetvalue(self->result, self->current_row, j));
    812818
    813819                        PyTuple_SET_ITEM(rowtuple, j, str);
     
    914920
    915921        /* gets field number */
    916         if (PyString_Check(param))
    917                 num = PQfnumber(self->result, PyString_AsString(param));
    918         else if (PyInt_Check(param))
    919                 num = PyInt_AsLong(param);
     922        if (PyBytes_Check(param))
     923                num = PQfnumber(self->result, PyBytes_AsString(param));
     924        else if (PyLong_Check(param))
     925                num = PyLong_AsLong(param);
    920926        else
    921927        {
     
    946952
    947953        /* affects field information */
    948         PyTuple_SET_ITEM(result, 0, PyInt_FromLong(num));
     954        PyTuple_SET_ITEM(result, 0, PyLong_FromLong(num));
    949955        PyTuple_SET_ITEM(result, 1,
    950                 PyString_FromString(PQfname(self->result, num)));
     956                PyBytes_FromString(PQfname(self->result, num)));
    951957        PyTuple_SET_ITEM(result, 2,
    952                 PyInt_FromLong(PQftype(self->result, num)));
     958                PyLong_FromLong(PQftype(self->result, num)));
    953959
    954960        return result;
     
    10491055                return NULL;
    10501056
    1051         return PyString_FromString(PQgetvalue(self->result,
     1057        return PyBytes_FromString(PQgetvalue(self->result,
    10521058                                                                        self->current_row, num));
    10531059}
     
    10981104        /* arraysize */
    10991105        if (!strcmp(name, "arraysize"))
    1100                 return PyInt_FromLong(self->arraysize);
     1106                return PyLong_FromLong(self->arraysize);
    11011107
    11021108        /* resulttype */
    11031109        if (!strcmp(name, "resulttype"))
    1104                 return PyInt_FromLong(self->result_type);
     1110                return PyLong_FromLong(self->result_type);
    11051111
    11061112        /* ntuples */
    11071113        if (!strcmp(name, "ntuples"))
    1108                 return PyInt_FromLong(self->max_row);
     1114                return PyLong_FromLong(self->max_row);
    11091115
    11101116        /* nfields */
    11111117        if (!strcmp(name, "nfields"))
    1112                 return PyInt_FromLong(self->num_fields);
     1118                return PyLong_FromLong(self->num_fields);
    11131119
    11141120        /* attributes list */
     
    11171123                PyObject *list = PyList_New(5);
    11181124
    1119                 PyList_SET_ITEM(list, 0, PyString_FromString("pgcnx"));
    1120                 PyList_SET_ITEM(list, 1, PyString_FromString("arraysize"));
    1121                 PyList_SET_ITEM(list, 2, PyString_FromString("resulttype"));
    1122                 PyList_SET_ITEM(list, 3, PyString_FromString("ntuples"));
    1123                 PyList_SET_ITEM(list, 4, PyString_FromString("nfields"));
     1125                PyList_SET_ITEM(list, 0, PyBytes_FromString("pgcnx"));
     1126                PyList_SET_ITEM(list, 1, PyBytes_FromString("arraysize"));
     1127                PyList_SET_ITEM(list, 2, PyBytes_FromString("resulttype"));
     1128                PyList_SET_ITEM(list, 3, PyBytes_FromString("ntuples"));
     1129                PyList_SET_ITEM(list, 4, PyBytes_FromString("nfields"));
    11241130
    11251131                return list;
     
    11281134        /* module name */
    11291135        if (!strcmp(name, "__module__"))
    1130                 return PyString_FromString(MODULE_NAME);
     1136                return PyBytes_FromString(MODULE_NAME);
    11311137
    11321138        /* class name */
    11331139        if (!strcmp(name, "__class__"))
    1134                 return PyString_FromString("pgsource");
     1140                return PyBytes_FromString("pgsource");
    11351141
    11361142        /* seeks name in methods (fallback) */
     
    11451151        if (!strcmp(name, "arraysize"))
    11461152        {
    1147                 if (!PyInt_Check(v))
     1153                if (!PyLong_Check(v))
    11481154                {
    11491155                        PyErr_SetString(PyExc_TypeError, "arraysize must be integer.");
     
    11511157                }
    11521158
    1153                 self->arraysize = PyInt_AsLong(v);
     1159                self->arraysize = PyLong_AsLong(v);
    11541160                return 0;
    11551161        }
     
    11631169pgsource_repr(pgsourceobject *self)
    11641170{
    1165         return PyString_FromString("<pg source object>");
     1171        return PyBytes_FromString("<pg source object>");
    11661172}
    11671173
     
    11771183                case RESULT_DDL:
    11781184                case RESULT_DML:
    1179                         return PyString_FromString(PQcmdStatus(self->result));
     1185                        return PyBytes_FromString(PQcmdStatus(self->result));
    11801186                case RESULT_EMPTY:
    11811187                default:
    1182                         return PyString_FromString("(empty PostgreSQL source object)");
     1188                        return PyBytes_FromString("(empty PostgreSQL source object)");
    11831189        }
    11841190}
    11851191
    11861192/* query type definition */
    1187 staticforward PyTypeObject PgSourceType = {
     1193static PyTypeObject PgSourceType = {
    11881194        PyObject_HEAD_INIT(NULL)
    11891195        0,                                                              /* ob_size */
     
    13351341
    13361342        /* allocate buffer and runs read */
    1337         buffer = PyString_FromStringAndSize((char *) NULL, size);
     1343        buffer = PyBytes_FromStringAndSize((char *) NULL, size);
    13381344
    13391345        if ((size = lo_read(self->pgcnx->cnx, self->lo_fd, BUF(buffer), size)) < 0)
     
    13451351
    13461352        /* resize buffer and returns it */
    1347         _PyString_Resize(&buffer, size);
     1353        _PyBytes_Resize(&buffer, size);
    13481354        return buffer;
    13491355}
     
    14201426
    14211427        /* returns position */
    1422         return PyInt_FromLong(ret);
     1428        return PyLong_FromLong(ret);
    14231429}
    14241430
     
    14691475
    14701476        /* returns size */
    1471         return PyInt_FromLong(end);
     1477        return PyLong_FromLong(end);
    14721478}
    14731479
     
    15021508
    15031509        /* returns size */
    1504         return PyInt_FromLong(start);
     1510        return PyLong_FromLong(start);
    15051511}
    15061512
     
    16081614        {
    16091615                if (check_lo_obj(self, 0))
    1610                         return PyInt_FromLong(self->lo_oid);
     1616                        return PyLong_FromLong(self->lo_oid);
    16111617
    16121618                Py_INCREF(Py_None);
     
    16161622        /* error (status) message */
    16171623        if (!strcmp(name, "error"))
    1618                 return PyString_FromString(PQerrorMessage(self->pgcnx->cnx));
     1624                return PyBytes_FromString(PQerrorMessage(self->pgcnx->cnx));
    16191625
    16201626        /* attributes list */
     
    16251631                if (list)
    16261632                {
    1627                         PyList_SET_ITEM(list, 0, PyString_FromString("oid"));
    1628                         PyList_SET_ITEM(list, 1, PyString_FromString("pgcnx"));
    1629                         PyList_SET_ITEM(list, 2, PyString_FromString("error"));
     1633                        PyList_SET_ITEM(list, 0, PyBytes_FromString("oid"));
     1634                        PyList_SET_ITEM(list, 1, PyBytes_FromString("pgcnx"));
     1635                        PyList_SET_ITEM(list, 2, PyBytes_FromString("error"));
    16301636                }
    16311637
     
    16351641        /* module name */
    16361642        if (!strcmp(name, "__module__"))
    1637                 return PyString_FromString(MODULE_NAME);
     1643                return PyBytes_FromString(MODULE_NAME);
    16381644
    16391645        /* class name */
    16401646        if (!strcmp(name, "__class__"))
    1641                 return PyString_FromString("pglarge");
     1647                return PyBytes_FromString("pglarge");
    16421648
    16431649        /* seeks name in methods (fallback) */
     
    16591665
    16601666/* object type definition */
    1661 staticforward PyTypeObject PglargeType = {
     1667static PyTypeObject PglargeType = {
    16621668        PyObject_HEAD_INIT(NULL)
    16631669        0,                                                      /* ob_size */
     
    17211727        /* handles defaults variables (for uninitialised vars) */
    17221728        if ((!pghost) && (pg_default_host != Py_None))
    1723                 pghost = PyString_AsString(pg_default_host);
     1729                pghost = PyBytes_AsString(pg_default_host);
    17241730
    17251731        if ((pgport == -1) && (pg_default_port != Py_None))
    1726                 pgport = PyInt_AsLong(pg_default_port);
     1732                pgport = PyLong_AsLong(pg_default_port);
    17271733
    17281734        if ((!pgopt) && (pg_default_opt != Py_None))
    1729                 pgopt = PyString_AsString(pg_default_opt);
     1735                pgopt = PyBytes_AsString(pg_default_opt);
    17301736
    17311737        if ((!pgtty) && (pg_default_tty != Py_None))
    1732                 pgtty = PyString_AsString(pg_default_tty);
     1738                pgtty = PyBytes_AsString(pg_default_tty);
    17331739
    17341740        if ((!pgdbname) && (pg_default_base != Py_None))
    1735                 pgdbname = PyString_AsString(pg_default_base);
     1741                pgdbname = PyBytes_AsString(pg_default_base);
    17361742
    17371743        if ((!pguser) && (pg_default_user != Py_None))
    1738                 pguser = PyString_AsString(pg_default_user);
     1744                pguser = PyBytes_AsString(pg_default_user);
    17391745
    17401746        if ((!pgpasswd) && (pg_default_passwd != Py_None))
    1741                 pgpasswd = PyString_AsString(pg_default_passwd);
     1747                pgpasswd = PyBytes_AsString(pg_default_passwd);
    17421748#endif /* DEFAULT_VARS */
    17431749
     
    19091915
    19101916        /* request that the server abandon processing of the current command */
    1911         return PyInt_FromLong((long) PQrequestCancel(self->cnx));
     1917        return PyLong_FromLong((long) PQrequestCancel(self->cnx));
    19121918}
    19131919
     
    19341940
    19351941#ifdef NO_PQSOCKET
    1936         return PyInt_FromLong((long) self->cnx->sock);
     1942        return PyLong_FromLong((long) self->cnx->sock);
    19371943#else
    1938         return PyInt_FromLong((long) PQsocket(self->cnx));
     1944        return PyLong_FromLong((long) PQsocket(self->cnx));
    19391945#endif
    19401946}
     
    20042010        }
    20052011
    2006         return PyInt_FromLong((long) PQntuples(self->result));
     2012        return PyLong_FromLong((long) PQntuples(self->result));
    20072013}
    20082014
     
    20352041        {
    20362042                name = PQfname(self->result, i);
    2037                 str = PyString_FromString(name);
     2043                str = PyBytes_FromString(name);
    20382044                PyTuple_SET_ITEM(fieldstuple, i, str);
    20392045        }
     
    20692075        /* gets fields name and builds object */
    20702076        name = PQfname(self->result, i);
    2071         return PyString_FromString(name);
     2077        return PyBytes_FromString(name);
    20722078}
    20732079
     
    20962102        }
    20972103
    2098         return PyInt_FromLong(num);
     2104        return PyLong_FromLong(num);
    20992105}
    21002106
     
    21572163                                {
    21582164                                        case 1:  /* int2/4 */
    2159                                                 val = PyInt_FromString(s, NULL, 10);
     2165                                                val = PyLong_FromString(s, NULL, 10);
    21602166                                                break;
    21612167
     
    21652171
    21662172                                        case 3:  /* float/double */
    2167                                                 tmp_obj = PyString_FromString(s);
     2173                                                tmp_obj = PyBytes_FromString(s);
    21682174                                                val = PyFloat_FromString(tmp_obj, NULL);
    21692175                                                Py_DECREF(tmp_obj);
     
    21942200                                                else
    21952201                                                {
    2196                                                         tmp_obj = PyString_FromString(s);
     2202                                                        tmp_obj = PyBytes_FromString(s);
    21972203                                                        val = PyFloat_FromString(tmp_obj, NULL);
    21982204                                                }
     
    22012207
    22022208                                        default:
    2203                                                 val = PyString_FromString(s);
     2209                                                val = PyBytes_FromString(s);
    22042210                                                break;
    22052211                                }
     
    22842290                                {
    22852291                                        case 1:  /* int2/4 */
    2286                                                 val = PyInt_FromString(s, NULL, 10);
     2292                                                val = PyLong_FromString(s, NULL, 10);
    22872293                                                break;
    22882294
     
    22922298
    22932299                                        case 3:  /* float/double */
    2294                                                 tmp_obj = PyString_FromString(s);
     2300                                                tmp_obj = PyBytes_FromString(s);
    22952301                                                val = PyFloat_FromString(tmp_obj, NULL);
    22962302                                                Py_DECREF(tmp_obj);
     
    23212327                                                else
    23222328                                                {
    2323                                                         tmp_obj = PyString_FromString(s);
     2329                                                        tmp_obj = PyBytes_FromString(s);
    23242330                                                        val = PyFloat_FromString(tmp_obj, NULL);
    23252331                                                }
     
    23282334
    23292335                                        default:
    2330                                                 val = PyString_FromString(s);
     2336                                                val = PyBytes_FromString(s);
    23312337                                                break;
    23322338                                }
     
    23862392
    23872393        if (ret == NULL)
    2388             return NULL;
     2394                return NULL;
    23892395
    23902396        return ret;
     
    24272433                                   *temp;
    24282434
    2429                 if (!(temp = PyString_FromString(notify->relname)))
     2435                if (!(temp = PyBytes_FromString(notify->relname)))
    24302436                        return NULL;
    24312437
     
    24352441                PyTuple_SET_ITEM(notify_result, 0, temp);
    24362442
    2437                 if (!(temp = PyInt_FromLong(notify->be_pid)))
     2443                if (!(temp = PyLong_FromLong(notify->be_pid)))
    24382444                {
    24392445                        Py_DECREF(notify_result);
     
    24442450
    24452451                /* extra exists even in old versions that did not support it */
    2446                 if (!(temp = PyString_FromString(notify->extra)))
     2452                if (!(temp = PyBytes_FromString(notify->extra)))
    24472453                {
    24482454                        Py_DECREF(notify_result);
     
    25832589                                        return NULL;
    25842590                                }
    2585                                 *p = PyString_AsString(*s);
    2586                                 *l = (int)PyString_Size(*s);
     2591                                *p = PyBytes_AsString(*s);
     2592                                *l = (int)PyBytes_Size(*s);
    25872593                        }
    25882594                        else
     
    26032609                                        return NULL;
    26042610                                }
    2605                                 *p = PyString_AsString(*s);
    2606                                 *l = (int)PyString_Size(*s);
     2611                                *p = PyBytes_AsString(*s);
     2612                                *l = (int)PyBytes_Size(*s);
    26072613                        }
    26082614                }
     
    26612667                                                if (ret[0])             /* return number of rows affected */
    26622668                                                {
    2663                                                         return PyString_FromString(ret);
     2669                                                        return PyBytes_FromString(ret);
    26642670                                                }
    26652671                                                Py_INCREF(Py_None);
     
    26682674                                        /* for a single insert, return the oid */
    26692675                                        PQclear(result);
    2670                                         return PyInt_FromLong(oid);
     2676                                        return PyLong_FromLong(oid);
    26712677                                }
    26722678                        case PGRES_COPY_OUT:            /* no data will be received */
     
    27542760        {
    27552761                case 0:
    2756                         str = PyString_FromString(line);
     2762                        str = PyBytes_FromString(line);
    27572763                        break;
    27582764                case 1:
     
    28042810pgquery_repr(pgqueryobject *self)
    28052811{
    2806         return PyString_FromString("<pg query result>");
     2812        return PyBytes_FromString("<pg query result>");
    28072813}
    28082814
     
    29542960                                        bufsiz = 0;
    29552961                        }
    2956                         else if (PyString_Check(item))
     2962                        else if (PyBytes_Check(item))
    29572963                        {
    2958                                 const char* t = PyString_AS_STRING(item);
     2964                                const char* t = PyBytes_AS_STRING(item);
    29592965                                while (*t && bufsiz)
    29602966                                {
     
    29672973                                }
    29682974                        }
    2969                         else if (PyInt_Check(item) || PyLong_Check(item))
     2975                        else if (PyLong_Check(item) || PyLong_Check(item))
    29702976                        {
    29712977                                PyObject* s = PyObject_Str(item);
    2972                                 const char* t = PyString_AsString(s);
     2978                                const char* t = PyBytes_AsString(s);
    29732979                                while (*t && bufsiz)
    29742980                                {
     
    29802986                        {
    29812987                                PyObject* s = PyObject_Repr(item);
    2982                                 const char* t = PyString_AsString(s);
     2988                                const char* t = PyBytes_AsString(s);
    29832989                                while (*t && bufsiz)
    29842990                                {
     
    30593065        }
    30603066
    3061         return PyInt_FromLong(PQtransactionStatus(self->cnx));
     3067        return PyLong_FromLong(PQtransactionStatus(self->cnx));
    30623068}
    30633069
     
    30873093
    30883094        if (name)
    3089                 return PyString_FromString(name);
     3095                return PyBytes_FromString(name);
    30903096
    30913097        /* unknown parameter, return None */
     
    33703376                if (!r)
    33713377                        r = "localhost";
    3372                 return PyString_FromString(r);
     3378                return PyBytes_FromString(r);
    33733379        }
    33743380
    33753381        /* postmaster port */
    33763382        if (!strcmp(name, "port"))
    3377                 return PyInt_FromLong(atol(PQport(self->cnx)));
     3383                return PyLong_FromLong(atol(PQport(self->cnx)));
    33783384
    33793385        /* selected database */
    33803386        if (!strcmp(name, "db"))
    3381                 return PyString_FromString(PQdb(self->cnx));
     3387                return PyBytes_FromString(PQdb(self->cnx));
    33823388
    33833389        /* selected options */
    33843390        if (!strcmp(name, "options"))
    3385                 return PyString_FromString(PQoptions(self->cnx));
     3391                return PyBytes_FromString(PQoptions(self->cnx));
    33863392
    33873393        /* selected postgres tty */
    33883394        if (!strcmp(name, "tty"))
    3389                 return PyString_FromString(PQtty(self->cnx));
     3395                return PyBytes_FromString(PQtty(self->cnx));
    33903396
    33913397        /* error (status) message */
    33923398        if (!strcmp(name, "error"))
    3393                 return PyString_FromString(PQerrorMessage(self->cnx));
     3399                return PyBytes_FromString(PQerrorMessage(self->cnx));
    33943400
    33953401        /* connection status : 1 - OK, 0 - BAD */
    33963402        if (!strcmp(name, "status"))
    3397                 return PyInt_FromLong(PQstatus(self->cnx) == CONNECTION_OK ? 1 : 0);
     3403                return PyLong_FromLong(PQstatus(self->cnx) == CONNECTION_OK ? 1 : 0);
    33983404
    33993405        /* provided user name */
    34003406        if (!strcmp(name, "user"))
    3401                 return PyString_FromString(PQuser(self->cnx));
     3407                return PyBytes_FromString(PQuser(self->cnx));
    34023408
    34033409        /* protocol version */
    34043410        if (!strcmp(name, "protocol_version"))
    3405                 return PyInt_FromLong(PQprotocolVersion(self->cnx));
     3411                return PyLong_FromLong(PQprotocolVersion(self->cnx));
    34063412
    34073413        /* backend version */
    34083414        if (!strcmp(name, "server_version"))
    34093415#if PG_VERSION_NUM < 80000
    3410                 return PyInt_FromLong(PG_VERSION_NUM);
     3416                return PyLong_FromLong(PG_VERSION_NUM);
    34113417#else
    3412                 return PyInt_FromLong(PQserverVersion(self->cnx));
     3418                return PyLong_FromLong(PQserverVersion(self->cnx));
    34133419#endif
    34143420
     
    34203426                if (list)
    34213427                {
    3422                         PyList_SET_ITEM(list, 0, PyString_FromString("host"));
    3423                         PyList_SET_ITEM(list, 1, PyString_FromString("port"));
    3424                         PyList_SET_ITEM(list, 2, PyString_FromString("db"));
    3425                         PyList_SET_ITEM(list, 3, PyString_FromString("options"));
    3426                         PyList_SET_ITEM(list, 4, PyString_FromString("tty"));
    3427                         PyList_SET_ITEM(list, 5, PyString_FromString("error"));
    3428                         PyList_SET_ITEM(list, 6, PyString_FromString("status"));
    3429                         PyList_SET_ITEM(list, 7, PyString_FromString("user"));
    3430                         PyList_SET_ITEM(list, 8, PyString_FromString("protocol_version"));
    3431                         PyList_SET_ITEM(list, 9, PyString_FromString("server_version"));
     3428                        PyList_SET_ITEM(list, 0, PyBytes_FromString("host"));
     3429                        PyList_SET_ITEM(list, 1, PyBytes_FromString("port"));
     3430                        PyList_SET_ITEM(list, 2, PyBytes_FromString("db"));
     3431                        PyList_SET_ITEM(list, 3, PyBytes_FromString("options"));
     3432                        PyList_SET_ITEM(list, 4, PyBytes_FromString("tty"));
     3433                        PyList_SET_ITEM(list, 5, PyBytes_FromString("error"));
     3434                        PyList_SET_ITEM(list, 6, PyBytes_FromString("status"));
     3435                        PyList_SET_ITEM(list, 7, PyBytes_FromString("user"));
     3436                        PyList_SET_ITEM(list, 8, PyBytes_FromString("protocol_version"));
     3437                        PyList_SET_ITEM(list, 9, PyBytes_FromString("server_version"));
    34323438                }
    34333439
     
    34393445
    34403446/* object type definition */
    3441 staticforward PyTypeObject PgType = {
     3447static PyTypeObject PgType = {
    34423448        PyObject_HEAD_INIT(NULL)
    34433449        0,                                                      /* ob_size */
     
    34893495        /* full message */
    34903496        if (!strcmp(name, "message"))
    3491                 return PyString_FromString(PQresultErrorMessage(res));
     3497                return PyBytes_FromString(PQresultErrorMessage(res));
    34923498
    34933499        /* other possible fields */
     
    35053511                char *s = PQresultErrorField(res, fieldcode);
    35063512                if (s)
    3507                         return PyString_FromString(s);
     3513                        return PyBytes_FromString(s);
    35083514                else
    35093515                {
     
    35183524                if (list)
    35193525                {
    3520                         PyList_SET_ITEM(list, 0, PyString_FromString("pgcnx"));
    3521                         PyList_SET_ITEM(list, 1, PyString_FromString("severity"));
    3522                         PyList_SET_ITEM(list, 2, PyString_FromString("message"));
    3523                         PyList_SET_ITEM(list, 3, PyString_FromString("primary"));
    3524                         PyList_SET_ITEM(list, 4, PyString_FromString("detail"));
    3525                         PyList_SET_ITEM(list, 5, PyString_FromString("hint"));
     3526                        PyList_SET_ITEM(list, 0, PyBytes_FromString("pgcnx"));
     3527                        PyList_SET_ITEM(list, 1, PyBytes_FromString("severity"));
     3528                        PyList_SET_ITEM(list, 2, PyBytes_FromString("message"));
     3529                        PyList_SET_ITEM(list, 3, PyBytes_FromString("primary"));
     3530                        PyList_SET_ITEM(list, 4, PyBytes_FromString("detail"));
     3531                        PyList_SET_ITEM(list, 5, PyBytes_FromString("hint"));
    35263532                }
    35273533                return list;
     
    35403546
    35413547/* object type definition */
    3542 staticforward PyTypeObject PgNoticeType = {
     3548static PyTypeObject PgNoticeType = {
    35433549        PyObject_HEAD_INIT(NULL)
    35443550        0,                                                      /* ob_size */
     
    35903596
    35913597/* query type definition */
    3592 staticforward PyTypeObject PgQueryType = {
     3598static PyTypeObject PgQueryType = {
    35933599        PyObject_HEAD_INIT(NULL)
    35943600        0,                                                              /* ob_size */
     
    37233729        if (PyArg_ParseTuple(args, ""))
    37243730        {
    3725                 ret = PyString_FromString(decimal_point);
     3731                ret = PyBytes_FromString(decimal_point);
    37263732        }
    37273733        else
     
    38293835
    38303836        if (temp)
    3831                 pg_default_host = PyString_FromString(temp);
     3837                pg_default_host = PyBytes_FromString(temp);
    38323838        else
    38333839        {
     
    38803886
    38813887        if (temp)
    3882                 pg_default_base = PyString_FromString(temp);
     3888                pg_default_base = PyBytes_FromString(temp);
    38833889        else
    38843890        {
     
    39313937
    39323938        if (temp)
    3933                 pg_default_opt = PyString_FromString(temp);
     3939                pg_default_opt = PyBytes_FromString(temp);
    39343940        else
    39353941        {
     
    39833989
    39843990        if (temp)
    3985                 pg_default_tty = PyString_FromString(temp);
     3991                pg_default_tty = PyBytes_FromString(temp);
    39863992        else
    39873993        {
     
    40354041
    40364042        if (temp)
    4037                 pg_default_user = PyString_FromString(temp);
     4043                pg_default_user = PyBytes_FromString(temp);
    40384044        else
    40394045        {
     
    40634069
    40644070        if (temp)
    4065                 pg_default_passwd = PyString_FromString(temp);
     4071                pg_default_passwd = PyBytes_FromString(temp);
    40664072        else
    40674073        {
     
    41154121
    41164122        if (port != -1)
    4117                 pg_default_port = PyInt_FromLong(port);
     4123                pg_default_port = PyLong_FromLong(port);
    41184124        else
    41194125        {
     
    41674173
    41684174/* Initialization function for the module */
    4169 DL_EXPORT(void)
     4175(void)
    41704176init_pg(void)
    41714177{
     
    42214227
    42224228        /* Make the version available */
    4223         v = PyString_FromString(PyPgVersion);
     4229        v = PyBytes_FromString(PyPgVersion);
    42244230        PyDict_SetItemString(dict, "version", v);
    42254231        PyDict_SetItemString(dict, "__version__", v);
     
    42274233
    42284234        /* results type for queries */
    4229         PyDict_SetItemString(dict, "RESULT_EMPTY", PyInt_FromLong(RESULT_EMPTY));
    4230         PyDict_SetItemString(dict, "RESULT_DML", PyInt_FromLong(RESULT_DML));
    4231         PyDict_SetItemString(dict, "RESULT_DDL", PyInt_FromLong(RESULT_DDL));
    4232         PyDict_SetItemString(dict, "RESULT_DQL", PyInt_FromLong(RESULT_DQL));
     4235        PyDict_SetItemString(dict, "RESULT_EMPTY", PyLong_FromLong(RESULT_EMPTY));
     4236        PyDict_SetItemString(dict, "RESULT_DML", PyLong_FromLong(RESULT_DML));
     4237        PyDict_SetItemString(dict, "RESULT_DDL", PyLong_FromLong(RESULT_DDL));
     4238        PyDict_SetItemString(dict, "RESULT_DQL", PyLong_FromLong(RESULT_DQL));
    42334239
    42344240        /* transaction states */
    4235         PyDict_SetItemString(dict,"TRANS_IDLE",PyInt_FromLong(PQTRANS_IDLE));
    4236         PyDict_SetItemString(dict,"TRANS_ACTIVE",PyInt_FromLong(PQTRANS_ACTIVE));
    4237         PyDict_SetItemString(dict,"TRANS_INTRANS",PyInt_FromLong(PQTRANS_INTRANS));
    4238         PyDict_SetItemString(dict,"TRANS_INERROR",PyInt_FromLong(PQTRANS_INERROR));
    4239         PyDict_SetItemString(dict,"TRANS_UNKNOWN",PyInt_FromLong(PQTRANS_UNKNOWN));
     4241        PyDict_SetItemString(dict,"TRANS_IDLE",PyLong_FromLong(PQTRANS_IDLE));
     4242        PyDict_SetItemString(dict,"TRANS_ACTIVE",PyLong_FromLong(PQTRANS_ACTIVE));
     4243        PyDict_SetItemString(dict,"TRANS_INTRANS",PyLong_FromLong(PQTRANS_INTRANS));
     4244        PyDict_SetItemString(dict,"TRANS_INERROR",PyLong_FromLong(PQTRANS_INERROR));
     4245        PyDict_SetItemString(dict,"TRANS_UNKNOWN",PyLong_FromLong(PQTRANS_UNKNOWN));
    42404246
    42414247#ifdef LARGE_OBJECTS
    42424248        /* create mode for large objects */
    4243         PyDict_SetItemString(dict, "INV_READ", PyInt_FromLong(INV_READ));
    4244         PyDict_SetItemString(dict, "INV_WRITE", PyInt_FromLong(INV_WRITE));
     4249        PyDict_SetItemString(dict, "INV_READ", PyLong_FromLong(INV_READ));
     4250        PyDict_SetItemString(dict, "INV_WRITE", PyLong_FromLong(INV_WRITE));
    42454251
    42464252        /* position flags for lo_lseek */
    4247         PyDict_SetItemString(dict, "SEEK_SET", PyInt_FromLong(SEEK_SET));
    4248         PyDict_SetItemString(dict, "SEEK_CUR", PyInt_FromLong(SEEK_CUR));
    4249         PyDict_SetItemString(dict, "SEEK_END", PyInt_FromLong(SEEK_END));
     4253        PyDict_SetItemString(dict, "SEEK_SET", PyLong_FromLong(SEEK_SET));
     4254        PyDict_SetItemString(dict, "SEEK_CUR", PyLong_FromLong(SEEK_CUR));
     4255        PyDict_SetItemString(dict, "SEEK_END", PyLong_FromLong(SEEK_END));
    42504256#endif /* LARGE_OBJECTS */
    42514257
Note: See TracChangeset for help on using the changeset viewer.