create multiple tables at once (piccolo-orm#235)

* added 'create_tables' function for creating multiple tables at once

* added an unittest for 'create_tables' function

* added a unit test for 'create_tables' function

* fix for 'CASCADE' problem in 'create_tables' test

* moved sort_table_classes, _get_graph and create_tables to piccolo/table.py

* add 'create_tables' to docs

Author: AliSayyah

docs/src/piccolo/query_types/create_table.rst

@@ -19,3 +19,13 @@ To prevent an error from being raised if the table already exists:
 
     >>> Band.create_table(if_not_exists=True).run_sync()
     []
+
+Also, you can create multiple tables at once.
+
+This function will automatically sort tables based on their foreign keys so they're created in the right order:
+
+.. code-block:: python
+    
+    >>> from piccolo.table import create_tables 
+    >>> create_tables(Band, Manager, if_not_exists=True)
+   

piccolo/apps/fixture/commands/dump.py

@@ -6,8 +6,8 @@
     FixtureConfig,
     create_pydantic_fixture_model,
 )
-from piccolo.apps.migrations.auto.migration_manager import sort_table_classes
 from piccolo.conf.apps import Finder
+from piccolo.table import sort_table_classes
 
 
 async def get_dump(

piccolo/apps/migrations/auto/migration_manager.py

@@ -14,8 +14,7 @@
 from piccolo.apps.migrations.auto.serialisation import deserialise_params
 from piccolo.columns import Column, column_types
 from piccolo.engine import engine_finder
-from piccolo.table import Table, create_table_class
-from piccolo.utils.graphlib import TopologicalSorter
+from piccolo.table import Table, create_table_class, sort_table_classes
 
 
 @dataclass
@@ -118,76 +117,6 @@ def table_class_names(self) -> t.List[str]:
         return list(set([i.table_class_name for i in self.alter_columns]))
 
 
-def _get_graph(
-    table_classes: t.List[t.Type[Table]],
-    iterations: int = 0,
-    max_iterations: int = 5,
-) -> t.Dict[str, t.Set[str]]:
-    """
-    Analyses the tables based on their foreign keys, and returns a data
-    structure like:
-
-    .. code-block:: python
-
-        {'band': {'manager'}, 'concert': {'band', 'venue'}, 'manager': set()}
-
-    The keys are tablenames, and the values are tablenames directly connected
-    to it via a foreign key.
-
-    """
-    output: t.Dict[str, t.Set[str]] = {}
-
-    if iterations >= max_iterations:
-        return output
-
-    for table_class in table_classes:
-        dependents: t.Set[str] = set()
-        for fk in table_class._meta.foreign_key_columns:
-            dependents.add(
-                fk._foreign_key_meta.resolved_references._meta.tablename
-            )
-
-            # We also recursively check the related tables to get a fuller
-            # picture of the schema and relationships.
-            referenced_table = fk._foreign_key_meta.resolved_references
-            output.update(
-                _get_graph(
-                    [referenced_table],
-                    iterations=iterations + 1,
-                )
-            )
-
-        output[table_class._meta.tablename] = dependents
-
-    return output
-
-
-def sort_table_classes(
-    table_classes: t.List[t.Type[Table]],
-) -> t.List[t.Type[Table]]:
-    """
-    Sort the table classes based on their foreign keys, so they can be created
-    in the correct order.
-    """
-    table_class_dict = {
-        table_class._meta.tablename: table_class
-        for table_class in table_classes
-    }
-
-    graph = _get_graph(table_classes)
-
-    sorter = TopologicalSorter(graph)
-    ordered_tablenames = tuple(sorter.static_order())
-
-    output: t.List[t.Type[Table]] = []
-    for tablename in ordered_tablenames:
-        table_class = table_class_dict.get(tablename, None)
-        if table_class is not None:
-            output.append(table_class)
-
-    return output
-
-
 @dataclass
 class MigrationManager:
     """

piccolo/apps/schema/commands/generate.py

@@ -6,7 +6,6 @@
 import black
 from typing_extensions import Literal
 
-from piccolo.apps.migrations.auto.migration_manager import sort_table_classes
 from piccolo.apps.migrations.auto.serialisation import serialise_params
 from piccolo.columns.base import Column
 from piccolo.columns.column_types import (
@@ -31,7 +30,7 @@
 )
 from piccolo.engine.finder import engine_finder
 from piccolo.engine.postgres import PostgresEngine
-from piccolo.table import Table, create_table_class
+from piccolo.table import Table, create_table_class, sort_table_classes
 from piccolo.utils.naming import _snake_to_camel
 
 if t.TYPE_CHECKING:  # pragma: no cover

piccolo/table.py

@@ -40,12 +40,12 @@
 from piccolo.query.methods.indexes import Indexes
 from piccolo.querystring import QueryString, Unquoted
 from piccolo.utils import _camel_to_snake
+from piccolo.utils.graphlib import TopologicalSorter
 from piccolo.utils.sql_values import convert_to_sql_value
 
 if t.TYPE_CHECKING:
     from piccolo.columns import Selectable
 
-
 PROTECTED_TABLENAMES = ("user",)
 
 
@@ -126,7 +126,6 @@ def __str__(cls):
 
 
 class Table(metaclass=TableMetaclass):
-
     # These are just placeholder values, so type inference isn't confused - the
     # actual values are set in __init_subclass__.
     _meta = TableMeta()
@@ -975,3 +974,82 @@ def create_table_class(
         kwds=class_kwargs,
         exec_body=lambda namespace: namespace.update(class_members),
     )
+
+
+def create_tables(*args: t.Type[Table], if_not_exists: bool = False) -> None:
+    """
+    Creates multiple tables that passed to it.
+    """
+    sorted_table_classes = sort_table_classes(list(args))
+    for table in sorted_table_classes:
+        Create(table=table, if_not_exists=if_not_exists).run_sync()
+
+
+def sort_table_classes(
+    table_classes: t.List[t.Type[Table]],
+) -> t.List[t.Type[Table]]:
+    """
+    Sort the table classes based on their foreign keys, so they can be created
+    in the correct order.
+    """
+    table_class_dict = {
+        table_class._meta.tablename: table_class
+        for table_class in table_classes
+    }
+
+    graph = _get_graph(table_classes)
+
+    sorter = TopologicalSorter(graph)
+    ordered_tablenames = tuple(sorter.static_order())
+
+    output: t.List[t.Type[Table]] = []
+    for tablename in ordered_tablenames:
+        table_class = table_class_dict.get(tablename, None)
+        if table_class is not None:
+            output.append(table_class)
+
+    return output
+
+
+def _get_graph(
+    table_classes: t.List[t.Type[Table]],
+    iterations: int = 0,
+    max_iterations: int = 5,
+) -> t.Dict[str, t.Set[str]]:
+    """
+    Analyses the tables based on their foreign keys, and returns a data
+    structure like:
+
+    .. code-block:: python
+
+        {'band': {'manager'}, 'concert': {'band', 'venue'}, 'manager': set()}
+
+    The keys are tablenames, and the values are tablenames directly connected
+    to it via a foreign key.
+
+    """
+    output: t.Dict[str, t.Set[str]] = {}
+
+    if iterations >= max_iterations:
+        return output
+
+    for table_class in table_classes:
+        dependents: t.Set[str] = set()
+        for fk in table_class._meta.foreign_key_columns:
+            dependents.add(
+                fk._foreign_key_meta.resolved_references._meta.tablename
+            )
+
+            # We also recursively check the related tables to get a fuller
+            # picture of the schema and relationships.
+            referenced_table = fk._foreign_key_meta.resolved_references
+            output.update(
+                _get_graph(
+                    [referenced_table],
+                    iterations=iterations + 1,
+                )
+            )
+
+        output[table_class._meta.tablename] = dependents
+
+    return output

tests/apps/migrations/auto/test_migration_manager.py

@@ -2,16 +2,13 @@
 from unittest import TestCase
 from unittest.mock import MagicMock, patch
 
-from piccolo.apps.migrations.auto.migration_manager import (
-    MigrationManager,
-    sort_table_classes,
-)
+from piccolo.apps.migrations.auto.migration_manager import MigrationManager
 from piccolo.apps.migrations.commands.base import BaseMigrationManager
 from piccolo.columns import Text, Varchar
 from piccolo.columns.base import OnDelete, OnUpdate
 from piccolo.columns.column_types import ForeignKey
 from piccolo.conf.apps import AppConfig
-from piccolo.table import Table
+from piccolo.table import Table, sort_table_classes
 from piccolo.utils.lazy_loader import LazyLoader
 from tests.base import DBTestCase, postgres_only, set_mock_return_value
 from tests.example_apps.music.tables import Band, Concert, Manager, Venue

tests/table/test_create_tables.py

@@ -0,0 +1,15 @@
+from unittest import TestCase
+
+from piccolo.table import create_tables
+from tests.example_apps.music.tables import Band, Manager
+
+
+class TestCreateTables(TestCase):
+    def tearDown(self) -> None:
+        Band.alter().drop_table(if_exists=True).run_sync()
+        Manager.alter().drop_table(if_exists=True).run_sync()
+
+    def test_create_tables(self):
+        create_tables(Manager, Band, if_not_exists=False)
+        self.assertTrue(Manager.table_exists().run_sync())
+        self.assertTrue(Band.table_exists().run_sync())