Switch to new Query model (see #62)

msiemens · Sep 17, 2015 · a211459 · a211459
1 parent e1f5a00
commit a211459
Show file tree

Hide file tree

Showing 4 changed files with 154 additions and 578 deletions.
diff --git a/tests/test_queries.py b/tests/test_queries.py
@@ -1,48 +1,54 @@
-from tinydb.queries import where
+import pytest
+from tinydb.queries import Query
+
+
+def test_no_path():
+    with pytest.raises(ValueError):
+        Query() == 2
 
 
 def test_eq():
-    query = where('value') == 1
+    query = Query().value == 1
     assert query({'value': 1})
     assert not query({'value': 2})
 
 
 def test_ne():
-    query = where('value') != 1
+    query = Query().value != 1
     assert query({'value': 2})
     assert not query({'value': 1})
 
 
 def test_lt():
-    query = where('value') < 1
+    query = Query().value < 1
     assert query({'value': 0})
     assert not query({'value': 1})
 
 
 def test_le():
-    query = where('value') <= 1
+    query = Query().value <= 1
     assert query({'value': 0})
     assert query({'value': 1})
     assert not query({'value': 2})
 
 
 def test_gt():
-    query = where('value') > 1
+    query = Query().value > 1
     assert query({'value': 2})
     assert not query({'value': 1})
 
 
 def test_ge():
-    query = where('value') >= 1
+    query = Query().value >= 1
     assert query({'value': 2})
     assert query({'value': 1})
     assert not query({'value': 0})
 
 
 def test_or():
     query = (
-        (where('val1') == 1) |
-        (where('val2') == 2)
+        (Query().val1 == 1) |
+        (Query().val2 == 2)
     )
     assert query({'val1': 1})
     assert query({'val2': 2})
@@ -52,8 +58,8 @@ def test_or():
 
 def test_and():
     query = (
-        (where('val1') == 1) &
-        (where('val2') == 2)
+        (Query().val1 == 1) &
+        (Query().val2 == 2)
     )
     assert query({'val1': 1, 'val2': 2})
     assert not query({'val1': 1})
@@ -62,13 +68,13 @@ def test_and():
 
 
 def test_not():
-    query = ~ (where('val1') == 1)
+    query = ~ (Query().val1 == 1)
     assert query({'val1': 5, 'val2': 2})
     assert not query({'val1': 1, 'val2': 2})
 
     query = (
-        (~ (where('val1') == 1)) &
-        (where('val2') == 2)
+        (~ (Query().val1 == 1)) &
+        (Query().val2 == 2)
     )
     assert query({'val1': '', 'val2': 2})
     assert query({'val2': 2})
@@ -78,21 +84,21 @@ def test_not():
 
 
 def test_has_key():
-    query = where('val3')
+    query = Query().val3.exists()
 
     assert query({'val3': 1})
     assert not query({'val1': 1, 'val2': 2})
 
 
 def test_regex():
-    query = where('val').matches(r'\d{2}\.')
+    query = Query().val.matches(r'\d{2}\.')
 
     assert query({'val': '42.'})
     assert not query({'val': '44'})
     assert not query({'val': 'ab.'})
     assert not query({'': None})
 
-    query = where('val').contains(r'\d+')
+    query = Query().val.search(r'\d+')
 
     assert query({'val': 'ab3'})
     assert not query({'val': 'abc'})
@@ -104,7 +110,7 @@ def test_custom():
     def test(value):
         return value == 42
 
-    query = where('val').test(test)
+    query = Query().val.test(test)
 
     assert query({'val': 42})
     assert not query({'val': 40})
@@ -116,7 +122,7 @@ def test_custom_with_params():
     def test(value, minimum, maximum):
         return minimum <= value <= maximum
 
-    query = where('val').test(test, 1, 10)
+    query = Query().val.test(test, 1, 10)
 
     assert query({'val': 5})
     assert not query({'val': 0})
@@ -125,47 +131,47 @@ def test(value, minimum, maximum):
 
 
 def test_any():
-    query = where('followers').any(where('name') == 'don')
+    query = Query().followers.any(Query().name == 'don')
 
     assert query({'followers': [{'name': 'don'}, {'name': 'john'}]})
     assert not query({'followers': 1})
     assert not query({})
 
-    query = where('followers').any(where('num').matches('\\d+'))
+    query = Query().followers.any(Query().num.matches('\\d+'))
     assert query({'followers': [{'num': '12'}, {'num': 'abc'}]})
     assert not query({'followers': [{'num': 'abc'}]})
 
-    query = where('followers').any(['don', 'jon'])
+    query = Query().followers.any(['don', 'jon'])
     assert query({'followers': ['don', 'greg', 'bill']})
     assert not query({'followers': ['greg', 'bill']})
     assert not query({})
 
-    query = where('followers').any([{'name': 'don'}, {'name': 'john'}])
+    query = Query().followers.any([{'name': 'don'}, {'name': 'john'}])
     assert query({'followers': [{'name': 'don'}, {'name': 'greg'}]})
     assert not query({'followers': [{'name': 'greg'}]})
 
 
 def test_all():
-    query = where('followers').all(where('name') == 'don')
+    query = Query().followers.all(Query().name == 'don')
     assert query({'followers': [{'name': 'don'}]})
     assert not query({'followers': [{'name': 'don'}, {'name': 'john'}]})
 
-    query = where('followers').all(where('num').matches('\\d+'))
+    query = Query().followers.all(Query().num.matches('\\d+'))
     assert query({'followers': [{'num': '123'}, {'num': '456'}]})
     assert not query({'followers': [{'num': '123'}, {'num': 'abc'}]})
 
-    query = where('followers').all(['don', 'john'])
+    query = Query().followers.all(['don', 'john'])
     assert query({'followers': ['don', 'john', 'greg']})
     assert not query({'followers': ['don', 'greg']})
     assert not query({})
 
-    query = where('followers').all([{'name': 'john'}, {'age': 17}])
+    query = Query().followers.all([{'name': 'john'}, {'age': 17}])
     assert query({'followers': [{'name': 'john'}, {'age': 17}]})
     assert not query({'followers': [{'name': 'john'}, {'age': 18}]})
 
 
 def test_has():
-    query = where('key1').has('key2')
+    query = Query().key1.key2.exists()
     str(query)  # This used to cause a bug...
 
     assert query({'key1': {'key2': {'key3': 1}}})
@@ -174,13 +180,13 @@ def test_has():
     assert not query({'key1': {'key1': 1}})
     assert not query({'key2': {'key1': 1}})
 
-    query = where('key1').has('key2') == 1
+    query = Query().key1.key2 == 1
 
     assert query({'key1': {'key2': 1}})
     assert not query({'key1': {'key2': 2}})
 
     # Nested has: key exists
-    query = where('key1').has('key2').has('key3')
+    query = Query().key1.key2.key3.exists()
     assert query({'key1': {'key2': {'key3': 1}}})
     # Not a dict
     assert not query({'key1': 1})
@@ -191,42 +197,43 @@ def test_has():
     assert not query({'key0': {'key2': {'key3': 1}}})
 
     # Nested has: check for value
-    query = where('key1').has('key2').has('key3') == 1
+    query = Query().key1.key2.key3 == 1
     assert query({'key1': {'key2': {'key3': 1}}})
     assert not query({'key1': {'key2': {'key3': 0}}})
 
     # Test special methods: regex matches
-    query = where('key1').has('value').matches(r'\d+')
+    query = Query().key1.value.matches(r'\d+')
     assert query({'key1': {'value': '123'}})
     assert not query({'key2': {'value': '123'}})
     assert not query({'key2': {'value': 'abc'}})
 
     # Test special methods: regex contains
-    query = where('key1').has('value').contains(r'\d+')
+    query = Query().key1.value.search(r'\d+')
     assert query({'key1': {'value': 'a2c'}})
     assert not query({'key2': {'value': 'a2c'}})
     assert not query({'key2': {'value': 'abc'}})
 
     # Test special methods: nested has and regex matches
-    query = where('key1').has('x').has('y').matches(r'\d+')
+    query = Query().key1.x.y.matches(r'\d+')
     assert query({'key1': {'x': {'y': '123'}}})
     assert not query({'key1': {'x': {'y': 'abc'}}})
 
     # Test special method: nested has and regex contains
-    query = where('key1').has('x').has('y').contains(r'\d+')
+    query = Query().key1.x.y.search(r'\d+')
     assert query({'key1': {'x': {'y': 'a2c'}}})
     assert not query({'key1': {'x': {'y': 'abc'}}})
 
     # Test special methods: custom test
-    query = where('key1').has('int').test(lambda x: x == 3)
+    query = Query().key1.int.test(lambda x: x == 3)
     assert query({'key1': {'int': 3}})
 
 
 def test_hash():
     d = {
-        where('key1') == 2: True,
-        where('key1').has('key2').has('key3'): True
+        Query().key1 == 2: True,
+        Query().key1.key2.key3.exists(): True
     }
 
-    assert (where('key1') == 2) in d
-    assert (where('key1').has('key2').has('key3')) in d
+    assert (Query().key1 == 2) in d
+    assert (Query().key1.key2.key3.exists()) in d
+    assert (Query()['key1.key2'].key3.exists()) not in d
diff --git a/tests/test_tinydb.py b/tests/test_tinydb.py
@@ -83,7 +83,7 @@ def generator():
 
     for i in range(10):
         assert db.count(where('int') == i) == 1
-    assert db.count(where('int')) == 10
+    assert db.count(where('int').exists()) == 10
 
     # Insert multiple from inline generator
     db.purge()

diff --git a/tinydb/__init__.py b/tinydb/__init__.py
@@ -23,8 +23,8 @@
 5
 """
 
-from tinydb.queries import where
+from tinydb.queries import Query, where
 from tinydb.storages import Storage, JSONStorage
 from tinydb.database import TinyDB
 
-__all__ = ('TinyDB', 'Storage', 'JSONStorage', 'where')
+__all__ = ('TinyDB', 'Storage', 'JSONStorage', 'Query', 'where')