code
stringlengths 26
870k
| docstring
stringlengths 1
65.6k
| func_name
stringlengths 1
194
| language
stringclasses 1
value | repo
stringlengths 8
68
| path
stringlengths 5
194
| url
stringlengths 46
254
| license
stringclasses 4
values |
|---|---|---|---|---|---|---|---|
async def test_edgeql_select_match_02(self):
await self.assert_query_result(
r"""
SELECT
Issue {number}
FILTER
Issue.name NOT LIKE '%edgedb'
ORDER BY Issue.number;
""",
[{'number': '1'}, {'number': '2'}, {'number': '3'},
{'number': '4'}],
)
await self.assert_query_result(
r"""
SELECT
Issue {number}
FILTER
Issue.name NOT LIKE '%EdgeDB'
ORDER BY Issue.number;
""",
[{'number': '2'}, {'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r"""
SELECT
Issue {number}
FILTER
Issue.name NOT LIKE '%Edge%'
ORDER BY Issue.number;
""",
[{'number': '3'}, {'number': '4'}],
) | ,
[{'number': '1'}, {'number': '2'}, {'number': '3'},
{'number': '4'}],
)
await self.assert_query_result(
r | test_edgeql_select_match_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_match_03(self):
await self.assert_query_result(
r"""
SELECT
Issue {number}
FILTER
Issue.name ILIKE '%edgedb'
ORDER BY Issue.number;
""",
[{'number': '1'}],
)
await self.assert_query_result(
r"""
SELECT
Issue {number}
FILTER
Issue.name ILIKE '%EdgeDB'
ORDER BY Issue.number;
""",
[{'number': '1'}],
)
await self.assert_query_result(
r"""
SELECT
Issue {number}
FILTER
Issue.name ILIKE '%re%'
ORDER BY Issue.number;
""",
[{'number': '1'}, {'number': '2'}, {'number': '3'},
{'number': '4'}],
) | ,
[{'number': '1'}],
)
await self.assert_query_result(
r | test_edgeql_select_match_03 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_match_04(self):
await self.assert_query_result(
r"""
SELECT
Issue {number}
FILTER
Issue.name NOT ILIKE '%edgedb'
ORDER BY Issue.number;
""",
[{'number': '2'}, {'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r"""
SELECT
Issue {number}
FILTER
Issue.name NOT ILIKE '%EdgeDB'
ORDER BY Issue.number;
""",
[{'number': '2'}, {'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r"""
SELECT
Issue {number}
FILTER
Issue.name NOT ILIKE '%re%'
ORDER BY Issue.number;
""",
[],
) | ,
[{'number': '2'}, {'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r | test_edgeql_select_match_04 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_match_07(self):
await self.assert_query_result(
r"""
SELECT
Text {body}
FILTER
re_test('ed', Text.body)
ORDER BY Text.body;
""",
[{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'We need to be able to render data in tabular format.'}],
)
await self.assert_query_result(
r"""
SELECT
Text {body}
FILTER
re_test('eD', Text.body)
ORDER BY Text.body;
""",
[{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Initial public release of EdgeDB.'}],
)
await self.assert_query_result(
r"""
SELECT
Text {body}
FILTER
re_test(r'ed([S\s]|$)', Text.body)
ORDER BY Text.body;
""",
[{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'We need to be able to render data in tabular format.'}]
) | ,
[{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'We need to be able to render data in tabular format.'}],
)
await self.assert_query_result(
r | test_edgeql_select_match_07 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_match_08(self):
await self.assert_query_result(
r"""
SELECT
Text {body}
FILTER
re_test('(?i)ed', Text.body)
ORDER BY Text.body;
""",
[{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'Initial public release of EdgeDB.'},
{'body': 'We need to be able to render data in tabular format.'}],
)
await self.assert_query_result(
r"""
SELECT
Text {body}
FILTER
re_test('(?i)eD', Text.body)
ORDER BY Text.body;
""",
[{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'Initial public release of EdgeDB.'},
{'body': 'We need to be able to render data in tabular format.'}],
)
await self.assert_query_result(
r"""
SELECT
Text {body}
FILTER
re_test(r'(?i)ed([S\s]|$)', Text.body)
ORDER BY Text.body;
""",
[{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'We need to be able to render data in tabular format.'}],
) | ,
[{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'Initial public release of EdgeDB.'},
{'body': 'We need to be able to render data in tabular format.'}],
)
await self.assert_query_result(
r | test_edgeql_select_match_08 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_type_04(self):
# Make sure that the __type__ attribute gets the same object
# as a direct schema::ObjectType query. As long as this is true,
# we can test the schema separately without any other data.
res = await self.con.query_single(r'''
SELECT User {
__type__: {
name,
id,
}
} LIMIT 1;
''')
await self.assert_query_result(
r'''
WITH MODULE schema
SELECT `ObjectType` {
name,
id,
} FILTER `ObjectType`.name = 'default::User';
''',
[{
'name': res.__type__.name,
'id': str(res.__type__.id),
}]
) | )
await self.assert_query_result(
r | test_edgeql_select_type_04 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_recursive_01(self):
await self.assert_query_result(
r'''
SELECT
Issue {
number,
related_to: {
number,
},
}
FILTER
Issue.number = '2';
''',
[{
'number': '3',
'related_to': [{
'number': '2',
}]
}],
)
await self.assert_query_result(
r'''
SELECT
Issue {
number,
related_to *1
}
FILTER
Issue.number = '2';
''',
[{
'number': '3',
'related_to': [{
'number': '2',
}]
}],
) | ,
[{
'number': '3',
'related_to': [{
'number': '2',
}]
}],
)
await self.assert_query_result(
r | test_edgeql_select_recursive_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_limit_01(self):
await self.assert_query_result(
r'''
SELECT
Issue {number}
ORDER BY Issue.number
OFFSET 2;
''',
[{'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r'''
SELECT
Issue {number}
ORDER BY Issue.number
LIMIT 3;
''',
[{'number': '1'}, {'number': '2'}, {'number': '3'}],
)
await self.assert_query_result(
r'''
SELECT
Issue {number}
ORDER BY Issue.number
OFFSET 2 LIMIT 3;
''',
[{'number': '3'}, {'number': '4'}],
) | ,
[{'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r | test_edgeql_select_limit_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_limit_02(self):
await self.assert_query_result(
r'''
SELECT
Issue {number}
ORDER BY Issue.number
OFFSET 1 + 1;
''',
[{'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r'''
SELECT
Issue {number}
ORDER BY Issue.number
LIMIT 6 // 2;
''',
[{'number': '1'}, {'number': '2'}, {'number': '3'}],
)
await self.assert_query_result(
r'''
SELECT
Issue {number}
ORDER BY Issue.number
OFFSET 4 - 2 LIMIT 5 * 2 - 7;
''',
[{'number': '3'}, {'number': '4'}],
) | ,
[{'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r | test_edgeql_select_limit_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_limit_03(self):
await self.assert_query_result(
r'''
SELECT
Issue {number}
ORDER BY Issue.number
OFFSET (SELECT count(Status));
''',
[{'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r'''
SELECT
Issue {number}
ORDER BY Issue.number
LIMIT (SELECT count(Status) + 1);
''',
[{'number': '1'}, {'number': '2'}, {'number': '3'}],
)
await self.assert_query_result(
r'''
SELECT
Issue {number}
ORDER BY Issue.number
OFFSET (SELECT count(Status))
LIMIT (SELECT count(Priority) + 1);
''',
[{'number': '3'}, {'number': '4'}],
) | ,
[{'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r | test_edgeql_select_limit_03 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_limit_11(self):
await self.assert_query_result(
r'''
SELECT (SELECT {<optional str>$0, 'x'} LIMIT 1)
''',
['x'],
variables=(None,),
)
await self.assert_query_result(
r'''
SELECT (SELECT {<optional str>$0, 'x'} OFFSET 1)
''',
[],
variables=(None,),
) | ,
['x'],
variables=(None,),
)
await self.assert_query_result(
r | test_edgeql_select_limit_11 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_polymorphic_01(self):
await self.assert_query_result(
r'''
SELECT
Text {body}
ORDER BY Text.body;
''',
[
{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'Initial public release of EdgeDB.'},
{'body': 'Minor lexer tweaks.'},
{'body': 'Rewriting everything.'},
{'body': 'We need to be able to render data '
'in tabular format.'}
],
)
await self.assert_query_result(
r'''
SELECT
Text {
[IS Issue].name,
body,
}
ORDER BY Text.body;
''',
[
{'body': 'EdgeDB needs to happen soon.',
'name': None},
{'body': 'Fix regression introduced by lexer tweak.',
'name': 'Regression.'},
{'body': 'Initial public release of EdgeDB.',
'name': 'Release EdgeDB'},
{'body': 'Minor lexer tweaks.',
'name': 'Repl tweak.'},
{'body': 'Rewriting everything.',
'name': None},
{'body': 'We need to be able to render data in '
'tabular format.',
'name': 'Improve EdgeDB repl output rendering.'}
]
) | ,
[
{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'Initial public release of EdgeDB.'},
{'body': 'Minor lexer tweaks.'},
{'body': 'Rewriting everything.'},
{'body': 'We need to be able to render data '
'in tabular format.'}
],
)
await self.assert_query_result(
r | test_edgeql_select_polymorphic_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_polymorphic_06(self):
await self.assert_query_result(
r'''
SELECT Object[IS Status].name;
''',
{
'Closed',
'Open',
},
)
await self.assert_query_result(
r'''
SELECT Object[IS Priority].name;
''',
{
'High',
'Low',
},
) | ,
{
'Closed',
'Open',
},
)
await self.assert_query_result(
r | test_edgeql_select_polymorphic_06 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_polymorphic_08(self):
await self.assert_query_result(
r'''
SELECT Object {
[IS Status | Priority].name,
} ORDER BY .name;
''',
[
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': 'Closed'},
{'name': 'High'},
{'name': 'Low'},
{'name': 'Open'}
],
)
await self.assert_query_result(
r'''
# the above should be equivalent to this:
SELECT Object {
name := Object[IS Status].name ?? Object[IS Priority].name,
} ORDER BY .name;
''',
[
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': 'Closed'},
{'name': 'High'},
{'name': 'Low'},
{'name': 'Open'}
],
) | ,
[
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': None},
{'name': 'Closed'},
{'name': 'High'},
{'name': 'Low'},
{'name': 'Open'}
],
)
await self.assert_query_result(
r | test_edgeql_select_polymorphic_08 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_polymorphic_10(self):
await self.assert_query_result(
r'''
SELECT
count(Object[IS Named][IS Text])
!= count(Object[IS Text]);
''',
[True]
)
await self.assert_query_result(
r'''
SELECT
count(User.<owner[IS Named][IS Text])
!= count(User.<owner[IS Text]);
''',
[True]
) | ,
[True]
)
await self.assert_query_result(
r | test_edgeql_select_polymorphic_10 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_polymorphic_12(self):
await self.con.execute('''
INSERT Issue {
name := 'Polymorphic Test 12',
body := 'foo',
number := '333',
owner := (SELECT User FILTER .name = 'Elvis'),
status := (SELECT Status FILTER .name = 'Open'),
references := (
INSERT Publication {
title := 'Introduction to EdgeDB',
authors := (
FOR v IN enumerate({'Yury', 'Elvis'})
UNION (
SELECT User { @list_order := v.0 }
FILTER .name = v.1
)
),
}
)
}
''')
await self.assert_query_result(
r'''
SELECT Issue {
references: {
[IS Publication].authors: {
name
} ORDER BY @list_order
}
}
FILTER .number = '333'
''',
[
{
'references': [{
'authors': [{
'name': 'Yury'
}, {
'name': 'Elvis'
}]
}],
},
],
) | )
await self.assert_query_result(
r | test_edgeql_select_polymorphic_12 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_polymorphic_13(self):
await self.con.execute('''
INSERT Issue {
name := 'Polymorphic Test 13',
body := 'foo',
number := '333',
owner := (SELECT User FILTER .name = 'Elvis'),
status := (SELECT Status FILTER .name = 'Open'),
references := (
FOR v IN {
('Introduction to EdgeDB Part Deux', 2),
('Introduction to EdgeDB', 1),
}
UNION (
INSERT Publication {
title := v.0,
@list_order := v.1,
}
)
)
}
''')
await self.assert_query_result(
r'''
SELECT Issue {
references[IS Publication]: {
title
} ORDER BY @list_order
}
FILTER .name = 'Polymorphic Test 13'
''',
[
{
'references': [{
'title': 'Introduction to EdgeDB',
}, {
'title': 'Introduction to EdgeDB Part Deux',
}],
},
],
) | )
await self.assert_query_result(
r | test_edgeql_select_polymorphic_13 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_splat_04(self):
# Polymorphic splats
await self.con.execute('''
insert Issue {
name := 'Polymorphic Splat Test 04',
body := 'foo',
number := '3333',
owner := (select User FILTER .name = 'Elvis'),
status := (select Status FILTER .name = 'Open'),
references := {
(insert Publication {
title := 'Introduction to EdgeDB',
authors := (
FOR v IN enumerate({'Yury', 'Elvis'})
UNION (
SELECT User { @list_order := v.0 }
FILTER .name = v.1
)
),
}),
(insert File {
name := 'file01.jpg',
}),
}
}
''')
await self.assert_query_result(
r'''
select Issue {
references: {
[is File].*,
[is Publication].**,
}
}
filter .name = 'Polymorphic Splat Test 04'
''',
tb.bag([
{
"references": tb.bag([
{
"title": "Introduction to EdgeDB",
"authors": tb.bag([
{
"name": "Yury",
},
{
"name": "Elvis",
},
]),
},
{
"name": "file01.jpg",
}
]),
},
]),
) | )
await self.assert_query_result(
r | test_edgeql_select_splat_04 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_splat_05(self):
# Polymorphic splat conflicts
res = [
{
"id": str,
"name": "Elvis",
"body": None,
"due_date": None,
"number": None,
"start_date": None,
"tags": None,
"time_estimate": None,
},
{
"id": str,
"name": "Release EdgeDB",
"body": "Initial public release of EdgeDB.",
"due_date": None,
"number": "1",
"start_date": str,
"tags": None,
"time_estimate": 3000,
},
]
await self.assert_query_result(
r'''
select Named { *, [is Issue].* }
filter .name in {'Elvis', 'Release EdgeDB'}
order by .name;
''',
res,
)
await self.assert_query_result(
r'''
select Named { [is Issue].*, * }
filter .name in {'Elvis', 'Release EdgeDB'}
order by .name;
''',
res,
)
await self.assert_query_result(
r'''
select {Issue, User} { [is Issue].*, * }
filter .name in {'Elvis', 'Release EdgeDB'}
order by .name;
''',
res,
)
await self.assert_query_result(
r'''
select {Issue, User} { *, [is Issue].* }
filter .name in {'Elvis', 'Release EdgeDB'}
order by .name;
''',
res,
)
await self.assert_query_result(
r'''
select Object { [is Named].*, [is Issue].* }
filter .name in {'Elvis', 'Release EdgeDB'}
order by .name;
''',
res
)
await self.assert_query_result(
r'''
select Object { [is Issue].*, [is Named].* }
filter .name in {'Elvis', 'Release EdgeDB'}
order by .name;
''',
res
)
# TODO: Ideally this would work
with self.assertRaisesRegex(
edgedb.QueryError,
"appears in splats for unrelated types",
):
await self.con.execute('''
select Object { [is User].*, [is Issue].* }
filter .name in {'Elvis', 'Release EdgeDB'}
order by .name;
''') | ,
res,
)
await self.assert_query_result(
r | test_edgeql_select_splat_05 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_splat_06(self):
# Target property and link property with same name
await self.con.execute('''
CREATE TYPE X {
CREATE PROPERTY a: int64;
};
CREATE TYPE Y {
CREATE LINK x: X {
CREATE PROPERTY a: int64;
};
};
insert Y { x := ( insert X { a := 1 } ){ @a := 2 } };
''')
await self.assert_query_result(
r'''
select Y {**}
''',
tb.bag([
{'x': {'a': 1, '@a': 2}}
]),
) | )
await self.assert_query_result(
r | test_edgeql_select_splat_06 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_reverse_link_02(self):
await self.assert_query_result(
r'''
SELECT
User.<owner[IS Issue]@since
''',
['2018-01-01T00:00:00+00:00'],
)
await self.assert_query_result(
r'''
SELECT
User.<owner[IS Named]@since
''',
['2018-01-01T00:00:00+00:00'],
) | ,
['2018-01-01T00:00:00+00:00'],
)
await self.assert_query_result(
r | test_edgeql_select_reverse_link_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_setops_02(self):
await self.assert_query_result(
r'''
WITH
Obj := (SELECT Issue UNION Comment)
SELECT Obj {
[IS Issue].name,
[IS Text].body
};
''',
tb.bag([
{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'Initial public release of EdgeDB.'},
{'body': 'Minor lexer tweaks.'},
{'body': 'We need to be able to render '
'data in tabular format.'}
]),
)
await self.assert_query_result(
r'''
# XXX: I think we should be able to drop [IS Text] from
# the query below.
WITH
Obj := (SELECT Issue UNION Comment)
SELECT Obj[IS Text] { id, body }
ORDER BY Obj[IS Text].body;
''',
[
{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'Initial public release of EdgeDB.'},
{'body': 'Minor lexer tweaks.'},
{'body': 'We need to be able to render '
'data in tabular format.'}
],
) | ,
tb.bag([
{'body': 'EdgeDB needs to happen soon.'},
{'body': 'Fix regression introduced by lexer tweak.'},
{'body': 'Initial public release of EdgeDB.'},
{'body': 'Minor lexer tweaks.'},
{'body': 'We need to be able to render '
'data in tabular format.'}
]),
)
await self.assert_query_result(
r | test_edgeql_select_setops_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_setops_19(self):
await self.assert_query_result(
r"""
# UNION between Issue and empty set Issue should be
# duck-typed to be effectively equivalent to Issue[IS
# Issue], which is just an Issue.
SELECT (Issue UNION <Issue>{}).name;
""",
{
'Release EdgeDB',
'Improve EdgeDB repl output rendering.',
'Repl tweak.',
'Regression.',
},
)
await self.assert_query_result(
r"""
SELECT (Issue UNION <Issue>{}).number;
""",
{'1', '2', '3', '4'},
) | ,
{
'Release EdgeDB',
'Improve EdgeDB repl output rendering.',
'Repl tweak.',
'Regression.',
},
)
await self.assert_query_result(
r | test_edgeql_select_setops_19 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_setops_23(self):
await self.assert_query_result(
r"""
WITH X := (insert Publication { title := "x" }),
Y := (insert Publication { title := "y" }),
foo := X union Y,
select foo { title1 };
""",
tb.bag([
{'title1': 'x'},
{'title1': 'y'},
])
)
await self.assert_query_result(
r"""
WITH X := (select Publication filter .title = 'x'),
Y := (select Publication filter .title = 'y'),
foo := X union Y,
select foo { title1 };
""",
tb.bag([
{'title1': 'x'},
{'title1': 'y'},
])
)
await self.assert_query_result(
r"""
SELECT (Issue UNION <Issue>{}).number;
""",
{'1', '2', '3', '4'},
) | ,
tb.bag([
{'title1': 'x'},
{'title1': 'y'},
])
)
await self.assert_query_result(
r | test_edgeql_select_setops_23 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_setops_24(self):
# Establish that EXCEPT and INTERSECT filter out the objects we'd
# expect.
await self.assert_query_result(
r"""
with A := Owned except {LogEntry, Comment}
select all(A in Issue) and all(Issue in A)
""",
{
True
},
)
await self.assert_query_result(
r"""
with A := Owned intersect Issue
select all(A in Owned[is Issue]) and all(Owned[is Issue] in A)
""",
{
True
},
) | ,
{
True
},
)
await self.assert_query_result(
r | test_edgeql_select_setops_24 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_setops_25(self):
# Establish that EXCEPT and INTERSECT filter out the objects we'd
# expect.
await self.assert_query_result(
r"""
with
A := (select Issue filter .name ilike '%edgedb%'),
B := (select Issue filter .owner.name = 'Elvis')
select (B except A) {name};
""",
[
{'name': 'Regression.'},
],
)
await self.assert_query_result(
r"""
with
A := (select Issue filter .name ilike '%edgedb%'),
B := (select Issue filter .owner.name = 'Elvis')
select (B intersect A) {name};
""",
[
{'name': 'Release EdgeDB'},
],
) | ,
[
{'name': 'Regression.'},
],
)
await self.assert_query_result(
r | test_edgeql_select_setops_25 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_setops_26(self):
# Establish that EXCEPT and INTERSECT filter out the objects we'd
# expect.
await self.assert_query_result(
r"""
select (Issue except Named);
""",
[],
)
await self.assert_query_result(
r"""
select (Issue intersect <Named>{});
""",
[],
) | ,
[],
)
await self.assert_query_result(
r | test_edgeql_select_setops_26 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_setops_27(self):
await self.assert_query_result(
r"""
with
A := (select Issue filter .name not ilike '%edgedb%').body
select _ :=
str_lower(array_unpack(str_split(A, ' ')))
except
{'minor', 'fix', 'lexer'}
order by _
""",
[
"by",
"introduced",
"lexer",
"regression",
"tweak.",
"tweaks.",
],
)
await self.assert_query_result(
r"""
with A := (select Issue filter .name not ilike '%edgedb%')
select _ :=
str_lower(array_unpack(str_split(A.body, ' ')))
except
str_lower(array_unpack(str_split(A.name, ' ')))
order by _
""",
[
"by",
"fix",
"introduced",
"lexer",
"lexer",
"minor",
"regression",
"tweaks.",
],
) | ,
[
"by",
"introduced",
"lexer",
"regression",
"tweak.",
"tweaks.",
],
)
await self.assert_query_result(
r | test_edgeql_select_setops_27 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_setops_28(self):
await self.assert_query_result(
r"""
select _ :=
len(array_unpack(str_split(Issue.body, ' ')))
intersect {1, 2, 2, 3, 3, 3, 7, 7, 7, 7, 7, 7, 7}
order by _
""",
[
2, 2, 3, 7, 7, 7, 7, 7, 7
],
)
await self.assert_query_result(
r"""
select _ :=
str_lower(array_unpack(str_split(Issue.name, ' ')))
except
str_lower(array_unpack(str_split(Issue.body, ' ')))
order by _
""",
[
"edgedb",
"edgedb",
"improve",
"output",
"regression.",
"rendering.",
"repl",
"repl",
],
) | ,
[
2, 2, 3, 7, 7, 7, 7, 7, 7
],
)
await self.assert_query_result(
r | test_edgeql_select_setops_28 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_setops_29(self):
# These queries all produced compiler ISEs in the past
# The results aren't super important, so just run them
await self.con.query('''
select std::BaseObject
UNION schema::Object UNION schema::TupleElement;
''')
await self.con.query('''
select std::BaseObject
EXCEPT schema::Object EXCEPT schema::TupleElement;
''')
await self.con.query('''
select std::BaseObject
EXCEPT schema::Object INTERSECT schema::TupleElement;
''')
await self.con.query('''
select std::BaseObject
INTERSECT schema::Object INTERSECT schema::TupleElement;
''') | )
await self.con.query( | test_edgeql_select_setops_29 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_order_01(self):
await self.assert_query_result(
r'''
SELECT Issue {name}
ORDER BY Issue.priority.name ASC EMPTY LAST THEN Issue.name;
''',
[
{'name': 'Improve EdgeDB repl output rendering.'},
{'name': 'Repl tweak.'},
{'name': 'Regression.'},
{'name': 'Release EdgeDB'},
],
)
await self.assert_query_result(
r'''
SELECT Issue {name}
ORDER BY Issue.priority.name ASC EMPTY FIRST THEN Issue.name;
''',
[
{'name': 'Regression.'},
{'name': 'Release EdgeDB'},
{'name': 'Improve EdgeDB repl output rendering.'},
{'name': 'Repl tweak.'},
]
) | ,
[
{'name': 'Improve EdgeDB repl output rendering.'},
{'name': 'Repl tweak.'},
{'name': 'Regression.'},
{'name': 'Release EdgeDB'},
],
)
await self.assert_query_result(
r | test_edgeql_select_order_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_func_05(self):
await self.con.execute(r'''
CREATE FUNCTION concat1(VARIADIC s: anytype) -> std::str
USING SQL FUNCTION 'concat';
''')
await self.assert_query_result(
r'''
SELECT schema::Function {
params: {
num,
kind,
type: {
name
}
}
} FILTER schema::Function.name = 'default::concat1';
''',
[{'params': [
{
'num': 0,
'kind': 'VariadicParam',
'type': {
'name': 'array<anytype>'
}
}
]}]
)
with self.assertRaisesRegex(
edgedb.QueryError,
r'function .+ does not exist'):
async with self.con.transaction():
await self.con.query(
"SELECT concat1('aaa', 'bbb', 2);")
await self.con.execute(r'''
DROP FUNCTION concat1(VARIADIC s: anytype);
''') | )
await self.assert_query_result(
r | test_edgeql_select_func_05 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_func_07(self):
await self.con.execute(r'''
CREATE FUNCTION concat3(sep: OPTIONAL std::str,
VARIADIC s: std::str)
-> std::str
USING EdgeQL $$
# poor man concat
SELECT (array_get(s, 0) ?? '') ++
(sep ?? '::') ++
(array_get(s, 1) ?? '')
$$;
''')
await self.assert_query_result(
r'''
SELECT schema::Function {
params: {
num,
name,
kind,
type: {
name,
[IS schema::Array].element_type: {
name
}
},
typemod
} ORDER BY .num ASC,
return_type: {
name
},
return_typemod
} FILTER schema::Function.name = 'default::concat3';
''',
[{
'params': [
{
'num': 0,
'name': 'sep',
'kind': 'PositionalParam',
'type': {
'name': 'std::str',
'element_type': None
},
'typemod': 'OptionalType'
},
{
'num': 1,
'name': 's',
'kind': 'VariadicParam',
'type': {
'name': 'array<std::str>',
'element_type': {'name': 'std::str'}
},
'typemod': 'SingletonType'
}
],
'return_type': {
'name': 'std::str'
},
'return_typemod': 'SingletonType'
}]
)
with self.assertRaisesRegex(
edgedb.QueryError,
r'function .+ does not exist'):
async with self.con.transaction():
await self.con.query(r'SELECT concat3(123);')
with self.assertRaisesRegex(
edgedb.QueryError,
r'function .+ does not exist'):
async with self.con.transaction():
await self.con.query(r'SELECT concat3("a", 123);')
await self.assert_query_result(
r'''
SELECT concat3('|', '1', '2');
''',
['1|2'],
)
await self.con.execute(r'''
DROP FUNCTION concat3(sep: std::str, VARIADIC s: std::str);
''') | )
await self.assert_query_result(
r | test_edgeql_select_func_07 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_exists_01(self):
await self.assert_query_result(
r'''
SELECT
Issue {
number
}
FILTER
NOT EXISTS Issue.time_estimate
ORDER BY
Issue.number;
''',
[{'number': '2'}, {'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r'''
SELECT
Issue {
number
}
FILTER
EXISTS Issue.time_estimate
ORDER BY
Issue.number;
''',
[{'number': '1'}],
) | ,
[{'number': '2'}, {'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r | test_edgeql_select_exists_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_coalesce_03(self):
issues_h = await self.con.query(r'''
SELECT Issue{number}
FILTER
Issue.priority.name = 'High'
ORDER BY Issue.number;
''')
issues_n = await self.con.query(r'''
SELECT Issue{number}
FILTER
NOT EXISTS Issue.priority
ORDER BY Issue.number;
''')
await self.assert_query_result(
r'''
SELECT Issue{number}
FILTER
Issue.priority.name ?? 'High' = 'High'
ORDER BY
Issue.priority.name EMPTY LAST THEN Issue.number;
''',
[{'number': o.number} for o in [*issues_h, *issues_n]]
) | )
issues_n = await self.con.query(r | test_edgeql_select_coalesce_03 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_or_01(self):
issues_h = await self.con.query(r'''
SELECT Issue{number}
FILTER
Issue.priority.name = 'High'
ORDER BY Issue.number;
''')
issues_l = await self.con.query(r'''
SELECT Issue{number}
FILTER
Issue.priority.name = 'Low'
ORDER BY Issue.number;
''')
# XXX(factor): need to follow multiple steps in warn analysis
await self.assert_query_result(
r'''
SELECT Issue{number}
FILTER
Issue.priority.name = 'High'
OR
Issue.priority.name = 'Low'
ORDER BY Issue.priority.name THEN Issue.number;
''',
[{'number': o.number} for o in [*issues_h, *issues_l]]
) | )
issues_l = await self.con.query(r | test_edgeql_select_or_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_or_04(self):
# XXX(factor): need to follow multiple steps in warn analysis
await self.assert_query_result(
r'''
SELECT Issue{number}
FILTER
Issue.priority.name = 'High'
OR
Issue.status.name = 'Closed'
ORDER BY Issue.number;
''',
[{'number': '2'}, {'number': '3'}],
)
await self.assert_query_result(
r'''
SELECT Issue{number}
FILTER
Issue.priority.name = 'High'
OR
Issue.priority.name = 'Low'
OR
Issue.status.name = 'Closed'
ORDER BY Issue.number;
''',
# it so happens that all low priority issues are also closed
[{'number': '2'}, {'number': '3'}],
)
await self.assert_query_result(
r'''
SELECT Issue{number}
FILTER
Issue.priority.name IN {'High', 'Low'}
OR
Issue.status.name = 'Closed'
ORDER BY Issue.number;
''',
[{'number': '2'}, {'number': '3'}],
) | ,
[{'number': '2'}, {'number': '3'}],
)
await self.assert_query_result(
r | test_edgeql_select_or_04 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_or_05(self):
await self.assert_query_result(
r'''
SELECT Issue{number}
FILTER
NOT EXISTS Issue.priority.id
OR
Issue.status.name = 'Closed'
ORDER BY Issue.number;
''',
[{'number': '1'}, {'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r'''
# should be identical
SELECT Issue{number}
FILTER
NOT EXISTS Issue.priority
OR
Issue.status.name = 'Closed'
ORDER BY Issue.number;
''',
[{'number': '1'}, {'number': '3'}, {'number': '4'}],
) | ,
[{'number': '1'}, {'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r | test_edgeql_select_or_05 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_not_01(self):
await self.assert_query_result(
r'''
SELECT Issue{number}
FILTER NOT Issue.priority.name = 'High'
ORDER BY Issue.number;
''',
[{'number': '3'}],
)
await self.assert_query_result(
r'''
SELECT Issue{number}
FILTER Issue.priority.name != 'High'
ORDER BY Issue.number;
''',
[{'number': '3'}],
) | ,
[{'number': '3'}],
)
await self.assert_query_result(
r | test_edgeql_select_not_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_not_02(self):
# testing double negation
await self.assert_query_result(
r'''
SELECT Issue{number}
FILTER NOT NOT NOT Issue.priority.name = 'High'
ORDER BY Issue.number;
''',
[{'number': '3'}],
)
await self.assert_query_result(
r'''
SELECT Issue{number}
FILTER NOT NOT Issue.priority.name != 'High'
ORDER BY Issue.number;
''',
[{'number': '3'}],
) | ,
[{'number': '3'}],
)
await self.assert_query_result(
r | test_edgeql_select_not_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_not_04(self):
# testing double negation
await self.assert_query_result(
r'''
select BooleanTest {
name,
val,
x := not (.val < 5)
} order by .name;
''',
[
{'name': 'circle', 'val': 2, 'x': False},
{'name': 'hexagon', 'val': 4, 'x': False},
{'name': 'pentagon', 'val': None, 'x': None},
{'name': 'square', 'val': None, 'x': None},
{'name': 'triangle', 'val': 10, 'x': True},
],
)
await self.assert_query_result(
r'''
select BooleanTest {
name,
val,
x := not not (.val < 5)
} order by .name;
''',
[
{'name': 'circle', 'val': 2, 'x': True},
{'name': 'hexagon', 'val': 4, 'x': True},
{'name': 'pentagon', 'val': None, 'x': None},
{'name': 'square', 'val': None, 'x': None},
{'name': 'triangle', 'val': 10, 'x': False},
],
) | ,
[
{'name': 'circle', 'val': 2, 'x': False},
{'name': 'hexagon', 'val': 4, 'x': False},
{'name': 'pentagon', 'val': None, 'x': None},
{'name': 'square', 'val': None, 'x': None},
{'name': 'triangle', 'val': 10, 'x': True},
],
)
await self.assert_query_result(
r | test_edgeql_select_not_04 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_not_05(self):
# testing double negation
await self.assert_query_result(
r'''
select BooleanTest {
name,
tags,
x := (select _ := not (.tags = 'red') order by _)
} order by .name;
''',
[{
'name': 'circle',
'tags': {'red', 'black'},
'x': [False, True],
}, {
'name': 'hexagon',
'tags': [],
'x': [],
}, {
'name': 'pentagon',
'tags': [],
'x': [],
}, {
'name': 'square',
'tags': {'red'},
'x': [False],
}, {
'name': 'triangle',
'tags': {'red', 'green'},
'x': [False, True],
}],
)
await self.assert_query_result(
r'''
select BooleanTest {
name,
tags,
x := (select _ := not not (.tags = 'red') order by _)
} order by .name;
''',
[{
'name': 'circle',
'tags': {'red', 'black'},
'x': [False, True],
}, {
'name': 'hexagon',
'tags': [],
'x': [],
}, {
'name': 'pentagon',
'tags': [],
'x': [],
}, {
'name': 'square',
'tags': {'red'},
'x': [True],
}, {
'name': 'triangle',
'tags': {'red', 'green'},
'x': [False, True],
}],
) | ,
[{
'name': 'circle',
'tags': {'red', 'black'},
'x': [False, True],
}, {
'name': 'hexagon',
'tags': [],
'x': [],
}, {
'name': 'pentagon',
'tags': [],
'x': [],
}, {
'name': 'square',
'tags': {'red'},
'x': [False],
}, {
'name': 'triangle',
'tags': {'red', 'green'},
'x': [False, True],
}],
)
await self.assert_query_result(
r | test_edgeql_select_not_05 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_empty_02(self):
await self.assert_query_result(
r"""
# Test short-circuiting operations with empty
SELECT Issue.number = '1' OR <bool>{};
""",
[],
)
await self.assert_query_result(
r"""
SELECT Issue.number = 'X' OR <bool>{};
""",
[],
)
await self.assert_query_result(
r"""
SELECT Issue.number = '1' AND <bool>{};
""",
[],
)
await self.assert_query_result(
r"""
SELECT Issue.number = 'X' AND <bool>{};
""",
[],
) | ,
[],
)
await self.assert_query_result(
r | test_edgeql_select_empty_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_empty_03(self):
await self.assert_query_result(
r"""
# Test short-circuiting operations with empty
SELECT count(Issue.number = '1' OR <bool>{});
""",
[0],
)
await self.assert_query_result(
r"""
SELECT count(Issue.number = 'X' OR <bool>{});
""",
[0],
)
await self.assert_query_result(
r"""
SELECT count(Issue.number = '1' AND <bool>{});
""",
[0],
)
await self.assert_query_result(
r"""
SELECT count(Issue.number = 'X' AND <bool>{});
""",
[0],
) | ,
[0],
)
await self.assert_query_result(
r | test_edgeql_select_empty_03 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_cross_07(self):
await self.assert_query_result(
r"""
SELECT _ := count(Issue.owner.name ++ Issue.watchers.name);
""",
[3],
)
await self.assert_query_result(
r"""
SELECT _ := count(DISTINCT (
Issue.owner.name ++ Issue.watchers.name));
""",
[2],
) | ,
[3],
)
await self.assert_query_result(
r | test_edgeql_select_cross_07 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_cross_13(self):
await self.assert_query_result(
r"""
SELECT count(count(Issue.watchers));
""",
[1],
)
await self.assert_query_result(
r"""
SELECT count(
(Issue, count(Issue.watchers))
);
""",
[4],
) | ,
[1],
)
await self.assert_query_result(
r | test_edgeql_select_cross_13 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_subqueries_11(self):
await self.assert_query_result(
r"""
SELECT Text{
[IS Issue].number,
body_length := len(Text.body)
} ORDER BY len(Text.body);
""",
[
{'number': '3', 'body_length': 19},
{'number': None, 'body_length': 21},
{'number': None, 'body_length': 28},
{'number': '1', 'body_length': 33},
{'number': '4', 'body_length': 41},
{'number': '2', 'body_length': 52},
],
)
await self.assert_query_result(
r"""
# find all issues such that there's at least one more
# Text item of similar body length (+/-5 characters)
SELECT Issue{
number,
}
FILTER
EXISTS (
SELECT Text
FILTER
Text != Issue
AND
(len(Text.body) - len(Issue.body)) ^ 2 <= 25
)
ORDER BY Issue.number;
""",
[{'number': '1'}, {'number': '3'}],
) | ,
[
{'number': '3', 'body_length': 19},
{'number': None, 'body_length': 21},
{'number': None, 'body_length': 28},
{'number': '1', 'body_length': 33},
{'number': '4', 'body_length': 41},
{'number': '2', 'body_length': 52},
],
)
await self.assert_query_result(
r | test_edgeql_select_subqueries_11 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_subqueries_18(self):
await self.assert_query_result(
r"""
# here, DETACHED doesn't do anything special, because the
# symbol U2 is reused on both sides of '+'
WITH
U2 := DETACHED User
SELECT U2.name ++ U2.name;
""",
{'ElvisElvis', 'YuryYury'},
)
await self.assert_query_result(
r"""
# DETACHED is reused on both sides of '+' directly
SELECT (DETACHED User).name ++ (DETACHED User).name;
""",
{'ElvisElvis', 'ElvisYury', 'YuryElvis', 'YuryYury'},
) | ,
{'ElvisElvis', 'YuryYury'},
)
await self.assert_query_result(
r | test_edgeql_select_subqueries_18 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_slice_01(self):
await self.assert_query_result(
r"""
# full name of the Issue is 'Release EdgeDB'
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).name[2];
""",
['l'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).name[-2];
""",
['D'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).name[2:4];
""",
['le'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).name[2:];
""",
['lease EdgeDB'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).name[:2];
""",
['Re'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).name[2:-1];
""",
['lease EdgeD'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).name[-2:];
""",
['DB'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).name[:-2];
""",
['Release Edge'],
) | ,
['l'],
)
await self.assert_query_result(
r | test_edgeql_select_slice_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_slice_02(self):
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).__type__.name;
""",
['default::Issue'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).__type__.name[2];
""",
['f'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).__type__.name[-2];
""",
['u'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).__type__.name[2:4];
""",
['fa'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).__type__.name[2:];
""",
['fault::Issue'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).__type__.name[:2];
""",
['de'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).__type__.name[2:-1];
""",
['fault::Issu'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).__type__.name[-2:];
""",
['ue'],
)
await self.assert_query_result(
r"""
SELECT (
SELECT Issue
FILTER Issue.number = '1'
).__type__.name[:-2];
""",
['default::Iss'],
) | ,
['default::Issue'],
)
await self.assert_query_result(
r | test_edgeql_select_slice_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_slice_04(self):
await self.assert_query_result(
r"""
select [1,2,3,4,5][1:];
""",
[[2, 3, 4, 5]],
)
await self.assert_query_result(
r"""
select [1,2,3,4,5][:3];
""",
[[1, 2, 3]],
)
await self.assert_query_result(
r"""
select [1,2,3][1:<int64>{}];
""",
[],
)
# try to trick the compiler and to pass NULL into edgedb._slice
await self.assert_query_result(
r"""
select [1,2,3][1:<optional int64>$0];
""",
[],
variables=(None,),
)
await self.assert_query_result(
r"""
select [1,2,3][<optional int64>$0:2];
""",
[],
variables=(None,),
)
await self.assert_query_result(
r"""
select [1,2,3][<optional int64>$0:<optional int64>$1];
""",
[],
variables=(
None,
None,
),
)
self.assertEqual(
await self.con.query(
r"""
select to_json('[true, 3, 4, null]')[1:];
"""
),
edgedb.Set(('[3, 4, null]',)),
)
self.assertEqual(
await self.con.query(
r"""
select to_json('[true, 3, 4, null]')[:2];
"""
),
edgedb.Set(('[true, 3]',)),
)
await self.assert_query_result(
r"""
select (<optional json>$0)[2:];
""",
[],
variables=(None,),
)
self.assertEqual(
await self.con.query(
r"""
select to_json('"hello world"')[2:];
"""
),
edgedb.Set(('"llo world"',)),
)
self.assertEqual(
await self.con.query(
r"""
select to_json('"hello world"')[:4];
"""
),
edgedb.Set(('"hell"',)),
)
await self.assert_query_result(
r"""
select (<array<str>>[])[0:];
""",
[[]],
)
await self.assert_query_result(
r'''select to_json('[]')[0:];''',
# JSON:
[[]],
# Binary:
['[]'],
)
await self.assert_query_result(
r'''select [(1,'foo'), (2,'bar'), (3,'baz')][1:];''',
[[(2, 'bar'), (3, 'baz')]],
)
await self.assert_query_result(
r'''select [(1,'foo'), (2,'bar'), (3,'baz')][:2];''',
[[(1, 'foo'), (2, 'bar')]],
)
await self.assert_query_result(
r'''select [(1,'foo'), (2,'bar'), (3,'baz')][1:2];''',
[[(2, 'bar')]],
)
await self.assert_query_result(
r'''
select [(1,'foo'), (2,'bar'), (3,'baz')][<optional int32>$0:];
''',
[],
variables=(None,),
)
await self.assert_query_result(
r'''
select (<optional array<int32>>$0)[2];
''',
[],
variables=(None,),
)
await self.assert_query_result(
r'''
select (<optional str>$0)[2];
''',
[],
variables=(None,),
)
await self.assert_query_result(
r'''
select to_json(<optional str>$0)[2];
''',
[],
variables=(None,),
)
await self.assert_query_result(
r'''
select (<optional array<int32>>$0)[1:2];
''',
[],
variables=(None,),
)
await self.assert_query_result(
r'''
select (<optional str>$0)[1:2];
''',
[],
variables=(None,),
)
await self.assert_query_result(
r'''
select to_json(<optional str>$0)[1:2];
''',
[],
variables=(None,),
) | ,
[[2, 3, 4, 5]],
)
await self.assert_query_result(
r | test_edgeql_select_slice_04 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_tuple_10(self):
# Tuple comparison
await self.assert_query_result(
r"""
WITH
U1 := User,
U2 := User
SELECT
(user := (SELECT U1{name} FILTER U1.name = 'Yury'))
=
(user := (SELECT U2{name} FILTER U2.name = 'Yury'));
""",
[True],
)
await self.assert_query_result(
r"""
WITH
U1 := User,
U2 := User
SELECT
(user := (SELECT U1{name} FILTER U1.name = 'Yury'))
=
(user := (SELECT U2{name} FILTER U2.name = 'Elvis'));
""",
[False],
) | ,
[True],
)
await self.assert_query_result(
r | test_edgeql_select_tuple_10 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_if_else_04(self):
await self.assert_query_result(
r"""
SELECT Issue{
kind := (Issue.priority.name
IF EXISTS Issue.priority.name
ELSE Issue.status.name)
}
ORDER BY Issue.number;
""",
[{'kind': 'Open'}, {'kind': 'High'},
{'kind': 'Low'}, {'kind': 'Closed'}],
)
await self.assert_query_result(
r"""
# Above IF is equivalent to ??,
SELECT Issue{
kind := Issue.priority.name ?? Issue.status.name
}
ORDER BY Issue.number;
""",
[{'kind': 'Open'}, {'kind': 'High'},
{'kind': 'Low'}, {'kind': 'Closed'}],
) | ,
[{'kind': 'Open'}, {'kind': 'High'},
{'kind': 'Low'}, {'kind': 'Closed'}],
)
await self.assert_query_result(
r | test_edgeql_select_if_else_04 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_if_else_05(self):
await self.assert_query_result(
r"""
SELECT Issue {number}
FILTER
Issue.priority.name = 'High'
IF EXISTS Issue.priority.name AND EXISTS 'High'
ELSE EXISTS Issue.priority.name = EXISTS 'High'
ORDER BY Issue.number;
""",
[{'number': '2'}],
)
await self.assert_query_result(
r"""
# Above IF is equivalent to ?=,
SELECT Issue {number}
FILTER
Issue.priority.name ?= 'High'
ORDER BY Issue.number;
""",
[{'number': '2'}],
) | ,
[{'number': '2'}],
)
await self.assert_query_result(
r | test_edgeql_select_if_else_05 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_if_else_06(self):
await self.assert_query_result(
r"""
SELECT Issue {number}
FILTER
Issue.priority.name != 'High'
IF EXISTS Issue.priority.name AND EXISTS 'High'
ELSE EXISTS Issue.priority.name != EXISTS 'High'
ORDER BY Issue.number;
""",
[{'number': '1'}, {'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r"""
# Above IF is equivalent to !?=,
SELECT Issue {number}
FILTER
Issue.priority.name ?!= 'High'
ORDER BY Issue.number;
""",
[{'number': '1'}, {'number': '3'}, {'number': '4'}],
) | ,
[{'number': '1'}, {'number': '3'}, {'number': '4'}],
)
await self.assert_query_result(
r | test_edgeql_select_if_else_06 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_union_target_01(self):
await self.assert_query_result(
r'''
SELECT Issue {
number,
} FILTER EXISTS (.references)
ORDER BY .number DESC;
''',
[{
'number': '2'
}],
)
await self.assert_query_result(
r'''
SELECT Issue {
number,
} FILTER .references[IS URL].address = 'https://edgedb.com'
ORDER BY .number DESC;
''',
[{
'number': '2'
}],
)
await self.assert_query_result(
r'''
SELECT Issue {
number,
} FILTER .references[IS Named].name = 'screenshot.png'
ORDER BY .number DESC;
''',
[{
'number': '2'
}],
)
await self.assert_query_result(
r'''
SELECT Issue {
number,
references[IS Named]: {
__type__: {
name
},
name
} ORDER BY .name
} FILTER EXISTS (.references)
ORDER BY .number DESC;
''',
[{
'number': '2',
'references': [
{
'name': 'edgedb.com',
'__type__': {
'name': 'default::URL'
}
},
{
'name': 'screenshot.png',
'__type__': {
'name': 'default::File'
}
}
]
}]
) | ,
[{
'number': '2'
}],
)
await self.assert_query_result(
r | test_edgeql_union_target_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_json_01a(self):
await self.assert_query_result(
r'''
# cast a type variant into a set of json
SELECT (
SELECT <json>Issue {
number,
time_estimate
} FILTER Issue.number = '1'
) = to_json('{"number": "1", "time_estimate": 3000}');
''',
[True],
)
await self.assert_query_result(
r'''
SELECT (
SELECT <json>Issue {
number,
time_estimate
} FILTER Issue.number = '2'
) = to_json('{"number": "2", "time_estimate": null}');
''',
[True],
) | ,
[True],
)
await self.assert_query_result(
r | test_edgeql_select_json_01a | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_json_01b(self):
await self.assert_query_result(
r'''
# cast a type variant into a set of json
SELECT <json>(
SELECT Issue {
number,
time_estimate
} FILTER Issue.number = '1'
) = to_json('{"number": "1", "time_estimate": 3000}');
''',
[True],
)
await self.assert_query_result(
r'''
SELECT <json>(
SELECT Issue {
number,
time_estimate
} FILTER Issue.number = '2'
) = to_json('{"number": "2", "time_estimate": null}');
''',
[True],
) | ,
[True],
)
await self.assert_query_result(
r | test_edgeql_select_json_01b | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_bad_reference_05(self):
with self.assertRaisesRegex(
edgedb.QueryError,
"object type 'default::Issue' has no link or property 'referrnce'",
_hint="did you mean 'references'?",
):
await self.con.query(
"""
select Issue filter .referrnce = '#4418';
"""
) | select Issue filter .referrnce = '#4418'; | test_edgeql_select_bad_reference_05 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_precedence_03(self):
await self.assert_query_result(
r'''
SELECT (<str>1)[0];
''',
['1'],
)
await self.assert_query_result(
r'''
SELECT (<str>Issue.time_estimate)[0];
''',
['3'],
) | ,
['1'],
)
await self.assert_query_result(
r | test_edgeql_select_precedence_03 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_precedence_04(self):
await self.assert_query_result(
r'''
SELECT EXISTS Issue{number};
''',
[True],
)
await self.assert_query_result(
r'''
SELECT EXISTS Issue;
''',
[True],
) | ,
[True],
)
await self.assert_query_result(
r | test_edgeql_select_precedence_04 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_is_12(self):
await self.assert_query_result(
r'''
SELECT [5] IS (array<int64>);
''',
[True],
)
await self.assert_query_result(
r'''
SELECT (5, 'hello') IS (tuple<int64, str>);
''',
[True],
) | ,
[True],
)
await self.assert_query_result(
r | test_edgeql_select_is_12 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_is_incompatible_union_01(self):
await self.con.execute('''
CREATE TYPE Dummy1 {
CREATE PROPERTY foo -> int64;
};
CREATE TYPE Dummy2 {
CREATE PROPERTY foo -> str;
};
''')
with self.assertRaisesRegex(
edgedb.SchemaError,
r"cannot create union \(default::Dummy1 \| default::Dummy2\) "
r"with property 'foo' using incompatible types std::int64, "
r"std::str"):
await self.con.query(
r'''
SELECT Object is Dummy1 | Dummy2;
''',
) | )
with self.assertRaisesRegex(
edgedb.SchemaError,
r"cannot create union \(default::Dummy1 \| default::Dummy2\) "
r"with property 'foo' using incompatible types std::int64, "
r"std::str"):
await self.con.query(
r | test_edgeql_select_is_incompatible_union_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_expr_objects_03(self):
await self.con.execute(
'''
CREATE FUNCTION issues() -> SET OF Issue
USING (Issue);
'''
)
await self.assert_query_result(
r'''
SELECT _ := issues().owner.name ORDER BY _;
''',
["Elvis", "Yury"],
) | CREATE FUNCTION issues() -> SET OF Issue
USING (Issue); | test_edgeql_select_expr_objects_03 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_expr_objects_04a(self):
await self.assert_query_result(
r'''
WITH items := array_agg((SELECT Named ORDER BY .name))
SELECT items[0] IS Status;
''',
[True],
)
await self.assert_query_result(
r'''
WITH items := array_agg((
SELECT Named ORDER BY .name LIMIT 1))
SELECT (items, items[0], items[0].name,
items[0] IS Status);
''',
[
[[{}], {}, "Closed", True]
],
) | ,
[True],
)
await self.assert_query_result(
r | test_edgeql_select_expr_objects_04a | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_expr_objects_07(self):
# get the User names and ids
res = await self.con.query(r'''
SELECT User {
name,
id
}
ORDER BY User.name;
''')
# we want to make sure that the reference to L is actually
# populated with 'id', since there was a bug in which in JSON
# mode it was populated with 'name' instead!
await self.assert_query_result(
r'''
WITH
L := ('x', User),
SELECT _ := (L, L.1 {name})
ORDER BY _.1.name;
''',
[
[['x', {'id': str(user.id)}], {'name': user.name}]
for user in res
]
)
await self.assert_query_result(
r'''
WITH
L := ('x', User),
SELECT _ := (L.1 {name}, L)
ORDER BY _.0.name;
''',
[
[{'name': user.name}, ['x', {'id': str(user.id)}]]
for user in res
]
) | )
# we want to make sure that the reference to L is actually
# populated with 'id', since there was a bug in which in JSON
# mode it was populated with 'name' instead!
await self.assert_query_result(
r | test_edgeql_select_expr_objects_07 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_expr_objects_08(self):
await self.assert_query_result(
r'''
SELECT DISTINCT
[(SELECT Issue {number, name} FILTER .number = "1")];
''',
[
[{'number': '1', 'name': 'Release EdgeDB'}],
]
)
await self.assert_query_result(
r'''
SELECT DISTINCT
((SELECT Issue {number, name} FILTER .number = "1"),
Issue.status.name);
''',
[
[{'number': '1', 'name': 'Release EdgeDB'}, "Open"],
]
) | ,
[
[{'number': '1', 'name': 'Release EdgeDB'}],
]
)
await self.assert_query_result(
r | test_edgeql_select_expr_objects_08 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_banned_free_shape_01(self):
async with self.assertRaisesRegexTx(
edgedb.QueryError,
"it is illegal to create a type union that causes a "
"computed property 'z' to mix with other versions of the "
"same property 'z'"
):
await self.con.execute("""
SELECT DISTINCT {{ z := 1 }, { z := 2 }};
""")
async with self.assertRaisesRegexTx(
edgedb.QueryError,
"cannot use DISTINCT on free shape",
):
await self.con.execute("""
SELECT DISTINCT { z := 1 } = { z := 2 };
""") | )
async with self.assertRaisesRegexTx(
edgedb.QueryError,
"cannot use DISTINCT on free shape",
):
await self.con.execute( | test_edgeql_select_banned_free_shape_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_reverse_overload_01(self):
await self.con.execute('''
CREATE TYPE Dummy {
CREATE LINK owner -> User;
}
''')
await self.assert_query_result(
r'''
SELECT User {
z := (SELECT .<owner[IS Named] { name }
ORDER BY .name)
} FILTER .name = 'Elvis';
''',
[{"z": [{"name": "Regression."}, {"name": "Release EdgeDB"}]}],
) | )
await self.assert_query_result(
r | test_edgeql_select_reverse_overload_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_reverse_overload_02(self):
await self.con.execute('''
CREATE TYPE Dummy1 {
CREATE MULTI LINK owner -> User;
};
CREATE TYPE Dummy2 {
CREATE SINGLE LINK owner -> User;
};
''')
await self.assert_query_result(
r'''
SELECT User {
z := (SELECT .<owner[IS Named] { name }
ORDER BY .name)
} FILTER .name = 'Elvis';
''',
[{"z": [{"name": "Regression."}, {"name": "Release EdgeDB"}]}],
) | )
await self.assert_query_result(
r | test_edgeql_select_reverse_overload_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_bare_backlink_01(self):
await self.con.execute('''
CREATE ABSTRACT TYPE Action;
CREATE TYPE Post EXTENDING Action;
CREATE TYPE Thing;
ALTER TYPE Action {
CREATE REQUIRED LINK thing -> Thing;
};
ALTER TYPE Thing {
CREATE LINK posts := (.<thing);
};
''')
await self.assert_query_result(
r'''
SELECT Thing { posts: {id} };
''',
[],
) | )
await self.assert_query_result(
r | test_edgeql_select_bare_backlink_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_reverse_overload_03(self):
await self.con.execute('''
CREATE TYPE Dummy1 {
CREATE LINK whatever -> User;
};
CREATE TYPE Dummy2 {
CREATE LINK whatever := (SELECT User FILTER .name = 'Elvis');
};
INSERT Dummy1 { whatever := (SELECT User FILTER .name = 'Yury') };
''')
# We should be able to query the whatever backlink as long as we
# filter it properly
await self.assert_query_result(
r'''
SELECT User.<whatever[IS Dummy1];
''',
[{}],
)
with self.assertRaisesRegex(
edgedb.QueryError,
r"cannot follow backlink 'whatever' because link 'whatever' "
r"of object type 'default::Dummy2' is computed"):
await self.con.query(
r'''
SELECT User.<whatever
''',
) | )
# We should be able to query the whatever backlink as long as we
# filter it properly
await self.assert_query_result(
r | test_edgeql_select_reverse_overload_03 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_incompatible_union_01(self):
await self.con.execute('''
CREATE TYPE Dummy1 {
CREATE PROPERTY foo -> int64;
};
CREATE TYPE Dummy2 {
CREATE PROPERTY foo -> str;
};
''')
with self.assertRaisesRegex(
edgedb.SchemaError,
r"cannot create union \(default::Dummy1 \| default::Dummy2\) "
r"with property 'foo' using incompatible types std::int64, "
r"std::str"):
await self.con.query(
r'''
SELECT Dummy1 union Dummy2;
''',
) | )
with self.assertRaisesRegex(
edgedb.SchemaError,
r"cannot create union \(default::Dummy1 \| default::Dummy2\) "
r"with property 'foo' using incompatible types std::int64, "
r"std::str"):
await self.con.query(
r | test_edgeql_select_incompatible_union_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_incompatible_union_02(self):
await self.con.execute('''
CREATE TYPE Bar;
CREATE TYPE Dummy1 {
CREATE PROPERTY foo -> int64;
};
CREATE TYPE Dummy2 {
CREATE LINK foo -> Bar;
};
''')
with self.assertRaisesRegex(
edgedb.SchemaError,
r"cannot create union \(default::Dummy1 \| default::Dummy2\) "
r"with link 'foo' using incompatible types default::Bar, "
r"std::int64"):
await self.con.query(
r'''
SELECT Dummy1 union Dummy2;
''',
) | )
with self.assertRaisesRegex(
edgedb.SchemaError,
r"cannot create union \(default::Dummy1 \| default::Dummy2\) "
r"with link 'foo' using incompatible types default::Bar, "
r"std::int64"):
await self.con.query(
r | test_edgeql_select_incompatible_union_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_incompatible_union_03(self):
await self.con.execute('''
CREATE TYPE Bar;
CREATE TYPE Dummy1 {
CREATE LINK foo -> Bar {
CREATE PROPERTY baz -> int64
}
};
CREATE TYPE Dummy2 {
CREATE LINK foo -> Bar {
CREATE PROPERTY baz -> str
}
};
''')
with self.assertRaisesRegex(
edgedb.SchemaError,
r"cannot create union \(default::Dummy1 \| default::Dummy2\) "
r"with link 'foo' with property 'baz' using incompatible types "
r"std::int64, std::str"):
await self.con.query(
r'''
SELECT Dummy1 union Dummy2;
''',
) | )
with self.assertRaisesRegex(
edgedb.SchemaError,
r"cannot create union \(default::Dummy1 \| default::Dummy2\) "
r"with link 'foo' with property 'baz' using incompatible types "
r"std::int64, std::str"):
await self.con.query(
r | test_edgeql_select_incompatible_union_03 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_collection_shape_01(self):
await self.assert_query_result(
r'''
SELECT <array<User>>{} UNION [User]
''',
[[{"id": str}], [{"id": str}]],
)
await self.assert_query_result(
r'''
SELECT <array<User>>{} ?? [User]
''',
[[{"id": str}], [{"id": str}]],
)
await self.assert_query_result(
r'''
SELECT <array<User>>{} IF false ELSE [User]
''',
[[{"id": str}], [{"id": str}]],
)
await self.assert_query_result(
r'''
SELECT assert_exists([User])
''',
[[{"id": str}], [{"id": str}]],
) | ,
[[{"id": str}], [{"id": str}]],
)
await self.assert_query_result(
r | test_edgeql_collection_shape_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_collection_shape_02(self):
await self.assert_query_result(
r'''
SELECT <array<User>>{} UNION array_agg(User)
''',
[[{"id": str}, {"id": str}]],
)
await self.assert_query_result(
r'''
SELECT <array<User>>{} ?? array_agg(User)
''',
[[{"id": str}, {"id": str}]],
)
await self.assert_query_result(
r'''
SELECT <array<User>>{} IF false ELSE array_agg(User)
''',
[[{"id": str}, {"id": str}]],
)
await self.assert_query_result(
r'''
SELECT assert_exists(array_agg(User))
''',
[[{"id": str}, {"id": str}]],
) | ,
[[{"id": str}, {"id": str}]],
)
await self.assert_query_result(
r | test_edgeql_collection_shape_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_collection_shape_03(self):
await self.assert_query_result(
r'''
SELECT <tuple<User, int64>>{} UNION (User, 2)
''',
[[{"id": str}, 2], [{"id": str}, 2]],
)
await self.assert_query_result(
r'''
SELECT <tuple<User, int64>>{} ?? (User, 2)
''',
[[{"id": str}, 2], [{"id": str}, 2]],
)
await self.assert_query_result(
r'''
SELECT <tuple<User, int64>>{} IF false ELSE (User, 2)
''',
[[{"id": str}, 2], [{"id": str}, 2]],
)
await self.assert_query_result(
r'''
SELECT assert_exists((User, 2))
''',
[[{"id": str}, 2], [{"id": str}, 2]],
) | ,
[[{"id": str}, 2], [{"id": str}, 2]],
)
await self.assert_query_result(
r | test_edgeql_collection_shape_03 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_collection_shape_04(self):
await self.assert_query_result(
r'''
SELECT [(User,)][0]
''',
[[{"id": str}], [{"id": str}]]
)
await self.assert_query_result(
r'''
SELECT [((SELECT User {name} ORDER BY .name),)][0]
''',
[[{"name": "Elvis"}], [{"name": "Yury"}]]
) | ,
[[{"id": str}], [{"id": str}]]
)
await self.assert_query_result(
r | test_edgeql_collection_shape_04 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_collection_shape_05(self):
await self.assert_query_result(
r'''
SELECT ([User],).0
''',
[[{"id": str}], [{"id": str}]]
)
await self.assert_query_result(
r'''
SELECT ([(SELECT User {name} ORDER BY .name)],).0
''',
[[{"name": "Elvis"}], [{"name": "Yury"}]]
) | ,
[[{"id": str}], [{"id": str}]]
)
await self.assert_query_result(
r | test_edgeql_collection_shape_05 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_collection_shape_07(self):
await self.assert_query_result(
r'''
WITH Z := (<array<User>>{} IF false ELSE [User]),
SELECT (Z, array_agg(array_unpack(Z))).1;
''',
[[{"id": str}], [{"id": str}]]
)
await self.assert_query_result(
r'''
WITH Z := (SELECT assert_exists([User]))
SELECT (Z, array_agg(array_unpack(Z))).1;
''',
[[{"id": str}], [{"id": str}]]
) | ,
[[{"id": str}], [{"id": str}]]
)
await self.assert_query_result(
r | test_edgeql_collection_shape_07 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_collection_shape_08(self):
await self.assert_query_result(
r'''
SELECT X := array_agg(User) FILTER X[0].name != 'Sully';
''',
[[{"id": str}, {"id": str}]]
)
await self.assert_query_result(
r'''
SELECT X := [User] FILTER X[0].name = 'Elvis';
''',
[[{"id": str}]]
) | ,
[[{"id": str}, {"id": str}]]
)
await self.assert_query_result(
r | test_edgeql_collection_shape_08 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_assert_fail_object_computed_01(self):
# check that accessing a trivial computable on an object
# that will fail to evaluate still fails
async with self.assertRaisesRegexTx(
edgedb.CardinalityViolationError,
"assert_exists violation",
):
await self.con.query("""
SELECT assert_exists((SELECT User {m := 10} FILTER false)).m;
""")
async with self.assertRaisesRegexTx(
edgedb.InvalidValueError,
"array index 1000 is out of bounds",
):
await self.con.query("""
SELECT array_agg((SELECT User {m := Issue}))[{1000}].m;
""")
async with self.assertRaisesRegexTx(
edgedb.InvalidValueError,
"array index 1000 is out of bounds",
):
await self.con.query("""
SELECT array_agg((SELECT User {m := 10}))[{1000}].m;
""") | )
async with self.assertRaisesRegexTx(
edgedb.InvalidValueError,
"array index 1000 is out of bounds",
):
await self.con.query( | test_edgeql_assert_fail_object_computed_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_call_null_01(self):
# testing calls with null args
await self.con.execute('''
create function foo(x: str, y: int64) -> str USING (x);
''')
await self.assert_query_result(
r'''
select BooleanTest {
name,
val,
x := foo(.name, .val)
} order by .name;
''',
[
{'name': 'circle', 'val': 2, 'x': 'circle'},
{'name': 'hexagon', 'val': 4, 'x': 'hexagon'},
{'name': 'pentagon', 'val': None, 'x': None},
{'name': 'square', 'val': None, 'x': None},
{'name': 'triangle', 'val': 10, 'x': 'triangle'},
],
) | )
await self.assert_query_result(
r | test_edgeql_select_call_null_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_call_null_02(self):
# testing calls with null args to a function that we can't mark
# as strict
await self.con.execute('''
create function foo(x: OPTIONAL str, y: int64) -> str USING (
x ?? "test"
);
''')
await self.assert_query_result(
r'''
select BooleanTest {
name,
val,
x := foo(.name, .val)
} order by .name;
''',
[
{'name': 'circle', 'val': 2, 'x': 'circle'},
{'name': 'hexagon', 'val': 4, 'x': 'hexagon'},
{'name': 'pentagon', 'val': None, 'x': None},
{'name': 'square', 'val': None, 'x': None},
{'name': 'triangle', 'val': 10, 'x': 'triangle'},
],
) | )
await self.assert_query_result(
r | test_edgeql_select_call_null_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_null_tuple_01(self):
await self.con.execute('''
CREATE TYPE Foo {
CREATE PROPERTY y -> tuple<str, int64>;
CREATE PROPERTY z -> tuple<x: int64, y: str>;
};
insert Foo;
''')
await self.assert_query_result(
r'''
select Foo { y, z }
''',
[
{'y': None, 'z': None}
],
) | )
await self.assert_query_result(
r | test_edgeql_select_null_tuple_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_null_tuple_02(self):
await self.assert_query_result(
r'''
SELECT { lol := array_get([(1, '2')], 1) }
''',
[
{'lol': None}
],
)
await self.assert_query_result(
r'''
SELECT { lol := array_get([(a := 1, b := '2')], 1) }
''',
[
{'lol': None}
],
) | ,
[
{'lol': None}
],
)
await self.assert_query_result(
r | test_edgeql_select_null_tuple_02 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_scalar_views_01(self):
# Test the fix for #3525. I did not have a lot of luck
# minimizing this one.
await self.con.execute('''
CREATE TYPE default::Pair {
CREATE REQUIRED PROPERTY similarity -> std::float64;
CREATE REQUIRED PROPERTY word1 -> std::str;
CREATE REQUIRED PROPERTY word2 -> std::str;
};
for tup in {
('hatch', 'foo', 0.5),
('hatch', 'bar', 0.5),
('hatch', 'baz', 0.5),
('balkanize', 'foo', 0.1),
('balkanize', 'bar', 0.2),
('balkanize', 'baz', 0.3),
('defenestrate', 'foo', 0.1),
('defenestrate', 'bar', 0.2),
('defenestrate', 'baz', 0.2),
} union {
(insert Pair { word1 := tup.0, word2 := tup.1,
similarity := tup.2 }),
(insert Pair { word1 := tup.1, word2 := tup.0,
similarity := tup.2 }),
};
''')
await self.assert_query_result(
'''
with
options := {'balkanize', 'defenestrate'},
word2 := (select Pair
filter .word1 = 'hatch' and .similarity = 0.5).word2,
select options filter (
with opt_pair := (
select Pair filter .word1 = options and .word2 in (word2)),
select count(opt_pair) = count(distinct opt_pair.similarity)
);
''',
['balkanize'],
) | )
await self.assert_query_result( | test_edgeql_select_scalar_views_01 | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
async def test_edgeql_select_where_order_dml(self):
async with self.assertRaisesRegexTx(
edgedb.QueryError,
"INSERT statements cannot be used in a FILTER clause"):
await self.con.query('''
select { foo := 1 } filter
(INSERT User {
name := 't1',
})
''')
async with self.assertRaisesRegexTx(
edgedb.QueryError,
"UPDATE statements cannot be used in a FILTER clause"):
await self.con.query('''
select { foo := 1 } filter
(UPDATE User set {
name := 't1',
})
''')
async with self.assertRaisesRegexTx(
edgedb.QueryError,
"DELETE statements cannot be used in a FILTER clause"):
await self.con.query('''
select { foo := 1 } filter
(DELETE User filter .name = 't1')
''')
async with self.assertRaisesRegexTx(
edgedb.QueryError,
"INSERT statements cannot be used in an ORDER BY clause"):
await self.con.query('''
select { foo := 1 } order by
(INSERT User {
name := 't1',
})
''')
async with self.assertRaisesRegexTx(
edgedb.QueryError,
"UPDATE statements cannot be used in an ORDER BY clause"):
await self.con.query('''
select { foo := 1 } order by
(UPDATE User set {
name := 't1',
})
''')
async with self.assertRaisesRegexTx(
edgedb.QueryError,
"DELETE statements cannot be used in an ORDER BY clause"):
await self.con.query('''
select { foo := 1 } order by
(DELETE User filter .name = 't1')
''') | )
async with self.assertRaisesRegexTx(
edgedb.QueryError,
"UPDATE statements cannot be used in a FILTER clause"):
await self.con.query( | test_edgeql_select_where_order_dml | python | geldata/gel | tests/test_edgeql_select.py | https://github.com/geldata/gel/blob/master/tests/test_edgeql_select.py | Apache-2.0 |
def test_graphql_mutation_insert_scalars_01(self):
data = {
'p_bool': False,
'p_str': 'New ScalarTest01',
'p_datetime': '2019-05-01T01:02:35.196811+00:00',
'p_local_datetime': '2019-05-01T01:02:35.196811',
'p_local_date': '2019-05-01',
'p_local_time': '01:02:35.196811',
'p_duration': 'PT21H30M',
'p_int16': 12345,
'p_int32': 1234567890,
# Some GraphQL implementations seem to have a limitation
# of not being able to handle 64-bit integer literals
# (GraphiQL is among them).
'p_int64': 1234567890,
'p_bigint': 123456789123456789123456789,
'p_float32': 4.5,
'p_float64': 4.5,
'p_decimal':
123456789123456789123456789.123456789123456789123456789,
}
validation_query = r"""
query {
ScalarTest(filter: {p_str: {eq: "New ScalarTest01"}}) {
p_bool
p_str
p_datetime
p_local_datetime
p_local_date
p_local_time
p_duration
p_int16
p_int32
p_int64
p_bigint
p_float32
p_float64
p_decimal
}
}
"""
self.assert_graphql_query_result(r"""
mutation insert_ScalarTest {
insert_ScalarTest(
data: [{
p_bool: false,
p_str: "New ScalarTest01",
p_datetime: "2019-05-01T01:02:35.196811+00:00",
p_local_datetime: "2019-05-01T01:02:35.196811",
p_local_date: "2019-05-01",
p_local_time: "01:02:35.196811",
p_duration: "21:30:00",
p_int16: 12345,
p_int32: 1234567890,
p_int64: 1234567890,
p_bigint: 123456789123456789123456789,
p_float32: 4.5,
p_float64: 4.5,
p_decimal:
123456789123456789123456789.123456789123456789123456789,
}]
) {
p_bool
p_str
p_datetime
p_local_datetime
p_local_date
p_local_time
p_duration
p_int16
p_int32
p_int64
p_bigint
p_float32
p_float64
p_decimal
}
}
""", {
"insert_ScalarTest": [data]
})
self.assert_graphql_query_result(validation_query, {
"ScalarTest": [data]
})
self.assert_graphql_query_result(r"""
mutation delete_ScalarTest {
delete_ScalarTest(filter: {p_str: {eq: "New ScalarTest01"}}) {
p_bool
p_str
p_datetime
p_local_datetime
p_local_date
p_local_time
p_duration
p_int16
p_int32
p_int64
p_bigint
p_float32
p_float64
p_decimal
}
}
""", {
"delete_ScalarTest": [data]
})
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"ScalarTest": []
}) | self.assert_graphql_query_result(r | test_graphql_mutation_insert_scalars_01 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
def test_graphql_mutation_insert_scalars_02(self):
# This tests int64 insertion. Apparently as long as the number
# is provided as a variable parameter in JSON, there's no
# limit on the number of digits of an Int.
data = {
'p_str': 'New ScalarTest02',
'p_int64': 1234567890123,
}
validation_query = r"""
query {
ScalarTest(filter: {p_str: {eq: "New ScalarTest02"}}) {
p_str
p_int64
}
}
"""
self.assert_graphql_query_result(r"""
mutation insert_ScalarTest($num: Int64!) {
insert_ScalarTest(
data: [{
p_str: "New ScalarTest02",
p_int64: $num,
}]
) {
p_str
p_int64
}
}
""", {
"insert_ScalarTest": [data]
}, variables={'num': data['p_int64']})
self.assert_graphql_query_result(validation_query, {
"ScalarTest": [data]
})
self.assert_graphql_query_result(r"""
mutation delete_ScalarTest {
delete_ScalarTest(filter: {p_str: {eq: "New ScalarTest02"}}) {
p_str
p_int64
}
}
""", {
"delete_ScalarTest": [data]
})
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"ScalarTest": []
}) | self.assert_graphql_query_result(r | test_graphql_mutation_insert_scalars_02 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
def test_graphql_mutation_insert_scalars_03(self):
# This tests custom scalar insertion.
data = {
'p_str': 'New ScalarTest03',
'p_posint': 42,
}
validation_query = r"""
query {
ScalarTest(filter: {p_str: {eq: "New ScalarTest03"}}) {
p_str
p_posint
}
}
"""
self.assert_graphql_query_result(r"""
mutation insert_ScalarTest {
insert_ScalarTest(
data: [{
p_str: "New ScalarTest03",
p_posint: 42,
}]
) {
p_str
p_posint
}
}
""", {
"insert_ScalarTest": [data]
})
self.assert_graphql_query_result(validation_query, {
"ScalarTest": [data]
})
self.assert_graphql_query_result(r"""
mutation delete_ScalarTest {
delete_ScalarTest(filter: {p_str: {eq: "New ScalarTest03"}}) {
p_str
p_posint
}
}
""", {
"delete_ScalarTest": [data]
})
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"ScalarTest": []
}) | self.assert_graphql_query_result(r | test_graphql_mutation_insert_scalars_03 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
def test_graphql_mutation_insert_scalars_04(self):
# This tests JSON insertion. JSON can only be inserted via a variable.
data = {
'p_str': 'New ScalarTest04',
'p_json': {"foo": [1, None, "aardvark"]},
}
validation_query = r"""
query {
ScalarTest(filter: {p_str: {eq: "New ScalarTest04"}}) {
p_str
p_json
}
}
"""
self.assert_graphql_query_result(
r"""
mutation insert_ScalarTest(
$p_str: String!,
$p_json: JSON
) {
insert_ScalarTest(
data: [{
p_str: $p_str,
p_json: $p_json,
}]
) {
p_str
p_json
}
}
""", {
"insert_ScalarTest": [data]
},
variables=data,
)
self.assert_graphql_query_result(validation_query, {
"ScalarTest": [data]
})
self.assert_graphql_query_result(
r"""
mutation delete_ScalarTest(
$p_json: JSON
) {
delete_ScalarTest(filter: {p_json: {eq: $p_json}}) {
p_str
p_json
}
}
""", {
"delete_ScalarTest": [data]
},
variables=data,
)
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"ScalarTest": []
}) | self.assert_graphql_query_result(
r | test_graphql_mutation_insert_scalars_04 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
def test_graphql_mutation_insert_scalars_05(self):
# This tests string escapes.
data = {
'p_str': 'New \"ScalarTest05\"\\',
}
validation_query = r"""
query {
ScalarTest(filter: {p_str: {eq: "New \"ScalarTest05\"\\"}}) {
p_str
}
}
"""
self.assert_graphql_query_result(r"""
mutation insert_ScalarTest {
insert_ScalarTest(
data: [{
p_str: "New \"ScalarTest05\"\\",
}]
) {
p_str
}
}
""", {
"insert_ScalarTest": [data]
})
self.assert_graphql_query_result(validation_query, {
"ScalarTest": [data]
})
self.assert_graphql_query_result(r"""
mutation delete_ScalarTest {
delete_ScalarTest(
filter: {p_str: {eq: "New \"ScalarTest05\"\\"}}
) {
p_str
}
}
""", {
"delete_ScalarTest": [data]
})
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"ScalarTest": []
}) | self.assert_graphql_query_result(r | test_graphql_mutation_insert_scalars_05 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
def test_graphql_mutation_insert_scalars_06(self):
# This tests float vs. decimal literals.
data = {
'p_str': 'New ScalarTest06',
'p_decimal':
123456789123456789123456789.123456789123456789123456789,
'p_decimal_str':
'123456789123456789123456789.123456789123456789123456789',
}
validation_query = r"""
query {
ScalarTest(filter: {p_str: {eq: "New ScalarTest06"}}) {
p_str
p_decimal
p_decimal_str
}
}
"""
self.assert_graphql_query_result(r"""
mutation insert_ScalarTest {
insert_ScalarTest(
data: [{
p_str: "New ScalarTest06",
p_decimal:
123456789123456789123456789.123456789123456789123456789,
}]
) {
p_str
p_decimal
p_decimal_str
}
}
""", {
"insert_ScalarTest": [data]
})
self.assert_graphql_query_result(validation_query, {
"ScalarTest": [data]
})
self.assert_graphql_query_result(r"""
mutation delete_ScalarTest {
delete_ScalarTest(
filter: {p_str: {eq: "New ScalarTest06"}}
) {
p_str
p_decimal
p_decimal_str
}
}
""", {
"delete_ScalarTest": [data]
})
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"ScalarTest": []
}) | self.assert_graphql_query_result(r | test_graphql_mutation_insert_scalars_06 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
def test_graphql_mutation_insert_enum_01(self):
# This tests enum values in insertion.
data = {
'select': 'New EnumTest01',
'color': 'GREEN',
}
validation_query = r"""
query {
other__Foo(filter: {select: {eq: "New EnumTest01"}}) {
select
color
}
}
"""
self.assert_graphql_query_result(r"""
mutation insert_other__Foo {
insert_other__Foo(
data: [{
select: "New EnumTest01",
color: GREEN,
}]
) {
select
color
}
}
""", {
"insert_other__Foo": [data]
})
self.assert_graphql_query_result(validation_query, {
"other__Foo": [data]
})
self.assert_graphql_query_result(r"""
mutation delete_other__Foo {
delete_other__Foo(
filter: {select: {eq: "New EnumTest01"}}
) {
select
color
}
}
""", {
"delete_other__Foo": [data]
})
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"other__Foo": []
}) | self.assert_graphql_query_result(r | test_graphql_mutation_insert_enum_01 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
def test_graphql_mutation_insert_enum_02(self):
# This tests enum values in insertion, using variables.
data = {
'select': 'New EnumTest02',
'color': 'RED',
}
validation_query = r"""
query {
other__Foo(filter: {select: {eq: "New EnumTest02"}}) {
select
color
}
}
"""
self.assert_graphql_query_result(r"""
mutation insert_other__Foo(
$select: String!,
$color: other__ColorEnum!
) {
insert_other__Foo(
data: [{
select: $select,
color: $color,
}]
) {
select
color
}
}
""", {
"insert_other__Foo": [data]
}, variables=data)
self.assert_graphql_query_result(validation_query, {
"other__Foo": [data]
})
self.assert_graphql_query_result(r"""
mutation delete_other__Foo {
delete_other__Foo(
filter: {select: {eq: "New EnumTest02"}}
) {
select
color
}
}
""", {
"delete_other__Foo": [data]
})
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"other__Foo": []
}) | self.assert_graphql_query_result(r | test_graphql_mutation_insert_enum_02 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
def test_graphql_mutation_insert_enum_03(self):
# This tests enum values in insertion.
data = {
'select': 'New EnumTest05',
'color': 'GREEN',
'color_array': ['RED', 'GREEN', 'RED'],
}
validation_query = r"""
query {
other__Foo(filter: {select: {eq: "New EnumTest05"}}) {
select
color
color_array
}
}
"""
self.assert_graphql_query_result(r"""
mutation insert_other__Foo {
insert_other__Foo(
data: [{
select: "New EnumTest05",
color: GREEN,
color_array: [RED, GREEN, RED],
}]
) {
select
color
color_array
}
}
""", {
"insert_other__Foo": [data]
})
self.assert_graphql_query_result(validation_query, {
"other__Foo": [data]
})
self.assert_graphql_query_result(r"""
mutation delete_other__Foo {
delete_other__Foo(
filter: {select: {eq: "New EnumTest05"}}
) {
select
color
color_array
}
}
""", {
"delete_other__Foo": [data]
})
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"other__Foo": []
}) | self.assert_graphql_query_result(r | test_graphql_mutation_insert_enum_03 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
def test_graphql_mutation_insert_enum_04(self):
# This tests enum values in insertion.
data = {
'select': 'New EnumTest03',
'color': 'GREEN',
'multi_color': {'RED', 'GREEN'},
}
validation_query = r"""
query {
other__Foo(filter: {select: {eq: "New EnumTest03"}}) {
select
color
multi_color
}
}
"""
self.assert_graphql_query_result(r"""
mutation insert_other__Foo {
insert_other__Foo(
data: [{
select: "New EnumTest03",
color: GREEN,
multi_color: [RED, GREEN],
}]
) {
select
color
multi_color
}
}
""", {
"insert_other__Foo": [data]
})
self.assert_graphql_query_result(validation_query, {
"other__Foo": [data]
})
self.assert_graphql_query_result(r"""
mutation delete_other__Foo {
delete_other__Foo(
filter: {select: {eq: "New EnumTest03"}}
) {
select
color
multi_color
}
}
""", {
"delete_other__Foo": [data]
})
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"other__Foo": []
}) | self.assert_graphql_query_result(r | test_graphql_mutation_insert_enum_04 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
def test_graphql_mutation_insert_range_01(self):
# This tests range and multirange values in insertion.
data = {
"name": "New RangeTest01",
"rval": {
"lower": -1.2,
"upper": 3.4,
"inc_lower": True,
"inc_upper": False
},
"mval": [
{
"lower": None,
"upper": -10,
"inc_lower": False,
"inc_upper": False
},
{
"lower": -3,
"upper": 12,
"inc_lower": True,
"inc_upper": False
},
],
"rdate": {
"lower": "2019-02-13",
"upper": "2023-08-29",
"inc_lower": True,
"inc_upper": False
},
"mdate": [
{
"lower": "2019-02-13",
"upper": "2023-08-29",
"inc_lower": True,
"inc_upper": False
},
{
"lower": "2026-10-20",
"upper": None,
"inc_lower": True,
"inc_upper": False
}
]
}
validation_query = r"""
query {
RangeTest(filter: {name: {eq: "New RangeTest01"}}) {
name
rval
mval
rdate
mdate
}
}
"""
self.assert_graphql_query_result(r"""
mutation insert_RangeTest {
insert_RangeTest(
data: [{
name: "New RangeTest01",
rval: {
lower: -1.2,
upper: 3.4,
inc_lower: true,
inc_upper: false
},
mval: [
{
lower: null,
upper: -10,
inc_lower: false,
inc_upper: false
},
{
lower: -3,
upper: 12,
inc_lower: true,
inc_upper: false
},
],
rdate: {
lower: "2019-02-13",
upper: "2023-08-29",
inc_lower: true,
inc_upper: false
},
mdate: [
{
lower: "2019-02-13",
upper: "2023-08-29",
inc_lower: true,
inc_upper: false
},
{
lower: "2026-10-20",
upper: null,
inc_lower: true,
inc_upper: false
}
]
}]
) {
name
rval
mval
rdate
mdate
}
}
""", {
"insert_RangeTest": [data]
})
self.assert_graphql_query_result(validation_query, {
"RangeTest": [data]
})
self.assert_graphql_query_result(r"""
mutation delete_RangeTest {
delete_RangeTest(
filter: {name: {eq: "New RangeTest01"}}
) {
name
rval
mval
rdate
mdate
}
}
""", {
"delete_RangeTest": [data]
})
# validate that the deletion worked
self.assert_graphql_query_result(validation_query, {
"RangeTest": []
}) | self.assert_graphql_query_result(r | test_graphql_mutation_insert_range_01 | python | geldata/gel | tests/test_http_graphql_mutation.py | https://github.com/geldata/gel/blob/master/tests/test_http_graphql_mutation.py | Apache-2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.