Add optional select parameter to client.tables.list()

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: tpellissier

src/PowerPlatform/Dataverse/data/_odata.py

@@ -1423,7 +1423,11 @@ def _get_table_info(self, table_schema_name: str) -> Optional[Dict[str, Any]]:
             "columns_created": [],
         }
 
-    def _list_tables(self, filter: Optional[str] = None) -> List[Dict[str, Any]]:
+    def _list_tables(
+        self,
+        filter: Optional[str] = None,
+        select: Optional[List[str]] = None,
+    ) -> List[Dict[str, Any]]:
         """List all non-private tables (``IsPrivate eq false``).
 
         :param filter: Optional additional OData ``$filter`` expression that is
@@ -1433,6 +1437,12 @@ def _list_tables(self, filter: Optional[str] = None) -> List[Dict[str, Any]]:
             When ``None`` (the default), only the ``IsPrivate eq false`` filter
             is applied.
         :type filter: ``str`` or ``None``
+        :param select: Optional list of property names to project via
+            ``$select``.  Values are passed as-is (PascalCase) because
+            ``EntityDefinitions`` uses PascalCase property names.
+            When ``None`` (the default), no ``$select`` is applied and all
+            properties are returned.
+        :type select: ``list[str]`` or ``None``
 
         :return: Metadata entries for non-private tables (may be empty).
         :rtype: ``list[dict[str, Any]]``
@@ -1445,7 +1455,9 @@ def _list_tables(self, filter: Optional[str] = None) -> List[Dict[str, Any]]:
             combined_filter = f"{base_filter} and {filter}"
         else:
             combined_filter = base_filter
-        params = {"$filter": combined_filter}
+        params: Dict[str, str] = {"$filter": combined_filter}
+        if select:
+            params["$select"] = ",".join(select)
         r = self._request("get", url, params=params)
         return r.json().get("value", [])
 

src/PowerPlatform/Dataverse/operations/tables.py

@@ -179,7 +179,12 @@ def get(self, table: str) -> Optional[Dict[str, Any]]:
 
     # ------------------------------------------------------------------- list
 
-    def list(self, *, filter: Optional[str] = None) -> List[Dict[str, Any]]:
+    def list(
+        self,
+        *,
+        filter: Optional[str] = None,
+        select: Optional[List[str]] = None,
+    ) -> List[Dict[str, Any]]:
         """List all non-private tables in the Dataverse environment.
 
         By default returns every table where ``IsPrivate eq false``.  Supply
@@ -193,6 +198,13 @@ def list(self, *, filter: Optional[str] = None) -> List[Dict[str, Any]]:
             expressions must use the exact property names from the
             ``EntityDefinitions`` metadata (typically PascalCase).
         :type filter: :class:`str` or None
+        :param select: Optional list of property names to include in the
+            response (projected via the OData ``$select`` query option).
+            Property names must use the exact PascalCase names from the
+            ``EntityDefinitions`` metadata (e.g.
+            ``["LogicalName", "SchemaName", "DisplayName"]``).
+            When ``None`` (the default), all properties are returned.
+        :type select: :class:`list` of :class:`str` or None
 
         :return: List of EntityDefinition metadata dictionaries.
         :rtype: :class:`list` of :class:`dict`
@@ -208,9 +220,14 @@ def list(self, *, filter: Optional[str] = None) -> List[Dict[str, Any]]:
             custom_tables = client.tables.list(
                 filter="startswith(SchemaName, 'new_')"
             )
+
+            # List tables with only specific properties
+            tables = client.tables.list(
+                select=["LogicalName", "SchemaName", "EntitySetName"]
+            )
         """
         with self._client._scoped_odata() as od:
-            return od._list_tables(filter=filter)
+            return od._list_tables(filter=filter, select=select)
 
     # ------------------------------------------------------------- add_columns
 

tests/unit/data/test_odata_internal.py

@@ -179,6 +179,69 @@ def test_returns_value_list(self):
         result = self.od._list_tables()
         self.assertEqual(result, expected)
 
+    def test_select_adds_query_param(self):
+        """_list_tables(select=...) adds $select as comma-joined string."""
+        self._setup_response([])
+        self.od._list_tables(select=["LogicalName", "SchemaName", "DisplayName"])
+
+        self.od._request.assert_called_once()
+        call_kwargs = self.od._request.call_args
+        params = call_kwargs.kwargs.get("params") or call_kwargs[1].get("params", {})
+        self.assertEqual(params["$select"], "LogicalName,SchemaName,DisplayName")
+
+    def test_select_none_omits_query_param(self):
+        """_list_tables(select=None) does not add $select to params."""
+        self._setup_response([])
+        self.od._list_tables(select=None)
+
+        call_kwargs = self.od._request.call_args
+        params = call_kwargs.kwargs.get("params") or call_kwargs[1].get("params", {})
+        self.assertNotIn("$select", params)
+
+    def test_select_empty_list_omits_query_param(self):
+        """_list_tables(select=[]) does not add $select (empty list is falsy)."""
+        self._setup_response([])
+        self.od._list_tables(select=[])
+
+        call_kwargs = self.od._request.call_args
+        params = call_kwargs.kwargs.get("params") or call_kwargs[1].get("params", {})
+        self.assertNotIn("$select", params)
+
+    def test_select_preserves_case(self):
+        """_list_tables does not lowercase select values (PascalCase preserved)."""
+        self._setup_response([])
+        self.od._list_tables(select=["EntitySetName", "LogicalName"])
+
+        call_kwargs = self.od._request.call_args
+        params = call_kwargs.kwargs.get("params") or call_kwargs[1].get("params", {})
+        self.assertEqual(params["$select"], "EntitySetName,LogicalName")
+
+    def test_select_with_filter(self):
+        """_list_tables with both select and filter sends both params."""
+        self._setup_response([{"LogicalName": "account"}])
+        self.od._list_tables(
+            filter="SchemaName eq 'Account'",
+            select=["LogicalName", "SchemaName"],
+        )
+
+        self.od._request.assert_called_once()
+        call_kwargs = self.od._request.call_args
+        params = call_kwargs.kwargs.get("params") or call_kwargs[1].get("params", {})
+        self.assertEqual(
+            params["$filter"],
+            "IsPrivate eq false and SchemaName eq 'Account'",
+        )
+        self.assertEqual(params["$select"], "LogicalName,SchemaName")
+
+    def test_select_single_property(self):
+        """_list_tables(select=[...]) with a single property works correctly."""
+        self._setup_response([])
+        self.od._list_tables(select=["LogicalName"])
+
+        call_kwargs = self.od._request.call_args
+        params = call_kwargs.kwargs.get("params") or call_kwargs[1].get("params", {})
+        self.assertEqual(params["$select"], "LogicalName")
+
 
 class TestUpsert(unittest.TestCase):
     """Unit tests for _ODataClient._upsert."""

tests/unit/test_tables_operations.py

@@ -100,7 +100,7 @@ def test_list(self):
 
         result = self.client.tables.list()
 
-        self.client._odata._list_tables.assert_called_once_with(filter=None)
+        self.client._odata._list_tables.assert_called_once_with(filter=None, select=None)
         self.assertIsInstance(result, list)
         self.assertEqual(result, expected_tables)
 
@@ -113,7 +113,7 @@ def test_list_with_filter(self):
 
         result = self.client.tables.list(filter="SchemaName eq 'Account'")
 
-        self.client._odata._list_tables.assert_called_once_with(filter="SchemaName eq 'Account'")
+        self.client._odata._list_tables.assert_called_once_with(filter="SchemaName eq 'Account'", select=None)
         self.assertIsInstance(result, list)
         self.assertEqual(result, expected_tables)
 
@@ -126,7 +126,52 @@ def test_list_with_filter_none_explicit(self):
 
         result = self.client.tables.list(filter=None)
 
-        self.client._odata._list_tables.assert_called_once_with(filter=None)
+        self.client._odata._list_tables.assert_called_once_with(filter=None, select=None)
+        self.assertEqual(result, expected_tables)
+
+    def test_list_with_select(self):
+        """list(select=...) should pass the select list to _list_tables."""
+        expected_tables = [
+            {"LogicalName": "account", "SchemaName": "Account"},
+        ]
+        self.client._odata._list_tables.return_value = expected_tables
+
+        result = self.client.tables.list(select=["LogicalName", "SchemaName", "EntitySetName"])
+
+        self.client._odata._list_tables.assert_called_once_with(
+            filter=None,
+            select=["LogicalName", "SchemaName", "EntitySetName"],
+        )
+        self.assertEqual(result, expected_tables)
+
+    def test_list_with_select_none_explicit(self):
+        """list(select=None) should behave identically to list() with no args."""
+        expected_tables = [
+            {"LogicalName": "account", "SchemaName": "Account"},
+        ]
+        self.client._odata._list_tables.return_value = expected_tables
+
+        result = self.client.tables.list(select=None)
+
+        self.client._odata._list_tables.assert_called_once_with(filter=None, select=None)
+        self.assertEqual(result, expected_tables)
+
+    def test_list_with_filter_and_select(self):
+        """list(filter=..., select=...) should pass both params to _list_tables."""
+        expected_tables = [
+            {"LogicalName": "account", "SchemaName": "Account"},
+        ]
+        self.client._odata._list_tables.return_value = expected_tables
+
+        result = self.client.tables.list(
+            filter="SchemaName eq 'Account'",
+            select=["LogicalName", "SchemaName"],
+        )
+
+        self.client._odata._list_tables.assert_called_once_with(
+            filter="SchemaName eq 'Account'",
+            select=["LogicalName", "SchemaName"],
+        )
         self.assertEqual(result, expected_tables)
 
     # ------------------------------------------------------------ add_columns