piccolo 1.7.0__py3-none-any.whl → 1.9.0__py3-none-any.whl

tests/apps/migrations/auto/test_migration_manager.py

@@ -768,15 +768,15 @@ class TestMigrationManager(DBTestCase):
         )
 
         asyncio.run(manager.run())
-        self.assertEqual(
-            self._get_column_default(),
-            [{"column_default": "'Unknown':::STRING"}],
+        self.assertIn(
+            self._get_column_default()[0]["column_default"],
+            ["'Unknown'", "'Unknown':::STRING"],
         )
 
         asyncio.run(manager.run(backwards=True))
-        self.assertEqual(
-            self._get_column_default(),
-            [{"column_default": "'':::STRING"}],
+        self.assertIn(
+            self._get_column_default()[0]["column_default"],
+            ["''", "'':::STRING"],
         )
 
     @engines_only("postgres")
@@ -856,9 +856,9 @@ class TestMigrationManager(DBTestCase):
             old_params={"default": None},
         )
         asyncio.run(manager_1.run())
-        self.assertEqual(
-            self._get_column_default(),
-            [{"column_default": "'Mr Manager':::STRING"}],
+        self.assertIn(
+            self._get_column_default()[0]["column_default"],
+            ["'Mr Manager'", "'Mr Manager':::STRING"],
         )
 
         # Drop the default.
@@ -879,9 +879,9 @@ class TestMigrationManager(DBTestCase):
         # And add it back once more to be sure.
         manager_3 = manager_1
         asyncio.run(manager_3.run())
-        self.assertEqual(
-            self._get_column_default(),
-            [{"column_default": "'Mr Manager':::STRING"}],
+        self.assertIn(
+            self._get_column_default()[0]["column_default"],
+            ["'Mr Manager'", "'Mr Manager':::STRING"],
         )
 
         # Run them all backwards
@@ -892,9 +892,9 @@ class TestMigrationManager(DBTestCase):
         )
 
         asyncio.run(manager_2.run(backwards=True))
-        self.assertEqual(
-            self._get_column_default(),
-            [{"column_default": "'Mr Manager':::STRING"}],
+        self.assertIn(
+            self._get_column_default()[0]["column_default"],
+            ["'Mr Manager'", "'Mr Manager':::STRING"],
         )
 
         asyncio.run(manager_1.run(backwards=True))

tests/columns/test_array.py

@@ -1,6 +1,8 @@
 import datetime
 from unittest import TestCase
 
+import pytest
+
 from piccolo.columns.column_types import (
     Array,
     BigInt,
@@ -10,8 +12,9 @@ from piccolo.columns.column_types import (
     Timestamp,
     Timestamptz,
 )
+from piccolo.querystring import QueryString
 from piccolo.table import Table
-from tests.base import engines_only, sqlite_only
+from tests.base import engines_only, engines_skip, sqlite_only
 
 
 class MyTable(Table):
@@ -40,12 +43,18 @@ class TestArray(TestCase):
     def tearDown(self):
         MyTable.alter().drop_table().run_sync()
 
-    @engines_only("postgres", "sqlite")
+    @pytest.mark.cockroach_array_slow
     def test_storage(self):
         """
         Make sure data can be stored and retrieved.
 
-        🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
         MyTable(value=[1, 2, 3]).save().run_sync()
@@ -54,12 +63,19 @@ class TestArray(TestCase):
         assert row is not None
         self.assertEqual(row.value, [1, 2, 3])
 
-    @engines_only("postgres")
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
     def test_index(self):
         """
         Indexes should allow individual array elements to be queried.
 
-        🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
         MyTable(value=[1, 2, 3]).save().run_sync()
@@ -68,66 +84,92 @@ class TestArray(TestCase):
             MyTable.select(MyTable.value[0]).first().run_sync(), {"value": 1}
         )
 
-    @engines_only("postgres")
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
     def test_all(self):
         """
         Make sure rows can be retrieved where all items in an array match a
         given value.
 
-        🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
         MyTable(value=[1, 1, 1]).save().run_sync()
 
+        # We have to explicitly specify the type, so CockroachDB works.
         self.assertEqual(
             MyTable.select(MyTable.value)
-            .where(MyTable.value.all(1))
+            .where(MyTable.value.all(QueryString("{}::INTEGER", 1)))
             .first()
             .run_sync(),
             {"value": [1, 1, 1]},
         )
 
+        # We have to explicitly specify the type, so CockroachDB works.
         self.assertEqual(
             MyTable.select(MyTable.value)
-            .where(MyTable.value.all(0))
+            .where(MyTable.value.all(QueryString("{}::INTEGER", 0)))
             .first()
             .run_sync(),
             None,
         )
 
-    @engines_only("postgres")
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
     def test_any(self):
         """
         Make sure rows can be retrieved where any items in an array match a
         given value.
 
-        🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
+
         MyTable(value=[1, 2, 3]).save().run_sync()
 
+        # We have to explicitly specify the type, so CockroachDB works.
         self.assertEqual(
             MyTable.select(MyTable.value)
-            .where(MyTable.value.any(1))
+            .where(MyTable.value.any(QueryString("{}::INTEGER", 1)))
             .first()
             .run_sync(),
             {"value": [1, 2, 3]},
         )
 
+        # We have to explicitly specify the type, so CockroachDB works.
         self.assertEqual(
             MyTable.select(MyTable.value)
-            .where(MyTable.value.any(0))
+            .where(MyTable.value.any(QueryString("{}::INTEGER", 0)))
             .first()
             .run_sync(),
             None,
         )
 
-    @engines_only("postgres")
+    @engines_skip("sqlite")
+    @pytest.mark.cockroach_array_slow
     def test_cat(self):
         """
         Make sure values can be appended to an array.
 
-        🐛 Cockroach bug: https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+        In CockroachDB <= v22.2.0 we had this error:
+
+        * https://github.com/cockroachdb/cockroach/issues/71908 "could not decorrelate subquery" error under asyncpg
+
+        In newer CockroachDB versions, it runs but is very slow:
+
+        * https://github.com/piccolo-orm/piccolo/issues/1005
 
         """  # noqa: E501
         MyTable(value=[1, 1, 1]).save().run_sync()
@@ -137,7 +179,8 @@ class TestArray(TestCase):
         ).run_sync()
 
         self.assertEqual(
-            MyTable.select().run_sync(), [{"id": 1, "value": [1, 1, 1, 2]}]
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [1, 1, 1, 2]}],
         )
 
         # Try plus symbol
@@ -147,7 +190,8 @@ class TestArray(TestCase):
         ).run_sync()
 
         self.assertEqual(
-            MyTable.select().run_sync(), [{"id": 1, "value": [1, 1, 1, 2, 3]}]
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [1, 1, 1, 2, 3]}],
         )
 
         # Make sure non-list values work
@@ -157,8 +201,8 @@ class TestArray(TestCase):
         ).run_sync()
 
         self.assertEqual(
-            MyTable.select().run_sync(),
-            [{"id": 1, "value": [1, 1, 1, 2, 3, 4]}],
+            MyTable.select(MyTable.value).run_sync(),
+            [{"value": [1, 1, 1, 2, 3, 4]}],
         )
 
     @sqlite_only

tests/columns/test_get_sql_value.py

@@ -0,0 +1,66 @@
+import datetime
+from unittest import TestCase
+
+from tests.base import engines_only
+from tests.example_apps.music.tables import Band
+
+
+@engines_only("postgres", "cockroach")
+class TestArrayPostgres(TestCase):
+
+    def test_string(self):
+        self.assertEqual(
+            Band.name.get_sql_value(["a", "b", "c"]),
+            '\'{"a","b","c"}\'',
+        )
+
+    def test_int(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3]),
+            "'{1,2,3}'",
+        )
+
+    def test_nested(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3, [4, 5, 6]]),
+            "'{1,2,3,{4,5,6}}'",
+        )
+
+    def test_time(self):
+        self.assertEqual(
+            Band.name.get_sql_value([datetime.time(hour=8, minute=0)]),
+            "'{\"08:00:00\"}'",
+        )
+
+
+@engines_only("sqlite")
+class TestArraySQLite(TestCase):
+    """
+    Note, we use ``.replace(" ", "")`` because we serialise arrays using
+    Python's json library, and there is inconsistency between Python versions
+    (some output ``["a", "b", "c"]``, and others ``["a","b","c"]``).
+    """
+
+    def test_string(self):
+        self.assertEqual(
+            Band.name.get_sql_value(["a", "b", "c"]).replace(" ", ""),
+            '\'["a","b","c"]\'',
+        )
+
+    def test_int(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3]).replace(" ", ""),
+            "'[1,2,3]'",
+        )
+
+    def test_nested(self):
+        self.assertEqual(
+            Band.name.get_sql_value([1, 2, 3, [4, 5, 6]]).replace(" ", ""),
+            "'[1,2,3,[4,5,6]]'",
+        )
+
+    def test_time(self):
+        self.assertEqual(
+            Band.name.get_sql_value([datetime.time(hour=8, minute=0)]),
+            "'[\"08:00:00\"]'",
+        )

tests/query/functions/base.py

@@ -0,0 +1,34 @@
+import typing as t
+from unittest import TestCase
+
+from piccolo.table import Table, create_db_tables_sync, drop_db_tables_sync
+from tests.example_apps.music.tables import Band, Manager
+
+
+class FunctionTest(TestCase):
+    tables: t.List[t.Type[Table]]
+
+    def setUp(self) -> None:
+        create_db_tables_sync(*self.tables)
+
+    def tearDown(self) -> None:
+        drop_db_tables_sync(*self.tables)
+
+
+class BandTest(FunctionTest):
+    tables = [Band, Manager]
+
+    def setUp(self) -> None:
+        super().setUp()
+
+        manager = Manager({Manager.name: "Guido"})
+        manager.save().run_sync()
+
+        band = Band(
+            {
+                Band.name: "Pythonistas",
+                Band.manager: manager,
+                Band.popularity: 1000,
+            }
+        )
+        band.save().run_sync()

tests/query/{test_functions.py → functions/test_functions.py}

@@ -1,51 +1,13 @@
-from unittest import TestCase
-
-from piccolo.query.functions.string import Reverse, Upper
+from piccolo.query.functions import Reverse, Upper
 from piccolo.querystring import QueryString
-from piccolo.table import create_db_tables_sync, drop_db_tables_sync
 from tests.base import engines_skip
-from tests.example_apps.music.tables import Band, Manager
-
-
-class FunctionTest(TestCase):
-    tables = (Band, Manager)
-
-    def setUp(self) -> None:
-        create_db_tables_sync(*self.tables)
-
-        manager = Manager({Manager.name: "Guido"})
-        manager.save().run_sync()
-
-        band = Band({Band.name: "Pythonistas", Band.manager: manager})
-        band.save().run_sync()
-
-    def tearDown(self) -> None:
-        drop_db_tables_sync(*self.tables)
-
+from tests.example_apps.music.tables import Band
 
-class TestUpperFunction(FunctionTest):
-
-    def test_column(self):
-        """
-        Make sure we can uppercase a column's value.
-        """
-        response = Band.select(Upper(Band.name)).run_sync()
-        self.assertListEqual(response, [{"upper": "PYTHONISTAS"}])
-
-    def test_alias(self):
-        response = Band.select(Upper(Band.name, alias="name")).run_sync()
-        self.assertListEqual(response, [{"name": "PYTHONISTAS"}])
-
-    def test_joined_column(self):
-        """
-        Make sure we can uppercase a column's value from a joined table.
-        """
-        response = Band.select(Upper(Band.manager._.name)).run_sync()
-        self.assertListEqual(response, [{"upper": "GUIDO"}])
+from .base import BandTest
 
 
 @engines_skip("sqlite")
-class TestNested(FunctionTest):
+class TestNested(BandTest):
     """
     Skip the the test for SQLite, as it doesn't support ``Reverse``.
     """
@@ -76,7 +38,7 @@ class TestNested(FunctionTest):
         self.assertListEqual(response, [{"concat": "GUIDO!"}])
 
 
-class TestWhereClause(FunctionTest):
+class TestWhereClause(BandTest):
 
     def test_where(self):
         """

tests/query/functions/test_math.py

@@ -0,0 +1,39 @@
+import decimal
+
+from piccolo.columns import Numeric
+from piccolo.query.functions.math import Abs, Ceil, Floor, Round
+from piccolo.table import Table
+
+from .base import FunctionTest
+
+
+class Ticket(Table):
+    price = Numeric(digits=(5, 2))
+
+
+class TestMath(FunctionTest):
+
+    tables = [Ticket]
+
+    def setUp(self):
+        super().setUp()
+        self.ticket = Ticket({Ticket.price: decimal.Decimal("36.50")})
+        self.ticket.save().run_sync()
+
+    def test_floor(self):
+        response = Ticket.select(Floor(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("36.00")}])
+
+    def test_ceil(self):
+        response = Ticket.select(Ceil(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("37.00")}])
+
+    def test_abs(self):
+        self.ticket.price = decimal.Decimal("-1.50")
+        self.ticket.save().run_sync()
+        response = Ticket.select(Abs(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("1.50")}])
+
+    def test_round(self):
+        response = Ticket.select(Round(Ticket.price, alias="price")).run_sync()
+        self.assertListEqual(response, [{"price": decimal.Decimal("37.00")}])

tests/query/functions/test_string.py

@@ -0,0 +1,25 @@
+from piccolo.query.functions.string import Upper
+from tests.example_apps.music.tables import Band
+
+from .base import BandTest
+
+
+class TestUpperFunction(BandTest):
+
+    def test_column(self):
+        """
+        Make sure we can uppercase a column's value.
+        """
+        response = Band.select(Upper(Band.name)).run_sync()
+        self.assertListEqual(response, [{"upper": "PYTHONISTAS"}])
+
+    def test_alias(self):
+        response = Band.select(Upper(Band.name, alias="name")).run_sync()
+        self.assertListEqual(response, [{"name": "PYTHONISTAS"}])
+
+    def test_joined_column(self):
+        """
+        Make sure we can uppercase a column's value from a joined table.
+        """
+        response = Band.select(Upper(Band.manager._.name)).run_sync()
+        self.assertListEqual(response, [{"upper": "GUIDO"}])

tests/query/functions/test_type_conversion.py

@@ -0,0 +1,134 @@
+from piccolo.columns import Integer, Text, Varchar
+from piccolo.query.functions import Cast, Length
+from tests.example_apps.music.tables import Band, Manager
+
+from .base import BandTest
+
+
+class TestCast(BandTest):
+    def test_varchar(self):
+        """
+        Make sure that casting to ``Varchar`` works.
+        """
+        response = Band.select(
+            Cast(
+                Band.popularity,
+                as_type=Varchar(),
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"popularity": "1000"}],
+        )
+
+    def test_text(self):
+        """
+        Make sure that casting to ``Text`` works.
+        """
+        response = Band.select(
+            Cast(
+                Band.popularity,
+                as_type=Text(),
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"popularity": "1000"}],
+        )
+
+    def test_integer(self):
+        """
+        Make sure that casting to ``Integer`` works.
+        """
+        Band.update({Band.name: "1111"}, force=True).run_sync()
+
+        response = Band.select(
+            Cast(
+                Band.name,
+                as_type=Integer(),
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"name": 1111}],
+        )
+
+    def test_join(self):
+        """
+        Make sure that casting works with joins.
+        """
+        Manager.update({Manager.name: "1111"}, force=True).run_sync()
+
+        response = Band.select(
+            Band.name,
+            Cast(
+                Band.manager.name,
+                as_type=Integer(),
+            ),
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [
+                {
+                    "name": "Pythonistas",
+                    "manager.name": 1111,
+                }
+            ],
+        )
+
+    def test_nested_inner(self):
+        """
+        Make sure ``Cast`` can be passed into other functions.
+        """
+        Band.update({Band.name: "1111"}, force=True).run_sync()
+
+        response = Band.select(
+            Length(
+                Cast(
+                    Band.popularity,
+                    as_type=Varchar(),
+                )
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"length": 4}],
+        )
+
+    def test_nested_outer(self):
+        """
+        Make sure a querystring can be passed into ``Cast`` (meaning it can be
+        nested).
+        """
+        response = Band.select(
+            Cast(
+                Length(Band.name),
+                as_type=Varchar(),
+                alias="length",
+            )
+        ).run_sync()
+
+        self.assertListEqual(
+            response,
+            [{"length": str(len("Pythonistas"))}],
+        )
+
+    def test_where_clause(self):
+        """
+        Make sure ``Cast`` works in a where clause.
+        """
+        response = (
+            Band.select(Band.name, Band.popularity)
+            .where(Cast(Band.popularity, Varchar()) == "1000")
+            .run_sync()
+        )
+
+        self.assertListEqual(
+            response,
+            [{"name": "Pythonistas", "popularity": 1000}],
+        )