fixing tests

Author: dantownsend

piccolo/columns/base.py

@@ -88,7 +88,6 @@ def get_full_name(self, just_alias=False) -> str:
             "$".join([i._name for i in self.call_chain])
             + f"${column_name}"
         )
-
         alias = f"{self.call_chain[-1].table_alias}.{self._name}"
         if just_alias:
             return alias

piccolo/columns/column_types.py

@@ -36,8 +36,15 @@ def __init__(self, **kwargs) -> None:
 
 
 class PrimaryKey(Column):
-    # Was column_type = 'SERIAL' for Postgres
-    column_type = 'INTEGER'
+
+    @property
+    def column_type(self):
+        engine_type = self._table.Meta.db.engine_type
+        if engine_type == 'postgres':
+            return 'SERIAL'
+        elif engine_type == 'sqlite':
+            return 'INTEGER'
+        raise Exception('Unrecognized engine type')
 
     def default(self, engine_type: str = 'postgres'):
         if engine_type == 'postgres':

piccolo/query/methods/select.py

@@ -1,10 +1,9 @@
 from __future__ import annotations
 from collections import OrderedDict
-from itertools import groupby
 import typing as t
 
 from piccolo.query.base import Query
-from piccolo.columns import Column, ForeignKey
+from piccolo.columns import Column
 from piccolo.query.mixins import (
     ColumnsMixin,
     CountMixin,
@@ -77,34 +76,32 @@ def check_valid_call_chain(self, keys: t.List[Column]) -> bool:
 
     @property
     def querystring(self) -> QueryString:
-        joins: t.List[str] = []
-
-        if len(self.selected_columns) == 0:
-            self.selected_columns = self.table.Meta.columns
-
-        column_names: t.List[str] = [
-            c.get_full_name() for c in self.selected_columns
-        ]
-        columns_str = ", ".join(column_names)
-
-        #######################################################################
         # JOIN
-
         self.check_valid_call_chain(self.selected_columns)
 
         select_joins = self.get_joins(self.selected_columns)
         where_joins = self.get_joins(self.get_where_columns())
         order_by_joins = self.get_joins(self.get_order_by_columns())
 
         # Combine all joins, and remove duplicates
-        joins = list(
+        joins: t.List[str] = list(
             OrderedDict.fromkeys(
                 select_joins + where_joins + order_by_joins
             )
         )
 
         #######################################################################
 
+        if len(self.selected_columns) == 0:
+            self.selected_columns = self.table.Meta.columns
+
+        column_names: t.List[str] = [
+            c.get_full_name() for c in self.selected_columns
+        ]
+        columns_str = ", ".join(column_names)
+
+        #######################################################################
+
         select = "SELECT DISTINCT" if self.distinct else "SELECT"
         query = f'{select} {columns_str} FROM {self.table.Meta.tablename}'
 

piccolo/query/methods/update.py

@@ -28,14 +28,14 @@ def postgres_querystring(self) -> QueryString:
         self.validate()
 
         columns_str = ', '.join([
-            f'{column_name} = {{}}' for column_name, _ in self._values.items()
+            f'{col._name} = {{}}' for col, _ in self._values.items()
         ])
 
         query = f'UPDATE {self.table.Meta.tablename} SET ' + columns_str
 
         querystring = QueryString(
             query,
-            self._values.values()
+            *self._values.values()
         )
 
         # TODO - need to support joins

piccolo/table.py

@@ -48,10 +48,13 @@ def __new__(cls, name, bases, namespace, **kwds):
                 if hasattr(base, 'Meta'):
                     _columns = getattr(base.Meta, 'columns', None)
                     if _columns:
-                        columns = _columns + columns
+                        # Don't copy over the primary key.
+                        columns = [i for i in _columns if not
+                                   isinstance(i, PrimaryKey)] + columns
 
-            if 'id' not in namespace.keys():
-                namespace['id'] = PrimaryKey()
+        primary_key = PrimaryKey()
+        namespace['id'] = primary_key
+        table.id = primary_key
 
         for key, value in namespace.items():
             if issubclass(type(value), Column):
@@ -236,10 +239,10 @@ def save(self):
         if type(self.id) == int:
             # pre-existing row
             kwargs = {
-                i._name: getattr(self, i._name, None) for i in cls.Meta.columns
+                i: getattr(self, i._name, None) for i in cls.Meta.columns
             }
             _id = kwargs.pop('id')
-            return cls.update(**kwargs).where(
+            return cls.update.values(kwargs).where(
                 cls.id == _id
             )
         else:

tests/table/test_instance.py

@@ -9,7 +9,7 @@ class TestInstance(DBTestCase):
 
     def test_insert(self):
         Pythonistas = Band(name="Pythonistas")
-        self.assertEqual(Pythonistas.__str__(), "(DEFAULT,'Pythonistas',null,null)")
+        self.assertEqual(Pythonistas.__str__(), "('Pythonistas',null,null,DEFAULT)")
 
     def test_non_existant_column(self):
         with self.assertRaises(ValueError):

tests/table/test_objects.py

@@ -16,7 +16,7 @@ def test_get_all(self):
         self.assertTrue(isinstance(instance, Band))
         self.assertTrue(instance.name == 'Pythonistas')
 
-        # No try changing the value and saving it.
+        # Now try changing the value and saving it.
         instance.name = 'Rustaceans'
         save_query = instance.save()
         save_query.run_sync()

tests/table/test_update.py

@@ -7,9 +7,9 @@ class TestUpdate(DBTestCase):
     def test_update(self):
         self.insert_rows()
 
-        Band.update(
-            name='Pythonistas3'
-        ).where(
+        Band.update.values({
+            Band.name: 'Pythonistas3'
+        }).where(
             Band.name == 'Pythonistas'
         ).run_sync()