Merge pull request piccolo-orm#30 from piccolo-orm/foreign_key_references_as_string

Foreign key references as string

Author: dantownsend

.gitignore

@@ -14,3 +14,4 @@ _build/
 .coverage
 *.sqlite
 htmlcov/
+prof/

piccolo/apps/migrations/auto/migration_manager.py

@@ -511,8 +511,15 @@ async def _run_add_columns(self, backwards=False):
                     AddColumnClass
                 ] = self.add_columns.for_table_class_name(table_class_name)
 
+                # Define the table, with the columns, so the metaclass
+                # sets up the columns correctly.
                 _Table: t.Type[Table] = type(
-                    add_columns[0].table_class_name, (Table,), {}
+                    add_columns[0].table_class_name,
+                    (Table,),
+                    {
+                        add_column.column._meta.name: add_column.column
+                        for add_column in add_columns
+                    },
                 )
                 _Table._meta.tablename = add_columns[0].tablename
 

piccolo/apps/migrations/auto/serialisation.py

@@ -9,6 +9,7 @@
 import uuid
 
 from piccolo.columns.defaults.base import Default
+from piccolo.columns.reference import LazyTableReference
 from piccolo.table import Table
 from .serialisation_legacy import deserialise_legacy_params
 
@@ -25,9 +26,15 @@ def __hash__(self):
     def __eq__(self, other):
         return self.__hash__() == other.__hash__()
 
+    def _serialise_value(self, value):
+        return f"'{value}'" if isinstance(value, str) else value
+
     def __repr__(self):
         args = ", ".join(
-            [f"{key}={value}" for key, value in self.instance.__dict__.items()]
+            [
+                f"{key}={self._serialise_value(value)}"
+                for key, value in self.instance.__dict__.items()
+            ]
         )
         return f"{self.instance.__class__.__name__}({args})"
 
@@ -177,6 +184,19 @@ def serialise_params(params: t.Dict[str, t.Any]) -> SerialisedParams:
             )
             continue
 
+        # Lazy imports - we need to resolve these now, in case the target
+        # table class gets deleted in the future.
+        if isinstance(value, LazyTableReference):
+            table_type = value.resolve()
+            params[key] = SerialisedCallable(callable_=table_type)
+            extra_definitions.append(
+                SerialisedTableType(table_type=table_type)
+            )
+            extra_imports.append(
+                Import(module=Table.__module__, target="Table")
+            )
+            continue
+
         # Replace any Table class values into class and table names
         if inspect.isclass(value) and issubclass(value, Table):
             params[key] = SerialisedCallable(callable_=value)

piccolo/apps/sql_shell/commands/run.py

@@ -7,7 +7,7 @@
 from piccolo.engine.sqlite import SQLiteEngine
 from piccolo.engine.finder import engine_finder
 
-if t.TYPE_CHECKING:
+if t.TYPE_CHECKING:  # pragma: no cover
     from piccolo.engine.base import Engine
 
 

piccolo/columns/__init__.py

@@ -17,6 +17,12 @@
     UUID,
     Varchar,
 )
-from .base import Column, ForeignKeyMeta, Selectable  # noqa: F401
-from .base import OnDelete, OnUpdate  # noqa: F401
+from .base import (  # noqa: F401
+    Column,
+    ForeignKeyMeta,
+    Selectable,
+    OnDelete,
+    OnUpdate,
+)
 from .combination import And, Or, Where  # noqa: F401
+from .reference import LazyTableReference  # noqa: F401

piccolo/columns/base.py

@@ -5,6 +5,7 @@
 import datetime
 import decimal
 from enum import Enum
+import inspect
 import typing as t
 
 from piccolo.columns.operators.comparison import (
@@ -24,12 +25,13 @@
 )
 from piccolo.columns.combination import Where
 from piccolo.columns.defaults.base import Default
+from piccolo.columns.reference import LazyTableReference
 from piccolo.querystring import QueryString
 from piccolo.utils.warnings import colored_warning
 
-if t.TYPE_CHECKING:
-    from piccolo.table import Table  # noqa
-    from .column_types import ForeignKey  # noqa
+if t.TYPE_CHECKING:  # pragma: no cover
+    from piccolo.table import Table
+    from piccolo.columns.column_types import ForeignKey
 
 
 class OnDelete(str, Enum):
@@ -62,11 +64,47 @@ def __repr__(self):
 
 @dataclass
 class ForeignKeyMeta:
-    references: t.Type[Table]
+    references: t.Union[t.Type[Table], LazyTableReference]
     on_delete: OnDelete
     on_update: OnUpdate
     proxy_columns: t.List[Column] = field(default_factory=list)
 
+    @property
+    def resolved_references(self) -> t.Type[Table]:
+        """
+        Evaluates the ``references`` attribute if it's a LazyTableReference,
+        raising a ``ValueError`` if it fails, otherwise returns a ``Table``
+        subclass.
+        """
+        from piccolo.table import Table
+
+        if isinstance(self.references, LazyTableReference):
+            return self.references.resolve()
+        elif inspect.isclass(self.references) and issubclass(
+            self.references, Table
+        ):
+            return self.references
+        else:
+            raise ValueError(
+                "The references attribute is neither a Table sublclass or a "
+                "LazyTableReference instance."
+            )
+
+    def copy(self) -> ForeignKeyMeta:
+        kwargs = self.__dict__.copy()
+        kwargs.update(proxy_columns=self.proxy_columns.copy())
+        return self.__class__(**kwargs)
+
+    def __copy__(self) -> ForeignKeyMeta:
+        return self.copy()
+
+    def __deepcopy__(self, memo) -> ForeignKeyMeta:
+        """
+        We override deepcopy, as it's too slow if it has to recreate
+        everything.
+        """
+        return self.copy()
+
 
 @dataclass
 class ColumnMeta:
@@ -141,6 +179,23 @@ def get_full_name(self, just_alias=False) -> str:
         else:
             return f'{alias} AS "{column_name}"'
 
+    def copy(self) -> ColumnMeta:
+        kwargs = self.__dict__.copy()
+        kwargs.update(
+            params=self.params.copy(), call_chain=self.call_chain.copy(),
+        )
+        return self.__class__(**kwargs)
+
+    def __copy__(self) -> ColumnMeta:
+        return self.copy()
+
+    def __deepcopy__(self, memo) -> ColumnMeta:
+        """
+        We override deepcopy, as it's too slow if it has to recreate
+        everything.
+        """
+        return self.copy()
+
 
 class Selectable(metaclass=ABCMeta):
     @abstractmethod
@@ -236,7 +291,7 @@ def _validate_default(
         """
         Make sure that the default value is of the allowed types.
         """
-        if getattr(self, "validated", None):
+        if getattr(self, "_validated", None):
             # If it has previously been validated by a subclass, don't
             # validate again.
             return True
@@ -245,10 +300,10 @@ def _validate_default(
             and None in allowed_types
             or type(default) in allowed_types
         ):
-            self.validated = True
+            self._validated = True
             return True
         elif callable(default):
-            self.validated = True
+            self._validated = True
             return True
         else:
             raise ValueError(
@@ -409,7 +464,7 @@ def querystring(self) -> QueryString:
             self, "_foreign_key_meta", None
         )
         if foreign_key_meta:
-            tablename = foreign_key_meta.references._meta.tablename
+            tablename = foreign_key_meta.resolved_references._meta.tablename
             on_delete = foreign_key_meta.on_delete.value
             on_update = foreign_key_meta.on_update.value
             query += (
@@ -432,8 +487,29 @@ def querystring(self) -> QueryString:
 
         return QueryString(query)
 
+    def copy(self) -> Column:
+        column: Column = copy.copy(self)
+        column._meta = self._meta.copy()
+        return column
+
+    def __deepcopy__(self, memo) -> Column:
+        """
+        We override deepcopy, as it's too slow if it has to recreate
+        everything.
+        """
+        return self.copy()
+
     def __str__(self):
         return self.querystring.__str__()
 
     def __repr__(self):
-        return f"{self._meta.name} - {self.__class__.__name__}"
+        try:
+            table = self._meta.table
+        except ValueError:
+            table_class_name = "Unknown"
+        else:
+            table_class_name = table.__name__
+        return (
+            f"{table_class_name}.{self._meta.name} - "
+            f"{self.__class__.__name__}"
+        )