added greater than

Author: dantownsend

aragorm/fields.py

@@ -1,7 +1,7 @@
 import typing
 import uuid
 
-from .operators import Operator, In, NotIn, Equal, NotEqual, Like
+from .operators import Operator, In, NotIn, Equal, NotEqual, Like, GreaterThan
 
 
 Iterable = typing.Iterable[typing.Any]
@@ -27,18 +27,13 @@ def like(self, value: str) -> 'Where':
             raise ValueError('% is required for like operators')
         return Where(field=self, value=value, operator=Like)
 
-    def __eq__(self, value) -> 'Where':
-        """
-        The challenge here is ... need the name of the field ...
+    def __gt__(self, value) -> 'Where':
+        return Where(field=self, value=value, operator=GreaterThan)
 
-        I'll have some way on the model to match fields instances to names ...
-        will be fine.
-        """
+    def __eq__(self, value) -> 'Where':
         return Where(field=self, value=value, operator=Equal)
 
     def __ne__(self, value) -> 'Where':
-        # Can either return it ... or just store the where clauses on the
-        # field ...
         return Where(field=self, value=value, operator=NotEqual)
 
 
@@ -50,7 +45,7 @@ def __init__(self, length: int = 255, default: str = None, **kwargs):
 
 
 class Integer(Field):
-    def __init__(self, default: int = None):
+    def __init__(self, default: int = None, **kwargs):
         self.default = default
         super().__init__(**kwargs)
 

aragorm/model.py

@@ -65,7 +65,7 @@ def select(cls, *field_names: [str]) -> Query:
             type='SELECT',
             model=cls,
             base=f'SELECT {fields_str} from {cls.tablename}'
-            )
+        )
 
     @classmethod
     async def insert(cls, *row: ["Model"]):

aragorm/operators.py

@@ -20,3 +20,8 @@ class NotIn(Operator):
 
 class Like(Operator):
     template = "{name} LIKE '{value}'"
+
+
+class GreaterThan(Operator):
+    # Add permitted types???
+    template = "{name} > {value}"

aragorm/query.py

@@ -26,22 +26,16 @@ class Query(object):
 
     valid_types = ['INSERT', 'UPDATE', 'SELECT']
 
-    where_clauses: [Where] = []
-
     def __init__(self, type: str, model: 'Model', base: str):
         """
         A query has to be a certain type.
         """
         # For example select * from my_table
         self.base = base
         self.model = model
+        self.where_clauses: [Where] = []
 
     def generate_query(self):
-        """
-        For each where clause ... need to get the name ...
-
-        The query needs a link to the table calling it ...
-        """
         query = self.base
         if self.where_clauses:
             query += ' WHERE '
@@ -51,20 +45,24 @@ def generate_query(self):
         print(query)
         return query
 
-    async def execute(self, as_dict=True) -> str:
+    def first(self):
+        """
+        LIMIT 1 ... and only return the first row ...
+
+        I want to think about using .limit() too ...
+        """
+
+    async def execute(self, as_dict=True):
         """
         Now ... just execute it from within here for now ...
         """
         conn = await asyncpg.connect(**TEST_CREDENTIALS)
         results = await conn.fetch(self.generate_query())
         await conn.close()
         # TODO Be able to output it in different formats.
-        return dict(results[0].items())
+        return [dict(i.items()) for i in results]
 
     def where(self, where: Where):
-        """
-        Just appends where clauses ...
-        """
         self.where_clauses.append(where)
         return self
 

tests/__init__.py

@@ -4,3 +4,4 @@
 
 class Pokemon(model.Model):
     name = fields.Varchar(length=50)
+    power = fields.Integer()

tests/example_project/__init__.py

@@ -3,7 +3,7 @@
 
 import asyncpg
 
-from example_project.models import Pokemon
+from .example_project.models import Pokemon
 
 
 TEST_CREDENTIALS = {
@@ -79,7 +79,7 @@ async def get_pokemon():
         print(f'response = {response}')
 
         self.assertDictEqual(
-            response,
+            response[0],
             {'name': 'pikachu', 'power': 1000}
         )
 
@@ -93,7 +93,7 @@ async def get_pokemon():
         print(f'response = {response}')
 
         self.assertDictEqual(
-            response,
+            response[0],
             {'name': 'pikachu'}
         )
 
@@ -115,6 +115,24 @@ async def get_pokemon():
             [{'name': 'pikachu'}, {'name': 'raichu'}]
         )
 
+    def test_where_greater_than(self):
+        self.insert_rows()
+
+        async def get_pokemon():
+            return await Pokemon.select(
+                'name'
+            ).where(
+                Pokemon.power > 1000
+            ).execute()
+
+        response = asyncio.run(get_pokemon())
+        print(f'response = {response}')
+
+        self.assertEqual(
+            response,
+            [{'name': 'raichu'}]
+        )
+
     def tearDown(self):
         self.drop_table()