piccolo 0.114.0__tar.gz → 0.115.0__tar.gz

{piccolo-0.114.0 → piccolo-0.115.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 0.114.0
+Version: 0.115.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend

piccolo-0.115.0/piccolo/__init__.py

@@ -0,0 +1 @@
+__VERSION__ = "0.115.0"

{piccolo-0.114.0 → piccolo-0.115.0}/piccolo/apps/fixtures/commands/load.py

@@ -1,19 +1,27 @@
 from __future__ import annotations
 
+import sys
 import typing as t
 
+import typing_extensions
+
 from piccolo.apps.fixtures.commands.shared import (
     FixtureConfig,
     create_pydantic_fixture_model,
 )
 from piccolo.conf.apps import Finder
 from piccolo.engine import engine_finder
+from piccolo.query.mixins import OnConflictAction
 from piccolo.table import Table, sort_table_classes
 from piccolo.utils.encoding import load_json
 from piccolo.utils.list import batch
 
 
-async def load_json_string(json_string: str, chunk_size: int = 1000):
+async def load_json_string(
+    json_string: str,
+    chunk_size: int = 1000,
+    on_conflict_action: t.Optional[OnConflictAction] = None,
+):
     """
     Parses the JSON string, and inserts the parsed data into the database.
     """
@@ -71,10 +79,23 @@ async def load_json_string(json_string: str, chunk_size: int = 1000):
             rows = data[table_class]
 
             for chunk in batch(data=rows, chunk_size=chunk_size):
-                await table_class.insert(*chunk).run()
-
-
-async def load(path: str = "fixture.json", chunk_size: int = 1000):
+                query = table_class.insert(*chunk)
+                if on_conflict_action is not None:
+                    query = query.on_conflict(
+                        target=table_class._meta.primary_key,
+                        action=on_conflict_action,
+                        values=table_class._meta.columns,
+                    )
+                await query.run()
+
+
+async def load(
+    path: str = "fixture.json",
+    chunk_size: int = 1000,
+    on_conflict: t.Optional[
+        typing_extensions.Literal["DO NOTHING", "DO UPDATE"]
+    ] = None,
+):
     """
     Reads the fixture file, and loads the contents into the database.
 
@@ -86,8 +107,28 @@ async def load(path: str = "fixture.json", chunk_size: int = 1000):
         determined by the database adapter, which has a max number of
         parameters per query.
 
+    :param on_conflict:
+        If specified, the fixture will be upserted, meaning that if a row
+        already exists with a matching primary key, then it will be overridden
+        if "DO UPDATE", or it will be ignored if "DO NOTHING".
+
     """
     with open(path, "r") as f:
         contents = f.read()
 
-    await load_json_string(contents, chunk_size=chunk_size)
+    on_conflict_action: t.Optional[OnConflictAction] = None
+
+    if on_conflict:
+        try:
+            on_conflict_action = OnConflictAction(on_conflict.upper())
+        except ValueError:
+            sys.exit(
+                f"{on_conflict} isn't a valid option - use 'DO NOTHING' or "
+                "'DO UPDATE'."
+            )
+
+    await load_json_string(
+        contents,
+        chunk_size=chunk_size,
+        on_conflict_action=on_conflict_action,
+    )

{piccolo-0.114.0 → piccolo-0.115.0}/piccolo/apps/migrations/auto/migration_manager.py

@@ -826,7 +826,7 @@ class MigrationManager:
                 await self._run_query(
                     schema_manager.move_table(
                         table_name=change_table_schema.tablename,
-                        new_schema=change_table_schema.new_schema,
+                        new_schema=change_table_schema.new_schema or "public",
                         current_schema=change_table_schema.old_schema,
                     )
                 )

{piccolo-0.114.0 → piccolo-0.115.0}/piccolo/columns/m2m.py

@@ -57,30 +57,34 @@ class M2MSelect(Selectable):
         )
 
     def get_select_string(self, engine_type: str, with_alias=True) -> str:
-        m2m_table_name = self.m2m._meta.resolved_joining_table._meta.tablename
+        m2m_table_name_with_schema = (
+            self.m2m._meta.resolved_joining_table._meta.get_formatted_tablename()  # noqa: E501
+        )  # noqa: E501
         m2m_relationship_name = self.m2m._meta.name
 
         fk_1 = self.m2m._meta.primary_foreign_key
         fk_1_name = fk_1._meta.db_column_name
         table_1 = fk_1._foreign_key_meta.resolved_references
         table_1_name = table_1._meta.tablename
+        table_1_name_with_schema = table_1._meta.get_formatted_tablename()
         table_1_pk_name = table_1._meta.primary_key._meta.db_column_name
 
         fk_2 = self.m2m._meta.secondary_foreign_key
         fk_2_name = fk_2._meta.db_column_name
         table_2 = fk_2._foreign_key_meta.resolved_references
         table_2_name = table_2._meta.tablename
+        table_2_name_with_schema = table_2._meta.get_formatted_tablename()
         table_2_pk_name = table_2._meta.primary_key._meta.db_column_name
 
         inner_select = f"""
-            "{m2m_table_name}"
-            JOIN "{table_1_name}" "inner_{table_1_name}" ON (
-                "{m2m_table_name}"."{fk_1_name}" = "inner_{table_1_name}"."{table_1_pk_name}"
+            {m2m_table_name_with_schema}
+            JOIN {table_1_name_with_schema} "inner_{table_1_name}" ON (
+                {m2m_table_name_with_schema}."{fk_1_name}" = "inner_{table_1_name}"."{table_1_pk_name}"
             )
-            JOIN "{table_2_name}" "inner_{table_2_name}" ON (
-                "{m2m_table_name}"."{fk_2_name}" = "inner_{table_2_name}"."{table_2_pk_name}"
+            JOIN {table_2_name_with_schema} "inner_{table_2_name}" ON (
+                {m2m_table_name_with_schema}."{fk_2_name}" = "inner_{table_2_name}"."{table_2_pk_name}"
             )
-            WHERE "{m2m_table_name}"."{fk_1_name}" = "{table_1_name}"."{table_1_pk_name}"
+            WHERE {m2m_table_name_with_schema}."{fk_1_name}" = "{table_1_name}"."{table_1_pk_name}"
         """  # noqa: E501
 
         if engine_type in ("postgres", "cockroach"):

{piccolo-0.114.0 → piccolo-0.115.0}/piccolo/query/methods/count.py

@@ -15,7 +15,7 @@ if t.TYPE_CHECKING:  # pragma: no cover
 
 class Count(Query):
 
-    __slots__ = ("where_delegate", "column", "distinct")
+    __slots__ = ("where_delegate", "column", "_distinct")
 
     def __init__(
         self,
@@ -26,7 +26,7 @@ class Count(Query):
     ):
         super().__init__(table, **kwargs)
         self.column = column
-        self.distinct = distinct
+        self._distinct = distinct
         self.where_delegate = WhereDelegate()
 
     ###########################################################################
@@ -36,6 +36,10 @@ class Count(Query):
         self.where_delegate.where(*where)
         return self
 
+    def distinct(self: Self, columns: t.Optional[t.Sequence[Column]]) -> Self:
+        self._distinct = columns
+        return self
+
     ###########################################################################
 
     async def response_handler(self, response) -> bool:
@@ -46,7 +50,7 @@ class Count(Query):
         table: t.Type[Table] = self.table
 
         query = table.select(
-            SelectCount(column=self.column, distinct=self.distinct)
+            SelectCount(column=self.column, distinct=self._distinct)
         )
 
         query.where_delegate._where = self.where_delegate._where

{piccolo-0.114.0 → piccolo-0.115.0}/piccolo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 0.114.0
+Version: 0.115.0
 Summary: A fast, user friendly ORM and query builder which supports asyncio.
 Home-page: https://github.com/piccolo-orm/piccolo
 Author: Daniel Townsend

{piccolo-0.114.0 → piccolo-0.115.0}/piccolo.egg-info/SOURCES.txt

@@ -254,7 +254,6 @@ tests/columns/test_double_precision.py
 tests/columns/test_interval.py
 tests/columns/test_json.py
 tests/columns/test_jsonb.py
-tests/columns/test_m2m.py
 tests/columns/test_numeric.py
 tests/columns/test_primary_key.py
 tests/columns/test_readable.py
@@ -267,6 +266,10 @@ tests/columns/test_timestamp.py
 tests/columns/test_timestamptz.py
 tests/columns/test_uuid.py
 tests/columns/test_varchar.py
+tests/columns/m2m/__init__.py
+tests/columns/m2m/base.py
+tests/columns/m2m/test_m2m.py
+tests/columns/m2m/test_m2m_schema.py
 tests/conf/__init__.py
 tests/conf/example.py
 tests/conf/test_apps.py

{piccolo-0.114.0 → piccolo-0.115.0}/tests/apps/fixtures/commands/test_dump_load.py

@@ -1,5 +1,7 @@
 import datetime
 import decimal
+import os
+import tempfile
 import typing as t
 import uuid
 from unittest import TestCase
@@ -8,7 +10,7 @@ from piccolo.apps.fixtures.commands.dump import (
     FixtureConfig,
     dump_to_json_string,
 )
-from piccolo.apps.fixtures.commands.load import load_json_string
+from piccolo.apps.fixtures.commands.load import load, load_json_string
 from piccolo.utils.sync import run_sync
 from tests.base import engines_only
 from tests.example_apps.mega.tables import MegaTable, SmallTable
@@ -240,3 +242,39 @@ class TestDumpLoad(TestCase):
                 "not_null_col": "hello",
             },
         )
+
+
+class TestOnConflict(TestCase):
+    def setUp(self) -> None:
+        SmallTable.create_table().run_sync()
+        SmallTable({SmallTable.varchar_col: "Test"}).save().run_sync()
+
+    def tearDown(self) -> None:
+        SmallTable.alter().drop_table().run_sync()
+
+    def test_on_conflict(self):
+        temp_dir = tempfile.gettempdir()
+
+        json_file_path = os.path.join(temp_dir, "fixture.json")
+
+        json_string = run_sync(
+            dump_to_json_string(
+                fixture_configs=[
+                    FixtureConfig(
+                        app_name="mega",
+                        table_class_names=["SmallTable"],
+                    )
+                ]
+            )
+        )
+
+        if os.path.exists(json_file_path):
+            os.unlink(json_file_path)
+
+        with open(json_file_path, "w") as f:
+            f.write(json_string)
+
+        run_sync(load(path=json_file_path, on_conflict="DO NOTHING"))
+        run_sync(load(path=json_file_path, on_conflict="DO UPDATE"))
+        run_sync(load(path=json_file_path, on_conflict="do nothing"))
+        run_sync(load(path=json_file_path, on_conflict="do update"))

{piccolo-0.114.0 → piccolo-0.115.0}/tests/apps/migrations/auto/integration/test_migrations.py

@@ -1138,9 +1138,10 @@ class TestSchemas(MigrationTestCase):
             ).run_sync(),
         )
 
-    def test_move_schemas(self):
+    def test_move_table_from_public_schema(self):
         """
-        Make sure the auto migrations detect that a table's schema has changed.
+        Make sure the auto migrations can move a table from the public schema
+        to a different schema.
         """
         self._test_migrations(
             table_snapshots=[
@@ -1181,6 +1182,37 @@ class TestSchemas(MigrationTestCase):
             self.schema_manager.list_schemas().run_sync(),
         )
 
+    def test_move_table_to_public_schema(self):
+        """
+        Make sure the auto migrations can move a table from a schema to the
+        public schema.
+        """
+        self._test_migrations(
+            table_snapshots=[
+                [self.manager_2],
+                [self.manager_1],
+            ],
+        )
+
+        # Make sure that the table is in the public schema.
+        self.assertIn(
+            "manager",
+            self.schema_manager.list_tables(schema_name="public").run_sync(),
+        )
+
+        #######################################################################
+
+        # Reverse the last migration, which should move the table back to the
+        # non-public schema.
+        self._run_backwards(migration_id="1")
+
+        self.assertIn(
+            "manager",
+            self.schema_manager.list_tables(
+                schema_name=self.new_schema
+            ).run_sync(),
+        )
+
 
 @engines_only("postgres", "cockroach")
 class TestSameTableName(MigrationTestCase):