Add list_columns, list_relationships, list_table_relationships APIs with tests and README examples

Co-authored-by: saurabhrb <32964911+saurabhrb@users.noreply.github.com>

Author: Copilot

README.md

@@ -307,6 +307,18 @@ client.tables.add_columns("new_Product", {"new_Category": "string"})
 # Remove columns
 client.tables.remove_columns("new_Product", ["new_Category"])
 
+# List all columns (attributes) for a table to discover schema
+columns = client.tables.list_columns("account")
+for col in columns:
+    print(f"{col['LogicalName']} ({col.get('AttributeType')})")
+
+# List only specific properties
+columns = client.tables.list_columns(
+    "account",
+    select=["LogicalName", "SchemaName", "AttributeType"],
+    filter="AttributeType eq 'String'",
+)
+
 # Clean up
 client.tables.delete("new_Product")
 ```
@@ -359,6 +371,16 @@ rel = client.tables.get_relationship("new_Department_Employee")
 if rel:
     print(f"Found: {rel['SchemaName']}")
 
+# List all relationships
+rels = client.tables.list_relationships()
+for rel in rels:
+    print(f"{rel['SchemaName']} ({rel.get('@odata.type')})")
+
+# List relationships for a specific table (one-to-many + many-to-many)
+account_rels = client.tables.list_table_relationships("account")
+for rel in account_rels:
+    print(f"{rel['SchemaName']} -> {rel.get('@odata.type')}")
+
 # Delete a relationship
 client.tables.delete_relationship(result['relationship_id'])
 ```

src/PowerPlatform/Dataverse/data/_odata.py

@@ -1039,6 +1039,50 @@ def _get_attribute_metadata(
                 return item
         return None
 
+    def _list_columns(
+        self,
+        table_schema_name: str,
+        *,
+        select: Optional[List[str]] = None,
+        filter: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """List all attribute (column) definitions for a table.
+
+        Issues ``GET EntityDefinitions({MetadataId})/Attributes`` with optional
+        ``$select`` and ``$filter`` query parameters.
+
+        :param table_schema_name: Schema name of the table
+            (e.g. ``"account"`` or ``"new_Product"``).
+        :type table_schema_name: ``str``
+        :param select: Optional list of property names to project via
+            ``$select``.  Values are passed as-is (PascalCase).
+        :type select: ``list[str]`` or ``None``
+        :param filter: Optional OData ``$filter`` expression.  For example,
+            ``"AttributeType eq 'String'"`` returns only string columns.
+        :type filter: ``str`` or ``None``
+
+        :return: List of raw attribute metadata dictionaries (may be empty).
+        :rtype: ``list[dict[str, Any]]``
+
+        :raises MetadataError: If the table is not found.
+        :raises HttpError: If the Web API request fails.
+        """
+        ent = self._get_entity_by_table_schema_name(table_schema_name)
+        if not ent or not ent.get("MetadataId"):
+            raise MetadataError(
+                f"Table '{table_schema_name}' not found.",
+                subcode=METADATA_TABLE_NOT_FOUND,
+            )
+        metadata_id = ent["MetadataId"]
+        url = f"{self.api}/EntityDefinitions({metadata_id})/Attributes"
+        params: Dict[str, str] = {}
+        if select:
+            params["$select"] = ",".join(select)
+        if filter:
+            params["$filter"] = filter
+        r = self._request("get", url, params=params)
+        return r.json().get("value", [])
+
     def _wait_for_attribute_visibility(
         self,
         entity_set: str,

src/PowerPlatform/Dataverse/data/_relationships.py

@@ -10,7 +10,7 @@
 from __future__ import annotations
 
 import re
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 
 class _RelationshipOperationsMixin:
@@ -142,6 +142,93 @@ def _get_relationship(self, schema_name: str) -> Optional[Dict[str, Any]]:
         results = data.get("value", [])
         return results[0] if results else None
 
+    def _list_relationships(
+        self,
+        *,
+        filter: Optional[str] = None,
+        select: Optional[List[str]] = None,
+    ) -> List[Dict[str, Any]]:
+        """List all relationship definitions.
+
+        Issues ``GET /RelationshipDefinitions`` with optional ``$filter`` and
+        ``$select`` query parameters.
+
+        :param filter: Optional OData ``$filter`` expression.  For example,
+            ``"RelationshipType eq Microsoft.Dynamics.CRM.RelationshipType'OneToManyRelationship'"``
+            returns only one-to-many relationships.
+        :type filter: ``str`` or ``None``
+        :param select: Optional list of property names to project via
+            ``$select``.  Values are passed as-is (PascalCase).
+        :type select: ``list[str]`` or ``None``
+
+        :return: List of raw relationship metadata dictionaries (may be empty).
+        :rtype: ``list[dict[str, Any]]``
+
+        :raises HttpError: If the Web API request fails.
+        """
+        url = f"{self.api}/RelationshipDefinitions"
+        params: Dict[str, str] = {}
+        if filter:
+            params["$filter"] = filter
+        if select:
+            params["$select"] = ",".join(select)
+        r = self._request("get", url, headers=self._headers(), params=params)
+        return r.json().get("value", [])
+
+    def _list_table_relationships(
+        self,
+        table_schema_name: str,
+        *,
+        filter: Optional[str] = None,
+        select: Optional[List[str]] = None,
+    ) -> List[Dict[str, Any]]:
+        """List all relationships for a specific table.
+
+        Issues ``GET EntityDefinitions({MetadataId})/OneToManyRelationships``
+        and ``GET EntityDefinitions({MetadataId})/ManyToManyRelationships``,
+        then combines the results.
+
+        :param table_schema_name: Schema name of the table (e.g. ``"account"``).
+        :type table_schema_name: ``str``
+        :param filter: Optional OData ``$filter`` expression applied to each
+            sub-request.
+        :type filter: ``str`` or ``None``
+        :param select: Optional list of property names to project via
+            ``$select``.  Values are passed as-is (PascalCase).
+        :type select: ``list[str]`` or ``None``
+
+        :return: Combined list of one-to-many and many-to-many relationship
+            metadata dictionaries (may be empty).
+        :rtype: ``list[dict[str, Any]]``
+
+        :raises MetadataError: If the table is not found.
+        :raises HttpError: If the Web API request fails.
+        """
+        from ..core.errors import MetadataError
+        from ..core._error_codes import METADATA_TABLE_NOT_FOUND
+
+        ent = self._get_entity_by_table_schema_name(table_schema_name)
+        if not ent or not ent.get("MetadataId"):
+            raise MetadataError(
+                f"Table '{table_schema_name}' not found.",
+                subcode=METADATA_TABLE_NOT_FOUND,
+            )
+
+        metadata_id = ent["MetadataId"]
+        params: Dict[str, str] = {}
+        if filter:
+            params["$filter"] = filter
+        if select:
+            params["$select"] = ",".join(select)
+
+        one_to_many_url = f"{self.api}/EntityDefinitions({metadata_id})/OneToManyRelationships"
+        many_to_many_url = f"{self.api}/EntityDefinitions({metadata_id})/ManyToManyRelationships"
+
+        r1 = self._request("get", one_to_many_url, headers=self._headers(), params=params)
+        r2 = self._request("get", many_to_many_url, headers=self._headers(), params=params)
+
+        return r1.json().get("value", []) + r2.json().get("value", [])
+
     def _extract_id_from_header(self, header_value: Optional[str]) -> Optional[str]:
         """
         Extract a GUID from an OData-EntityId header value.

src/PowerPlatform/Dataverse/operations/tables.py

@@ -706,3 +706,142 @@ def delete_alternate_key(self, table: str, key_id: str) -> None:
         """
         with self._client._scoped_odata() as od:
             od._delete_alternate_key(table, key_id)
+
+    # -------------------------------------------------------- list_columns
+
+    def list_columns(
+        self,
+        table: str,
+        *,
+        select: Optional[List[str]] = None,
+        filter: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """List all attribute (column) definitions for a table.
+
+        :param table: Schema name of the table (e.g. ``"account"`` or
+            ``"new_Product"``).
+        :type table: :class:`str`
+        :param select: Optional list of property names to project via
+            ``$select``.  Values are passed as-is (PascalCase).
+        :type select: :class:`list` of :class:`str` or None
+        :param filter: Optional OData ``$filter`` expression.  For example,
+            ``"AttributeType eq 'String'"`` returns only string columns.
+        :type filter: :class:`str` or None
+
+        :return: List of raw attribute metadata dictionaries.
+        :rtype: :class:`list` of :class:`dict`
+
+        :raises ~PowerPlatform.Dataverse.core.errors.MetadataError:
+            If the table is not found.
+        :raises ~PowerPlatform.Dataverse.core.errors.HttpError:
+            If the Web API request fails.
+
+        Example::
+
+            # List all columns on the account table
+            columns = client.tables.list_columns("account")
+            for col in columns:
+                print(f"{col['LogicalName']} ({col.get('AttributeType')})")
+
+            # List only specific properties
+            columns = client.tables.list_columns(
+                "account",
+                select=["LogicalName", "SchemaName", "AttributeType"],
+            )
+
+            # Filter to only string attributes
+            columns = client.tables.list_columns(
+                "account",
+                filter="AttributeType eq 'String'",
+            )
+        """
+        with self._client._scoped_odata() as od:
+            return od._list_columns(table, select=select, filter=filter)
+
+    # ------------------------------------------------- list_relationships
+
+    def list_relationships(
+        self,
+        *,
+        filter: Optional[str] = None,
+        select: Optional[List[str]] = None,
+    ) -> List[Dict[str, Any]]:
+        """List all relationship definitions in the environment.
+
+        :param filter: Optional OData ``$filter`` expression.  For example,
+            ``"RelationshipType eq Microsoft.Dynamics.CRM.RelationshipType'OneToManyRelationship'"``
+            returns only one-to-many relationships.
+        :type filter: :class:`str` or None
+        :param select: Optional list of property names to project via
+            ``$select``.  Values are passed as-is (PascalCase).
+        :type select: :class:`list` of :class:`str` or None
+
+        :return: List of raw relationship metadata dictionaries.
+        :rtype: :class:`list` of :class:`dict`
+
+        :raises ~PowerPlatform.Dataverse.core.errors.HttpError:
+            If the Web API request fails.
+
+        Example::
+
+            # List all relationships
+            rels = client.tables.list_relationships()
+            for rel in rels:
+                print(f"{rel['SchemaName']} ({rel.get('@odata.type')})")
+
+            # Filter by type
+            one_to_many = client.tables.list_relationships(
+                filter="RelationshipType eq Microsoft.Dynamics.CRM.RelationshipType'OneToManyRelationship'"
+            )
+
+            # Select specific properties
+            rels = client.tables.list_relationships(
+                select=["SchemaName", "ReferencedEntity", "ReferencingEntity"]
+            )
+        """
+        with self._client._scoped_odata() as od:
+            return od._list_relationships(filter=filter, select=select)
+
+    # --------------------------------------------- list_table_relationships
+
+    def list_table_relationships(
+        self,
+        table: str,
+        *,
+        filter: Optional[str] = None,
+        select: Optional[List[str]] = None,
+    ) -> List[Dict[str, Any]]:
+        """List all relationships for a specific table.
+
+        Combines one-to-many and many-to-many relationships for the given
+        table by querying both
+        ``EntityDefinitions({id})/OneToManyRelationships`` and
+        ``EntityDefinitions({id})/ManyToManyRelationships``.
+
+        :param table: Schema name of the table (e.g. ``"account"``).
+        :type table: :class:`str`
+        :param filter: Optional OData ``$filter`` expression applied to each
+            sub-request.
+        :type filter: :class:`str` or None
+        :param select: Optional list of property names to project via
+            ``$select``.  Values are passed as-is (PascalCase).
+        :type select: :class:`list` of :class:`str` or None
+
+        :return: Combined list of one-to-many and many-to-many relationship
+            metadata dictionaries.
+        :rtype: :class:`list` of :class:`dict`
+
+        :raises ~PowerPlatform.Dataverse.core.errors.MetadataError:
+            If the table is not found.
+        :raises ~PowerPlatform.Dataverse.core.errors.HttpError:
+            If the Web API request fails.
+
+        Example::
+
+            # List all relationships for the account table
+            rels = client.tables.list_table_relationships("account")
+            for rel in rels:
+                print(f"{rel['SchemaName']} -> {rel.get('@odata.type')}")
+        """
+        with self._client._scoped_odata() as od:
+            return od._list_table_relationships(table, filter=filter, select=select)