Changeset 813 for trunk


Ignore:
Timestamp:
Feb 1, 2016, 11:14:36 AM (4 years ago)
Author:
cito
Message:

Make better use of ml_flags in the C module

This made the code a bit cleaner and smaller.

Also adapted some tests that still assumed set_bool(False).

Location:
trunk
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/pgmodule.c

    r806 r813  
    7474#define QUERY_MOVENEXT          3
    7575#define QUERY_MOVEPREV          4
    76 
    77 /* moves names for errors */
    78 const char *__movename[5] =
    79 {"", "movefirst", "movelast", "movenext", "moveprev"};
    8076
    8177#define MAX_BUFFER_SIZE 8192    /* maximum transaction size */
     
    14311427
    14321428static PyObject *
    1433 largeClose(largeObject *self, PyObject *args)
    1434 {
    1435         /* checks args */
    1436         if (!PyArg_ParseTuple(args, ""))
    1437         {
    1438                 PyErr_SetString(PyExc_TypeError,
    1439                         "Method close() takes no arguments");
    1440                 return NULL;
    1441         }
    1442 
     1429largeClose(largeObject *self, PyObject *noargs)
     1430{
    14431431        /* checks validity */
    14441432        if (!check_lo_obj(self, CHECK_OPEN))
     
    15841572
    15851573static PyObject *
    1586 largeSize(largeObject *self, PyObject *args)
     1574largeSize(largeObject *self, PyObject *noargs)
    15871575{
    15881576        int                     start,
    15891577                                end;
    1590 
    1591         /* checks args */
    1592         if (!PyArg_ParseTuple(args, ""))
    1593         {
    1594                 PyErr_SetString(PyExc_TypeError,
    1595                         "Method size() takes no arguments");
    1596                 return NULL;
    1597         }
    15981578
    15991579        /* checks validity */
     
    16341614
    16351615static PyObject *
    1636 largeTell(largeObject *self, PyObject *args)
     1616largeTell(largeObject *self, PyObject *noargs)
    16371617{
    16381618        int                     start;
    1639 
    1640         /* checks args */
    1641         if (!PyArg_ParseTuple(args, ""))
    1642         {
    1643                 PyErr_SetString(PyExc_TypeError,
    1644                         "Method tell() takes no arguments");
    1645                 return NULL;
    1646         }
    16471619
    16481620        /* checks validity */
     
    16791651        {
    16801652                PyErr_SetString(PyExc_TypeError,
    1681                         "export(filename), with filename (string)");
     1653                        "The method export() takes a filename as argument");
    16821654                return NULL;
    16831655        }
     
    17001672
    17011673static PyObject *
    1702 largeUnlink(largeObject *self, PyObject *args)
    1703 {
    1704         /* checks args */
    1705         if (!PyArg_ParseTuple(args, ""))
    1706         {
    1707                 PyErr_SetString(PyExc_TypeError,
    1708                         "Method unlink() takes no arguments");
    1709                 return NULL;
    1710         }
    1711 
     1674largeUnlink(largeObject *self, PyObject *noargs)
     1675{
    17121676        /* checks validity */
    17131677        if (!check_lo_obj(self, CHECK_CLOSE))
     
    17281692/* get the list of large object attributes */
    17291693static PyObject *
    1730 largeDir(largeObject *self)
     1694largeDir(largeObject *self, PyObject *noargs)
    17311695{
    17321696        PyObject *attrs;
     
    17431707        {"__dir__", (PyCFunction) largeDir,  METH_NOARGS, NULL},
    17441708        {"open", (PyCFunction) largeOpen, METH_VARARGS, largeOpen__doc__},
    1745         {"close", (PyCFunction) largeClose, METH_VARARGS, largeClose__doc__},
     1709        {"close", (PyCFunction) largeClose, METH_NOARGS, largeClose__doc__},
    17461710        {"read", (PyCFunction) largeRead, METH_VARARGS, largeRead__doc__},
    17471711        {"write", (PyCFunction) largeWrite, METH_VARARGS, largeWrite__doc__},
    17481712        {"seek", (PyCFunction) largeSeek, METH_VARARGS, largeSeek__doc__},
    1749         {"size", (PyCFunction) largeSize, METH_VARARGS, largeSize__doc__},
    1750         {"tell", (PyCFunction) largeTell, METH_VARARGS, largeTell__doc__},
    1751         {"export",(PyCFunction) largeExport,METH_VARARGS,largeExport__doc__},
    1752         {"unlink",(PyCFunction) largeUnlink,METH_VARARGS,largeUnlink__doc__},
     1713        {"size", (PyCFunction) largeSize, METH_NOARGS, largeSize__doc__},
     1714        {"tell", (PyCFunction) largeTell, METH_NOARGS, largeTell__doc__},
     1715        {"export",(PyCFunction) largeExport, METH_VARARGS, largeExport__doc__},
     1716        {"unlink",(PyCFunction) largeUnlink, METH_NOARGS, largeUnlink__doc__},
    17531717        {NULL, NULL}
    17541718};
     
    18631827
    18641828static PyObject *
    1865 connSource(connObject *self, PyObject *args)
     1829connSource(connObject *self, PyObject *noargs)
    18661830{
    18671831        sourceObject *npgobj;
     
    18701834        if (!check_cnx_obj(self))
    18711835                return NULL;
    1872 
    1873         /* checks args */
    1874         if (!PyArg_ParseTuple(args, ""))
    1875         {
    1876                 PyErr_SetString(PyExc_TypeError,
    1877                         "Method source() takes no arguments");
    1878                 return NULL;
    1879         }
    18801836
    18811837        /* allocates new query object */
     
    21432099        if (!PyArg_ParseTuple(args, "s#", &line, &line_length))
    21442100        {
    2145                 PyErr_SetString(PyExc_TypeError, "putline(line), with line (string)");
     2101                PyErr_SetString(PyExc_TypeError,
     2102                        "Method putline() takes a string argument");
    21462103                return NULL;
    21472104        }
     
    21622119
    21632120static PyObject *
    2164 connGetLine(connObject *self, PyObject *args)
     2121connGetLine(connObject *self, PyObject *noargs)
    21652122{
    21662123        char            line[MAX_BUFFER_SIZE];
     
    21702127        {
    21712128                PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    2172                 return NULL;
    2173         }
    2174 
    2175         /* checks args */
    2176         if (!PyArg_ParseTuple(args, ""))
    2177         {
    2178                 PyErr_SetString(PyExc_TypeError,
    2179                         "Method getline() takes no arguments");
    21802129                return NULL;
    21812130        }
     
    22052154
    22062155static PyObject *
    2207 connEndCopy(connObject *self, PyObject *args)
     2156connEndCopy(connObject *self, PyObject *noargs)
    22082157{
    22092158        if (!self->cnx)
    22102159        {
    22112160                PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    2212                 return NULL;
    2213         }
    2214 
    2215         /* checks args */
    2216         if (!PyArg_ParseTuple(args, ""))
    2217         {
    2218                 PyErr_SetString(PyExc_TypeError,
    2219                         "Method endcopy() takes no arguments");
    22202161                return NULL;
    22212162        }
     
    24852426
    24862427static PyObject *
    2487 connTransaction(connObject *self, PyObject *args)
     2428connTransaction(connObject *self, PyObject *noargs)
    24882429{
    24892430        if (!self->cnx)
    24902431        {
    24912432                PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    2492                 return NULL;
    2493         }
    2494 
    2495         /* checks args */
    2496         if (!PyArg_ParseTuple(args, ""))
    2497         {
    2498                 PyErr_SetString(PyExc_TypeError,
    2499                         "Method transaction() takes no arguments");
    25002433                return NULL;
    25012434        }
     
    25442477
    25452478static PyObject *
    2546 connEscapeLiteral(connObject *self, PyObject *args)
    2547 {
    2548         PyObject   *from_obj, /* the object that was passed in */
     2479connEscapeLiteral(connObject *self, PyObject *string)
     2480{
     2481        PyObject   *tmp_obj = NULL, /* auxiliary string object */
    25492482                           *to_obj; /* string object to return */
    25502483        char       *from, /* our string argument as encoded string */
     
    25542487        int                     encoding = -1; /* client encoding */
    25552488
    2556         if (!PyArg_ParseTuple(args, "O", &from_obj))
    2557                 return NULL;
    2558 
    2559         if (PyBytes_Check(from_obj))
    2560         {
    2561                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
    2562                 from_obj = NULL;
    2563         }
    2564         else if (PyUnicode_Check(from_obj))
     2489        if (PyBytes_Check(string))
     2490        {
     2491                PyBytes_AsStringAndSize(string, &from, &from_length);
     2492        }
     2493        else if (PyUnicode_Check(string))
    25652494        {
    25662495                encoding = PQclientEncoding(self->cnx);
    2567                 from_obj = get_encoded_string(from_obj, encoding);
    2568                 if (!from_obj) return NULL; /* pass the UnicodeEncodeError */
    2569                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
     2496                tmp_obj = get_encoded_string(string, encoding);
     2497                if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     2498                PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    25702499        }
    25712500        else
     
    25792508        to_length = strlen(to);
    25802509
    2581         Py_XDECREF(from_obj);
     2510        Py_XDECREF(tmp_obj);
    25822511
    25832512        if (encoding == -1)
     
    25952524
    25962525static PyObject *
    2597 connEscapeIdentifier(connObject *self, PyObject *args)
    2598 {
    2599         PyObject   *from_obj, /* the object that was passed in */
     2526connEscapeIdentifier(connObject *self, PyObject *string)
     2527{
     2528        PyObject   *tmp_obj = NULL, /* auxiliary string object */
    26002529                           *to_obj; /* string object to return */
    26012530        char       *from, /* our string argument as encoded string */
     
    26052534        int                     encoding = -1; /* client encoding */
    26062535
    2607         if (!PyArg_ParseTuple(args, "O", &from_obj))
    2608                 return NULL;
    2609 
    2610         if (PyBytes_Check(from_obj))
    2611         {
    2612                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
    2613                 from_obj = NULL;
    2614         }
    2615         else if (PyUnicode_Check(from_obj))
     2536        if (PyBytes_Check(string))
     2537        {
     2538                PyBytes_AsStringAndSize(string, &from, &from_length);
     2539        }
     2540        else if (PyUnicode_Check(string))
    26162541        {
    26172542                encoding = PQclientEncoding(self->cnx);
    2618                 from_obj = get_encoded_string(from_obj, encoding);
    2619                 if (!from_obj) return NULL; /* pass the UnicodeEncodeError */
    2620                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
     2543                tmp_obj = get_encoded_string(string, encoding);
     2544                if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     2545                PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    26212546        }
    26222547        else
     
    26302555        to_length = strlen(to);
    26312556
    2632         Py_XDECREF(from_obj);
     2557        Py_XDECREF(tmp_obj);
    26332558
    26342559        if (encoding == -1)
     
    26482573
    26492574static PyObject *
    2650 connEscapeString(connObject *self, PyObject *args)
    2651 {
    2652         PyObject   *from_obj, /* the object that was passed in */
     2575connEscapeString(connObject *self, PyObject *string)
     2576{
     2577        PyObject   *tmp_obj = NULL, /* auxiliary string object */
    26532578                           *to_obj; /* string object to return */
    26542579        char       *from, /* our string argument as encoded string */
     
    26582583        int                     encoding = -1; /* client encoding */
    26592584
    2660         if (!PyArg_ParseTuple(args, "O", &from_obj))
    2661                 return NULL;
    2662 
    2663         if (PyBytes_Check(from_obj))
    2664         {
    2665                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
    2666                 from_obj = NULL;
    2667         }
    2668         else if (PyUnicode_Check(from_obj))
     2585        if (PyBytes_Check(string))
     2586        {
     2587                PyBytes_AsStringAndSize(string, &from, &from_length);
     2588        }
     2589        else if (PyUnicode_Check(string))
    26692590        {
    26702591                encoding = PQclientEncoding(self->cnx);
    2671                 from_obj = get_encoded_string(from_obj, encoding);
    2672                 if (!from_obj) return NULL; /* pass the UnicodeEncodeError */
    2673                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
     2592                tmp_obj = get_encoded_string(string, encoding);
     2593                if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     2594                PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    26742595        }
    26752596        else
     
    26902611                to, from, (size_t)from_length, NULL);
    26912612
    2692         Py_XDECREF(from_obj);
     2613        Py_XDECREF(tmp_obj);
    26932614
    26942615        if (encoding == -1)
     
    27052626
    27062627static PyObject *
    2707 connEscapeBytea(connObject *self, PyObject *args)
    2708 {
    2709         PyObject   *from_obj, /* the object that was passed in */
     2628connEscapeBytea(connObject *self, PyObject *data)
     2629{
     2630        PyObject   *tmp_obj = NULL, /* auxiliary string object */
    27102631                           *to_obj; /* string object to return */
    27112632        char       *from, /* our string argument as encoded string */
     
    27152636        int                     encoding = -1; /* client encoding */
    27162637
    2717         if (!PyArg_ParseTuple(args, "O", &from_obj))
    2718                 return NULL;
    2719 
    2720         if (PyBytes_Check(from_obj))
    2721         {
    2722                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
    2723                 from_obj = NULL;
    2724         }
    2725         else if (PyUnicode_Check(from_obj))
     2638        if (PyBytes_Check(data))
     2639        {
     2640                PyBytes_AsStringAndSize(data, &from, &from_length);
     2641        }
     2642        else if (PyUnicode_Check(data))
    27262643        {
    27272644                encoding = PQclientEncoding(self->cnx);
    2728                 from_obj = get_encoded_string(from_obj, encoding);
    2729                 if (!from_obj) return NULL; /* pass the UnicodeEncodeError */
    2730                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
     2645                tmp_obj = get_encoded_string(data, encoding);
     2646                if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     2647                PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    27312648        }
    27322649        else
     
    27402657                (unsigned char *)from, (size_t)from_length, &to_length);
    27412658
    2742         Py_XDECREF(from_obj);
     2659        Py_XDECREF(tmp_obj);
    27432660
    27442661        if (encoding == -1)
     
    27702687        {
    27712688                PyErr_SetString(PyExc_TypeError,
    2772                         "locreate(mode), with mode (integer)");
     2689                        "Method locreate() takes an integer argument");
    27732690                return NULL;
    27742691        }
     
    28012718        if (!PyArg_ParseTuple(args, "i", &lo_oid))
    28022719        {
    2803                 PyErr_SetString(PyExc_TypeError, "getlo(oid), with oid (integer)");
     2720                PyErr_SetString(PyExc_TypeError,
     2721                        "Method getlo() takes an integer argument");
    28042722                return NULL;
    28052723        }
     
    28322750        if (!PyArg_ParseTuple(args, "s", &name))
    28332751        {
    2834                 PyErr_SetString(PyExc_TypeError, "loimport(name), with name (string)");
     2752                PyErr_SetString(PyExc_TypeError,
     2753                        "Method loimport() takes a string argument");
    28352754                return NULL;
    28362755        }
     
    28552774
    28562775static PyObject *
    2857 connReset(connObject *self, PyObject *args)
     2776connReset(connObject *self, PyObject *noargs)
    28582777{
    28592778        if (!self->cnx)
    28602779        {
    28612780                PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    2862                 return NULL;
    2863         }
    2864 
    2865         /* checks args */
    2866         if (!PyArg_ParseTuple(args, ""))
    2867         {
    2868                 PyErr_SetString(PyExc_TypeError,
    2869                         "Method reset() takes no arguments");
    28702781                return NULL;
    28712782        }
     
    28822793
    28832794static PyObject *
    2884 connCancel(connObject *self, PyObject *args)
     2795connCancel(connObject *self, PyObject *noargs)
    28852796{
    28862797        if (!self->cnx)
    28872798        {
    28882799                PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    2889                 return NULL;
    2890         }
    2891 
    2892         /* checks args */
    2893         if (!PyArg_ParseTuple(args, ""))
    2894         {
    2895                 PyErr_SetString(PyExc_TypeError,
    2896                         "Method cancel() takes no arguments");
    28972800                return NULL;
    28982801        }
     
    29072810
    29082811static PyObject *
    2909 connFileno(connObject *self, PyObject *args)
     2812connFileno(connObject *self, PyObject *noargs)
    29102813{
    29112814        if (!self->cnx)
    29122815        {
    29132816                PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    2914                 return NULL;
    2915         }
    2916 
    2917         /* checks args */
    2918         if (!PyArg_ParseTuple(args, ""))
    2919         {
    2920                 PyErr_SetString(PyExc_TypeError,
    2921                         "Method fileno() takes no arguments");
    29222817                return NULL;
    29232818        }
     
    29352830
    29362831static PyObject *
    2937 connSetCastHook(connObject * self, PyObject * args)
     2832connSetCastHook(connObject *self, PyObject *func)
    29382833{
    29392834        PyObject *ret = NULL;
    2940         PyObject *func;
    2941 
    2942         if (PyArg_ParseTuple(args, "O", &func))
    2943         {
    2944                 if (func == Py_None)
    2945                 {
    2946                         Py_XDECREF(self->cast_hook);
    2947                         self->cast_hook = NULL;
    2948                         Py_INCREF(Py_None); ret = Py_None;
    2949                 }
    2950                 else if (PyCallable_Check(func))
    2951                 {
    2952                         Py_XINCREF(func); Py_XDECREF(self->cast_hook);
    2953                         self->cast_hook = func;
    2954                         Py_INCREF(Py_None); ret = Py_None;
    2955                 }
    2956                 else
    2957                         PyErr_SetString(PyExc_TypeError,
    2958                                 "Method set_cast_hook() expects"
    2959                                  " a callable or None as argument");
    2960         }
     2835
     2836        if (func == Py_None)
     2837        {
     2838                Py_XDECREF(self->cast_hook);
     2839                self->cast_hook = NULL;
     2840                Py_INCREF(Py_None); ret = Py_None;
     2841        }
     2842        else if (PyCallable_Check(func))
     2843        {
     2844                Py_XINCREF(func); Py_XDECREF(self->cast_hook);
     2845                self->cast_hook = func;
     2846                Py_INCREF(Py_None); ret = Py_None;
     2847        }
     2848        else
     2849                PyErr_SetString(PyExc_TypeError,
     2850                        "Method set_cast_hook() expects"
     2851                         " a callable or None as argument");
     2852
    29612853        return ret;
    29622854}
     
    29672859
    29682860static PyObject *
    2969 connGetCastHook(connObject * self, PyObject * args)
    2970 {
    2971         PyObject *ret = NULL;
    2972 
    2973         if (PyArg_ParseTuple(args, ""))
    2974         {
    2975                 ret = self->cast_hook;
    2976                 if (!ret)
    2977                         ret = Py_None;
    2978                 Py_INCREF(ret);
    2979         }
    2980         else
    2981                 PyErr_SetString(PyExc_TypeError,
    2982                         "Method get_cast_hook() takes no arguments");
     2861connGetCastHook(connObject *self, PyObject *noargs)
     2862{
     2863        PyObject *ret = self->cast_hook;;
     2864
     2865        if (!ret)
     2866                ret = Py_None;
     2867        Py_INCREF(ret);
    29832868
    29842869        return ret;
     
    29902875
    29912876static PyObject *
    2992 connSetNoticeReceiver(connObject * self, PyObject * args)
     2877connSetNoticeReceiver(connObject *self, PyObject *func)
    29932878{
    29942879        PyObject *ret = NULL;
    2995         PyObject *func;
    2996 
    2997         if (PyArg_ParseTuple(args, "O", &func))
    2998         {
    2999                 if (func == Py_None)
    3000                 {
    3001                         Py_XDECREF(self->notice_receiver);
    3002                         self->notice_receiver = NULL;
    3003                         Py_INCREF(Py_None); ret = Py_None;
    3004                 }
    3005                 else if (PyCallable_Check(func))
    3006                 {
    3007                         Py_XINCREF(func); Py_XDECREF(self->notice_receiver);
    3008                         self->notice_receiver = func;
    3009                         PQsetNoticeReceiver(self->cnx, notice_receiver, self);
    3010                         Py_INCREF(Py_None); ret = Py_None;
    3011                 }
    3012                 else
    3013                         PyErr_SetString(PyExc_TypeError,
    3014                                 "Method set_notice_receiver() expects"
    3015                                  " a callable or None as argument");
    3016         }
     2880
     2881        if (func == Py_None)
     2882        {
     2883                Py_XDECREF(self->notice_receiver);
     2884                self->notice_receiver = NULL;
     2885                Py_INCREF(Py_None); ret = Py_None;
     2886        }
     2887        else if (PyCallable_Check(func))
     2888        {
     2889                Py_XINCREF(func); Py_XDECREF(self->notice_receiver);
     2890                self->notice_receiver = func;
     2891                PQsetNoticeReceiver(self->cnx, notice_receiver, self);
     2892                Py_INCREF(Py_None); ret = Py_None;
     2893        }
     2894        else
     2895                PyErr_SetString(PyExc_TypeError,
     2896                        "Method set_notice_receiver() expects"
     2897                         " a callable or None as argument");
     2898
    30172899        return ret;
    30182900}
     
    30232905
    30242906static PyObject *
    3025 connGetNoticeReceiver(connObject * self, PyObject * args)
    3026 {
    3027         PyObject *ret = NULL;
    3028 
    3029         if (PyArg_ParseTuple(args, ""))
    3030         {
    3031                 ret = self->notice_receiver;
    3032                 if (!ret)
    3033                         ret = Py_None;
    3034                 Py_INCREF(ret);
    3035         }
    3036         else
    3037                 PyErr_SetString(PyExc_TypeError,
    3038                         "Method get_notice_receiver() takes no arguments");
     2907connGetNoticeReceiver(connObject *self, PyObject *noargs)
     2908{
     2909        PyObject *ret = self->notice_receiver;
     2910
     2911        if (!ret)
     2912                ret = Py_None;
     2913        Py_INCREF(ret);
    30392914
    30402915        return ret;
     
    30482923
    30492924static PyObject *
    3050 connClose(connObject *self, PyObject *args)
    3051 {
    3052         /* gets args */
    3053         if (!PyArg_ParseTuple(args, ""))
    3054         {
    3055                 PyErr_SetString(PyExc_TypeError, "close()");
    3056                 return NULL;
    3057         }
    3058 
     2925connClose(connObject *self, PyObject *noargs)
     2926{
    30592927        /* connection object cannot already be closed */
    30602928        if (!self->cnx)
     
    30782946
    30792947static PyObject *
    3080 connGetNotify(connObject *self, PyObject *args)
     2948connGetNotify(connObject *self, PyObject *noargs)
    30812949{
    30822950        PGnotify   *notify;
     
    30852953        {
    30862954                PyErr_SetString(PyExc_TypeError, "Connection is not valid");
    3087                 return NULL;
    3088         }
    3089 
    3090         /* checks args */
    3091         if (!PyArg_ParseTuple(args, ""))
    3092         {
    3093                 PyErr_SetString(PyExc_TypeError,
    3094                         "Method getnotify() takes no arguments");
    30952955                return NULL;
    30962956        }
     
    31423002/* get the list of connection attributes */
    31433003static PyObject *
    3144 connDir(connObject *self)
     3004connDir(connObject *self, PyObject *noargs)
    31453005{
    31463006        PyObject *attrs;
     
    31583018        {"__dir__", (PyCFunction) connDir,  METH_NOARGS, NULL},
    31593019
    3160         {"source", (PyCFunction) connSource, METH_VARARGS, connSource__doc__},
     3020        {"source", (PyCFunction) connSource, METH_NOARGS, connSource__doc__},
    31613021        {"query", (PyCFunction) connQuery, METH_VARARGS, connQuery__doc__},
    3162         {"reset", (PyCFunction) connReset, METH_VARARGS, connReset__doc__},
    3163         {"cancel", (PyCFunction) connCancel, METH_VARARGS, connCancel__doc__},
    3164         {"close", (PyCFunction) connClose, METH_VARARGS, connClose__doc__},
    3165         {"fileno", (PyCFunction) connFileno, METH_VARARGS, connFileno__doc__},
    3166         {"get_cast_hook", (PyCFunction) connGetCastHook, METH_VARARGS,
     3022        {"reset", (PyCFunction) connReset, METH_NOARGS, connReset__doc__},
     3023        {"cancel", (PyCFunction) connCancel, METH_NOARGS, connCancel__doc__},
     3024        {"close", (PyCFunction) connClose, METH_NOARGS, connClose__doc__},
     3025        {"fileno", (PyCFunction) connFileno, METH_NOARGS, connFileno__doc__},
     3026        {"get_cast_hook", (PyCFunction) connGetCastHook, METH_NOARGS,
    31673027                        connGetCastHook__doc__},
    3168         {"set_cast_hook", (PyCFunction) connSetCastHook, METH_VARARGS,
     3028        {"set_cast_hook", (PyCFunction) connSetCastHook, METH_O,
    31693029                        connSetCastHook__doc__},
    3170         {"get_notice_receiver", (PyCFunction) connGetNoticeReceiver, METH_VARARGS,
     3030        {"get_notice_receiver", (PyCFunction) connGetNoticeReceiver, METH_NOARGS,
    31713031                        connGetNoticeReceiver__doc__},
    3172         {"set_notice_receiver", (PyCFunction) connSetNoticeReceiver, METH_VARARGS,
     3032        {"set_notice_receiver", (PyCFunction) connSetNoticeReceiver, METH_O,
    31733033                        connSetNoticeReceiver__doc__},
    3174         {"getnotify", (PyCFunction) connGetNotify, METH_VARARGS,
     3034        {"getnotify", (PyCFunction) connGetNotify, METH_NOARGS,
    31753035                        connGetNotify__doc__},
    31763036        {"inserttable", (PyCFunction) connInsertTable, METH_VARARGS,
    31773037                        connInsertTable__doc__},
    3178         {"transaction", (PyCFunction) connTransaction, METH_VARARGS,
     3038        {"transaction", (PyCFunction) connTransaction, METH_NOARGS,
    31793039                        connTransaction__doc__},
    31803040        {"parameter", (PyCFunction) connParameter, METH_VARARGS,
     
    31823042
    31833043#ifdef ESCAPING_FUNCS
    3184         {"escape_literal", (PyCFunction) connEscapeLiteral, METH_VARARGS,
     3044        {"escape_literal", (PyCFunction) connEscapeLiteral, METH_O,
    31853045                        connEscapeLiteral__doc__},
    3186         {"escape_identifier", (PyCFunction) connEscapeIdentifier, METH_VARARGS,
     3046        {"escape_identifier", (PyCFunction) connEscapeIdentifier, METH_O,
    31873047                        connEscapeIdentifier__doc__},
    31883048#endif  /* ESCAPING_FUNCS */
    3189         {"escape_string", (PyCFunction) connEscapeString, METH_VARARGS,
     3049        {"escape_string", (PyCFunction) connEscapeString, METH_O,
    31903050                        connEscapeString__doc__},
    3191         {"escape_bytea", (PyCFunction) connEscapeBytea, METH_VARARGS,
     3051        {"escape_bytea", (PyCFunction) connEscapeBytea, METH_O,
    31923052                        connEscapeBytea__doc__},
    31933053
    31943054#ifdef DIRECT_ACCESS
    31953055        {"putline", (PyCFunction) connPutLine, METH_VARARGS, connPutLine__doc__},
    3196         {"getline", (PyCFunction) connGetLine, METH_VARARGS, connGetLine__doc__},
    3197         {"endcopy", (PyCFunction) connEndCopy, METH_VARARGS, connEndCopy__doc__},
     3056        {"getline", (PyCFunction) connGetLine, METH_NOARGS, connGetLine__doc__},
     3057        {"endcopy", (PyCFunction) connEndCopy, METH_NOARGS, connEndCopy__doc__},
    31983058#endif /* DIRECT_ACCESS */
    31993059
     
    33533213
    33543214static PyObject *
    3355 sourceClose(sourceObject *self, PyObject *args)
    3356 {
    3357         /* checks args */
    3358         if (!PyArg_ParseTuple(args, ""))
    3359         {
    3360                 PyErr_SetString(PyExc_TypeError, "Method close() takes no arguments");
    3361                 return NULL;
    3362         }
    3363 
     3215sourceClose(sourceObject *self, PyObject *noargs)
     3216{
    33643217        /* frees result if necessary and invalidates object */
    33653218        if (self->result)
     
    33853238
    33863239static PyObject *
    3387 sourceExecute(sourceObject *self, PyObject *args)
    3388 {
    3389         PyObject        *query_obj;
    3390         char            *query;
     3240sourceExecute(sourceObject *self, PyObject *sql)
     3241{
     3242        PyObject   *tmp_obj = NULL; /* auxiliary string object */
     3243        char       *query;
    33913244        int                     encoding;
    33923245
     
    33993252                return NULL;
    34003253
    3401         /* get query args */
    3402         if (!PyArg_ParseTuple(args, "O", &query_obj))
    3403         {
    3404                 return NULL;
    3405         }
    3406 
    34073254        encoding = PQclientEncoding(self->pgcnx->cnx);
    34083255
    3409         if (PyBytes_Check(query_obj))
    3410         {
    3411                 query = PyBytes_AsString(query_obj);
    3412                 query_obj = NULL;
    3413         }
    3414         else if (PyUnicode_Check(query_obj))
    3415         {
    3416                 query_obj = get_encoded_string(query_obj, encoding);
    3417                 if (!query_obj) return NULL; /* pass the UnicodeEncodeError */
    3418                 query = PyBytes_AsString(query_obj);
     3256        if (PyBytes_Check(sql))
     3257        {
     3258                query = PyBytes_AsString(sql);
     3259        }
     3260        else if (PyUnicode_Check(sql))
     3261        {
     3262                tmp_obj = get_encoded_string(sql, encoding);
     3263                if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     3264                query = PyBytes_AsString(tmp_obj);
    34193265        }
    34203266        else
     
    34413287        Py_END_ALLOW_THREADS
    34423288
    3443         /* we don't need the query any more */
    3444         Py_XDECREF(query_obj);
     3289        /* we don't need the auxiliary string any more */
     3290        Py_XDECREF(tmp_obj);
    34453291
    34463292        /* checks result validity */
     
    35043350
    35053351static PyObject *
    3506 sourceStatusOID(sourceObject *self, PyObject *args)
     3352sourceStatusOID(sourceObject *self, PyObject *noargs)
    35073353{
    35083354        Oid                     oid;
     
    35113357        if (!check_source_obj(self, CHECK_RESULT))
    35123358                return NULL;
    3513 
    3514         /* checks args */
    3515         if (args && !PyArg_ParseTuple(args, ""))
    3516         {
    3517                 PyErr_SetString(PyExc_TypeError,
    3518                         "Method oidstatus() takes no arguments");
    3519                 return NULL;
    3520         }
    35213359
    35223360        /* retrieves oid status */
     
    36233461/* changes current row (internal wrapper for all "move" methods) */
    36243462static PyObject *
    3625 pgsource_move(sourceObject *self, PyObject *args, int move)
     3463pgsource_move(sourceObject *self, int move)
    36263464{
    36273465        /* checks validity */
    36283466        if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
    36293467                return NULL;
    3630 
    3631         /* checks args */
    3632         if (!PyArg_ParseTuple(args, ""))
    3633         {
    3634                 char            errbuf[256];
    3635                 PyOS_snprintf(errbuf, sizeof(errbuf),
    3636                         "Method %s() takes no arguments", __movename[move]);
    3637                 PyErr_SetString(PyExc_TypeError, errbuf);
    3638                 return NULL;
    3639         }
    36403468
    36413469        /* changes the current row */
     
    36673495
    36683496static PyObject *
    3669 sourceMoveFirst(sourceObject *self, PyObject *args)
    3670 {
    3671         return pgsource_move(self, args, QUERY_MOVEFIRST);
     3497sourceMoveFirst(sourceObject *self, PyObject *noargs)
     3498{
     3499        return pgsource_move(self, QUERY_MOVEFIRST);
    36723500}
    36733501
     
    36773505
    36783506static PyObject *
    3679 sourceMoveLast(sourceObject *self, PyObject *args)
    3680 {
    3681         return pgsource_move(self, args, QUERY_MOVELAST);
     3507sourceMoveLast(sourceObject *self, PyObject *noargs)
     3508{
     3509        return pgsource_move(self, QUERY_MOVELAST);
    36823510}
    36833511
     
    36873515
    36883516static PyObject *
    3689 sourceMoveNext(sourceObject *self, PyObject *args)
    3690 {
    3691         return pgsource_move(self, args, QUERY_MOVENEXT);
     3517sourceMoveNext(sourceObject *self, PyObject *noargs)
     3518{
     3519        return pgsource_move(self, QUERY_MOVENEXT);
    36923520}
    36933521
     
    36973525
    36983526static PyObject *
    3699 sourceMovePrev(sourceObject *self, PyObject *args)
    3700 {
    3701         return pgsource_move(self, args, QUERY_MOVEPREV);
     3527sourceMovePrev(sourceObject *self, PyObject *noargs)
     3528{
     3529        return pgsource_move(self, QUERY_MOVEPREV);
    37023530}
    37033531
    37043532/* put copy data */
    37053533static char sourcePutData__doc__[] =
    3706 "getdata(buffer) -- send data to server during copy from stdin";
    3707 
    3708 static PyObject *
    3709 sourcePutData(sourceObject *self, PyObject *args)
    3710 {
    3711         PyObject   *buffer_obj; /* the buffer object that was passed in */
    3712         char       *buffer; /* the buffer as encoded string */
     3534"putdata(buffer) -- send data to server during copy from stdin";
     3535
     3536static PyObject *
     3537sourcePutData(sourceObject *self, PyObject *buffer)
     3538{
     3539        PyObject   *tmp_obj = NULL; /* an auxiliary object */
     3540        char       *buf; /* the buffer as encoded string */
    37133541        Py_ssize_t      nbytes; /* length of string */
    37143542        char       *errormsg = NULL; /* error message */
     
    37243552                return NULL;
    37253553
    3726         if (!PyArg_ParseTuple(args, "O", &buffer_obj))
    3727                 return NULL;
    3728 
    3729         if (buffer_obj == Py_None)
     3554        if (buffer == Py_None)
    37303555        {
    37313556                /* pass None for terminating the operation */
    3732                 buffer = errormsg = NULL;
    3733                 buffer_obj = NULL;
    3734         }
    3735         else if (PyBytes_Check(buffer_obj))
     3557                buf = errormsg = NULL;
     3558        }
     3559        else if (PyBytes_Check(buffer))
    37363560        {
    37373561                /* or pass a byte string */
    3738                 PyBytes_AsStringAndSize(buffer_obj, &buffer, &nbytes);
    3739                 buffer_obj = NULL;
    3740         }
    3741         else if (PyUnicode_Check(buffer_obj))
     3562                PyBytes_AsStringAndSize(buffer, &buf, &nbytes);
     3563        }
     3564        else if (PyUnicode_Check(buffer))
    37423565        {
    37433566                /* or pass a unicode string */
    3744                 buffer_obj = get_encoded_string(
    3745                         buffer_obj, PQclientEncoding(self->pgcnx->cnx));
    3746                 if (!buffer_obj) return NULL; /* pass the UnicodeEncodeError */
    3747                 PyBytes_AsStringAndSize(buffer_obj, &buffer, &nbytes);
    3748         }
    3749         else if (PyErr_GivenExceptionMatches(buffer_obj, PyExc_BaseException))
     3567                tmp_obj = get_encoded_string(
     3568                        buffer, PQclientEncoding(self->pgcnx->cnx));
     3569                if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     3570                PyBytes_AsStringAndSize(tmp_obj, &buf, &nbytes);
     3571        }
     3572        else if (PyErr_GivenExceptionMatches(buffer, PyExc_BaseException))
    37503573        {
    37513574                /* or pass a Python exception for sending an error message */
    3752                 buffer_obj = PyObject_Str(buffer_obj);
    3753                 if (PyUnicode_Check(buffer_obj))
    3754                 {
    3755                         PyObject *obj = buffer_obj;
    3756                         buffer_obj = get_encoded_string(
     3575                tmp_obj = PyObject_Str(buffer);
     3576                if (PyUnicode_Check(tmp_obj))
     3577                {
     3578                        PyObject *obj = tmp_obj;
     3579                        tmp_obj = get_encoded_string(
    37573580                                obj, PQclientEncoding(self->pgcnx->cnx));
    37583581                        Py_DECREF(obj);
    3759                         if (!buffer_obj) return NULL; /* pass the UnicodeEncodeError */
    3760                 }
    3761                 errormsg = PyBytes_AsString(buffer_obj);
    3762                 buffer = NULL;
     3582                        if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     3583                }
     3584                errormsg = PyBytes_AsString(tmp_obj);
     3585                buf = NULL;
    37633586        }
    37643587        else
     
    37773600                PyErr_SetString(PyExc_IOError,
    37783601                        "Connection is invalid or not in copy_in state");
    3779                 Py_XDECREF(buffer_obj);
    3780                 return NULL;
    3781         }
    3782 
    3783         if (buffer)
    3784         {
    3785                 res = nbytes ? PQputCopyData(self->pgcnx->cnx, buffer, (int)nbytes) : 1;
     3602                Py_XDECREF(tmp_obj);
     3603                return NULL;
     3604        }
     3605
     3606        if (buf)
     3607        {
     3608                res = nbytes ? PQputCopyData(self->pgcnx->cnx, buf, (int)nbytes) : 1;
    37863609        }
    37873610        else
     
    37903613        }
    37913614
    3792         Py_XDECREF(buffer_obj);
     3615        Py_XDECREF(tmp_obj);
    37933616
    37943617        if (res != 1)
     
    37983621        }
    37993622
    3800         if (buffer) /* buffer has been sent */
     3623        if (buf) /* buffer has been sent */
    38013624        {
    38023625                ret = Py_None;
     
    39753798
    39763799static PyObject *
    3977 sourceListInfo(sourceObject *self, PyObject *args)
     3800sourceListInfo(sourceObject *self, PyObject *noargs)
    39783801{
    39793802        int                     i;
     
    39853808                return NULL;
    39863809
    3987         /* gets args */
    3988         if (!PyArg_ParseTuple(args, ""))
    3989         {
    3990                 PyErr_SetString(PyExc_TypeError,
    3991                         "Method listinfo() takes no arguments");
    3992                 return NULL;
    3993         }
    3994 
    39953810        /* builds result */
    39963811        if (!(result = PyTuple_New(self->num_fields)))
     
    40173832
    40183833static PyObject *
    4019 sourceFieldInfo(sourceObject *self, PyObject *args)
    4020 {
    4021         static const char short_usage[] =
    4022         "fieldinfo(desc), with desc (string|integer)";
     3834sourceFieldInfo(sourceObject *self, PyObject *desc)
     3835{
    40233836        int                     num;
    4024         PyObject   *param;
    4025 
    4026         /* gets args */
    4027         if (!PyArg_ParseTuple(args, "O", &param))
    4028         {
    4029                 PyErr_SetString(PyExc_TypeError, short_usage);
    4030                 return NULL;
    4031         }
    40323837
    40333838        /* checks args and validity */
    4034         if ((num = sourceFieldindex(self, param, short_usage)) == -1)
     3839        if ((num = sourceFieldindex(self, desc,
     3840                        "Method fieldinfo() needs a string or integer as argument")) == -1)
    40353841                return NULL;
    40363842
     
    40443850
    40453851static PyObject *
    4046 sourceField(sourceObject *self, PyObject *args)
    4047 {
    4048         static const char short_usage[] =
    4049         "field(desc), with desc (string|integer)";
     3852sourceField(sourceObject *self, PyObject *desc)
     3853{
    40503854        int                     num;
    4051         PyObject   *param;
    4052 
    4053         /* gets args */
    4054         if (!PyArg_ParseTuple(args, "O", &param))
    4055         {
    4056                 PyErr_SetString(PyExc_TypeError, short_usage);
    4057                 return NULL;
    4058         }
    40593855
    40603856        /* checks args and validity */
    4061         if ((num = sourceFieldindex(self, param, short_usage)) == -1)
    4062                 return NULL;
    4063 
    4064         return PyStr_FromString(PQgetvalue(self->result,
    4065                                                                         self->current_row, num));
     3857        if ((num = sourceFieldindex(self, desc,
     3858                        "Method field() needs a string or integer as argument")) == -1)
     3859                return NULL;
     3860
     3861        return PyStr_FromString(
     3862                PQgetvalue(self->result, self->current_row, num));
    40663863}
    40673864
    40683865/* get the list of source object attributes */
    40693866static PyObject *
    4070 sourceDir(connObject *self)
     3867sourceDir(connObject *self, PyObject *noargs)
    40713868{
    40723869        PyObject *attrs;
     
    40823879static PyMethodDef sourceMethods[] = {
    40833880        {"__dir__", (PyCFunction) sourceDir,  METH_NOARGS, NULL},
    4084         {"close", (PyCFunction) sourceClose, METH_VARARGS,
    4085                         sourceClose__doc__},
    4086         {"execute", (PyCFunction) sourceExecute, METH_VARARGS,
    4087                         sourceExecute__doc__},
    4088         {"oidstatus", (PyCFunction) sourceStatusOID, METH_VARARGS,
     3881        {"close", (PyCFunction) sourceClose, METH_NOARGS, sourceClose__doc__},
     3882        {"execute", (PyCFunction) sourceExecute, METH_O, sourceExecute__doc__},
     3883        {"oidstatus", (PyCFunction) sourceStatusOID, METH_NOARGS,
    40893884                        sourceStatusOID__doc__},
    40903885        {"fetch", (PyCFunction) sourceFetch, METH_VARARGS,
    40913886                        sourceFetch__doc__},
    4092         {"movefirst", (PyCFunction) sourceMoveFirst, METH_VARARGS,
     3887        {"movefirst", (PyCFunction) sourceMoveFirst, METH_NOARGS,
    40933888                        sourceMoveFirst__doc__},
    4094         {"movelast", (PyCFunction) sourceMoveLast, METH_VARARGS,
     3889        {"movelast", (PyCFunction) sourceMoveLast, METH_NOARGS,
    40953890                        sourceMoveLast__doc__},
    4096         {"movenext", (PyCFunction) sourceMoveNext, METH_VARARGS,
     3891        {"movenext", (PyCFunction) sourceMoveNext, METH_NOARGS,
    40973892                        sourceMoveNext__doc__},
    4098         {"moveprev", (PyCFunction) sourceMovePrev, METH_VARARGS,
     3893        {"moveprev", (PyCFunction) sourceMovePrev, METH_NOARGS,
    40993894                        sourceMovePrev__doc__},
    4100         {"putdata", (PyCFunction) sourcePutData, METH_VARARGS,
    4101                         sourcePutData__doc__},
     3895        {"putdata", (PyCFunction) sourcePutData, METH_O, sourcePutData__doc__},
    41023896        {"getdata", (PyCFunction) sourceGetData, METH_VARARGS,
    41033897                        sourceGetData__doc__},
    4104         {"field", (PyCFunction) sourceField, METH_VARARGS,
     3898        {"field", (PyCFunction) sourceField, METH_O,
    41053899                        sourceField__doc__},
    4106         {"fieldinfo", (PyCFunction) sourceFieldInfo, METH_VARARGS,
     3900        {"fieldinfo", (PyCFunction) sourceFieldInfo, METH_O,
    41073901                        sourceFieldInfo__doc__},
    4108         {"listinfo", (PyCFunction) sourceListInfo, METH_VARARGS,
     3902        {"listinfo", (PyCFunction) sourceListInfo, METH_NOARGS,
    41093903                        sourceListInfo__doc__},
    41103904        {NULL, NULL}
     
    43244118
    43254119static PyObject *
    4326 queryNTuples(queryObject *self, PyObject *args)
    4327 {
    4328         /* checks args */
    4329         if (!PyArg_ParseTuple(args, ""))
    4330         {
    4331                 PyErr_SetString(PyExc_TypeError,
    4332                         "Method ntuples() takes no arguments");
    4333                 return NULL;
    4334         }
    4335 
     4120queryNTuples(queryObject *self, PyObject *noargs)
     4121{
    43364122        return PyInt_FromLong((long) PQntuples(self->result));
    43374123}
     
    43424128
    43434129static PyObject *
    4344 queryListFields(queryObject *self, PyObject *args)
     4130queryListFields(queryObject *self, PyObject *noargs)
    43454131{
    43464132        int                     i,
     
    43504136                           *str;
    43514137
    4352         /* checks args */
    4353         if (!PyArg_ParseTuple(args, ""))
    4354         {
    4355                 PyErr_SetString(PyExc_TypeError,
    4356                         "Method listfields() takes no arguments");
    4357                 return NULL;
    4358         }
    4359 
    43604138        /* builds tuple */
    43614139        n = PQnfields(self->result);
     
    43864164        {
    43874165                PyErr_SetString(PyExc_TypeError,
    4388                         "fieldname(number), with number(integer)");
     4166                        "Method fieldname() takes an integer as argument");
    43894167                return NULL;
    43904168        }
     
    44154193        if (!PyArg_ParseTuple(args, "s", &name))
    44164194        {
    4417                 PyErr_SetString(PyExc_TypeError, "fieldnum(name), with name (string)");
     4195                PyErr_SetString(PyExc_TypeError,
     4196                        "Method fieldnum() takes a string as argument");
    44184197                return NULL;
    44194198        }
     
    44364215
    44374216static PyObject *
    4438 queryGetResult(queryObject *self, PyObject *args)
     4217queryGetResult(queryObject *self, PyObject *noargs)
    44394218{
    44404219        PyObject   *reslist;
    44414220        int                     i, m, n, *col_types;
    44424221        int                     encoding = self->encoding;
    4443 
    4444         /* checks args (args == NULL for an internal call) */
    4445         if (args && !PyArg_ParseTuple(args, ""))
    4446         {
    4447                 PyErr_SetString(PyExc_TypeError,
    4448                         "Method getresult() takes no arguments");
    4449                 return NULL;
    4450         }
    44514222
    44524223        /* stores result in tuple */
     
    45304301
    45314302static PyObject *
    4532 queryDictResult(queryObject *self, PyObject *args)
     4303queryDictResult(queryObject *self, PyObject *noargs)
    45334304{
    45344305        PyObject   *reslist;
     
    45384309                           *col_types;
    45394310        int                     encoding = self->encoding;
    4540 
    4541         /* checks args (args == NULL for an internal call) */
    4542         if (args && !PyArg_ParseTuple(args, ""))
    4543         {
    4544                 PyErr_SetString(PyExc_TypeError,
    4545                         "Method dictresult() takes no arguments");
    4546                 return NULL;
    4547         }
    45484311
    45494312        /* stores result in list */
     
    46284391
    46294392static PyObject *
    4630 queryNamedResult(queryObject *self, PyObject *args)
     4393queryNamedResult(queryObject *self, PyObject *noargs)
    46314394{
    46324395        PyObject   *ret;
     
    46344397        if (namedresult)
    46354398        {
    4636                 /* checks args (args == NULL for an internal call) */
    4637                 if (args && !PyArg_ParseTuple(args, ""))
    4638                 {
    4639                         PyErr_SetString(PyExc_TypeError,
    4640                                 "Method namedresult() takes no arguments");
    4641                         return NULL;
    4642                 }
    4643 
    46444399                ret = PyObject_CallFunction(namedresult, "(O)", self);
    46454400
     
    46494404        else
    46504405        {
    4651                 ret = queryGetResult(self, args);
     4406                ret = queryGetResult(self, NULL);
    46524407        }
    46534408
     
    47214476/* get the list of notice attributes */
    47224477static PyObject *
    4723 noticeDir(noticeObject *self)
     4478noticeDir(noticeObject *self, PyObject *noargs)
    47244479{
    47254480        PyObject *attrs;
     
    47734528/* query object methods */
    47744529static struct PyMethodDef queryMethods[] = {
    4775         {"getresult", (PyCFunction) queryGetResult, METH_VARARGS,
     4530        {"getresult", (PyCFunction) queryGetResult, METH_NOARGS,
    47764531                        queryGetResult__doc__},
    4777         {"dictresult", (PyCFunction) queryDictResult, METH_VARARGS,
     4532        {"dictresult", (PyCFunction) queryDictResult, METH_NOARGS,
    47784533                        queryDictResult__doc__},
    4779         {"namedresult", (PyCFunction) queryNamedResult, METH_VARARGS,
     4534        {"namedresult", (PyCFunction) queryNamedResult, METH_NOARGS,
    47804535                        queryNamedResult__doc__},
    47814536        {"fieldname", (PyCFunction) queryFieldName, METH_VARARGS,
     
    47834538        {"fieldnum", (PyCFunction) queryFieldNumber, METH_VARARGS,
    47844539                        queryFieldNumber__doc__},
    4785         {"listfields", (PyCFunction) queryListFields, METH_VARARGS,
     4540        {"listfields", (PyCFunction) queryListFields, METH_NOARGS,
    47864541                        queryListFields__doc__},
    4787         {"ntuples", (PyCFunction) queryNTuples, METH_VARARGS,
     4542        {"ntuples", (PyCFunction) queryNTuples, METH_NOARGS,
    47884543                        queryNTuples__doc__},
    47894544        {NULL, NULL}
     
    48324587
    48334588static PyObject *
    4834 pgEscapeString(PyObject *self, PyObject *args)
    4835 {
    4836         PyObject   *from_obj, /* the object that was passed in */
     4589pgEscapeString(PyObject *self, PyObject *string)
     4590{
     4591        PyObject   *tmp_obj = NULL, /* auxiliary string object */
    48374592                           *to_obj; /* string object to return */
    48384593        char       *from, /* our string argument as encoded string */
     
    48424597        int                     encoding = -1; /* client encoding */
    48434598
    4844         if (!PyArg_ParseTuple(args, "O", &from_obj))
    4845                 return NULL;
    4846 
    4847         if (PyBytes_Check(from_obj))
    4848         {
    4849                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
    4850                 from_obj = NULL;
    4851         }
    4852         else if (PyUnicode_Check(from_obj))
     4599        if (PyBytes_Check(string))
     4600        {
     4601                PyBytes_AsStringAndSize(string, &from, &from_length);
     4602        }
     4603        else if (PyUnicode_Check(string))
    48534604        {
    48544605                encoding = pg_encoding_ascii;
    4855                 from_obj = get_encoded_string(from_obj, encoding);
    4856                 if (!from_obj) return NULL; /* pass the UnicodeEncodeError */
    4857                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
     4606                tmp_obj = get_encoded_string(string, encoding);
     4607                if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     4608                PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    48584609        }
    48594610        else
     
    48734624        to_length = (int)PQescapeString(to, from, (size_t)from_length);
    48744625
    4875         Py_XDECREF(from_obj);
     4626        Py_XDECREF(tmp_obj);
    48764627
    48774628        if (encoding == -1)
     
    48884639
    48894640static PyObject *
    4890 pgEscapeBytea(PyObject *self, PyObject *args)
    4891 {
    4892         PyObject   *from_obj, /* the object that was passed in */
     4641pgEscapeBytea(PyObject *self, PyObject *data)
     4642{
     4643        PyObject   *tmp_obj = NULL, /* auxiliary string object */
    48934644                           *to_obj; /* string object to return */
    48944645        char       *from, /* our string argument as encoded string */
     
    48984649        int                     encoding = -1; /* client encoding */
    48994650
    4900         if (!PyArg_ParseTuple(args, "O", &from_obj))
    4901                 return NULL;
    4902 
    4903         if (PyBytes_Check(from_obj))
    4904         {
    4905                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
    4906                 from_obj = NULL;
    4907         }
    4908         else if (PyUnicode_Check(from_obj))
     4651        if (PyBytes_Check(data))
     4652        {
     4653                PyBytes_AsStringAndSize(data, &from, &from_length);
     4654        }
     4655        else if (PyUnicode_Check(data))
    49094656        {
    49104657                encoding = pg_encoding_ascii;
    4911                 from_obj = get_encoded_string(from_obj, encoding);
    4912                 if (!from_obj) return NULL; /* pass the UnicodeEncodeError */
    4913                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
     4658                tmp_obj = get_encoded_string(data, encoding);
     4659                if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     4660                PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    49144661        }
    49154662        else
     
    49234670                (unsigned char*)from, (size_t)from_length, &to_length);
    49244671
    4925         Py_XDECREF(from_obj);
     4672        Py_XDECREF(tmp_obj);
    49264673
    49274674        if (encoding == -1)
     
    49384685"unescape_bytea(string) -- unescape bytea data retrieved as text";
    49394686
    4940 static PyObject
    4941 *pgUnescapeBytea(PyObject *self, PyObject *args)
    4942 {
    4943         PyObject   *from_obj, /* the object that was passed in */
     4687static PyObject *
     4688pgUnescapeBytea(PyObject *self, PyObject *data)
     4689{
     4690        PyObject   *tmp_obj = NULL, /* auxiliary string object */
    49444691                           *to_obj; /* string object to return */
    49454692        char       *from, /* our string argument as encoded string */
     
    49484695        size_t          to_length; /* length of result */
    49494696
    4950         if (!PyArg_ParseTuple(args, "O", &from_obj))
    4951                 return NULL;
    4952 
    4953         if (PyBytes_Check(from_obj))
    4954         {
    4955                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
    4956                 from_obj = NULL;
    4957         }
    4958         else if (PyUnicode_Check(from_obj))
    4959         {
    4960                 from_obj = get_encoded_string(from_obj, pg_encoding_ascii);
    4961                 if (!from_obj) return NULL; /* pass the UnicodeEncodeError */
    4962                 PyBytes_AsStringAndSize(from_obj, &from, &from_length);
     4697        if (PyBytes_Check(data))
     4698        {
     4699                PyBytes_AsStringAndSize(data, &from, &from_length);
     4700        }
     4701        else if (PyUnicode_Check(data))
     4702        {
     4703                tmp_obj = get_encoded_string(data, pg_encoding_ascii);
     4704                if (!tmp_obj) return NULL; /* pass the UnicodeEncodeError */
     4705                PyBytes_AsStringAndSize(tmp_obj, &from, &from_length);
    49634706        }
    49644707        else
     
    49714714        to = (char *)PQunescapeBytea((unsigned char*)from, &to_length);
    49724715
    4973         Py_XDECREF(from_obj);
     4716        Py_XDECREF(tmp_obj);
    49744717
    49754718        if (!to) return PyErr_NoMemory();
     
    49864729
    49874730static PyObject *
    4988 pgGetDecimalPoint(PyObject *self, PyObject * args)
    4989 {
    4990         PyObject *ret = NULL;
     4731pgGetDecimalPoint(PyObject *self, PyObject *noargs)
     4732{
     4733        PyObject *ret;
    49914734        char s[2];
    49924735
    4993         if (PyArg_ParseTuple(args, ""))
    4994         {
    4995                 if (decimal_point)
    4996                 {
    4997                         s[0] = decimal_point; s[1] = '\0';
    4998                         ret = PyStr_FromString(s);
    4999                 }
    5000                 else
    5001                 {
    5002                         Py_INCREF(Py_None); ret = Py_None;
    5003                 }
     4736        if (decimal_point)
     4737        {
     4738                s[0] = decimal_point; s[1] = '\0';
     4739                ret = PyStr_FromString(s);
    50044740        }
    50054741        else
    5006                 PyErr_SetString(PyExc_TypeError,
    5007                         "Function get_decimal_point() takes no arguments");
     4742        {
     4743                Py_INCREF(Py_None); ret = Py_None;
     4744        }
    50084745
    50094746        return ret;
     
    50154752
    50164753static PyObject *
    5017 pgSetDecimalPoint(PyObject *self, PyObject * args)
     4754pgSetDecimalPoint(PyObject *self, PyObject *args)
    50184755{
    50194756        PyObject *ret = NULL;
     
    50474784
    50484785static PyObject *
    5049 pgGetDecimal(PyObject *self, PyObject *args)
    5050 {
    5051         PyObject *ret = NULL;
    5052 
    5053         if (PyArg_ParseTuple(args, ""))
    5054         {
    5055                 ret = decimal ? decimal : Py_None;
    5056                 Py_INCREF(ret);
    5057         }
    5058         else
    5059                 PyErr_SetString(PyExc_TypeError,
    5060                         "Function get_decimal() takes no arguments");
     4786pgGetDecimal(PyObject *self, PyObject *noargs)
     4787{
     4788        PyObject *ret;
     4789
     4790        ret = decimal ? decimal : Py_None;
     4791        Py_INCREF(ret);
    50614792
    50624793        return ret;
     
    50994830
    51004831static PyObject *
    5101 pgGetBool(PyObject *self, PyObject * args)
    5102 {
    5103         PyObject *ret = NULL;
    5104 
    5105         if (PyArg_ParseTuple(args, ""))
    5106         {
    5107                 ret = bool_as_text ? Py_False : Py_True;
    5108                 Py_INCREF(ret);
    5109         }
    5110         else
    5111                 PyErr_SetString(PyExc_TypeError,
    5112                         "Function get_bool() takes no arguments");
     4832pgGetBool(PyObject *self, PyObject *noargs)
     4833{
     4834        PyObject *ret;
     4835
     4836        ret = bool_as_text ? Py_False : Py_True;
     4837        Py_INCREF(ret);
    51134838
    51144839        return ret;
     
    51204845
    51214846static PyObject *
    5122 pgSetBool(PyObject *self, PyObject * args)
     4847pgSetBool(PyObject *self, PyObject *args)
    51234848{
    51244849        PyObject *ret = NULL;
     
    51434868
    51444869static PyObject *
    5145 pgGetArray(PyObject *self, PyObject * args)
    5146 {
    5147         PyObject *ret = NULL;
    5148 
    5149         if (PyArg_ParseTuple(args, ""))
    5150         {
    5151                 ret = array_as_text ? Py_False : Py_True;
    5152                 Py_INCREF(ret);
    5153         }
    5154         else
    5155                 PyErr_SetString(PyExc_TypeError,
    5156                         "Function get_array() takes no arguments");
     4870pgGetArray(PyObject *self, PyObject *noargs)
     4871{
     4872        PyObject *ret;
     4873
     4874        ret = array_as_text ? Py_False : Py_True;
     4875        Py_INCREF(ret);
    51574876
    51584877        return ret;
     
    51644883
    51654884static PyObject *
    5166 pgSetArray(PyObject *self, PyObject * args)
     4885pgSetArray(PyObject *self, PyObject *args)
    51674886{
    51684887        PyObject *ret = NULL;
     
    51874906
    51884907static PyObject *
    5189 pgGetByteaEscaped(PyObject *self, PyObject * args)
    5190 {
    5191         PyObject *ret = NULL;
    5192 
    5193         if (PyArg_ParseTuple(args, ""))
    5194         {
    5195                 ret = bytea_escaped ? Py_True : Py_False;
    5196                 Py_INCREF(ret);
    5197         }
    5198         else
    5199                 PyErr_SetString(PyExc_TypeError,
    5200                         "Function get_bytea_escaped() takes no arguments");
     4908pgGetByteaEscaped(PyObject *self, PyObject *noargs)
     4909{
     4910        PyObject *ret;
     4911
     4912        ret = bytea_escaped ? Py_True : Py_False;
     4913        Py_INCREF(ret);
    52014914
    52024915        return ret;
     
    52084921
    52094922static PyObject *
    5210 pgSetByteaEscaped(PyObject *self, PyObject * args)
     4923pgSetByteaEscaped(PyObject *self, PyObject *args)
    52114924{
    52124925        PyObject *ret = NULL;
     
    52314944
    52324945static PyObject *
    5233 pgGetNamedresult(PyObject *self, PyObject *args)
    5234 {
    5235         PyObject *ret = NULL;
    5236 
    5237         if (PyArg_ParseTuple(args, ""))
    5238         {
    5239                 ret = namedresult ? namedresult : Py_None;
    5240                 Py_INCREF(ret);
    5241         }
    5242         else
    5243                 PyErr_SetString(PyExc_TypeError,
    5244                         "Function get_namedresult() takes no arguments");
     4946pgGetNamedresult(PyObject *self, PyObject *noargs)
     4947{
     4948        PyObject *ret;
     4949
     4950        ret = namedresult ? namedresult : Py_None;
     4951        Py_INCREF(ret);
    52454952
    52464953        return ret;
     
    52834990
    52844991static PyObject *
    5285 pgGetJsondecode(PyObject *self, PyObject *args)
    5286 {
    5287         PyObject *ret = NULL;
    5288 
    5289         if (PyArg_ParseTuple(args, ""))
    5290         {
    5291                 ret = jsondecode;
    5292                 if (!ret)
    5293                         ret = Py_None;
    5294                 Py_INCREF(ret);
    5295         }
    5296         else
    5297         {
    5298                 PyErr_SetString(PyExc_TypeError,
    5299                         "Function get_jsondecode() takes no arguments");
    5300         }
     4992pgGetJsondecode(PyObject *self, PyObject *noargs)
     4993{
     4994        PyObject *ret;
     4995
     4996        ret = jsondecode;
     4997        if (!ret)
     4998                ret = Py_None;
     4999        Py_INCREF(ret);
     5000
    53015001        return ret;
    53025002}
     
    53405040
    53415041static PyObject *
    5342 pgGetDefHost(PyObject *self, PyObject *args)
    5343 {
    5344         /* checks args */
    5345         if (!PyArg_ParseTuple(args, ""))
    5346         {
    5347                 PyErr_SetString(PyExc_TypeError,
    5348                         "Function get_defhost() takes no arguments");
    5349                 return NULL;
    5350         }
    5351 
     5042pgGetDefHost(PyObject *self, PyObject *noargs)
     5043{
    53525044        Py_XINCREF(pg_default_host);
    53535045        return pg_default_host;
     
    53915083
    53925084static PyObject *
    5393 pgGetDefBase(PyObject *self, PyObject *args)
    5394 {
    5395         /* checks args */
    5396         if (!PyArg_ParseTuple(args, ""))
    5397         {
    5398                 PyErr_SetString(PyExc_TypeError,
    5399                         "Function get_defbase() takes no arguments");
    5400                 return NULL;
    5401         }
    5402 
     5085pgGetDefBase(PyObject *self, PyObject *noargs)
     5086{
    54035087        Py_XINCREF(pg_default_base);
    54045088        return pg_default_base;
     
    54425126
    54435127static PyObject *
    5444 pgGetDefOpt(PyObject *self, PyObject *args)
    5445 {
    5446         /* checks args */
    5447         if (!PyArg_ParseTuple(args, ""))
    5448         {
    5449                 PyErr_SetString(PyExc_TypeError,
    5450                         "Function get_defopt() takes no arguments");
    5451                 return NULL;
    5452         }
    5453 
     5128pgGetDefOpt(PyObject *self, PyObject *noargs)
     5129{
    54545130        Py_XINCREF(pg_default_opt);
    54555131        return pg_default_opt;
     
    54935169
    54945170static PyObject *
    5495 pgGetDefUser(PyObject *self, PyObject *args)
    5496 {
    5497         /* checks args */
    5498         if (!PyArg_ParseTuple(args, ""))
    5499         {
    5500                 PyErr_SetString(PyExc_TypeError,
    5501                         "Function get_defuser() takes no arguments");
    5502                 return NULL;
    5503         }
    5504 
     5171pgGetDefUser(PyObject *self, PyObject *noargs)
     5172{
    55055173        Py_XINCREF(pg_default_user);
    55065174        return pg_default_user;
     
    55745242
    55755243static PyObject *
    5576 pgGetDefPort(PyObject *self, PyObject *args)
    5577 {
    5578         /* checks args */
    5579         if (!PyArg_ParseTuple(args, ""))
    5580         {
    5581                 PyErr_SetString(PyExc_TypeError,
    5582                         "Function get_defport() takes no arguments");
    5583                 return NULL;
    5584         }
    5585 
     5244pgGetDefPort(PyObject *self, PyObject *noargs)
     5245{
    55865246        Py_XINCREF(pg_default_port);
    55875247        return pg_default_port;
     
    57545414        {"connect", (PyCFunction) pgConnect, METH_VARARGS|METH_KEYWORDS,
    57555415                        pgConnect__doc__},
    5756         {"escape_string", (PyCFunction) pgEscapeString, METH_VARARGS,
     5416        {"escape_string", (PyCFunction) pgEscapeString, METH_O,
    57575417                        pgEscapeString__doc__},
    5758         {"escape_bytea", (PyCFunction) pgEscapeBytea, METH_VARARGS,
     5418        {"escape_bytea", (PyCFunction) pgEscapeBytea, METH_O,
    57595419                        pgEscapeBytea__doc__},
    5760         {"unescape_bytea", (PyCFunction) pgUnescapeBytea, METH_VARARGS,
     5420        {"unescape_bytea", (PyCFunction) pgUnescapeBytea, METH_O,
    57615421                        pgUnescapeBytea__doc__},
    5762         {"get_decimal_point", (PyCFunction) pgGetDecimalPoint, METH_VARARGS,
     5422        {"get_decimal_point", (PyCFunction) pgGetDecimalPoint, METH_NOARGS,
    57635423                        pgGetDecimalPoint__doc__},
    57645424        {"set_decimal_point", (PyCFunction) pgSetDecimalPoint, METH_VARARGS,
    57655425                        pgSetDecimalPoint__doc__},
    5766         {"get_decimal", (PyCFunction) pgGetDecimal, METH_VARARGS,
     5426        {"get_decimal", (PyCFunction) pgGetDecimal, METH_NOARGS,
    57675427                        pgGetDecimal__doc__},
    57685428        {"set_decimal", (PyCFunction) pgSetDecimal, METH_VARARGS,
    57695429                        pgSetDecimal__doc__},
    5770         {"get_bool", (PyCFunction) pgGetBool, METH_VARARGS, pgGetBool__doc__},
     5430        {"get_bool", (PyCFunction) pgGetBool, METH_NOARGS, pgGetBool__doc__},
    57715431        {"set_bool", (PyCFunction) pgSetBool, METH_VARARGS, pgSetBool__doc__},
    5772         {"get_array", (PyCFunction) pgGetArray, METH_VARARGS, pgGetArray__doc__},
     5432        {"get_array", (PyCFunction) pgGetArray, METH_NOARGS, pgGetArray__doc__},
    57735433        {"set_array", (PyCFunction) pgSetArray, METH_VARARGS, pgSetArray__doc__},
    5774         {"get_bytea_escaped", (PyCFunction) pgGetByteaEscaped, METH_VARARGS,
     5434        {"get_bytea_escaped", (PyCFunction) pgGetByteaEscaped, METH_NOARGS,
    57755435                pgGetByteaEscaped__doc__},
    57765436        {"set_bytea_escaped", (PyCFunction) pgSetByteaEscaped, METH_VARARGS,
    57775437                pgSetByteaEscaped__doc__},
    5778         {"get_namedresult", (PyCFunction) pgGetNamedresult, METH_VARARGS,
     5438        {"get_namedresult", (PyCFunction) pgGetNamedresult, METH_NOARGS,
    57795439                        pgGetNamedresult__doc__},
    57805440        {"set_namedresult", (PyCFunction) pgSetNamedresult, METH_VARARGS,
    57815441                        pgSetNamedresult__doc__},
    5782         {"get_jsondecode", (PyCFunction) pgGetJsondecode, METH_VARARGS,
     5442        {"get_jsondecode", (PyCFunction) pgGetJsondecode, METH_NOARGS,
    57835443                        pgGetJsondecode__doc__},
    57845444        {"set_jsondecode", (PyCFunction) pgSetJsondecode, METH_VARARGS,
     
    57905450
    57915451#ifdef DEFAULT_VARS
    5792         {"get_defhost", pgGetDefHost, METH_VARARGS, pgGetDefHost__doc__},
     5452        {"get_defhost", pgGetDefHost, METH_NOARGS, pgGetDefHost__doc__},
    57935453        {"set_defhost", pgSetDefHost, METH_VARARGS, pgSetDefHost__doc__},
    5794         {"get_defbase", pgGetDefBase, METH_VARARGS, pgGetDefBase__doc__},
     5454        {"get_defbase", pgGetDefBase, METH_NOARGS, pgGetDefBase__doc__},
    57955455        {"set_defbase", pgSetDefBase, METH_VARARGS, pgSetDefBase__doc__},
    5796         {"get_defopt", pgGetDefOpt, METH_VARARGS, pgGetDefOpt__doc__},
     5456        {"get_defopt", pgGetDefOpt, METH_NOARGS, pgGetDefOpt__doc__},
    57975457        {"set_defopt", pgSetDefOpt, METH_VARARGS, pgSetDefOpt__doc__},
    5798         {"get_defport", pgGetDefPort, METH_VARARGS, pgGetDefPort__doc__},
     5458        {"get_defport", pgGetDefPort, METH_NOARGS, pgGetDefPort__doc__},
    57995459        {"set_defport", pgSetDefPort, METH_VARARGS, pgSetDefPort__doc__},
    5800         {"get_defuser", pgGetDefUser, METH_VARARGS, pgGetDefUser__doc__},
     5460        {"get_defuser", pgGetDefUser, METH_NOARGS, pgGetDefUser__doc__},
    58015461        {"set_defuser", pgSetDefUser, METH_VARARGS, pgSetDefUser__doc__},
    58025462        {"set_defpasswd", pgSetDefPassword, METH_VARARGS, pgSetDefPassword__doc__},
  • trunk/tests/test_classic_connection.py

    r806 r813  
    759759            pg.set_bool(bool_enabled)
    760760        try:
    761             v_false, v_true = (False, True) if bool_enabled else 'ft'
     761            bool_on = bool_enabled or bool_enabled is None
     762            v_false, v_true = (False, True) if bool_on else 'ft'
    762763            r_false, r_true = [(v_false,)], [(v_true,)]
    763764            self.assertEqual(query("select false").getresult(), r_false)
     
    10431044                self.assertIsInstance(row[2], long)
    10441045            if row[3] is not None:  # boolean
    1045                 self.assertIsInstance(row[3], str)
    1046                 row[3] = {'f': False, 't': True}.get(row[3])
     1046                self.assertIsInstance(row[3], bool)
    10471047            if row[4] is not None:  # date
    10481048                self.assertIsInstance(row[4], str)
     
    14051405        self.c = connect()
    14061406        self.c.query("set client_encoding=utf8")
     1407        self.c.query('set bytea_output=hex')
    14071408        self.c.query("set lc_monetary='C'")
    14081409
     
    16151616        self.assertRaises(TypeError, pg.get_bool, use_bool)
    16161617        self.assertIsInstance(use_bool, bool)
    1617         self.assertIs(use_bool, False)  # the default setting
     1618        self.assertIs(use_bool, True)  # the default setting
     1619        pg.set_bool(False)
     1620        try:
     1621            r = pg.get_bool()
     1622        finally:
     1623            pg.set_bool(use_bool)
     1624        self.assertIsInstance(r, bool)
     1625        self.assertIs(r, False)
    16181626        pg.set_bool(True)
    16191627        try:
     
    16231631        self.assertIsInstance(r, bool)
    16241632        self.assertIs(r, True)
    1625         pg.set_bool(False)
     1633        pg.set_bool(0)
    16261634        try:
    16271635            r = pg.get_bool()
     
    16371645        self.assertIsInstance(r, bool)
    16381646        self.assertIs(r, True)
    1639         pg.set_bool(0)
    1640         try:
    1641             r = pg.get_bool()
    1642         finally:
    1643             pg.set_bool(use_bool)
    1644         self.assertIsInstance(r, bool)
    1645         self.assertIs(r, False)
    16461647
    16471648    def testSetBool(self):
     
    16551656            self.skipTest('database does not support bool')
    16561657        r = r.getresult()[0][0]
     1658        self.assertIsInstance(r, bool)
     1659        self.assertEqual(r, True)
     1660        r = query("select true::bool")
     1661        pg.set_bool(False)
     1662        try:
     1663            r = r.getresult()[0][0]
     1664        finally:
     1665            pg.set_bool(use_bool)
    16571666        self.assertIsInstance(r, str)
    1658         self.assertEqual(r, 't')
     1667        self.assertIs(r, 't')
    16591668        r = query("select true::bool")
    16601669        pg.set_bool(True)
     
    16651674        self.assertIsInstance(r, bool)
    16661675        self.assertIs(r, True)
    1667         r = query("select true::bool")
    1668         pg.set_bool(False)
     1676
     1677    def testGetByteEscaped(self):
     1678        bytea_escaped = pg.get_bytea_escaped()
     1679        # error if a parameter is passed
     1680        self.assertRaises(TypeError, pg.get_bytea_escaped, bytea_escaped)
     1681        self.assertIsInstance(bytea_escaped, bool)
     1682        self.assertIs(bytea_escaped, False)  # the default setting
     1683        pg.set_bytea_escaped(True)
     1684        try:
     1685            r = pg.get_bytea_escaped()
     1686        finally:
     1687            pg.set_bytea_escaped(bytea_escaped)
     1688        self.assertIsInstance(r, bool)
     1689        self.assertIs(r, True)
     1690        pg.set_bytea_escaped(False)
     1691        try:
     1692            r = pg.get_bytea_escaped()
     1693        finally:
     1694            pg.set_bytea_escaped(bytea_escaped)
     1695        self.assertIsInstance(r, bool)
     1696        self.assertIs(r, False)
     1697        pg.set_bytea_escaped(1)
     1698        try:
     1699            r = pg.get_bytea_escaped()
     1700        finally:
     1701            pg.set_bytea_escaped(bytea_escaped)
     1702        self.assertIsInstance(r, bool)
     1703        self.assertIs(r, True)
     1704        pg.set_bytea_escaped(0)
     1705        try:
     1706            r = pg.get_bytea_escaped()
     1707        finally:
     1708            pg.set_bytea_escaped(bytea_escaped)
     1709        self.assertIsInstance(r, bool)
     1710        self.assertIs(r, False)
     1711
     1712    def testSetByteaEscaped(self):
     1713        bytea_escaped = pg.get_bytea_escaped()
     1714        # error if no parameter is passed
     1715        self.assertRaises(TypeError, pg.set_bytea_escaped)
     1716        query = self.c.query
     1717        try:
     1718            r = query("select 'data'::bytea")
     1719        except pg.ProgrammingError:
     1720            self.skipTest('database does not support bytea')
     1721        r = r.getresult()[0][0]
     1722        self.assertIsInstance(r, bytes)
     1723        self.assertEqual(r, b'data')
     1724        r = query("select 'data'::bytea")
     1725        pg.set_bytea_escaped(True)
    16691726        try:
    16701727            r = r.getresult()[0][0]
    16711728        finally:
    1672             pg.set_bool(use_bool)
     1729            pg.set_bytea_escaped(bytea_escaped)
    16731730        self.assertIsInstance(r, str)
    1674         self.assertIs(r, 't')
     1731        self.assertEqual(r, '\\x64617461')
     1732        r = query("select 'data'::bytea")
     1733        pg.set_bytea_escaped(False)
     1734        try:
     1735            r = r.getresult()[0][0]
     1736        finally:
     1737            pg.set_bytea_escaped(bytea_escaped)
     1738        self.assertIsInstance(r, bytes)
     1739        self.assertEqual(r, b'data')
    16751740
    16761741    def testGetNamedresult(self):
  • trunk/tests/test_classic_functions.py

    r806 r813  
    751751            self.assertIs(r, False)
    752752        finally:
    753             pg.set_bool(bytea_escaped)
     753            pg.set_bytea_escaped(bytea_escaped)
    754754        r = pg.get_bytea_escaped()
    755755        self.assertIsInstance(r, bool)
Note: See TracChangeset for help on using the changeset viewer.