Changeset 798 for trunk/pgmodule.c


Ignore:
Timestamp:
Jan 30, 2016, 2:55:18 PM (4 years ago)
Author:
cito
Message:

Port type cache and typecasting from pgdb to pg

So far, the typecasting in the classic module was been only done by
the C extension module and was not extensible through typecasting
functions in Python. This has now been made extensible by adding
a cast hook to the C extension module which has been hooked up to
a new type cache object that holds information on the types and the
associated typecast functions. All of this works very similar to the
pgdb module now, except that the basic types are still handled by
the C extension module and the Python typecast functions are only
called via the hook for types which are not supported internally.

Also added tests and a chapter on the type cache in the documentation,
and cleaned up the error messages in the C extension module.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/pgmodule.c

    r794 r798  
    142142        PyObject_HEAD
    143143        int                     valid;                          /* validity flag */
    144         PGconn          *cnx;                           /* PostGres connection handle */
    145         PyObject        *notice_receiver;       /* current notice receiver */
     144        PGconn     *cnx;                                /* PostGres connection handle */
     145        PyObject   *cast_hook;                  /* external typecast method */
     146        PyObject   *notice_receiver;    /* current notice receiver */
    146147}       connObject;
    147148#define is_connObject(v) (PyType(v) == &connType)
     
    151152        PyObject_HEAD
    152153        int                     valid;                  /* validity flag */
    153         connObject      *pgcnx;                 /* parent connection object */
     154        connObject *pgcnx;                      /* parent connection object */
    154155        PGresult        *result;                /* result content */
    155156        int                     encoding;               /* client encoding */
     
    165166{
    166167        PyObject_HEAD
    167         connObject      *pgcnx;         /* parent connection object */
    168         PGresult        const *res;     /* an error or warning */
     168        connObject *pgcnx;                      /* parent connection object */
     169        PGresult        const *res;             /* an error or warning */
    169170}       noticeObject;
    170171#define is_noticeObject(v) (PyType(v) == &noticeType)
     
    173174{
    174175        PyObject_HEAD
    175         PGresult        *result;                /* result content */
     176        connObject *pgcnx;                      /* parent connection object */
     177        PGresult   *result;                     /* result content */
    176178        int                     encoding;               /* client encoding */
    177179}       queryObject;
     
    182184{
    183185        PyObject_HEAD
    184         connObject      *pgcnx;                 /* parent connection object */
     186        connObject *pgcnx;                      /* parent connection object */
    185187        Oid                     lo_oid;                 /* large object oid */
    186188        int                     lo_fd;                  /* large object fd */
     
    202204#define PYGRES_BYTEA 9
    203205#define PYGRES_JSON 10
    204 #define PYGRES_EXTERNAL 11
     206#define PYGRES_OTHER 11
    205207/* array types */
    206208#define PYGRES_ARRAY 16
     
    242244/* helper functions */
    243245
    244 /* get PyGreSQL internal types for  a PostgreSQL type */
     246/* get PyGreSQL internal types for a PostgreSQL type */
    245247static int
    246248get_type(Oid pgtype)
     
    290292                        break;
    291293
     294                case BPCHAROID:
     295                case CHAROID:
     296                case TEXTOID:
     297                case VARCHAROID:
     298                case NAMEOID:
     299                case DATEOID:
     300                case INTERVALOID:
     301                case TIMEOID:
     302                case TIMETZOID:
     303                case TIMESTAMPOID:
     304                case TIMESTAMPTZOID:
     305                case REGTYPEOID:
     306                        t = PYGRES_TEXT;
     307                        break;
     308
    292309                /* array types */
    293310
     
    331348                        break;
    332349
    333                 case ANYARRAYOID:
    334350                case BPCHARARRAYOID:
    335351                case CHARARRAYOID:
    336352                case TEXTARRAYOID:
    337353                case VARCHARARRAYOID:
     354                case NAMEARRAYOID:
    338355                case DATEARRAYOID:
    339356                case INTERVALARRAYOID:
     
    342359                case TIMESTAMPARRAYOID:
    343360                case TIMESTAMPTZARRAYOID:
     361                case REGTYPEARRAYOID:
    344362                        t = PYGRES_TEXT | PYGRES_ARRAY;
    345363                        break;
    346364
    347365                default:
    348                         t = PYGRES_TEXT;
     366                        t = PYGRES_OTHER;
    349367        }
    350368
     
    427445        }
    428446
     447        return obj;
     448}
     449
     450/* Cast an arbitrary type to a Python object using a callback function.
     451   This needs the character string, size, encoding, the Postgres type
     452   and the external typecast function to be called. */
     453static PyObject *
     454cast_other(char *s, Py_ssize_t size, int encoding, int pgtype,
     455        PyObject *cast_hook)
     456{
     457        PyObject *obj;
     458
     459        obj = cast_sized_text(s, size, encoding, PYGRES_TEXT);
     460
     461        if (cast_hook)
     462        {
     463                PyObject *tmp_obj = obj;
     464                obj = PyObject_CallFunction(cast_hook, "(Oi)", obj, pgtype);
     465                Py_DECREF(tmp_obj);
     466        }
    429467        return obj;
    430468}
     
    10531091        PyGILState_STATE gstate = PyGILState_Ensure();
    10541092        connObject *self = (connObject*) arg;
    1055         PyObject *proc = self->notice_receiver;
    1056         if (proc && PyCallable_Check(proc))
     1093        PyObject *func = self->notice_receiver;
     1094
     1095        if (func)
    10571096        {
    10581097                noticeObject *notice = PyObject_NEW(noticeObject, &noticeType);
     
    10681107                        notice = (noticeObject *)(void *)Py_None;
    10691108                }
    1070                 ret = PyObject_CallFunction(proc, "(O)", notice);
     1109                ret = PyObject_CallFunction(func, "(O)", notice);
    10711110                Py_XDECREF(ret);
    10721111        }
     
    13591398        if (!PyArg_ParseTuple(args, "i", &mode))
    13601399        {
    1361                 PyErr_SetString(PyExc_TypeError, "open(mode), with mode(integer)");
     1400                PyErr_SetString(PyExc_TypeError,
     1401                        "The open() method takes an integer argument");
    13621402                return NULL;
    13631403        }
     
    13911431        {
    13921432                PyErr_SetString(PyExc_TypeError,
    1393                         "Method close() takes no parameters");
     1433                        "Method close() takes no arguments");
    13941434                return NULL;
    13951435        }
     
    14261466        if (!PyArg_ParseTuple(args, "i", &size))
    14271467        {
    1428                 PyErr_SetString(PyExc_TypeError, "read(size), with size (integer)");
     1468                PyErr_SetString(PyExc_TypeError,
     1469                        "Method read() takes an integer argument");
    14291470                return NULL;
    14301471        }
     
    14321473        if (size <= 0)
    14331474        {
    1434                 PyErr_SetString(PyExc_ValueError, "Parameter size must be positive");
     1475                PyErr_SetString(PyExc_ValueError,
     1476                        "Method read() takes a positive integer as argument");
    14351477                return NULL;
    14361478        }
     
    14721514        {
    14731515                PyErr_SetString(PyExc_TypeError,
    1474                         "write(buffer), with buffer (sized string)");
     1516                        "Method write() expects a sized string as argument");
    14751517                return NULL;
    14761518        }
     
    15111553        {
    15121554                PyErr_SetString(PyExc_TypeError,
    1513                         "lseek(offset, whence), with offset and whence (integers)");
     1555                        "Method lseek() expects two integer arguments");
    15141556                return NULL;
    15151557        }
     
    15451587        {
    15461588                PyErr_SetString(PyExc_TypeError,
    1547                         "Method size() takes no parameters");
     1589                        "Method size() takes no arguments");
    15481590                return NULL;
    15491591        }
     
    15941636        {
    15951637                PyErr_SetString(PyExc_TypeError,
    1596                         "Method tell() takes no parameters");
     1638                        "Method tell() takes no arguments");
    15971639                return NULL;
    15981640        }
     
    16581700        {
    16591701                PyErr_SetString(PyExc_TypeError,
    1660                         "Method unlink() takes no parameters");
     1702                        "Method unlink() takes no arguments");
    16611703                return NULL;
    16621704        }
     
    18051847                Py_END_ALLOW_THREADS
    18061848        }
    1807         if (self->notice_receiver)
    1808         {
    1809                 Py_DECREF(self->notice_receiver);
    1810         }
     1849        Py_XDECREF(self->cast_hook);
     1850        Py_XDECREF(self->notice_receiver);
    18111851        PyObject_Del(self);
    18121852}
     
    18291869        {
    18301870                PyErr_SetString(PyExc_TypeError,
    1831                         "Method source() takes no parameter");
     1871                        "Method source() takes no arguments");
    18321872                return NULL;
    18331873        }
     
    18931933        {
    18941934                PyErr_SetString(PyExc_TypeError,
    1895                         "Query command must be a string");
     1935                        "Method query() expects a string as first argument");
    18961936                return NULL;
    18971937        }
     
    19041944        {
    19051945                param_obj = PySequence_Fast(param_obj,
    1906                         "Query parameters must be a sequence");
     1946                        "Method query() expects a sequence as second argument");
    19071947                if (!param_obj)
    19081948                {
     
    20702110
    20712111        /* stores result and returns object */
     2112        Py_XINCREF(self);
     2113        npgobj->pgcnx = self;
    20722114        npgobj->result = result;
    20732115        npgobj->encoding = encoding;
     
    21292171        {
    21302172                PyErr_SetString(PyExc_TypeError,
    2131                         "Method getline() takes no parameters");
     2173                        "Method getline() takes no arguments");
    21322174                return NULL;
    21332175        }
     
    21692211        {
    21702212                PyErr_SetString(PyExc_TypeError,
    2171                         "Method endcopy() takes no parameters");
     2213                        "Method endcopy() takes no arguments");
    21722214                return NULL;
    21732215        }
     
    22252267        {
    22262268                PyErr_SetString(PyExc_TypeError,
    2227                         "inserttable(table, content), with table (string) "
    2228                         "and content (list)");
     2269                        "Method inserttable() expects a string and a list as arguments");
    22292270                return NULL;
    22302271        }
     
    22442285        {
    22452286                PyErr_SetString(PyExc_TypeError,
    2246                         "Second arg must be some kind of array");
     2287                        "Method inserttable() expects some kind of array"
     2288                        " as second argument");
    22472289                return NULL;
    22482290        }
     
    24492491        {
    24502492                PyErr_SetString(PyExc_TypeError,
    2451                         "Method transaction() takes no parameters");
     2493                        "Method transaction() takes no arguments");
    24522494                return NULL;
    24532495        }
     
    24582500/* get parameter setting */
    24592501static char connParameter__doc__[] =
    2460 "parameter() -- look up a current parameter setting";
     2502"parameter(name) -- look up a current parameter setting";
    24612503
    24622504static PyObject *
     
    24752517        {
    24762518                PyErr_SetString(PyExc_TypeError,
    2477                         "parameter(name), with name (string)");
     2519                        "Method parameter() takes a string as argument");
    24782520                return NULL;
    24792521        }
     
    25232565        else
    25242566        {
    2525                 PyErr_SetString(PyExc_TypeError, "escape_literal() expects a string");
     2567                PyErr_SetString(PyExc_TypeError,
     2568                        "Method escape_literal() expects a string as argument");
    25262569                return NULL;
    25272570        }
     
    25742617        {
    25752618                PyErr_SetString(PyExc_TypeError,
    2576                         "escape_identifier() expects a string");
     2619                        "Method escape_identifier() expects a string as argument");
    25772620                return NULL;
    25782621        }
     
    26262669        else
    26272670        {
    2628                 PyErr_SetString(PyExc_TypeError, "escape_string() expects a string");
     2671                PyErr_SetString(PyExc_TypeError,
     2672                        "Method escape_string() expects a string as argument");
    26292673                return NULL;
    26302674        }
     
    26822726        else
    26832727        {
    2684                 PyErr_SetString(PyExc_TypeError, "escape_bytea() expects a string");
     2728                PyErr_SetString(PyExc_TypeError,
     2729                        "Method escape_bytea() expects a string as argument");
    26852730                return NULL;
    26862731        }
     
    28162861        {
    28172862                PyErr_SetString(PyExc_TypeError,
    2818                         "Method reset() takes no parameters");
     2863                        "Method reset() takes no arguments");
    28192864                return NULL;
    28202865        }
     
    28432888        {
    28442889                PyErr_SetString(PyExc_TypeError,
    2845                         "Method cancel() takes no parameters");
     2890                        "Method cancel() takes no arguments");
    28462891                return NULL;
    28472892        }
     
    28682913        {
    28692914                PyErr_SetString(PyExc_TypeError,
    2870                         "Method fileno() takes no parameters");
     2915                        "Method fileno() takes no arguments");
    28712916                return NULL;
    28722917        }
     
    28792924}
    28802925
     2926/* set external typecast callback function */
     2927static char connSetCastHook__doc__[] =
     2928"set_cast_hook(func) -- set a fallback typecast function";
     2929
     2930static PyObject *
     2931connSetCastHook(connObject * self, PyObject * args)
     2932{
     2933        PyObject *ret = NULL;
     2934        PyObject *func;
     2935
     2936        if (PyArg_ParseTuple(args, "O", &func))
     2937        {
     2938                if (func == Py_None)
     2939                {
     2940                        Py_XDECREF(self->cast_hook);
     2941                        self->cast_hook = NULL;
     2942                        Py_INCREF(Py_None); ret = Py_None;
     2943                }
     2944                else if (PyCallable_Check(func))
     2945                {
     2946                        Py_XINCREF(func); Py_XDECREF(self->cast_hook);
     2947                        self->cast_hook = func;
     2948                        Py_INCREF(Py_None); ret = Py_None;
     2949                }
     2950                else
     2951                        PyErr_SetString(PyExc_TypeError,
     2952                                "Method set_cast_hook() expects"
     2953                                 " a callable or None as argument");
     2954        }
     2955        return ret;
     2956}
     2957
     2958/* get notice receiver callback function */
     2959static char connGetCastHook__doc__[] =
     2960"get_cast_hook() -- get the fallback typecast function";
     2961
     2962static PyObject *
     2963connGetCastHook(connObject * self, PyObject * args)
     2964{
     2965        PyObject *ret = NULL;
     2966
     2967        if (PyArg_ParseTuple(args, ""))
     2968        {
     2969                ret = self->cast_hook;
     2970                if (!ret)
     2971                        ret = Py_None;
     2972                Py_INCREF(ret);
     2973        }
     2974        else
     2975                PyErr_SetString(PyExc_TypeError,
     2976                        "Method get_cast_hook() takes no arguments");
     2977
     2978        return ret;
     2979}
     2980
    28812981/* set notice receiver callback function */
    28822982static char connSetNoticeReceiver__doc__[] =
    2883 "set_notice_receiver() -- set the current notice receiver";
     2983"set_notice_receiver(func) -- set the current notice receiver";
    28842984
    28852985static PyObject *
     
    28872987{
    28882988        PyObject *ret = NULL;
    2889         PyObject *proc;
    2890 
    2891         if (PyArg_ParseTuple(args, "O", &proc))
    2892         {
    2893                 if (PyCallable_Check(proc))
    2894                 {
    2895                         Py_XINCREF(proc);
    2896                         self->notice_receiver = proc;
     2989        PyObject *func;
     2990
     2991        if (PyArg_ParseTuple(args, "O", &func))
     2992        {
     2993                if (func == Py_None)
     2994                {
     2995                        Py_XDECREF(self->notice_receiver);
     2996                        self->notice_receiver = NULL;
     2997                        Py_INCREF(Py_None); ret = Py_None;
     2998                }
     2999                else if (PyCallable_Check(func))
     3000                {
     3001                        Py_XINCREF(func); Py_XDECREF(self->notice_receiver);
     3002                        self->notice_receiver = func;
    28973003                        PQsetNoticeReceiver(self->cnx, notice_receiver, self);
    28983004                        Py_INCREF(Py_None); ret = Py_None;
     
    29003006                else
    29013007                        PyErr_SetString(PyExc_TypeError,
    2902                                 "Notice receiver must be callable");
     3008                                "Method set_notice_receiver() expects"
     3009                                 " a callable or None as argument");
    29033010        }
    29043011        return ret;
     
    29223029        }
    29233030        else
    2924         {
    2925                 PyErr_SetString(PyExc_TypeError,
    2926                         "Method get_notice_receiver() takes no parameters");
    2927         }
     3031                PyErr_SetString(PyExc_TypeError,
     3032                        "Method get_notice_receiver() takes no arguments");
     3033
    29283034        return ret;
    29293035}
     
    29803086        {
    29813087                PyErr_SetString(PyExc_TypeError,
    2982                         "Method getnotify() takes no parameters");
     3088                        "Method getnotify() takes no arguments");
    29833089                return NULL;
    29843090        }
     
    30523158        {"close", (PyCFunction) connClose, METH_VARARGS, connClose__doc__},
    30533159        {"fileno", (PyCFunction) connFileno, METH_VARARGS, connFileno__doc__},
     3160        {"get_cast_hook", (PyCFunction) connGetCastHook, METH_VARARGS,
     3161                        connGetCastHook__doc__},
     3162        {"set_cast_hook", (PyCFunction) connSetCastHook, METH_VARARGS,
     3163                        connSetCastHook__doc__},
    30543164        {"get_notice_receiver", (PyCFunction) connGetNoticeReceiver, METH_VARARGS,
    30553165                        connGetNoticeReceiver__doc__},
     
    32423352        if (!PyArg_ParseTuple(args, ""))
    32433353        {
    3244                 PyErr_SetString(PyExc_TypeError, "Method close() takes no parameter");
     3354                PyErr_SetString(PyExc_TypeError, "Method close() takes no arguments");
    32453355                return NULL;
    32463356        }
     
    33043414        else
    33053415        {
    3306                 PyErr_SetString(PyExc_TypeError, "Executed SQL must be a string");
     3416                PyErr_SetString(PyExc_TypeError,
     3417                        "Method execute() expects a string as argument");
    33073418                return NULL;
    33083419        }
     
    33993510        {
    34003511                PyErr_SetString(PyExc_TypeError,
    3401                         "Method oidstatus() takes no parameters");
     3512                        "Method oidstatus() takes no arguments");
    34023513                return NULL;
    34033514        }
     
    35173628                char            errbuf[256];
    35183629                PyOS_snprintf(errbuf, sizeof(errbuf),
    3519                         "Method %s() takes no parameter", __movename[move]);
     3630                        "Method %s() takes no arguments", __movename[move]);
    35203631                PyErr_SetString(PyExc_TypeError, errbuf);
    35213632                return NULL;
     
    36483759        {
    36493760                PyErr_SetString(PyExc_TypeError,
    3650                         "putdata() expects a buffer, None or an exception");
     3761                        "Method putdata() expects a buffer, None"
     3762                         " or an exception as argument");
    36513763                return NULL;
    36523764        }
     
    38713983        {
    38723984                PyErr_SetString(PyExc_TypeError,
    3873                         "Method listinfo() takes no parameter");
     3985                        "Method listinfo() takes no arguments");
    38743986                return NULL;
    38753987        }
     
    41234235        int                     pgport;
    41244236        char            port_buffer[20];
    4125         connObject   *npgobj;
     4237        connObject *npgobj;
    41264238
    41274239        pghost = pgopt = pgdbname = pguser = pgpasswd = NULL;
     
    41674279        npgobj->valid = 1;
    41684280        npgobj->cnx = NULL;
     4281        npgobj->cast_hook = NULL;
    41694282        npgobj->notice_receiver = NULL;
    41704283
     
    41934306queryDealloc(queryObject *self)
    41944307{
     4308        Py_XDECREF(self->pgcnx);
    41954309        if (self->result)
    41964310                PQclear(self->result);
     
    42104324        {
    42114325                PyErr_SetString(PyExc_TypeError,
    4212                         "Method ntuples() takes no parameters");
     4326                        "Method ntuples() takes no arguments");
    42134327                return NULL;
    42144328        }
     
    42344348        {
    42354349                PyErr_SetString(PyExc_TypeError,
    4236                         "Method listfields() takes no parameters");
     4350                        "Method listfields() takes no arguments");
    42374351                return NULL;
    42384352        }
     
    43264440        {
    43274441                PyErr_SetString(PyExc_TypeError,
    4328                         "Method getresult() takes no parameters");
     4442                        "Method getresult() takes no arguments");
    43294443                return NULL;
    43304444        }
     
    43714485                                else if (type == PYGRES_BYTEA)
    43724486                                        val = cast_bytea_text(s);
     4487                                else if (type == PYGRES_OTHER)
     4488                                        val = cast_other(s,
     4489                                                PQgetlength(self->result, i, j), encoding,
     4490                                                PQftype(self->result, j), self->pgcnx->cast_hook);
    43734491                                else if (type & PYGRES_TEXT)
    43744492                                        val = cast_sized_text(s, PQgetlength(self->result, i, j),
     
    44194537        {
    44204538                PyErr_SetString(PyExc_TypeError,
    4421                         "Method dictresult() takes no parameters");
     4539                        "Method dictresult() takes no arguments");
    44224540                return NULL;
    44234541        }
     
    44644582                                else if (type == PYGRES_BYTEA)
    44654583                                        val = cast_bytea_text(s);
     4584                                else if (type == PYGRES_OTHER)
     4585                                        val = cast_other(s,
     4586                                                PQgetlength(self->result, i, j), encoding,
     4587                                                PQftype(self->result, j), self->pgcnx->cast_hook);
    44664588                                else if (type & PYGRES_TEXT)
    44674589                                        val = cast_sized_text(s, PQgetlength(self->result, i, j),
     
    45104632                {
    45114633                        PyErr_SetString(PyExc_TypeError,
    4512                                 "Method namedresult() takes no parameters");
     4634                                "Method namedresult() takes no arguments");
    45134635                        return NULL;
    45144636                }
     
    47314853        else
    47324854        {
    4733                 PyErr_SetString(PyExc_TypeError, "escape_string() expects a string");
     4855                PyErr_SetString(PyExc_TypeError,
     4856                        "Method escape_string() expects a string as argument");
    47344857                return NULL;
    47354858        }
     
    47864909        else
    47874910        {
    4788                 PyErr_SetString(PyExc_TypeError, "escape_bytea() expects a string");
     4911                PyErr_SetString(PyExc_TypeError,
     4912                        "Method escape_bytea() expects a string as argument");
    47894913                return NULL;
    47904914        }
     
    48344958        else
    48354959        {
    4836                 PyErr_SetString(PyExc_TypeError, "unescape_bytea() expects a string");
     4960                PyErr_SetString(PyExc_TypeError,
     4961                        "Method unescape_bytea() expects a string as argument");
    48374962                return NULL;
    48384963        }
     
    48734998        }
    48744999        else
    4875         {
    4876                 PyErr_SetString(PyExc_TypeError,
    4877                         "get_decimal_point() takes no parameter");
    4878         }
     5000                PyErr_SetString(PyExc_TypeError,
     5001                        "Function get_decimal_point() takes no arguments");
    48795002
    48805003        return ret;
     
    49065029        }
    49075030        else
    4908         {
    4909                 PyErr_SetString(PyExc_TypeError,
    4910                         "set_decimal_point() expects a decimal mark character");
    4911         }
     5031                PyErr_SetString(PyExc_TypeError,
     5032                        "Function set_decimal_mark() expects"
     5033                        " a decimal mark character as argument");
    49125034
    49135035        return ret;
     
    49165038/* get decimal type */
    49175039static char pgGetDecimal__doc__[] =
    4918 "get_decimal() -- set a decimal type to be used for numeric values";
     5040"get_decimal() -- get the decimal type to be used for numeric values";
    49195041
    49205042static PyObject *
     
    49285050                Py_INCREF(ret);
    49295051        }
     5052        else
     5053                PyErr_SetString(PyExc_TypeError,
     5054                        "Function get_decimal() takes no arguments");
    49305055
    49315056        return ret;
     
    49565081                else
    49575082                        PyErr_SetString(PyExc_TypeError,
    4958                                 "Decimal type must be None or callable");
     5083                                "Function set_decimal() expects"
     5084                                 " a callable or None as argument");
    49595085        }
    49605086
     
    49765102                Py_INCREF(ret);
    49775103        }
     5104        else
     5105                PyErr_SetString(PyExc_TypeError,
     5106                        "Function get_bool() takes no arguments");
    49785107
    49795108        return ret;
     
    49965125                Py_INCREF(Py_None); ret = Py_None;
    49975126        }
     5127        else
     5128                PyErr_SetString(PyExc_TypeError,
     5129                        "Function set_bool() expects a boolean value as argument");
    49985130
    49995131        return ret;
     
    50025134/* get named result factory */
    50035135static char pgGetNamedresult__doc__[] =
    5004 "get_namedresult(cls) -- get the function used for getting named results";
     5136"get_namedresult() -- get the function used for getting named results";
    50055137
    50065138static PyObject *
     
    50145146                Py_INCREF(ret);
    50155147        }
     5148        else
     5149                PyErr_SetString(PyExc_TypeError,
     5150                        "Function get_namedresult() takes no arguments");
    50165151
    50175152        return ret;
     
    50205155/* set named result factory */
    50215156static char pgSetNamedresult__doc__[] =
    5022 "set_namedresult(cls) -- set a function to be used for getting named results";
     5157"set_namedresult(func) -- set a function to be used for getting named results";
    50235158
    50245159static PyObject *
     
    50415176                }
    50425177                else
    5043                         PyErr_SetString(PyExc_TypeError, "Parameter must be callable");
     5178                        PyErr_SetString(PyExc_TypeError,
     5179                                "Function set_namedresult() expectst"
     5180                                 " a callable or None as argument");
    50445181        }
    50455182
     
    50495186/* get json decode function */
    50505187static char pgGetJsondecode__doc__[] =
    5051 "get_jsondecode(cls) -- get the function used for decoding json results";
     5188"get_jsondecode() -- get the function used for decoding json results";
    50525189
    50535190static PyObject *
     
    50585195        if (PyArg_ParseTuple(args, ""))
    50595196        {
    5060                 ret = jsondecode ? jsondecode : Py_None;
     5197                ret = jsondecode;
     5198                if (!ret)
     5199                        ret = Py_None;
    50615200                Py_INCREF(ret);
    50625201        }
    5063 
     5202        else
     5203        {
     5204                PyErr_SetString(PyExc_TypeError,
     5205                        "Function get_jsondecode() takes no arguments");
     5206        }
    50645207        return ret;
    50655208}
     
    50675210/* set json decode function */
    50685211static char pgSetJsondecode__doc__[] =
    5069 "set_jsondecode(cls) -- set a function to be used for decoding json results";
     5212"set_jsondecode() -- set a function to be used for decoding json results";
    50705213
    50715214static PyObject *
     
    50885231                }
    50895232                else
    5090                         PyErr_SetString(PyExc_TypeError, "Parameter must be callable");
     5233                        PyErr_SetString(PyExc_TypeError,
     5234                                "Function jsondecode() expects"
     5235                                 " a callable or None as argument");
    50915236        }
    50925237
     
    51075252        {
    51085253                PyErr_SetString(PyExc_TypeError,
    5109                         "Method get_defhost() takes no parameter");
     5254                        "Function get_defhost() takes no arguments");
    51105255                return NULL;
    51115256        }
     
    51295274        {
    51305275                PyErr_SetString(PyExc_TypeError,
    5131                         "set_defhost(name), with name (string/None)");
     5276                        "Function set_defhost() expects a string or None as argument");
    51325277                return NULL;
    51335278        }
     
    51585303        {
    51595304                PyErr_SetString(PyExc_TypeError,
    5160                         "Method get_defbase() takes no parameter");
     5305                        "Function get_defbase() takes no arguments");
    51615306                return NULL;
    51625307        }
     
    51805325        {
    51815326                PyErr_SetString(PyExc_TypeError,
    5182                         "set_defbase(name), with name (string/None)");
     5327                        "Function set_defbase() Argument a string or None as argument");
    51835328                return NULL;
    51845329        }
     
    52095354        {
    52105355                PyErr_SetString(PyExc_TypeError,
    5211                         "Method get_defopt() takes no parameter");
     5356                        "Function get_defopt() takes no arguments");
    52125357                return NULL;
    52135358        }
     
    52315376        {
    52325377                PyErr_SetString(PyExc_TypeError,
    5233                         "set_defopt(name), with name (string/None)");
     5378                        "Function set_defopt() expects a string or None as argument");
    52345379                return NULL;
    52355380        }
     
    52605405        {
    52615406                PyErr_SetString(PyExc_TypeError,
    5262                         "Method get_defuser() takes no parameter");
    5263 
     5407                        "Function get_defuser() takes no arguments");
    52645408                return NULL;
    52655409        }
     
    52845428        {
    52855429                PyErr_SetString(PyExc_TypeError,
    5286                         "set_defuser(name), with name (string/None)");
     5430                        "Function set_defuser() expects a string or None as argument");
    52875431                return NULL;
    52885432        }
     
    53155459        {
    53165460                PyErr_SetString(PyExc_TypeError,
    5317                         "set_defpasswd(password), with password (string/None)");
     5461                        "Function set_defpasswd() expects a string or None as argument");
    53185462                return NULL;
    53195463        }
     
    53425486        {
    53435487                PyErr_SetString(PyExc_TypeError,
    5344                         "Method get_defport() takes no parameter");
     5488                        "Function get_defport() takes no arguments");
    53455489                return NULL;
    53465490        }
     
    53635507        if ((!PyArg_ParseTuple(args, "l", &port)) || (port < -1))
    53645508        {
    5365                 PyErr_SetString(PyExc_TypeError, "set_defport(port), with port "
    5366                         "(positive integer/-1)");
     5509                PyErr_SetString(PyExc_TypeError,
     5510                        "Function set_deport expects"
     5511                         " a positive integer or -1 as argument");
    53675512                return NULL;
    53685513        }
     
    54155560        else
    54165561        {
    5417                 PyErr_SetString(PyExc_TypeError, "cast_array() expects a string");
     5562                PyErr_SetString(PyExc_TypeError,
     5563                        "Function cast_array() expects a string as first argument");
    54185564                return NULL;
    54195565        }
     
    54285574        else if (!PyCallable_Check(cast_obj))
    54295575        {
    5430                 PyErr_SetString(PyExc_TypeError, "The cast argument must be callable");
     5576                PyErr_SetString(PyExc_TypeError,
     5577                        "Function cast_array() expects a callable as second argument");
    54315578                return NULL;
    54325579        }
     
    54715618        else
    54725619        {
    5473                 PyErr_SetString(PyExc_TypeError, "cast_record() expects a string");
     5620                PyErr_SetString(PyExc_TypeError,
     5621                        "Function cast_record() expects a string as first argument");
    54745622                return NULL;
    54755623        }
     
    54945642        {
    54955643                PyErr_SetString(PyExc_TypeError,
    5496                         "The cast argument must be callable or a tuple or list of such");
     5644                        "Function cast_record() expects a callable"
     5645                         " or tuple or list of callables as second argument");
    54975646                return NULL;
    54985647        }
Note: See TracChangeset for help on using the changeset viewer.