Esempio n. 1
0
    async def test_enum_and_range(self):
        await self.con.execute('''
            CREATE TYPE enum_t AS ENUM ('abc', 'def', 'ghi');
            CREATE TABLE testtab (
                a int4range,
                b enum_t
            );

            INSERT INTO testtab VALUES (
                '[10, 20)', 'abc'
            );
        ''')

        try:
            result = await self.con.fetchrow(
                '''
                SELECT testtab.a FROM testtab WHERE testtab.b = $1
            ''', 'abc')

            self.assertEqual(result, (asyncpg.Range(10, 20), ))
        finally:
            await self.con.execute('''
                DROP TABLE testtab;
                DROP TYPE enum_t;
            ''')
Esempio n. 2
0
async def enum_stuff():
    devices = await generated.device.read_many()
    device_id = choice(devices).id
    item = await generated.reserved_vid.create(
        vid=asyncpg.Range(lower=10, upper=20),
        type=generated.vid_reservation_enum.Customer.value,
        device_id=device_id)
    print(item)
Esempio n. 3
0
async def json_stuff():
    devices = await generated.device.read_many()
    device_id = choice(devices).id
    item = await generated.reserved_vid.create(
        vid=asyncpg.Range(lower=10, upper=20),
        type=generated.vid_reservation_enum.Customer.value,
        device_id=device_id)
    serialized = item.json(pretty=True)
    assert serialized
    print(serialized)
Esempio n. 4
0
    async def test_range_types(self):
        """Test encoding/decoding of range types."""

        cases = [
            ('int4range',
             [[(1, 9), asyncpg.Range(1, 10)],
              [
                  asyncpg.Range(0, 9, lower_inc=False, upper_inc=True),
                  asyncpg.Range(1, 10)
              ], [(), asyncpg.Range(empty=True)],
              [asyncpg.Range(empty=True),
               asyncpg.Range(empty=True)], [(None, 2),
                                            asyncpg.Range(None, 3)],
              [asyncpg.Range(None, 2, upper_inc=True),
               asyncpg.Range(None, 3)], [(2, ), asyncpg.Range(2, None)],
              [(2, None), asyncpg.Range(2, None)],
              [asyncpg.Range(2, None),
               asyncpg.Range(2, None)],
              [(None, None), asyncpg.Range(None, None)],
              [asyncpg.Range(None, None),
               asyncpg.Range(None, None)]])
        ]

        for (typname, sample_data) in cases:
            st = await self.con.prepare("SELECT $1::" + typname)

            for sample, expected in sample_data:
                with self.subTest(sample=sample, typname=typname):
                    result = await st.fetchval(sample)
                    self.assertEqual(result, expected)

        with self.assertRaisesRegex(TypeError,
                                    'list, tuple or Range object expected'):
            await self.con.fetch("SELECT $1::int4range", 'aa')

        with self.assertRaisesRegex(ValueError, 'expected 0, 1 or 2 elements'):
            await self.con.fetch("SELECT $1::int4range", (0, 2, 3))