allow all_columns at the root, and exclude (piccolo-orm#212)

* allow all_columns at the root, and exclude

* add an extra test for make_nested

Author: dantownsend

docs/src/piccolo/query_types/select.rst

@@ -31,6 +31,8 @@ Or use an alias to make it shorter:
 
 .. hint:: All of these examples also work with async by using .run() inside coroutines - see :ref:`SyncAndAsync`.
 
+-------------------------------------------------------------------------------
+
 as_alias
 --------
 
@@ -43,6 +45,8 @@ By using ``as_alias``, the name of the row can be overriden in the response.
 
 This is equivalent to ``SELECT name AS title FROM band`` in SQL.
 
+-------------------------------------------------------------------------------
+
 Joins
 -----
 
@@ -51,7 +55,10 @@ One of the most powerful things about ``select`` is it's support for joins.
 .. code-block:: python
 
     >>> Band.select(Band.name, Band.manager.name).run_sync()
-    [{'name': 'Pythonistas', 'manager.name': 'Guido'}, {'name': 'Rustaceans', 'manager.name': 'Graydon'}]
+    [
+        {'name': 'Pythonistas', 'manager.name': 'Guido'},
+        {'name': 'Rustaceans', 'manager.name': 'Graydon'}
+    ]
 
 
 The joins can go several layers deep.
@@ -61,36 +68,90 @@ The joins can go several layers deep.
     >>> Concert.select(Concert.id, Concert.band_1.manager.name).run_sync()
     [{'id': 1, 'band_1.manager.name': 'Guido'}]
 
+all_columns
+~~~~~~~~~~~
+
 If you want all of the columns from a related table you can use
 ``all_columns``, which is a useful shortcut which saves you from typing them
 all out:
 
 .. code-block:: python
 
-    >>> Band.select(Band.name, *Band.manager.all_columns()).run_sync()
+    >>> Band.select(Band.name, Band.manager.all_columns()).run_sync()
     [
         {'name': 'Pythonistas', 'manager.id': 1, 'manager.name': 'Guido'},
         {'name': 'Rustaceans', 'manager.id': 2, 'manager.name': 'Graydon'}
     ]
 
-    # In Piccolo > 0.41.0 you no longer need to explicitly unpack ``all_columns``.
-    # This is equivalent:
-    >>> Band.select(Band.name, Band.manager.all_columns()).run_sync()
+
+In Piccolo < 0.41.0 you had to explicitly unpack ``all_columns``. This is
+equivalent to the code above:
+
+.. code-block:: python
+
+    >>> Band.select(Band.name, *Band.manager.all_columns()).run_sync()
+
+
+You can exclude some columns if you like:
+
+.. code-block:: python
+
+    >>> Band.select(
+    >>>     Band.name,
+    >>>     Band.manager.all_columns(exclude=[Band.manager.id)
+    >>> ).run_sync()
+    [
+        {'name': 'Pythonistas', 'manager.name': 'Guido'},
+        {'name': 'Rustaceans', 'manager.name': 'Graydon'}
+    ]
+
+
+Strings are supported too if you prefer:
+
+.. code-block:: python
+
+    >>> Band.select(
+    >>>     Band.name,
+    >>>     Band.manager.all_columns(exclude=['id'])
+    >>> ).run_sync()
+    [
+        {'name': 'Pythonistas', 'manager.name': 'Guido'},
+        {'name': 'Rustaceans', 'manager.name': 'Graydon'}
+    ]
+
+You can also use ``all_columns`` on the root table, which saves you time if
+you have lots of columns. It works identically to related tables:
+
+.. code-block:: python
+
+    >>> Band.select(
+    >>>     Band.all_columns(exclude=[Band.id]),
+    >>>     Band.manager.all_columns(exclude=[Band.manager.id])
+    >>> ).run_sync()
+    [
+        {'name': 'Pythonistas', 'popularity': 1000, 'manager.name': 'Guido'},
+        {'name': 'Rustaceans', 'popularity': 500, 'manager.name': 'Graydon'}
+    ]
+
+Nested
+~~~~~~
 
 You can also get the response as nested dictionaries, which can be very useful:
 
 .. code-block:: python
 
-    >>> Band.select(Band.name, *Band.manager.all_columns()).output(nested=True).run_sync()
+    >>> Band.select(Band.name, Band.manager.all_columns()).output(nested=True).run_sync()
     [
         {'name': 'Pythonistas', 'manager': {'id': 1, 'name': 'Guido'}},
         {'name': 'Rustaceans', 'manager': {'id': 2, 'manager.name': 'Graydon'}}
     ]
 
+-------------------------------------------------------------------------------
+
 String syntax
 -------------
 
-Alternatively, you can specify the column names using a string. The
+You can specify the column names using a string if you prefer. The
 disadvantage is you won't have tab completion, but sometimes it's more
 convenient.
 
@@ -101,6 +162,7 @@ convenient.
     # For joins:
     Band.select('manager.name').run_sync()
 
+-------------------------------------------------------------------------------
 
 Aggregate functions
 -------------------
@@ -189,6 +251,7 @@ And can use aliases for aggregate functions like this:
     >>> response["popularity_avg"]
     750.0
 
+-------------------------------------------------------------------------------
 
 Query clauses
 -------------

piccolo/columns/column_types.py

@@ -1220,20 +1220,44 @@ def copy(self) -> ForeignKey:
         column._foreign_key_meta = self._foreign_key_meta.copy()
         return column
 
-    def all_columns(self):
+    def all_columns(
+        self, exclude: t.List[t.Union[Column, str]] = []
+    ) -> t.List[Column]:
         """
         Allow a user to access all of the columns on the related table.
 
         For example:
 
-        Band.select(Band.name, *Band.manager.all_columns()).run_sync()
+        .. code-block:: python
+
+            Band.select(Band.name, Band.manager.all_columns()).run_sync()
+
+        To exclude certain columns:
+
+        .. code-block:: python
+
+            Band.select(
+                Band.name,
+                Band.manager.all_columns(
+                    exclude=[Band.manager.id]
+                )
+            ).run_sync()
+
+        :param exclude:
+            Columns to exclude - can be the name of a column, or a column
+            instance. For example ``['id']`` or ``[Band.manager.id]``.
 
         """
         _fk_meta = object.__getattribute__(self, "_foreign_key_meta")
 
+        excluded_column_names = [
+            i._meta.name if isinstance(i, Column) else i for i in exclude
+        ]
+
         return [
             getattr(self, column._meta.name)
             for column in _fk_meta.resolved_references._meta.columns
+            if column._meta.name not in excluded_column_names
         ]
 
     def set_proxy_columns(self):

piccolo/table.py

@@ -517,6 +517,39 @@ def __repr__(self) -> str:
     ###########################################################################
     # Classmethods
 
+    @classmethod
+    def all_columns(
+        cls, exclude: t.List[t.Union[str, Column]] = []
+    ) -> t.List[Column]:
+        """
+        Just as we can use ``all_columns`` to retrieve all of the columns from
+        a related table, we can also use it at the root of our query to get
+        all of the columns for the root table. For example:
+
+        .. code-block:: python
+
+            await Band.select(
+                Band.all_columns(),
+                Band.manager.all_columns()
+            ).run()
+
+        This is mostly useful when the table has a lot of columns, and typing
+        them out by hand would be tedious.
+
+        :param exclude:
+            You can request all columns, except these.
+
+        """
+        excluded_column_names = [
+            i._meta.name if isinstance(i, Column) else i for i in exclude
+        ]
+
+        return [
+            i
+            for i in cls._meta.columns
+            if i._meta.name not in excluded_column_names
+        ]
+
     @classmethod
     def ref(cls, column_name: str) -> Column:
         """

piccolo/utils/dictionary.py

@@ -27,7 +27,22 @@ def make_nested(dictionary: t.Dict[str, t.Any]) -> t.Dict[str, t.Any]:
         if len(path) == 1:
             output[path[0]] = value
         else:
-            dictionary = output.setdefault(path[0], {})
+            # Force the root element to be an empty dictionary, if it's some
+            # other value (most likely an integer). This is because there are
+            # situations where a query can have `band` and `band.id`.
+            # For example:
+            # await Band.select(
+            #     Band.all_columns(),
+            #     Band.manager.all_columns()
+            # ).run()
+            # In this situation nesting takes precendence.
+            root = output.get(path[0], None)
+            if isinstance(root, dict):
+                dictionary = root
+            else:
+                dictionary = {}
+                output[path[0]] = dictionary
+
             for path_element in path[1:-1]:
                 dictionary = dictionary.setdefault(path_element, {})
             dictionary[path[-1]] = value

tests/columns/test_foreignkey.py

@@ -204,3 +204,16 @@ def test_all_columns_deep(self):
             all_columns[1]._meta.call_chain,
             Concert.band_1.manager.name._meta.call_chain,
         )
+
+    def test_all_columns_exclude(self):
+        """
+        Make sure you can exclude some columns.
+        """
+        self.assertEqual(
+            Band.manager.all_columns(exclude=["id"]), [Band.manager.name]
+        )
+
+        self.assertEqual(
+            Band.manager.all_columns(exclude=[Band.manager.id]),
+            [Band.manager.name],
+        )

tests/table/test_all_columns.py

@@ -0,0 +1,23 @@
+from unittest import TestCase
+
+from tests.example_app.tables import Band
+
+
+class TestAllColumns(TestCase):
+    def test_all_columns(self):
+        self.assertEqual(
+            Band.all_columns(),
+            [Band.id, Band.name, Band.manager, Band.popularity],
+        )
+        self.assertEqual(Band.all_columns(), Band._meta.columns)
+
+    def test_all_columns_excluding(self):
+        self.assertEqual(
+            Band.all_columns(exclude=[Band.id]),
+            [Band.name, Band.manager, Band.popularity],
+        )
+
+        self.assertEqual(
+            Band.all_columns(exclude=["id"]),
+            [Band.name, Band.manager, Band.popularity],
+        )