def test_order_by_pk(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.order_by("pk").query)
self.assertEqual("__key__", query.order_by[0])
query = transform_query(
connections['default'],
TransformTestModel.objects.order_by("-pk").query)
self.assertEqual("-__key__", query.order_by[0])
def test_order_by_pk(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.order_by("pk").query
)
self.assertEqual("__key__", query.order_by[0])
query = transform_query(
connections['default'],
TransformTestModel.objects.order_by("-pk").query
)
self.assertEqual("-__key__", query.order_by[0])
def test_distinct(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.distinct("field2", "field3").query)
self.assertTrue(query.distinct)
self.assertEqual(query.columns, ["field2", "field3"])
query = transform_query(
connections['default'],
TransformTestModel.objects.distinct().values("field2",
"field3").query)
self.assertTrue(query.distinct)
self.assertEqual(query.columns, ["field2", "field3"])
def test_projection_on_textfield_disabled(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.values_list("field4").query)
self.assertFalse(query.columns)
self.assertFalse(query.projection_possible)
def test_clear_ordering(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.order_by("pk").order_by().query
)
self.assertFalse(query.order_by)
def test_clear_ordering(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.order_by("pk").order_by().query
)
self.assertFalse(query.order_by)
def test_reversed_ordering(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.order_by("pk").reverse().query
)
self.assertEqual("-__key__", query.order_by[0])
def test_distinct(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.distinct("field2", "field3").query
)
self.assertTrue(query.distinct)
self.assertEqual(query.columns, set(["field2", "field3"]))
query = transform_query(
connections['default'],
TransformTestModel.objects.distinct().values("field2", "field3").query
)
self.assertTrue(query.distinct)
self.assertEqual(query.columns, set(["field2", "field3"]))
def test_reversed_ordering(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.order_by("pk").reverse().query
)
self.assertEqual("-__key__", query.order_by[0])
def test_isnull(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.filter(field3__isnull=True).all()[5:10].query
)
self.assertTrue(query.where.children[0].value)
self.assertEqual("ISNULL", query.where.children[0].operator)
def test_projection_on_textfield_disabled(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.values_list("field4").query
)
self.assertFalse(query.columns)
self.assertFalse(query.projection_possible)
def test_basic_query(self):
query = transform_query(connections['default'],
TransformTestModel.objects.all().query)
self.assertEqual(query.model, TransformTestModel)
self.assertEqual(query.kind, 'SELECT')
self.assertEqual(query.tables, [TransformTestModel._meta.db_table])
self.assertIsNone(query.where)
def test_isnull(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.filter(field3__isnull=True).all()[5:10].query
)
self.assertTrue(query.where.children[0].value)
self.assertEqual("ISNULL", query.where.children[0].operator)
def test_offset_and_limit(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.all()[5:10].query
)
self.assertEqual(5, query.low_mark)
self.assertEqual(10, query.high_mark)
def test_offset_and_limit(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.all()[5:10].query
)
self.assertEqual(5, query.low_mark)
self.assertEqual(10, query.high_mark)
def test_projection(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.only("field1").query)
self.assertItemsEqual(["id", "field1"], query.columns)
query = transform_query(
connections['default'],
TransformTestModel.objects.values_list("field1").query)
self.assertEqual(["field1"], query.columns)
query = transform_query(
connections['default'],
TransformTestModel.objects.defer("field1", "field4").query)
self.assertItemsEqual(["id", "field2", "field3"], query.columns)
def test_basic_query(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.all().query
)
self.assertEqual(query.model, TransformTestModel)
self.assertEqual(query.kind, 'SELECT')
self.assertEqual(query.tables, [ TransformTestModel._meta.db_table ])
self.assertIsNone(query.where)
def test_and_filter(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.filter(field1="One", field2="Two").all().query
)
self.assertEqual(query.model, TransformTestModel)
self.assertEqual(query.kind, 'SELECT')
self.assertEqual(query.tables, [ TransformTestModel._meta.db_table ])
self.assertTrue(query.where)
self.assertEqual(2, len(query.where.children)) # Two child nodes
def test_polymodel_filter_applied(self):
query = transform_query(
connections['default'],
InheritedModel.objects.filter(field1="One").all().query)
query.prepare()
self.assertEqual(2, len(query.where.children))
self.assertTrue(query.where.children[0].children[0].is_leaf)
self.assertTrue(query.where.children[1].children[0].is_leaf)
self.assertEqual("class", query.where.children[0].children[0].column)
self.assertEqual("field1", query.where.children[1].children[0].column)
def test_and_filter(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.filter(field1="One", field2="Two").all().query
)
self.assertEqual(query.model, TransformTestModel)
self.assertEqual(query.kind, 'SELECT')
self.assertEqual(query.tables, [ TransformTestModel._meta.db_table ])
self.assertTrue(query.where)
self.assertEqual(2, len(query.where.children)) # Two child nodes
def test_projection(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.only("field1").query
)
self.assertItemsEqual(["id", "field1"], query.columns)
query = transform_query(
connections['default'],
TransformTestModel.objects.values_list("field1").query
)
self.assertEqual(set(["field1"]), query.columns)
query = transform_query(
connections['default'],
TransformTestModel.objects.defer("field1", "field4").query
)
self.assertItemsEqual(set(["id", "field2", "field3"]), query.columns)
def test_polymodel_filter_applied(self):
query = transform_query(
connections['default'],
InheritedModel.objects.filter(field1="One").all().query
)
query.prepare()
self.assertEqual(2, len(query.where.children))
self.assertTrue(query.where.children[0].children[0].is_leaf)
self.assertTrue(query.where.children[1].children[0].is_leaf)
self.assertEqual("class", query.where.children[0].children[0].column)
self.assertEqual("field1", query.where.children[1].children[0].column)
def test_exclude_filter(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.exclude(field1="One").all().query)
self.assertEqual(query.model, TransformTestModel)
self.assertEqual(query.kind, 'SELECT')
self.assertEqual(query.tables, [TransformTestModel._meta.db_table])
self.assertTrue(query.where)
self.assertEqual(1, len(query.where.children)) # One child node
self.assertTrue(query.where.children[0].negated)
self.assertEqual(1, len(query.where.children[0].children))
def test_exclude_filter(self):
query = transform_query(
connections['default'],
TransformTestModel.objects.exclude(field1="One").all().query
)
self.assertEqual(query.model, TransformTestModel)
self.assertEqual(query.kind, 'SELECT')
self.assertEqual(query.tables, [ TransformTestModel._meta.db_table ])
self.assertTrue(query.where)
self.assertEqual(1, len(query.where.children)) # One child node
self.assertTrue(query.where.children[0].negated)
self.assertEqual(1, len(query.where.children[0].children))
def __init__(self, connection, query, keys_only=False):
self.connection = connection
self.namespace = connection.ops.connection.settings_dict.get("NAMESPACE")
self.query = transform_query(connection, query)
self.query.prepare()
self.query = normalize_query(self.query)
self.original_query = query
self.keys_only = (keys_only or [x.field for x in query.select] == [ query.model._meta.pk ])
# MultiQuery doesn't support keys_only
if self.query.where and len(self.query.where.children) > 1:
self.keys_only = False
def __init__(self, connection, query, keys_only=False):
self.connection = connection
self.query = transform_query(connection, query)
self.query.prepare()
self.query = normalize_query(self.query)
self.original_query = query
self.keys_only = keys_only or [x.field for x in query.select] == [query.model._meta.pk]
# MultiQuery doesn't support keys_only
if self.query.where and len(self.query.where.children) > 1:
self.keys_only = False
self.excluded_pks = self.query.excluded_pks
def __init__(self, connection, query, keys_only=False):
self.connection = connection
self.query = transform_query(connection, query)
self.query.prepare()
self.query = normalize_query(self.query)
self.original_query = query
self.keys_only = (keys_only or [x.field for x in query.select] == [ query.model._meta.pk ])
# MultiQuery doesn't support keys_only
if self.query.where and len(self.query.where.children) > 1:
self.keys_only = False
self.excluded_pks = self.query.excluded_pks
def __init__(self, connection, query, keys_only=False):
self.connection = connection
self.namespace = connection.ops.connection.settings_dict.get(
"NAMESPACE")
self.query = transform_query(connection, query)
self.query.prepare()
self.query = normalize_query(self.query)
self.original_query = query
self.keys_only = (keys_only
or [x.field
for x in query.select] == [query.model._meta.pk])
# MultiQuery doesn't support keys_only
if self.query.where and len(self.query.where.children) > 1:
self.keys_only = False
def __init__(self, connection, query, keys_only=False):
self.connection = connection
self.namespace = connection.ops.connection.settings_dict.get("NAMESPACE")
self.query = transform_query(connection, query)
self.query.prepare()
self.query = normalize_query(self.query)
self.original_query = query
# We enable keys only queries if they have been forced, or, if
# someone did only("pk") or someone did values_list("pk") this is a little
# inconsistent with other fields which aren't projected if just values(_list) is used
self.keys_only = keys_only or (
query.deferred_loading[1] is False and
len(query.deferred_loading[0]) == 1 and query.model._meta.pk.column in query.deferred_loading[0]
) or (
len(query.select) == 1 and query.select[0].field == query.model._meta.pk
)
# MultiQuery doesn't support keys_only
if self.query.where and len(self.query.where.children) > 1:
self.keys_only = False
def __init__(self, connection, query, keys_only=False):
self.connection = connection
self.namespace = connection.ops.connection.settings_dict.get("NAMESPACE")
self.query = transform_query(connection, query)
self.query.prepare()
self.query = normalize_query(self.query)
self.original_query = query
# We enable keys only queries if they have been forced, or, if
# someone did only("pk") or someone did values_list("pk") this is a little
# inconsistent with other fields which aren't projected if just values(_list) is used
self.keys_only = keys_only or (
query.deferred_loading[1] is False and
len(query.deferred_loading[0]) == 1 and query.model._meta.pk.column in query.deferred_loading[0]
) or (
len(query.select) == 1 and query.select[0].field == query.model._meta.pk
)
# MultiQuery doesn't support keys_only
if self.query.where and len(self.query.where.children) > 1:
self.keys_only = False
def test_or_queries(self):
from .test_connector import TestUser
qs = TestUser.objects.filter(
username="******").filter(
Q(username__in=["ruby", "jruby"]) | (Q(username="******") & ~Q(username="******"))
)
query = normalize_query(transform_query(
connections['default'],
qs.query
))
# After IN and != explosion, we have...
# (AND: (username='******', OR: (username='******', username='******', AND: (username='******', AND: (username < 'perl', username > 'perl')))))
# Working backwards,
# AND: (username < 'perl', username > 'perl') can't be simplified
# AND: (username='******', AND: (username < 'perl', username > 'perl')) can become (OR: (AND: username = '******', username < 'perl'), (AND: username='******', username > 'perl'))
# OR: (username='******', username='******', (OR: (AND: username = '******', username < 'perl'), (AND: username='******', username > 'perl')) can't be simplified
# (AND: (username='******', OR: (username='******', username='******', (OR: (AND: username = '******', username < 'perl'), (AND: username='******', username > 'perl'))
# becomes...
# (OR: (AND: username='******', username = '******'), (AND: username='******', username='******'), (AND: username='******', username='******', username < 'perl') \
# (AND: username='******', username='******', username > 'perl')
self.assertTrue(4, len(query.where.children[0].children))
self.assertEqual(query.where.children[0].connector, "AND")
self.assertEqual(query.where.children[0].children[0].column, "username")
self.assertEqual(query.where.children[0].children[0].operator, "=")
self.assertEqual(query.where.children[0].children[0].value, "python")
self.assertEqual(query.where.children[0].children[1].column, "username")
self.assertEqual(query.where.children[0].children[1].operator, "=")
self.assertEqual(query.where.children[0].children[1].value, "php")
self.assertEqual(query.where.children[0].children[2].column, "username")
self.assertEqual(query.where.children[0].children[2].operator, "<")
self.assertEqual(query.where.children[0].children[2].value, "perl")
self.assertEqual(query.where.children[1].connector, "AND")
self.assertEqual(query.where.children[1].children[0].column, "username")
self.assertEqual(query.where.children[1].children[0].operator, "=")
self.assertEqual(query.where.children[1].children[0].value, "python")
self.assertEqual(query.where.children[1].children[1].column, "username")
self.assertEqual(query.where.children[1].children[1].operator, "=")
self.assertEqual(query.where.children[1].children[1].value, "jruby")
self.assertEqual(query.where.children[2].connector, "AND")
self.assertEqual(query.where.children[2].children[0].column, "username")
self.assertEqual(query.where.children[2].children[0].operator, "=")
self.assertEqual(query.where.children[2].children[0].value, "python")
self.assertEqual(query.where.children[2].children[1].column, "username")
self.assertEqual(query.where.children[2].children[1].operator, "=")
self.assertEqual(query.where.children[2].children[1].value, "php")
self.assertEqual(query.where.children[2].children[2].column, "username")
self.assertEqual(query.where.children[2].children[2].operator, ">")
self.assertEqual(query.where.children[2].children[2].value, "perl")
self.assertEqual(query.where.connector, "OR")
self.assertEqual(query.where.children[3].connector, "AND")
self.assertEqual(query.where.children[3].children[0].column, "username")
self.assertEqual(query.where.children[3].children[0].operator, "=")
self.assertEqual(query.where.children[3].children[0].value, "python")
self.assertEqual(query.where.children[3].children[1].column, "username")
self.assertEqual(query.where.children[3].children[1].operator, "=")
self.assertEqual(query.where.children[3].children[1].value, "ruby")
qs = TestUser.objects.filter(username="******") | TestUser.objects.filter(username="******")
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertEqual(query.where.connector, "OR")
self.assertEqual(2, len(query.where.children))
self.assertTrue(query.where.children[0].is_leaf)
self.assertEqual("cheese", query.where.children[0].value)
self.assertTrue(query.where.children[1].is_leaf)
self.assertEqual("test", query.where.children[1].value)
qs = TestUser.objects.using("default").filter(username__in=set()).values_list('email')
with self.assertRaises(EmptyResultSet):
query = normalize_query(transform_query(
connections['default'],
qs.query
))
qs = TestUser.objects.filter(username__startswith='Hello') | TestUser.objects.filter(username__startswith='Goodbye')
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertEqual(2, len(query.where.children))
self.assertEqual("_idx_startswith_username", query.where.children[0].column)
self.assertEqual(u"Goodbye", query.where.children[0].value)
self.assertEqual("_idx_startswith_username", query.where.children[1].column)
self.assertEqual(u"Hello", query.where.children[1].value)
qs = TestUser.objects.filter(pk__in=[1, 2, 3])
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertEqual(3, len(query.where.children))
self.assertEqual("__key__", query.where.children[0].column)
self.assertEqual("__key__", query.where.children[1].column)
self.assertEqual("__key__", query.where.children[2].column)
self.assertEqual({
datastore.Key.from_path(TestUser._meta.db_table, 1, namespace=DEFAULT_NAMESPACE),
datastore.Key.from_path(TestUser._meta.db_table, 2, namespace=DEFAULT_NAMESPACE),
datastore.Key.from_path(TestUser._meta.db_table, 3, namespace=DEFAULT_NAMESPACE),
}, {
query.where.children[0].value,
query.where.children[1].value,
query.where.children[2].value,
}
)
qs = TestUser.objects.filter(pk__in=[1, 2, 3]).filter(username="******")
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertEqual(3, len(query.where.children))
self.assertEqual("__key__", query.where.children[0].children[0].column)
self.assertEqual("test", query.where.children[0].children[1].value)
self.assertEqual("__key__", query.where.children[1].children[0].column)
self.assertEqual("test", query.where.children[0].children[1].value)
self.assertEqual("__key__", query.where.children[2].children[0].column)
self.assertEqual("test", query.where.children[0].children[1].value)
self.assertEqual({
datastore.Key.from_path(TestUser._meta.db_table, 1, namespace=DEFAULT_NAMESPACE),
datastore.Key.from_path(TestUser._meta.db_table, 2, namespace=DEFAULT_NAMESPACE),
datastore.Key.from_path(TestUser._meta.db_table, 3, namespace=DEFAULT_NAMESPACE),
}, {
query.where.children[0].children[0].value,
query.where.children[1].children[0].value,
query.where.children[2].children[0].value,
}
)
def test_and_queries(self):
from .test_connector import TestUser
qs = TestUser.objects.filter(username="******").all()
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertTrue(1, len(query.where.children))
self.assertEqual(query.where.children[0].children[0].column, "username")
self.assertEqual(query.where.children[0].children[0].operator, "=")
self.assertEqual(query.where.children[0].children[0].value, "test")
qs = TestUser.objects.filter(username="******", email="*****@*****.**")
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertTrue(2, len(query.where.children[0].children))
self.assertEqual(query.where.connector, "OR")
self.assertEqual(query.where.children[0].connector, "AND")
self.assertEqual(query.where.children[0].children[0].column, "username")
self.assertEqual(query.where.children[0].children[0].operator, "=")
self.assertEqual(query.where.children[0].children[0].value, "test")
self.assertEqual(query.where.children[0].children[1].column, "email")
self.assertEqual(query.where.children[0].children[1].operator, "=")
self.assertEqual(query.where.children[0].children[1].value, "*****@*****.**")
qs = TestUser.objects.filter(username="******").exclude(email="*****@*****.**")
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertTrue(2, len(query.where.children[0].children))
self.assertEqual(query.where.connector, "OR")
self.assertEqual(query.where.children[0].connector, "AND")
self.assertEqual(query.where.children[0].children[0].column, "username")
self.assertEqual(query.where.children[0].children[0].operator, "=")
self.assertEqual(query.where.children[0].children[0].value, "test")
self.assertEqual(query.where.children[0].children[1].column, "email")
self.assertEqual(query.where.children[0].children[1].operator, "<")
self.assertEqual(query.where.children[0].children[1].value, "*****@*****.**")
self.assertEqual(query.where.children[1].children[0].column, "username")
self.assertEqual(query.where.children[1].children[0].operator, "=")
self.assertEqual(query.where.children[1].children[0].value, "test")
self.assertEqual(query.where.children[1].children[1].column, "email")
self.assertEqual(query.where.children[1].children[1].operator, ">")
self.assertEqual(query.where.children[1].children[1].value, "*****@*****.**")
instance = Relation(pk=1)
qs = instance.related_set.filter(headline__startswith='Fir')
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertTrue(2, len(query.where.children[0].children))
self.assertEqual(query.where.connector, "OR")
self.assertEqual(query.where.children[0].connector, "AND")
self.assertEqual(query.where.children[0].children[0].column, "relation_id")
self.assertEqual(query.where.children[0].children[0].operator, "=")
self.assertEqual(query.where.children[0].children[0].value, 1)
self.assertEqual(query.where.children[0].children[1].column, "_idx_startswith_headline")
self.assertEqual(query.where.children[0].children[1].operator, "=")
self.assertEqual(query.where.children[0].children[1].value, u"Fir")
def test_and_queries(self):
from .test_connector import TestUser
qs = TestUser.objects.filter(username="******").all()
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertTrue(1, len(query.where.children))
self.assertEqual(query.where.children[0].children[0].column, "username")
self.assertEqual(query.where.children[0].children[0].operator, "=")
self.assertEqual(query.where.children[0].children[0].value, "test")
qs = TestUser.objects.filter(username="******", email="*****@*****.**")
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertTrue(2, len(query.where.children[0].children))
self.assertEqual(query.where.connector, "OR")
self.assertEqual(query.where.children[0].connector, "AND")
self.assertEqual(query.where.children[0].children[0].column, "username")
self.assertEqual(query.where.children[0].children[0].operator, "=")
self.assertEqual(query.where.children[0].children[0].value, "test")
self.assertEqual(query.where.children[0].children[1].column, "email")
self.assertEqual(query.where.children[0].children[1].operator, "=")
self.assertEqual(query.where.children[0].children[1].value, "*****@*****.**")
qs = TestUser.objects.filter(username="******").exclude(email="*****@*****.**")
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertTrue(2, len(query.where.children[0].children))
self.assertEqual(query.where.connector, "OR")
self.assertEqual(query.where.children[0].connector, "AND")
self.assertEqual(query.where.children[0].children[0].column, "username")
self.assertEqual(query.where.children[0].children[0].operator, "=")
self.assertEqual(query.where.children[0].children[0].value, "test")
self.assertEqual(query.where.children[0].children[1].column, "email")
self.assertEqual(query.where.children[0].children[1].operator, "<")
self.assertEqual(query.where.children[0].children[1].value, "*****@*****.**")
self.assertEqual(query.where.children[1].children[0].column, "username")
self.assertEqual(query.where.children[1].children[0].operator, "=")
self.assertEqual(query.where.children[1].children[0].value, "test")
self.assertEqual(query.where.children[1].children[1].column, "email")
self.assertEqual(query.where.children[1].children[1].operator, ">")
self.assertEqual(query.where.children[1].children[1].value, "*****@*****.**")
instance = Relation(pk=1)
qs = instance.related_set.filter(headline__startswith='Fir')
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertTrue(2, len(query.where.children[0].children))
self.assertEqual(query.where.connector, "OR")
self.assertEqual(query.where.children[0].connector, "AND")
self.assertEqual(query.where.children[0].children[0].column, "relation_id")
self.assertEqual(query.where.children[0].children[0].operator, "=")
self.assertEqual(query.where.children[0].children[0].value, 1)
self.assertEqual(query.where.children[0].children[1].column, "_idx_startswith_headline")
self.assertEqual(query.where.children[0].children[1].operator, "=")
self.assertEqual(query.where.children[0].children[1].value, u"Fir")
def test_or_queries(self):
from .test_connector import TestUser
qs = TestUser.objects.filter(
username="******").filter(
Q(username__in=["ruby", "jruby"]) | (Q(username="******") & ~Q(username="******"))
)
query = normalize_query(transform_query(
connections['default'],
qs.query
))
# After IN and != explosion, we have...
# (AND: (username='******', OR: (username='******', username='******', AND: (username='******', AND: (username < 'perl', username > 'perl')))))
# Working backwards,
# AND: (username < 'perl', username > 'perl') can't be simplified
# AND: (username='******', AND: (username < 'perl', username > 'perl')) can become (OR: (AND: username = '******', username < 'perl'), (AND: username='******', username > 'perl'))
# OR: (username='******', username='******', (OR: (AND: username = '******', username < 'perl'), (AND: username='******', username > 'perl')) can't be simplified
# (AND: (username='******', OR: (username='******', username='******', (OR: (AND: username = '******', username < 'perl'), (AND: username='******', username > 'perl'))
# becomes...
# (OR: (AND: username='******', username = '******'), (AND: username='******', username='******'), (AND: username='******', username='******', username < 'perl') \
# (AND: username='******', username='******', username > 'perl')
self.assertTrue(4, len(query.where.children[0].children))
self.assertEqual(query.where.children[0].connector, "AND")
self.assertEqual(query.where.children[0].children[0].column, "username")
self.assertEqual(query.where.children[0].children[0].operator, "=")
self.assertEqual(query.where.children[0].children[0].value, "python")
self.assertEqual(query.where.children[0].children[1].column, "username")
self.assertEqual(query.where.children[0].children[1].operator, "=")
self.assertEqual(query.where.children[0].children[1].value, "php")
self.assertEqual(query.where.children[0].children[2].column, "username")
self.assertEqual(query.where.children[0].children[2].operator, "<")
self.assertEqual(query.where.children[0].children[2].value, "perl")
self.assertEqual(query.where.children[1].connector, "AND")
self.assertEqual(query.where.children[1].children[0].column, "username")
self.assertEqual(query.where.children[1].children[0].operator, "=")
self.assertEqual(query.where.children[1].children[0].value, "python")
self.assertEqual(query.where.children[1].children[1].column, "username")
self.assertEqual(query.where.children[1].children[1].operator, "=")
self.assertEqual(query.where.children[1].children[1].value, "jruby")
self.assertEqual(query.where.children[2].connector, "AND")
self.assertEqual(query.where.children[2].children[0].column, "username")
self.assertEqual(query.where.children[2].children[0].operator, "=")
self.assertEqual(query.where.children[2].children[0].value, "python")
self.assertEqual(query.where.children[2].children[1].column, "username")
self.assertEqual(query.where.children[2].children[1].operator, "=")
self.assertEqual(query.where.children[2].children[1].value, "php")
self.assertEqual(query.where.children[2].children[2].column, "username")
self.assertEqual(query.where.children[2].children[2].operator, ">")
self.assertEqual(query.where.children[2].children[2].value, "perl")
self.assertEqual(query.where.connector, "OR")
self.assertEqual(query.where.children[3].connector, "AND")
self.assertEqual(query.where.children[3].children[0].column, "username")
self.assertEqual(query.where.children[3].children[0].operator, "=")
self.assertEqual(query.where.children[3].children[0].value, "python")
self.assertEqual(query.where.children[3].children[1].column, "username")
self.assertEqual(query.where.children[3].children[1].operator, "=")
self.assertEqual(query.where.children[3].children[1].value, "ruby")
qs = TestUser.objects.filter(username="******") | TestUser.objects.filter(username="******")
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertEqual(query.where.connector, "OR")
self.assertEqual(2, len(query.where.children))
self.assertTrue(query.where.children[0].is_leaf)
self.assertEqual("cheese", query.where.children[0].value)
self.assertTrue(query.where.children[1].is_leaf)
self.assertEqual("test", query.where.children[1].value)
qs = TestUser.objects.using("default").filter(username__in=set()).values_list('email')
with self.assertRaises(EmptyResultSet):
query = normalize_query(transform_query(
connections['default'],
qs.query
))
qs = TestUser.objects.filter(username__startswith='Hello') | TestUser.objects.filter(username__startswith='Goodbye')
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertEqual(2, len(query.where.children))
self.assertEqual("_idx_startswith_username", query.where.children[0].column)
self.assertEqual(u"Goodbye", query.where.children[0].value)
self.assertEqual("_idx_startswith_username", query.where.children[1].column)
self.assertEqual(u"Hello", query.where.children[1].value)
qs = TestUser.objects.filter(pk__in=[1, 2, 3])
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertEqual(3, len(query.where.children))
self.assertEqual("__key__", query.where.children[0].column)
self.assertEqual("__key__", query.where.children[1].column)
self.assertEqual("__key__", query.where.children[2].column)
self.assertEqual({
datastore.Key.from_path(TestUser._meta.db_table, 1, namespace=DEFAULT_NAMESPACE),
datastore.Key.from_path(TestUser._meta.db_table, 2, namespace=DEFAULT_NAMESPACE),
datastore.Key.from_path(TestUser._meta.db_table, 3, namespace=DEFAULT_NAMESPACE),
}, {
query.where.children[0].value,
query.where.children[1].value,
query.where.children[2].value,
}
)
qs = TestUser.objects.filter(pk__in=[1, 2, 3]).filter(username="******")
query = normalize_query(transform_query(
connections['default'],
qs.query
))
self.assertEqual(3, len(query.where.children))
self.assertEqual("__key__", query.where.children[0].children[0].column)
self.assertEqual("test", query.where.children[0].children[1].value)
self.assertEqual("__key__", query.where.children[1].children[0].column)
self.assertEqual("test", query.where.children[0].children[1].value)
self.assertEqual("__key__", query.where.children[2].children[0].column)
self.assertEqual("test", query.where.children[0].children[1].value)
self.assertEqual({
datastore.Key.from_path(TestUser._meta.db_table, 1, namespace=DEFAULT_NAMESPACE),
datastore.Key.from_path(TestUser._meta.db_table, 2, namespace=DEFAULT_NAMESPACE),
datastore.Key.from_path(TestUser._meta.db_table, 3, namespace=DEFAULT_NAMESPACE),
}, {
query.where.children[0].children[0].value,
query.where.children[1].children[0].value,
query.where.children[2].children[0].value,
}
)
