piccolo 1.7.0__tar.gz → 1.8.0__tar.gz

{piccolo-1.7.0 → piccolo-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.7.0
+Version: 1.8.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-1.8.0/piccolo/__init__.py

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

{piccolo-1.7.0 → piccolo-1.8.0}/piccolo/columns/base.py

@@ -201,6 +201,10 @@ class ColumnMeta:
             )
         return self._table
 
+    @table.setter
+    def table(self, value: t.Type[Table]):
+        self._table = value
+
     ###########################################################################
 
     # Used by Foreign Keys:

{piccolo-1.7.0 → piccolo-1.8.0}/piccolo/query/functions/__init__.py

@@ -1,8 +1,10 @@
 from .aggregate import Avg, Count, Max, Min, Sum
 from .string import Length, Lower, Ltrim, Reverse, Rtrim, Upper
+from .type_conversion import Cast
 
 __all__ = (
     "Avg",
+    "Cast",
     "Count",
     "Length",
     "Lower",

{piccolo-1.7.0 → piccolo-1.8.0}/piccolo/query/functions/aggregate.py

@@ -12,17 +12,17 @@ class Avg(Function):
 
     .. code-block:: python
 
-        await Band.select(Avg(Band.popularity)).run()
+        await Band.select(Avg(Band.popularity))
 
         # We can use an alias. These two are equivalent:
 
         await Band.select(
             Avg(Band.popularity, alias="popularity_avg")
-        ).run()
+        )
 
         await Band.select(
             Avg(Band.popularity).as_alias("popularity_avg")
-        ).run()
+        )
 
     """
 
@@ -103,17 +103,17 @@ class Min(Function):
 
     .. code-block:: python
 
-        await Band.select(Min(Band.popularity)).run()
+        await Band.select(Min(Band.popularity))
 
         # We can use an alias. These two are equivalent:
 
         await Band.select(
             Min(Band.popularity, alias="popularity_min")
-        ).run()
+        )
 
         await Band.select(
             Min(Band.popularity).as_alias("popularity_min")
-        ).run()
+        )
 
     """
 
@@ -128,17 +128,17 @@ class Max(Function):
 
         await Band.select(
             Max(Band.popularity)
-        ).run()
+        )
 
         # We can use an alias. These two are equivalent:
 
         await Band.select(
             Max(Band.popularity, alias="popularity_max")
-        ).run()
+        )
 
         await Band.select(
             Max(Band.popularity).as_alias("popularity_max")
-        ).run()
+        )
 
     """
 
@@ -153,17 +153,17 @@ class Sum(Function):
 
         await Band.select(
             Sum(Band.popularity)
-        ).run()
+        )
 
         # We can use an alias. These two are equivalent:
 
         await Band.select(
             Sum(Band.popularity, alias="popularity_sum")
-        ).run()
+        )
 
         await Band.select(
             Sum(Band.popularity).as_alias("popularity_sum")
-        ).run()
+        )
 
     """
 

piccolo-1.8.0/piccolo/query/functions/type_conversion.py

@@ -0,0 +1,82 @@
+import typing as t
+
+from piccolo.columns.base import Column
+from piccolo.querystring import QueryString
+
+
+class Cast(QueryString):
+    def __init__(
+        self,
+        identifier: t.Union[Column, QueryString],
+        as_type: Column,
+        alias: t.Optional[str] = None,
+    ):
+        """
+        Cast a value to a different type. For example::
+
+            >>> from piccolo.query.functions import Cast
+
+            >>> await Concert.select(
+            ...     Cast(Concert.starts, Time(), "start_time")
+            ... )
+            [{"start_time": datetime.time(19, 0)}]
+
+        :param identifier:
+            Identifies what is being converted (e.g. a column).
+        :param as_type:
+            The type to be converted to.
+
+        """
+        # Make sure the identifier is a supported type.
+
+        if not isinstance(identifier, (Column, QueryString)):
+            raise ValueError(
+                "The identifier is an unsupported type - only Column and "
+                "QueryString instances are allowed."
+            )
+
+        #######################################################################
+        # Convert `as_type` to a string which can be used in the query.
+
+        if not isinstance(as_type, Column):
+            raise ValueError("The `as_type` value must be a Column instance.")
+
+        # We need to give the column a reference to a table, and hence
+        # the database engine, as the column type is sometimes dependent
+        # on which database is being used.
+        from piccolo.table import Table, create_table_class
+
+        table: t.Optional[t.Type[Table]] = None
+
+        if isinstance(identifier, Column):
+            table = identifier._meta.table
+        elif isinstance(identifier, QueryString):
+            table = (
+                identifier.columns[0]._meta.table
+                if identifier.columns
+                else None
+            )
+
+        as_type._meta.table = table or create_table_class("Table")
+        as_type_string = as_type.column_type
+
+        #######################################################################
+        # Preserve the original alias from the column.
+
+        if isinstance(identifier, Column):
+            alias = (
+                alias
+                or identifier._alias
+                or identifier._meta.get_default_alias()
+            )
+
+        #######################################################################
+
+        super().__init__(
+            f"CAST({{}} AS {as_type_string})",
+            identifier,
+            alias=alias,
+        )
+
+
+__all__ = ("Cast",)

{piccolo-1.7.0 → piccolo-1.8.0}/piccolo/querystring.py

@@ -270,6 +270,18 @@ class QueryString(Selectable):
     def __sub__(self, value) -> QueryString:
         return QueryString("{} - {}", self, value)
 
+    def __gt__(self, value) -> QueryString:
+        return QueryString("{} > {}", self, value)
+
+    def __ge__(self, value) -> QueryString:
+        return QueryString("{} >= {}", self, value)
+
+    def __lt__(self, value) -> QueryString:
+        return QueryString("{} < {}", self, value)
+
+    def __le__(self, value) -> QueryString:
+        return QueryString("{} <= {}", self, value)
+
     def is_in(self, value) -> QueryString:
         return QueryString("{} IN {}", self, value)
 

{piccolo-1.7.0 → piccolo-1.8.0}/piccolo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: piccolo
-Version: 1.7.0
+Version: 1.8.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-1.7.0 → piccolo-1.8.0}/piccolo.egg-info/SOURCES.txt

@@ -163,6 +163,7 @@ piccolo/query/functions/__init__.py
 piccolo/query/functions/aggregate.py
 piccolo/query/functions/base.py
 piccolo/query/functions/string.py
+piccolo/query/functions/type_conversion.py
 piccolo/query/methods/__init__.py
 piccolo/query/methods/alter.py
 piccolo/query/methods/count.py

{piccolo-1.7.0 → piccolo-1.8.0}/tests/apps/migrations/auto/integration/test_migrations.py

@@ -288,7 +288,12 @@ class TestMigrations(MigrationTestCase):
                 [
                     x.data_type == "text",
                     x.is_nullable == "NO",
-                    x.column_default in ("''::text", "'':::STRING"),
+                    x.column_default
+                    in (
+                        "''",
+                        "''::text",
+                        "'':::STRING",
+                    ),
                 ]
             ),
         )
@@ -461,6 +466,7 @@ class TestMigrations(MigrationTestCase):
                     in (
                         "now()",
                         "CURRENT_TIMESTAMP",
+                        "current_timestamp()::TIMESTAMP",
                         "current_timestamp():::TIMESTAMPTZ::TIMESTAMP",
                     ),
                 ]
@@ -541,7 +547,11 @@ class TestMigrations(MigrationTestCase):
                     x.data_type == "interval",
                     x.is_nullable == "NO",
                     x.column_default
-                    in ("'00:00:00'::interval", "'00:00:00':::INTERVAL"),
+                    in (
+                        "'00:00:00'",
+                        "'00:00:00'::interval",
+                        "'00:00:00':::INTERVAL",
+                    ),
                 ]
             ),
         )
@@ -743,7 +753,12 @@ class TestMigrations(MigrationTestCase):
                 [
                     x.data_type == "jsonb",
                     x.is_nullable == "NO",
-                    x.column_default in ("'{}'::jsonb", "'{}':::JSONB"),
+                    x.column_default
+                    in (
+                        "'{}'",
+                        "'{}'::jsonb",
+                        "'{}':::JSONB",
+                    ),
                 ]
             ),
         )
@@ -766,7 +781,11 @@ class TestMigrations(MigrationTestCase):
                     x.data_type == "character varying",
                     x.is_nullable == "NO",
                     x.column_default
-                    in ("''::character varying", "'':::STRING"),
+                    in (
+                        "''",
+                        "''::character varying",
+                        "'':::STRING",
+                    ),
                 ]
             ),
         )
@@ -788,7 +807,11 @@ class TestMigrations(MigrationTestCase):
                     x.data_type == "character varying",
                     x.is_nullable == "NO",
                     x.column_default
-                    in ("''::character varying", "'':::STRING"),
+                    in (
+                        "''",
+                        "''::character varying",
+                        "'':::STRING",
+                    ),
                 ]
             ),
         )

{piccolo-1.7.0 → piccolo-1.8.0}/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))

piccolo-1.8.0/tests/query/test_functions.py

@@ -0,0 +1,238 @@
+from unittest import TestCase
+
+from piccolo.columns import Integer, Text, Varchar
+from piccolo.query.functions import Cast, Length, 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.popularity: 1000,
+            }
+        )
+        band.save().run_sync()
+
+    def tearDown(self) -> None:
+        drop_db_tables_sync(*self.tables)
+
+
+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"}])
+
+
+@engines_skip("sqlite")
+class TestNested(FunctionTest):
+    """
+    Skip the the test for SQLite, as it doesn't support ``Reverse``.
+    """
+
+    def test_nested(self):
+        """
+        Make sure we can nest functions.
+        """
+        response = Band.select(Upper(Reverse(Band.name))).run_sync()
+        self.assertListEqual(response, [{"upper": "SATSINOHTYP"}])
+
+    def test_nested_with_joined_column(self):
+        """
+        Make sure nested functions can be used on a column from a joined table.
+        """
+        response = Band.select(Upper(Reverse(Band.manager._.name))).run_sync()
+        self.assertListEqual(response, [{"upper": "ODIUG"}])
+
+    def test_nested_within_querystring(self):
+        """
+        If we wrap a function in a custom QueryString - make sure the columns
+        are still accessible, so joins are successful.
+        """
+        response = Band.select(
+            QueryString("CONCAT({}, '!')", Upper(Band.manager._.name)),
+        ).run_sync()
+
+        self.assertListEqual(response, [{"concat": "GUIDO!"}])
+
+
+class TestWhereClause(FunctionTest):
+
+    def test_where(self):
+        """
+        Make sure where clauses work with functions.
+        """
+        response = (
+            Band.select(Band.name)
+            .where(Upper(Band.name) == "PYTHONISTAS")
+            .run_sync()
+        )
+        self.assertListEqual(response, [{"name": "Pythonistas"}])
+
+    def test_where_with_joined_column(self):
+        """
+        Make sure where clauses work with functions, when a joined column is
+        used.
+        """
+        response = (
+            Band.select(Band.name)
+            .where(Upper(Band.manager._.name) == "GUIDO")
+            .run_sync()
+        )
+        self.assertListEqual(response, [{"name": "Pythonistas"}])
+
+
+class TestCast(FunctionTest):
+    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}],
+        )

piccolo-1.7.0/piccolo/__init__.py

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