def test_sync_basic_datatypes_01(self):
for _ in range(10):
self.assertEqual(self.con.query_one('select ()'), ())
self.assertEqual(self.con.query('select (1,)'),
edgedb.Set([(1, )]))
self.assertEqual(self.con.query_one('select <array<int64>>[]'), [])
self.assertEqual(self.con.query('select ["a", "b"]'),
edgedb.Set([["a", "b"]]))
self.assertEqual(
self.con.query('''
SELECT {(a := 1 + 1 + 40, world := ("hello", 32)),
(a:=1, world := ("yo", 10))};
'''),
edgedb.Set([
edgedb.NamedTuple(a=42, world=("hello", 32)),
edgedb.NamedTuple(a=1, world=("yo", 10)),
]))
with self.assertRaisesRegex(
edgedb.InterfaceError,
r'query cannot be executed with query_one\('):
self.con.query_one('SELECT {1, 2}')
with self.assertRaisesRegex(edgedb.NoDataError,
r'\bquery_one_json\('):
self.con.query_one_json('SELECT <int64>{}')
async def test_async_basic_datatypes_01(self):
for _ in range(10):
self.assertEqual(await self.con.query_one('select ()'), ())
self.assertEqual(await self.con.query('select (1,)'),
edgedb.Set([(1, )]))
async with self.con.transaction(isolation='repeatable_read'):
self.assertEqual(
await self.con.query_one('select <array<int64>>[]'), [])
self.assertEqual(await self.con.query('select ["a", "b"]'),
edgedb.Set([["a", "b"]]))
self.assertEqual(
await self.con.query('''
SELECT {(a := 1 + 1 + 40, world := ("hello", 32)),
(a:=1, world := ("yo", 10))};
'''),
edgedb.Set([
edgedb.NamedTuple(a=42, world=("hello", 32)),
edgedb.NamedTuple(a=1, world=("yo", 10)),
]))
with self.assertRaisesRegex(
edgedb.InterfaceError,
r'query_one\(\) as it returns a multiset'):
await self.con.query_one('SELECT {1, 2}')
with self.assertRaisesRegex(edgedb.NoDataError, r'\bquery_one\('):
await self.con.query_one('SELECT <int64>{}')
async def test_async_basic_datatypes_01(self):
for _ in range(10):
self.assertEqual(await self.client.query_single('select ()'), ())
self.assertEqual(await self.client.query('select (1,)'),
edgedb.Set([(1, )]))
self.assertEqual(await self.client.query('select ["a", "b"]'),
edgedb.Set([["a", "b"]]))
self.assertEqual(
await self.client.query('''
SELECT {(a := 1 + 1 + 40, world := ("hello", 32)),
(a:=1, world := ("yo", 10))};
'''),
edgedb.Set([
edgedb.NamedTuple(a=42, world=("hello", 32)),
edgedb.NamedTuple(a=1, world=("yo", 10)),
]))
with self.assertRaisesRegex(
edgedb.InterfaceError,
r'query_single\(\) as it returns a multiset'):
await self.client.query_single('SELECT {1, 2}')
with self.assertRaisesRegex(
edgedb.InterfaceError,
r'query_required_single\(\) as it returns a multiset'):
await self.client.query_required_single('SELECT {1, 2}')
with self.assertRaisesRegex(edgedb.NoDataError,
r'\bquery_required_single\('):
await self.client.query_required_single('SELECT <int64>{}')
def test_sync_basic_datatypes_02(self):
self.assertEqual(
self.con.query(r'''select [b"\x00a", b"b", b'', b'\na']'''),
edgedb.Set([[b"\x00a", b"b", b'', b'\na']]))
self.assertEqual(self.con.query(r'select <bytes>$0', b'he\x00llo'),
edgedb.Set([b'he\x00llo']))
def test_set_2(self):
s = edgedb.Set((1, 2, 3000, 'a'))
self.assertEqual(repr(s), "Set{1, 2, 3000, 'a'}")
self.assertEqual(hash(s),
hash(edgedb.Set((1, 2, sum([1000, 2000]), 'a'))))
self.assertNotEqual(hash(s), hash((1, 2, 3000, 'a')))
def test_set_7(self):
self.assertEqual(
edgedb.Set([1, 2, 3]),
[1, 2, 3])
self.assertNotEqual(
edgedb.Set([1, 2, 3]),
[3, 2, 1])
self.assertNotEqual(
edgedb.Set([1, 2, 3]),
1)
def test_set_1(self):
s = edgedb.Set(())
self.assertEqual(repr(s), 'Set{}')
s = edgedb.Set((1, 2, [], 'a'))
self.assertEqual(s[1], 2)
self.assertEqual(s[2], [])
self.assertEqual(len(s), 4)
with self.assertRaises(IndexError):
s[10]
with self.assertRaises(TypeError):
s[0] = 1
async def test_async_basic_datatypes_04(self):
val = await self.con.query_one(
'''
SELECT schema::ObjectType {
foo := {
[(a := 1, b := 2), (a := 3, b := 4)],
[(a := 5, b := 6)],
<array <tuple<a: int64, b: int64>>>[],
}
} LIMIT 1
'''
)
self.assertEqual(
val.foo,
edgedb.Set([
edgedb.Array([
edgedb.NamedTuple(a=1, b=2),
edgedb.NamedTuple(a=3, b=4),
]),
edgedb.Array([
edgedb.NamedTuple(a=5, b=6),
]),
edgedb.Array([]),
]),
)
def test_object_links_2(self):
User = private.create_object_factory(
id='property',
friends='link',
enemies='link',
)
u1 = User(1, edgedb.Set([]), edgedb.Set([]))
u2 = User(2, edgedb.Set([]), edgedb.Set([]))
u3 = User(3, edgedb.Set([]), edgedb.Set([]))
u4 = User(4, edgedb.Set([u1, u2]), edgedb.Set([u1, u2]))
u5 = User(5, edgedb.Set([u1, u3]), edgedb.Set([u1, u2]))
self.assertNotEqual(u4['friends'], u4['enemies'])
self.assertNotEqual(u4['enemies'], u5['enemies'])
self.assertEqual(set(dir(u1)), {'id', 'friends', 'enemies'})
def test_set_6(self):
f = private.create_object_factory(id={'property', 'implicit'},
lb='link-property',
c='property')
o1 = f(1, 'aa', edgedb.Set([1, 2, 3]))
o2 = f(1, 'ab', edgedb.Set([1, 2, 4]))
o3 = f(3, 'ac', edgedb.Set([5, 5, 5, 5]))
self.assertEqual(edgedb.Set([o1, o2, o3]), edgedb.Set([o2, o3, o1]))
self.assertEqual(edgedb.Set([o1, o3]), edgedb.Set([o2, o3]))
self.assertNotEqual(edgedb.Set([o1, o1]), edgedb.Set([o2, o3]))
def test_sync_exec_error_recover_03(self):
query = 'select 10 // <int64>$0;'
for i in [1, 2, 0, 3, 1, 0, 1]:
if i:
self.assertEqual(self.con.query(query, i),
edgedb.Set([10 // i]))
else:
with self.assertRaises(edgedb.DivisionByZeroError):
self.con.query(query, i)
def test_sync_exec_error_recover_01(self):
for _ in range(2):
with self.assertRaises(edgedb.DivisionByZeroError):
self.con.query('select 1 / 0;')
with self.assertRaises(edgedb.DivisionByZeroError):
self.con.query('select 1 / 0;')
for _ in range(10):
self.assertEqual(self.con.query('select 1;'), edgedb.Set(
(1, )))
async def test_json_elements(self):
result, _ = await self.client.connection.raw_query(
abstract.QueryContext(
query=abstract.QueryWithArgs('SELECT {"aaa", "bbb"}', (), {}),
cache=self.client._get_query_cache(),
query_options=abstract.QueryOptions(
io_format=protocol.IoFormat.JSON_ELEMENTS,
expect_one=False,
required_one=False,
),
retry_options=None,
))
self.assertEqual(result, edgedb.Set(['"aaa"', '"bbb"']))
def test_object_links_1(self):
O2 = private.create_object_factory(
id='property',
lb='link-property',
c='property'
)
O1 = private.create_object_factory(
id='property',
o2s='link'
)
o2_1 = O2(1, 'linkprop o2 1', 3)
o2_2 = O2(4, 'linkprop o2 2', 6)
o1 = O1(2, edgedb.Set((o2_1, o2_2)))
linkset = o1['o2s']
self.assertEqual(len(linkset), 2)
self.assertEqual(linkset, o1['o2s'])
self.assertEqual(hash(linkset), hash(o1['o2s']))
self.assertEqual(
repr(linkset),
"LinkSet(name='o2s', source_id=2, target_ids={1, 4})")
link1 = linkset[0]
self.assertIs(link1.source, o1)
self.assertIs(link1.target, o2_1)
self.assertEqual(
repr(link1),
"Link(name='o2s', source_id=2, target_id=1)")
self.assertEqual(set(dir(link1)), {'target', 'source', 'lb'})
link2 = linkset[1]
self.assertIs(link2.source, o1)
self.assertIs(link2.target, o2_2)
self.assertNotEqual(link1, link2)
self.assertEqual(list(linkset), [link1, link2])
self.assertEqual([l for l in linkset], [link1, link2])
self.assertNotEqual(link1, link2)
self.assertEqual(link1.lb, 'linkprop o2 1')
self.assertEqual(link2.lb, 'linkprop o2 2')
with self.assertRaises(AttributeError):
link2.aaaa
def test_sync_parse_error_recover_01(self):
for _ in range(2):
with self.assertRaises(edgedb.EdgeQLSyntaxError):
self.con.query('select syntax error')
with self.assertRaises(edgedb.EdgeQLSyntaxError):
self.con.query('select syntax error')
with self.assertRaisesRegex(edgedb.EdgeQLSyntaxError,
'Unexpected end of line'):
self.con.query('select (')
with self.assertRaisesRegex(edgedb.EdgeQLSyntaxError,
'Unexpected end of line'):
self.con.query_json('select (')
for _ in range(10):
self.assertEqual(self.con.query('select 1;'), edgedb.Set(
(1, )))
self.assertFalse(self.con.is_closed())
def test_object_links_3(self):
User = private.create_object_factory(
id='property',
friend='link',
)
u1 = User(1, None)
u2 = User(2, u1)
u3 = User(3, edgedb.Set([]))
self.assertEqual(set(dir(u2['friend'])), {'source', 'target'})
self.assertIs(u2['friend'].target, u1)
self.assertIsNone(u1['friend'])
self.assertEqual(len(u3['friend']), 0)
self.assertEqual(repr(u3['friend']),
"LinkSet(name='friend', source_id=3, target_ids={})")
self.assertEqual(repr(u2['friend']),
"Link(name='friend', source_id=2, target_id=1)")
def test_set_3(self):
s = edgedb.Set(())
self.assertEqual(len(s), 0)
self.assertEqual(hash(s), hash(edgedb.Set(())))
self.assertNotEqual(hash(s), hash(()))
async def test_async_args_01(self):
self.assertEqual(
await self.con.fetchall(
'select (<array<str>>$foo)[0] ++ (<array<str>>$bar)[0];',
foo=['aaa'], bar=['bbb']),
edgedb.Set(('aaabbb',)))
async def test_async_args_02(self):
self.assertEqual(
await self.con.fetchall(
'select (<array<str>>$0)[0] ++ (<array<str>>$1)[0];',
['aaa'], ['bbb']),
edgedb.Set(('aaabbb',)))
async def test_json_elements(self):
self.assertEqual(
await self.con._fetchall_json_elements('SELECT {"aaa", "bbb"}'),
edgedb.Set(['"aaa"', '"bbb"']))
def test_set_4(self):
s = edgedb.Set(([], ))
s[0].append(s)
self.assertEqual(repr(s), "Set{[Set{...}]}")
def test_set_5(self):
self.assertEqual(edgedb.Set([1, 2, 3]), edgedb.Set([3, 2, 1]))
self.assertEqual(edgedb.Set([]), edgedb.Set([]))
self.assertEqual(edgedb.Set([1]), edgedb.Set([1]))
self.assertNotEqual(edgedb.Set([1]), edgedb.Set([]))
self.assertNotEqual(edgedb.Set([1]), edgedb.Set([2]))
self.assertNotEqual(edgedb.Set([1, 2]), edgedb.Set([2, 2]))
self.assertNotEqual(edgedb.Set([1, 1, 2]), edgedb.Set([2, 2, 1]))
def test_sync_args_01(self):
self.assertEqual(
self.con.query(
'select (<array<str>>$foo)[0] ++ (<array<str>>$bar)[0];',
foo=['aaa'],
bar=['bbb']), edgedb.Set(('aaabbb', )))
def test_set_8(self):
s = edgedb.Set([1, 2, 3])
si = iter(s)
self.assertEqual(list(si), [1, 2, 3])
def test_sync_args_02(self):
self.assertEqual(
self.con.query(
'select (<array<str>>$0)[0] ++ (<array<str>>$1)[0];', ['aaa'],
['bbb']), edgedb.Set(('aaabbb', )))
