field name lookup working

Author: dantownsend

aragorm/fields.py

@@ -1,4 +1,5 @@
 import typing
+import uuid
 
 from .operators import Operator, In, NotIn, Equal, NotEqual, Like
 
@@ -10,6 +11,10 @@ class Field():
 
     def __init__(self, null: bool = True):
         self.null = null
+        self.uuid = uuid.uuid4()
+
+    def __hash__(self):
+        return hash(self.uuid)
 
     def is_in(self, values: Iterable) -> 'Where':
         return Where(field=self, values=values, operator=In)

aragorm/model.py

@@ -22,39 +22,27 @@ def __new__(cls, name, bases, namespace, **kwds):
         """
         model = super().__new__(cls, name, bases, namespace)
 
-        tablename = _camel_to_snake(name)
-        model.__tablename__ = tablename
+        tablename = namespace.get('tablename')
+        if not tablename:
+            model.tablename = _camel_to_snake(name)
 
         fields = {}
         for key, value in namespace.items():
             if issubclass(type(value), Field):
-                fields[name] = value
+                fields[value] = key
 
-        model.__fields__ = fields
+        model.fields = fields
         return model
 
 
 class Model(metaclass=ModelMeta):
 
     @classmethod
-    def _tablename(cls):
-        tablename = getattr(cls, 'tablename', None)
-        if tablename:
-            return tablename
-        else:
-            # TODO - FooBar -> foo_bar
-            return cls.__name__.lower()
-
-    @property
-    def fields() -> [Field]:
-        """
-        Needs to inspect the subclass, and return all Fields.
-
-        Also ... needs to be a classproperty, or just stored by the meta
-        class.
-
-        Want this generated once by the meta class, or cached.
-        """
+    def get_field_name(cls, field: Field) -> str:
+        field_name = cls.fields.get(field, None)
+        if not field_name:
+            raise ValueError(f'Unrecognised field')
+        return field_name
 
     @classmethod
     def select(cls, *field_names: [str]) -> Query:
@@ -73,11 +61,10 @@ def select(cls, *field_names: [str]) -> Query:
             # TODO - make sure the fields passed in are valid
             fields_str = ', '.join(field_names)
 
-        tablename = cls._tablename()
         return Query(
             type='SELECT',
             model=cls,
-            base=f'SELECT {fields_str} from {tablename}'
+            base=f'SELECT {fields_str} from {cls.tablename}'
             )
 
     @classmethod

aragorm/query.py

@@ -42,7 +42,14 @@ def generate_query(self):
 
         The query needs a link to the table calling it ...
         """
-        return self.base
+        query = self.base
+        if self.where_clauses:
+            query += ' WHERE '
+            for clause in self.where_clauses:
+                name = self.model.get_field_name(clause.field)
+                query += clause.get_sql(name)
+        print(query)
+        return query
 
     async def execute(self, as_dict=True) -> str:
         """

tests/test_model.py

@@ -122,4 +122,4 @@ def tearDown(self):
 class TestMetaClass(TestCase):
 
     def test_tablename(self):
-        self.assertEqual(Pokemon.__tablename__, 'pokemon')
+        self.assertEqual(Pokemon.tablename, 'pokemon')