piccolo 0.113.0__tar.gz → 0.115.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 0.113.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.113.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.113.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.113.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.113.0 → piccolo-0.115.0}/piccolo/query/methods/count.py

@@ -4,19 +4,29 @@ import typing as t
 
 from piccolo.custom_types import Combinable
 from piccolo.query.base import Query
-from piccolo.query.methods.select import Select
+from piccolo.query.methods.select import Count as SelectCount
 from piccolo.query.mixins import WhereDelegate
 from piccolo.querystring import QueryString
 
 if t.TYPE_CHECKING:  # pragma: no cover
+    from piccolo.columns import Column
     from piccolo.table import Table
 
 
 class Count(Query):
-    __slots__ = ("where_delegate",)
 
-    def __init__(self, table: t.Type[Table], **kwargs):
+    __slots__ = ("where_delegate", "column", "_distinct")
+
+    def __init__(
+        self,
+        table: t.Type[Table],
+        column: t.Optional[Column] = None,
+        distinct: t.Optional[t.Sequence[Column]] = None,
+        **kwargs,
+    ):
         super().__init__(table, **kwargs)
+        self.column = column
+        self._distinct = distinct
         self.where_delegate = WhereDelegate()
 
     ###########################################################################
@@ -26,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:
@@ -33,14 +47,15 @@ class Count(Query):
 
     @property
     def default_querystrings(self) -> t.Sequence[QueryString]:
-        select = Select(self.table)
-        select.where_delegate._where = self.where_delegate._where
-        return [
-            QueryString(
-                'SELECT COUNT(*) AS "count" FROM ({}) AS "subquery"',
-                select.querystrings[0],
-            )
-        ]
+        table: t.Type[Table] = self.table
+
+        query = table.select(
+            SelectCount(column=self.column, distinct=self._distinct)
+        )
+
+        query.where_delegate._where = self.where_delegate._where
+
+        return query.querystrings
 
 
 Self = t.TypeVar("Self", bound=Count)

{piccolo-0.113.0 → piccolo-0.115.0}/piccolo/query/methods/select.py

@@ -99,43 +99,84 @@ class Avg(Selectable):
 
 class Count(Selectable):
     """
-    Used in conjunction with the ``group_by`` clause in ``Select`` queries.
+    Used in ``Select`` queries, usually in conjunction with the ``group_by``
+    clause::
 
-    If a column is specified, the count is for non-null values in that
-    column. If no column is specified, the count is for all rows, whether
-    they have null values or not.
+        >>> await Band.select(
+        ...     Band.manager.name.as_alias('manager_name'),
+        ...     Count(alias='band_count')
+        ... ).group_by(Band.manager)
+        [{'manager_name': 'Guido', 'count': 1}, ...]
 
-    .. code-block:: python
-
-        await Band.select(Band.name, Count()).group_by(Band.name)
-
-        # We can use an alias. These two are equivalent:
-
-        await Band.select(
-            Band.name, Count(alias="total")
-        ).group_by(Band.name)
+    It can also be used without the ``group_by`` clause (though you may prefer
+    to the :meth:`Table.count <piccolo.table.Table.count>` method instead, as
+    it's more convenient)::
 
-        await Band.select(
-            Band.name,
-            Count().as_alias("total")
-        ).group_by(Band.name)
+        >>> await Band.select(Count())
+        [{'count': 3}]
 
     """
 
     def __init__(
-        self, column: t.Optional[Column] = None, alias: str = "count"
+        self,
+        column: t.Optional[Column] = None,
+        distinct: t.Optional[t.Sequence[Column]] = None,
+        alias: str = "count",
     ):
+        """
+        :param column:
+            If specified, the count is for non-null values in that column.
+        :param distinct:
+            If specified, the count is for distinct values in those columns.
+        :param alias:
+            The name of the value in the response::
+
+                # These two are equivalent:
+
+                await Band.select(
+                    Band.name, Count(alias="total")
+                ).group_by(Band.name)
+
+                await Band.select(
+                    Band.name,
+                    Count().as_alias("total")
+                ).group_by(Band.name)
+
+        """
+        if distinct and column:
+            raise ValueError("Only specify `column` or `distinct`")
+
         self.column = column
+        self.distinct = distinct
         self._alias = alias
 
     def get_select_string(
         self, engine_type: str, with_alias: bool = True
     ) -> str:
-        if self.column is None:
-            column_name = "*"
+        expression: str
+
+        if self.distinct:
+            if engine_type == "sqlite":
+                # SQLite doesn't allow us to specify multiple columns, so
+                # instead we concatenate the values.
+                column_names = " || ".join(
+                    i._meta.get_full_name(with_alias=False)
+                    for i in self.distinct
+                )
+            else:
+                column_names = ", ".join(
+                    i._meta.get_full_name(with_alias=False)
+                    for i in self.distinct
+                )
+
+            expression = f"DISTINCT ({column_names})"
         else:
-            column_name = self.column._meta.get_full_name(with_alias=False)
-        return f'COUNT({column_name}) AS "{self._alias}"'
+            if self.column:
+                expression = self.column._meta.get_full_name(with_alias=False)
+            else:
+                expression = "*"
+
+        return f'COUNT({expression}) AS "{self._alias}"'
 
 
 class Max(Selectable):
@@ -737,12 +778,10 @@ class Select(Query[TableInstance, t.List[t.Dict[str, t.Any]]]):
         query = "SELECT"
 
         distinct = self.distinct_delegate._distinct
-        if distinct:
-            if distinct.on:
-                distinct.validate_on(self.order_by_delegate._order_by)
-
-            query += "{}"
-            args.append(distinct.querystring)
+        if distinct.on:
+            distinct.validate_on(self.order_by_delegate._order_by)
+        query += "{}"
+        args.append(distinct.querystring)
 
         query += f" {columns_str} FROM {self.table._meta.get_formatted_tablename()}"  # noqa: E501
 

{piccolo-0.113.0 → piccolo-0.115.0}/piccolo/table.py

@@ -1114,16 +1114,54 @@ class Table(metaclass=TableMetaclass):
         return Objects[TableInstance](table=cls, prefetch=prefetch)
 
     @classmethod
-    def count(cls) -> Count:
-        """
-        Count the number of matching rows.
+    def count(
+        cls,
+        column: t.Optional[Column] = None,
+        distinct: t.Optional[t.Sequence[Column]] = None,
+    ) -> Count:
 
-        .. code-block:: python
+        """
+        Count the number of matching rows::
 
             await Band.count().where(Band.popularity > 1000)
 
+        :param column:
+            If specified, just count rows where this column isn't null.
+
+        :param distinct:
+            Counts the number of distinct values for these columns. For
+            example, if we have a concerts table::
+
+                class Concert(Table):
+                    band = Varchar()
+                    start_date = Date()
+
+            With this data:
+
+            .. table::
+                :widths: auto
+
+                ===========  ==========
+                band         start_date
+                ===========  ==========
+                Pythonistas  2023-01-01
+                Pythonistas  2023-02-03
+                Rustaceans   2023-01-01
+                ===========  ==========
+
+            Without the ``distinct`` argument, we get the count of all
+            rows::
+
+                >>> await Concert.count()
+                3
+
+            To get the number of unique concert dates::
+
+                >>> await Concert.count(distinct=[Concert.start_date])
+                2
+
         """
-        return Count(table=cls)
+        return Count(table=cls, column=column, distinct=distinct)
 
     @classmethod
     def exists(cls) -> Exists:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 0.113.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.113.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.113.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.113.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):