Changeset 634


Ignore:
Timestamp:
Nov 26, 2015, 12:02:32 PM (4 years ago)
Author:
cito
Message:

Add support for bool values in classic module

Bool values have been already supported on input. Now they can also be
enabled on output by calling pg.set_bool(True). With pg.get_bool() you
can check whether the feautre is enabled. The default is "off" for now,
so everything is still fully backward compatible.

Location:
trunk/module
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/module/TEST_PyGreSQL_classic_connection.py

    r629 r634  
    719719            ).getresult(), [(None,)])
    720720
    721     def testQueryWithBoolParams(self):
     721    def testQueryWithBoolParams(self, use_bool=None):
    722722        query = self.c.query
    723         self.assertEqual(query("select false").getresult(), [('f',)])
    724         self.assertEqual(query("select true").getresult(), [('t',)])
    725         self.assertEqual(query("select $1::bool", (None,)).getresult(),
    726             [(None,)])
    727         self.assertEqual(query("select $1::bool", ('f',)).getresult(), [('f',)])
    728         self.assertEqual(query("select $1::bool", ('t',)).getresult(), [('t',)])
    729         self.assertEqual(query("select $1::bool", ('false',)).getresult(),
    730             [('f',)])
    731         self.assertEqual(query("select $1::bool", ('true',)).getresult(),
    732             [('t',)])
    733         self.assertEqual(query("select $1::bool", ('n',)).getresult(), [('f',)])
    734         self.assertEqual(query("select $1::bool", ('y',)).getresult(), [('t',)])
    735         self.assertEqual(query("select $1::bool", (0,)).getresult(), [('f',)])
    736         self.assertEqual(query("select $1::bool", (1,)).getresult(), [('t',)])
    737         self.assertEqual(query("select $1::bool", (False,)).getresult(),
    738             [('f',)])
    739         self.assertEqual(query("select $1::bool", (True,)).getresult(),
    740             [('t',)])
     723        if use_bool is not None:
     724            use_bool_default = pg.get_bool()
     725            pg.set_bool(use_bool)
     726        try:
     727            v_false, v_true = (False, True) if use_bool else 'ft'
     728            r_false, r_true = [(v_false,)], [(v_true,)]
     729            self.assertEqual(query("select false").getresult(), r_false)
     730            self.assertEqual(query("select true").getresult(), r_true)
     731            q = "select $1::bool"
     732            self.assertEqual(query(q, (None,)).getresult(), [(None,)])
     733            self.assertEqual(query(q, ('f',)).getresult(), r_false)
     734            self.assertEqual(query(q, ('t',)).getresult(), r_true)
     735            self.assertEqual(query(q, ('false',)).getresult(), r_false)
     736            self.assertEqual(query(q, ('true',)).getresult(), r_true)
     737            self.assertEqual(query(q, ('n',)).getresult(), r_false)
     738            self.assertEqual(query(q, ('y',)).getresult(), r_true)
     739            self.assertEqual(query(q, (0,)).getresult(), r_false)
     740            self.assertEqual(query(q, (1,)).getresult(), r_true)
     741            self.assertEqual(query(q, (False,)).getresult(), r_false)
     742            self.assertEqual(query(q, (True,)).getresult(), r_true)
     743        finally:
     744            if use_bool is not None:
     745                pg.set_bool(use_bool_default)
     746
     747    def testQueryWithBoolParamsAndUseBool(self):
     748        self.testQueryWithBoolParams(use_bool=True)
    741749
    742750    def testQueryWithIntParams(self):
     
    14721480        self.assertEqual(r, long(3425))
    14731481
     1482    def testGetBool(self):
     1483        use_bool = pg.get_bool()
     1484        # error if a parameter is passed
     1485        self.assertRaises(TypeError, pg.get_bool, use_bool)
     1486        self.assertIsInstance(use_bool, bool)
     1487        self.assertIs(use_bool, False)  # the default setting
     1488        pg.set_bool(True)
     1489        try:
     1490            r = pg.get_bool()
     1491        finally:
     1492            pg.set_bool(use_bool)
     1493        self.assertIsInstance(r, bool)
     1494        self.assertIs(r, True)
     1495        pg.set_bool(False)
     1496        try:
     1497            r = pg.get_bool()
     1498        finally:
     1499            pg.set_bool(use_bool)
     1500        self.assertIsInstance(r, bool)
     1501        self.assertIs(r, False)
     1502        pg.set_bool(1)
     1503        try:
     1504            r = pg.get_bool()
     1505        finally:
     1506            pg.set_bool(use_bool)
     1507        self.assertIsInstance(r, bool)
     1508        self.assertIs(r, True)
     1509        pg.set_bool(0)
     1510        try:
     1511            r = pg.get_bool()
     1512        finally:
     1513            pg.set_bool(use_bool)
     1514        self.assertIsInstance(r, bool)
     1515        self.assertIs(r, False)
     1516
     1517    def testSetBool(self):
     1518        use_bool = pg.get_bool()
     1519        query = self.c.query
     1520        try:
     1521            r = query("select true::bool")
     1522        except pg.ProgrammingError:
     1523            self.skipTest('database does not support bool')
     1524        r = r.getresult()[0][0]
     1525        self.assertIsInstance(r, str)
     1526        self.assertEqual(r, 't')
     1527        r = query("select true::bool")
     1528        pg.set_bool(True)
     1529        try:
     1530            r = r.getresult()[0][0]
     1531        finally:
     1532            pg.set_bool(use_bool)
     1533        self.assertIsInstance(r, bool)
     1534        self.assertIs(r, True)
     1535        r = query("select true::bool")
     1536        pg.set_bool(False)
     1537        try:
     1538            r = r.getresult()[0][0]
     1539        finally:
     1540            pg.set_bool(use_bool)
     1541        self.assertIsInstance(r, str)
     1542        self.assertIs(r, 't')
     1543
    14741544    def testSetNamedresult(self):
    14751545        query = self.c.query
  • trunk/module/TEST_PyGreSQL_classic_functions.py

    r629 r634  
    336336        pg.set_decimal_point('*')
    337337        r = pg.get_decimal_point()
     338        pg.set_decimal_point(point)
    338339        self.assertIsInstance(r, str)
    339340        self.assertEqual(r, '*')
    340         pg.set_decimal_point(point)
    341341
    342342    def testSetDecimal(self):
     
    344344        pg.set_decimal(long)
    345345        pg.set_decimal(decimal_class)
     346
     347    def testGetBool(self):
     348        r = pg.get_bool()
     349        self.assertIsInstance(r, bool)
     350        self.assertIs(r, False)
     351
     352    def testSetBoool(self):
     353        use_bool = pg.get_bool()
     354        pg.set_bool(True)
     355        r = pg.get_bool()
     356        pg.set_bool(use_bool)
     357        self.assertIsInstance(r, bool)
     358        self.assertIs(r, True)
     359        pg.set_bool(False)
     360        r = pg.get_bool()
     361        pg.set_bool(use_bool)
     362        self.assertIsInstance(r, bool)
     363        self.assertIs(r, False)
    346364
    347365    def testSetNamedresult(self):
  • trunk/module/pgmodule.c

    r629 r634  
    110110                                *namedresult = NULL; /* function for getting named results */
    111111static char decimal_point = '.'; /* decimal point used in money values */
     112static int use_bool = 0; /* whether or not bool objects shall be returned */
    112113
    113114static int pg_encoding_utf8 = 0;
     
    208209#define PYGRES_DECIMAL 4
    209210#define PYGRES_MONEY 5
    210 #define PYGRES_DEFAULT 6
     211#define PYGRES_BOOL 6
     212#define PYGRES_DEFAULT 7
    211213
    212214/* --------------------------------------------------------------------- */
     
    282284                        case CASHOID:
    283285                                typ[j] = PYGRES_MONEY;
     286                                break;
     287
     288                        case BOOLOID:
     289                                typ[j] = PYGRES_BOOL;
    284290                                break;
    285291
     
    34603466                                                cashbuf[k] = '\0';
    34613467                                                s = cashbuf;
    3462 
    3463                                         /* FALLTHROUGH */ /* no break */
     3468                                                /* FALLTHROUGH */ /* no break here */
     3469
    34643470                                        case PYGRES_DECIMAL:
    34653471                                                if (decimal)
     
    34803486                                                break;
    34813487
     3488                                        case PYGRES_BOOL:
     3489                                                /* convert to bool only if bool_type is set */
     3490                                                if (use_bool)
     3491                                                {
     3492                                                        val = *s == 't' ? Py_True : Py_False;
     3493                                                        Py_INCREF(val);
     3494                                                        break;
     3495                                                }
     3496                                                /* FALLTHROUGH */ /* no break here */
     3497
    34823498                                        default:
    34833499                                        default_case:
     
    36213637                                                cashbuf[k] = '\0';
    36223638                                                s = cashbuf;
    3623 
    3624                                         /* FALLTHROUGH */ /* no break */
     3639                                                /* FALLTHROUGH */ /* no break here */
     3640
    36253641                                        case PYGRES_DECIMAL:
    36263642                                                if (decimal)
     
    36403656                                                Py_DECREF(tmp_obj);
    36413657                                                break;
     3658
     3659                                        case PYGRES_BOOL:
     3660                                                /* convert to bool only if bool_type is set */
     3661                                                if (use_bool)
     3662                                                {
     3663                                                        val = *s == 't' ? Py_True : Py_False;
     3664                                                        Py_INCREF(val);
     3665                                                        break;
     3666                                                }
     3667                                                /* FALLTHROUGH */ /* no break here */
    36423668
    36433669                                        default:
     
    41124138                }
    41134139                else
    4114                         PyErr_SetString(PyExc_TypeError, "decimal type must be None or callable");
    4115         }
     4140                        PyErr_SetString(PyExc_TypeError,
     4141                                "decimal type must be None or callable");
     4142        }
     4143        return ret;
     4144}
     4145
     4146/* set usage of bool values */
     4147static char pgSetBool__doc__[] =
     4148"set_bool() -- set whether boolean values should be converted to bool.";
     4149
     4150static PyObject *
     4151pgSetBool(PyObject *self, PyObject * args)
     4152{
     4153        PyObject *ret = NULL;
     4154        int                     i;
     4155
     4156        /* gets arguments */
     4157        if (PyArg_ParseTuple(args, "i", &i))
     4158        {
     4159                use_bool = i ? 1 : 0;
     4160                Py_INCREF(Py_None); ret = Py_None;
     4161        }
     4162
     4163        return ret;
     4164}
     4165
     4166/* ge usage of bool values */
     4167static char pgGetBool__doc__[] =
     4168"get_bool() -- check whether boolean values are converted to bool.";
     4169
     4170static PyObject *
     4171pgGetBool(PyObject *self, PyObject * args)
     4172{
     4173        PyObject *ret = NULL;
     4174
     4175        if (PyArg_ParseTuple(args, ""))
     4176        {
     4177                ret = use_bool ? Py_True : Py_False;
     4178                Py_INCREF(ret);
     4179        }
     4180
    41164181        return ret;
    41174182}
     
    44984563        {"set_decimal", (PyCFunction) pgSetDecimal, METH_VARARGS,
    44994564                        pgSetDecimal__doc__},
     4565        {"set_bool", (PyCFunction) pgSetBool, METH_VARARGS, pgSetBool__doc__},
     4566        {"get_bool", (PyCFunction) pgGetBool, METH_VARARGS, pgGetBool__doc__},
    45004567        {"set_namedresult", (PyCFunction) pgSetNamedresult, METH_VARARGS,
    45014568                        pgSetNamedresult__doc__},
Note: See TracChangeset for help on using the changeset viewer.