geobox 2.3.0__py3-none-any.whl → 2.4.0__py3-none-any.whl

geobox/table.py

@@ -1,21 +1,35 @@
 from typing import List, Dict, Optional, TYPE_CHECKING, Union, Any
 from urllib.parse import urljoin
-
-from geobox.enums import TableExportFormat
+from dataclasses import dataclass
 
 from .base import Base
 from .task import Task
-from .enums import FieldType
+from .field import Field
+from .vectorlayer import VectorLayer
+from .enums import FieldType, TableExportFormat, RelationshipCardinality
 from .exception import NotFoundError
 from .utils import clean_data
 
 if TYPE_CHECKING:
     from . import GeoboxClient
     from .user import User
-    from .aio import AsyncGeoboxClient
     from .file import File
-    from .aio.table import Table as AsyncTable, AsyncTableRow, AsyncTableField
+    from .feature import Feature
+
+
+@dataclass(frozen=True)
+class RelationshipEndpoint:
+    """
+    Represents one endpoint (source or target) of a relationship
 
+    Args:
+        table (Table | VectorLayer): The source or target table or vector layer
+        field (TableField | Field | str): The field name or object on the source/target entity
+        fk_field (TableField | Field | str, optional): The foreign key field name or object on the relation table. (Required for Many-to-Many relationships)
+    """
+    table: Union['Table', 'VectorLayer']
+    field: Union['TableField', 'Field', str]
+    fk_field: Optional[Union['TableField', 'Field', str]] = None
 
 
 class TableRow(Base):
@@ -153,30 +167,182 @@ class TableRow(Base):
         super()._delete(self.endpoint)
 
 
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncTableRow':
+    def _get_other_side_of_relationship(
+        self, 
+        relationship: 'Relationship',
+    ) -> Union['Table', 'VectorLayer']:
+        """
+        Determine which side of a relationship this table is on and return the opposite side.
+        
+        Used internally to navigate bidirectional relationships.
+        
+        Args:
+            relationship (Relationship): The relationship to examine.
+            
+        Returns:
+            Table | VectorLayer: The endpoint (table or layer) on the opposite side
+            of the relationship from this table.
+            
+        Raises:
+            ValueError: If this table is not part of the given relationship.
+            
+        Note:
+            This method assumes the table is either the source or target,
+            not the relation table in Many-to-Many relationships.
+        """
+        if relationship.source_id == self.table.id:
+            return relationship.get_target()
+
+        if relationship.target_id == self.table.id:
+            return relationship.get_source()
+
+        raise ValueError("Relationship does not involve this table.")
+
+
+    def _fetch_related_from_target(
+        self, 
+        target: Union['Table', 'VectorLayer'], 
+        relationship_uuid: str,
+    ) -> Union[List['TableRow'], List['Feature']]:
+        """
+        Fetch related rows/features from a relationship target.
+        
+        Internal helper that dispatches to the appropriate API method
+        based on target type.
+        
+        Args:
+            target (Table | VectorLayer): The target endpoint (Table or VectorLayer) to query.
+            relationship_uuid (str): UUID of the relationship to traverse.
+            
+        Raises:
+            TypeError: If target is not a Table or VectorLayer.
+
+        Returns:
+            List[TableRow] | List[Feature]: Related rows or features.
+        """
+        if isinstance(target, Table):
+            return target.get_rows(
+                relationship_uuid=relationship_uuid,
+                related_record_id=self.id,
+            )
+
+        if isinstance(target, VectorLayer):
+            return target.get_features(
+                relationship_uuid=relationship_uuid,
+                related_record_id=self.id,
+            )
+
+        raise TypeError(f"Unsupported target type: {type(target)}")
+
+
+    def get_related_records(self,
+        relationship_uuid: str,
+    ) -> Union[List['TableRow'], List['Feature']]:
+        """
+        Get the related records on the *other side* of the relationship that are linked to this row
+
+        Args:
+            relationship_uuid (str): The uuid of relationship
+
+        Returns:
+            List[TableRow] | List[Feature]: a list of the related records
+
+        Raises:
+            ValueError:
+                If the given relationship does not involve the current table
+                (i.e., this row is neither the source nor the target of the relationship).
+
+            TypeError:
+                If the relationship target type is not supported for fetching
+                related records.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> table = client.get_table(uuid="12345678-1234-5678-1234-567812345678")
+            >>> row = table.get_row(row_id=1)
+            >>> related_records = row.get_related_records(relationship_uuid="12345678-1234-5678-1234-567812345678")
+        """
+        relationship = self.api.get_relationship(relationship_uuid)
+
+        other_side = self._get_other_side_of_relationship(relationship)
+
+        return self._fetch_related_from_target(
+            target=other_side,
+            relationship_uuid=relationship_uuid,
+        )
+
+
+    def associate_with(
+        self,
+        relationship_uuid: str,
+        *,
+        target_ids: Optional[List[int]] = None,
+        q: Optional[str] = None,
+    ) -> Dict:
         """
-        Switch to async version of the table row instance to have access to the async methods
+        Create relationships between the source record and target records
 
         Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+            relationship_uuid (str): the relationship uuid
+            target_ids (List[int], optional): a list of target record ids to be associated with the current record
+            q (str, optional): query filter on target layer or table to select which target features or rows that are going to be related to the current record
 
         Returns:
-            AsyncTableRow: the async instance of the TableRow.
+            Dict: the record association result
 
         Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox import GeoboxClient
             >>> client = GeoboxClient()
             >>> table = client.get_table(uuid="12345678-1234-5678-1234-567812345678")
             >>> row = table.get_row(row_id=1)
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_row = row.to_async(async_client)
+            >>> row.associate_with(
+            ...     relationship_uuid="12345678-1234-5678-1234-567812345678",
+            ...     target_ids=[1, 2, 3],
+            ... )
         """
-        from .aio.table import AsyncTableRow
+        relationship = self.api.get_relationship(uuid=relationship_uuid)
+        return relationship.associate_records(
+            source_id=self.id,
+            target_ids=target_ids,
+            q=q,
+        )
 
-        async_table = self.table.to_async(async_client=async_client)
-        return AsyncTableRow(table=async_table, data=self.data)
 
+    def disassociate_with(
+        self,
+        relationship_uuid: str,
+        *,
+        target_ids: Optional[List[int]] = None,
+        q: Optional[str] = None,
+    ) -> Dict:
+        """
+        Remove relationships between the source record and target records
+
+        Args:
+            relationship_uuid (str): the relationship uuid
+            target_ids (List[int], optional): a list of target record ids to be disassociated with the current record
+            q (str, optional): query filter on target layer or table to select which target features or rows that are going to be related to the current 
+            
+        Returns:
+            Dict: the record disassociation result
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> table = client.get_table(uuid="12345678-1234-5678-1234-567812345678")
+            >>> row = table.get_row(row_id=1)
+            >>> row.disassociate_with(
+            ...     relationship_uuid="12345678-1234-5678-1234-567812345678",
+            ...     target_ids=[1, 2, 3],
+            ... )
+        """
+        relationship = self.api.get_relationship(uuid=relationship_uuid)
+        return relationship.disassociate_records(
+            source_id=self.id,
+            target_ids=target_ids,
+            q=q,
+        )
 
 
 class TableField(Base):
@@ -373,31 +539,469 @@ class TableField(Base):
         return self.domain
 
 
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncTableField':
+class Relationship(Base):
+    BASE_ENDPOINT = 'relationships/'
+
+    def __init__(self, 
+        api: 'GeoboxClient',
+        uuid: str,
+        data: Optional[Dict] = {},
+    ):
         """
-        Switch to async version of the field instance to have access to the async methods
+        Initialize a relationship instance.
 
         Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            uuid (str): The unique identifier for the relationship.
+            data (Dict): The response data of the table.
+        """
+        super().__init__(api=api, uuid=uuid, data=data)
+
+
+    def __repr__(self) -> str:
+        """
+        Return a string representation of the Relationship.
 
         Returns:
-            AsyncField: the async instance of the field.
+            str: The string representation of the Relationship.
+        """
+        return f"Relationship(uuid={self.uuid}, name={self.relation_name}, cardinality={self.relation_cardinality})"
+
+
+    @classmethod
+    def get_relationships(
+        cls, 
+        api: 'GeoboxClient', 
+        **kwargs,
+    ) -> Union[List['Relationship'], int]:
+        """
+        Get a list of relationships with optional filtering and pagination.
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+
+        Keyword Args:
+            q (str): query filter based on OGC CQL standard. e.g. "field1 LIKE '%GIS%' AND created_at > '2021-01-01'"
+            search (str): search term for keyword-based searching among search_fields or all textual fields if search_fields does not have value. NOTE: if q param is defined this param will be ignored
+            search_fields (str): comma separated list of fields for searching
+            order_by (str): comma separated list of fields for sorting results [field1 A|D, field2 A|D, …]. e.g. name A, type D. NOTE: "A" denotes ascending order and "D" denotes descending order.
+            return_count (bool): Whether to return total count. default: False.
+            skip (int): Number of items to skip. default: 0
+            limit (int): Number of items to return. default: 10
+            user_id (int): Specific user. privileges required
+            shared (bool): Whether to return shared tables. default: False
+
+        Returns:
+            List[Relationship] | int: A list of relationship instances or the total number of relationships.
 
         Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
+            >>> from geobox import GeoboxClient
+            >>> from geobox.table import Relatinship
             >>> client = GeoboxClient()
-            >>> table = client.get_table(uuid="12345678-1234-5678-1234-567812345678")
-            >>> field = table.get_field(name='test')
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_field = field.to_async(async_client)
+            >>> relationships = client.get_relationships(q="name LIKE '%My relationship%'")
+            or
+            >>> relationships = Table.get_relationships(client, q="name LIKE '%My relationship%'")
+        """
+        params = {
+           'f': 'json',
+           'q': kwargs.get('q'),
+           'search': kwargs.get('search'),
+           'search_fields': kwargs.get('search_fields'),
+           'order_by': kwargs.get('order_by'),
+           'return_count': kwargs.get('return_count', False),
+           'skip': kwargs.get('skip', 0),
+           'limit': kwargs.get('limit', 10),
+           'user_id': kwargs.get('user_id'),
+           'shared': kwargs.get('shared', False),
+        }
+        return super()._get_list(api, cls.BASE_ENDPOINT, params, factory_func=lambda api, item: Relationship(api, item['uuid'], item))
+
+
+    @classmethod
+    def create_relationship(
+        cls,
+        api: 'GeoboxClient',
+        name: str,
+        cardinality: RelationshipCardinality,
+        *,
+        source: 'RelationshipEndpoint',
+        target: 'RelationshipEndpoint',
+        relation_table: Optional['Table'] = None,
+        display_name: Optional[str] = None,
+        description: Optional[str] = None,
+        user_id: Optional[int] = None,
+    ) -> 'Relationship':
+        """
+        Create a new Relationship
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            name (str): name of the relationship
+            cardinality (RelationshipCardinality): One to One, One to Many, or Many to Many
+            
+        Keyword Args:
+            source (RelationshipEndpoint): Definition of the source side of the relationship, including the table (or layer), field, and foreign-key field
+            target (RelationshipEndpoint): Definition of the target side of the relationship, including the table (or layer), field, and foreign-key field
+            relation_table (Table, optional): The table that stores the relationship metadata or join records. (Required for Many-to-Many relationships)
+            display_name (str, optional): Human-readable name for the relationship
+            description (str, optional): the description of the relationship
+            user_id (int, optional): Specific user. privileges required.
+
+        Returns:
+            Relationship: a relationship instance
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.table import Relationship, RelationshipEndpoint, RelationshipCardinality
+            >>> client = GeoboxClient()
+            >>> source = RelationshipEndpoint(
+            ...     table=client.get_table_by_name('owner'),
+            ...     field="name", # on source table
+            ...     fk_field="book_name", # on relation table
+            ... )
+            >>> target = RelationshipEndpoint(
+            ...     table=client.get_table_by_name('parcel'),
+            ...     field="name", # on target table
+            ...     fk_field="author_name", # on relation table
+            ... )
+            >>> relationship = client.create_relationship(
+            ...     name="book_author",
+            ...     cardinality=RelationshipCardinality.ManytoMany,
+            ...     source=source,
+            ...     target=target,
+            ...     relation_table=client.get_table_by_name('owner_parcel'),
+            ... )
+            or
+            >>> relationship = Relationsh.create_relationship(
+            ...     client,
+            ...     name="owner_parcel",
+            ...     cardinality=RelationshipCardinality.ManytoMany,
+            ...     source=source,
+            ...     target=target,
+            ...     relation_table=client.get_table_by_name('owner_parcel'),
+            ... )   
+        """
+        data = {
+            "relation_name": name,
+            "display_name": display_name,
+            "description": description,
+            "relation_cardinality": cardinality.value,
+            "relation_table_id": relation_table.id if relation_table else None,
+            "relation_table_search": f"{relation_table.__class__.__name__}/{relation_table.name}" if relation_table else None,
+            "source_field_name": source.field if type(source.field) == str else source.field.name,
+            "source_fk_name": (source.fk_field if not source.fk_field or type(source.fk_field) == str else source.fk_field.name) if relation_table else None,
+            "source_id": source.table.id,
+            "source_search": f"{source.table.__class__.__name__}/{source.table.name}",
+            "source_type": str(source.table.__class__.__name__),
+            "target_field_name": target.field if type(target.field) == str else target.field.name,
+            "target_fk_name": (target.fk_field if not target.fk_field or type(target.fk_field) == str else target.fk_field.name) if relation_table else None,
+            "target_id": target.table.id,
+            "target_search": f"{target.table.__class__.__name__}/{target.table.name}",
+            "target_type": str(target.table.__class__.__name__),
+            "user_id": user_id,
+        }
+        return super()._create(api, cls.BASE_ENDPOINT, data, factory_func=lambda api, item: Relationship(api, item['uuid'], item))
+
+
+    @classmethod
+    def get_relationship(
+        cls, 
+        api: 'GeoboxClient', 
+        uuid: str, 
+        user_id: Optional[int] = None,
+    ) -> 'Relationship':
+        """
+        Get a relationship by UUID.
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            uuid (str): The UUID of the relationship to get.
+            user_id (int, optional): Specific user. privileges required.
+
+        Returns:
+            Relationship: The Relationship object.
+
+        Raises:
+            NotFoundError: If the Relationship with the specified UUID is not found.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.table import Relationship
+            >>> client = GeoboxClient()
+            >>> relationship = client.get_relationship(uuid="12345678-1234-5678-1234-567812345678")
+            or
+            >>> relationship = Relationship.get_relationship(client, uuid="12345678-1234-5678-1234-567812345678")
+        """
+        params = {
+            'f': 'json',
+            'user_id': user_id,
+        }
+        return super()._get_detail(api, cls.BASE_ENDPOINT, uuid, params, factory_func=lambda api, item: Relationship(api, item['uuid'], item))
+
+
+    @classmethod
+    def get_relationship_by_name(
+        cls, 
+        api: 'GeoboxClient', 
+        name: str, 
+        user_id: Optional[int] = None,
+    ) -> Union['Relationship', None]:
+        """
+        Get a relationship by name
+
+        Args:
+            api (GeoboxClient): The GeoboxClient instance for making requests.
+            name (str): the name of the relationship to get
+            user_id (int, optional): specific user. privileges required.
+
+        Returns:
+            Relationship | None: returns the relationship if a relationship matches the given name, else None
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.relationship import Relationship
+            >>> client = GeoboxClient()
+            >>> relationship = client.get_relationship_by_name(name='test')
+            or
+            >>> relationship = Relationship.get_relationship_by_name(client, name='test')
+        """
+        relationships = cls.get_relationships(api, q=f"name = '{name}'", user_id=user_id)
+        if relationships and relationships[0].relation_name == name:
+            return relationships[0]
+        else:
+            return None
+
+
+    def update(self, **kwargs) -> Dict:
         """
-        from .aio.table import AsyncTableField
+        Update the relationship.
+
+        Keyword Args:
+            name (str): The name of the relationship.
+            display_name (str): The display name of the relationship.
+            description (str): The description of the relationship.
+
+        Returns:
+            Dict: The updated relationship data.
 
-        async_table = self.table.to_async(async_client=async_client)
-        return AsyncTableField(table=async_table, data_type=self.data_type, field_id=self.field_id, data=self.data)
+        Raises:
+            ValidationError: If the relationship data is invalid.
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.table import Relationship
+            >>> client = GeoboxClient()
+            >>> relationship = Relationship.get_relationship(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> relationship.update(display_name="New Display Name")
+        """
+        data = {
+            "name": kwargs.get('name'),
+            "display_name": kwargs.get('display_name'),   
+            "description": kwargs.get('description'),
+        }
+        return super()._update(self.endpoint, data)
 
 
+    def delete(self) -> None:
+        """
+        Delete the Relationship
+
+        Returns:
+            None
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> from geobox.table import Relationship
+            >>> client = GeoboxClient()
+            >>> relationship = Relationship.get_relationship(client, uuid="12345678-1234-5678-1234-567812345678")
+            >>> relationship.delete()
+        """
+        super()._delete(self.endpoint)
+
+
+    def get_source(self) -> Union['Table', 'VectorLayer']:
+        """
+        Get the source table or layer
+
+        Returns:
+            Table | VectorLayer: the source table or layer
+
+        Raises:
+            NotFoundError: if the table or layer has been deleted
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> relationship = client.get_relationship(uuid="12345678-1234-5678-1234-567812345678")
+            >>> source = relationship.get_source()
+        """
+        try:
+            result = []
+            if self.source_type == 'Table':
+                result = self.api.get_tables(
+                    q=f"id = {self.source_id}"
+                )
+            elif self.source_type == 'VectorLayer':
+                result = self.api.get_vector(
+                    q=f"id = {self.source_id}"
+                )
+            source = next(source for source in result if source.id == self.source_id)
+            return source
+            
+        except StopIteration:
+            raise NotFoundError("Source dataset not found!")
+
+
+    def get_target(self) -> Union['Table', 'VectorLayer']:
+        """
+        Get the target table or layer
+
+        Returns:
+            Table | VectorLayer: the target table or layer
+
+        Raises:
+            NotFoundError: if the table or layer has been deleted
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> relationship = client.get_relationship(uuid="12345678-1234-5678-1234-567812345678")
+            >>> target_table = relationship.get_target()
+        """
+        try:
+            result = []
+            if self.target_type == 'Table':
+                result = self.api.get_tables(
+                    q=f"id = {self.target_id}"
+                )
+            elif self.target_type == 'VectorLayer':
+                result = self.api.get_vectors(
+                    q=f"id = {self.target_id}"
+                )
+            target = next(target for target in result if target.id == self.target_id)
+            return target
+            
+        except StopIteration:
+            raise NotFoundError("Table not found!")
+
+
+    def get_relation_table(self) -> 'Table':
+        """
+        Get the relation table
+
+        Returns:
+            Table: the relation table
+
+        Raises:
+            ValueError: If the relationship is not Many-to-Many and thus has no relation table
+            NotFoundError: if the table has been deleted
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> relationship = client.get_relationship(uuid="12345678-1234-5678-1234-567812345678")
+            >>> relation_table = relationship.get_relation_table()
+        """
+        try:
+            if not self.relation_table_id:
+                raise ValueError(
+                    "Relationship is not Many-to-Many. "
+                    "Relation tables are only used for Many-to-Many cardinality."
+                )
+
+            result = self.api.get_tables(
+                q=f"id = {self.relation_table_id}"
+            )
+            table = next(table for table in result if table.id == self.relation_table_id)
+            return table
+            
+        except StopIteration:
+            raise NotFoundError("Table not found!")
+
+
+    def associate_records(
+        self,
+        source_id: int,
+        *,
+        target_ids: Optional[List[int]] = None,
+        q: Optional[str] = None,
+    ) -> Dict:
+        """
+        Create relationships between the source record and target records
+
+        Args:
+            source_id (int): the id of feature/row in the source layer/table
+            target_ids (List[int], optional): a list of target record ids to be associated with the current record
+            q (str, optional): query filter on target layer or table to select which target features or rows that are going to be related to the current record
+        
+        Returns:
+            Dict: the record association result
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> relationship = client.get_relationship(uuid="12345678-1234-5678-1234-567812345678")
+            >>> result = relationship.associate_records(
+            ...     source_id=1,
+            ...     target_ids=[1, 2, 3],
+            ...     q="name LIKE '%_school'",
+            ... )
+        """
+        data = {
+            'source_id': source_id,
+            'target_ids': ', '.join([str(i) for i in target_ids]),
+            'q': q,
+        }
+
+        endpoint = f"{self.endpoint}associateRecords/"
+        return self.api.post(
+            endpoint,
+            clean_data(data),
+            is_json=False,
+        )
+
+
+    def disassociate_records(
+        self,
+        source_id: int,
+        *,
+        target_ids: Optional[List[int]] = None,
+        q: Optional[str] = None,
+    ) -> Dict:
+        """
+        Remove relationships between the source record and target records
+
+        Args:
+            source_id (int): the id of feature/row in the source layer/table
+            target_ids (List[int], optional): a list of target record ids to be disassociated with the current record
+            q (str, optional): query filter on target layer or table to select which target features or rows that are going to be related to the current record
+        
+        Returns:
+            Dict: the record disassociation result
+
+        Example:
+            >>> from geobox import GeoboxClient
+            >>> client = GeoboxClient()
+            >>> relationship = client.get_relationship(uuid="12345678-1234-5678-1234-567812345678")
+            >>> result = relationship.disassociate_records(
+            ...     source_id=1,
+            ...     target_ids=[1, 2, 3],
+            ...     q="name LIKE '%_school'",
+            ... )
+        """
+        data = {
+            'source_id': source_id,
+            'target_ids': ', '.join([str(i) for i in target_ids]),
+            'q': q,
+        }
+
+        endpoint = f"{self.endpoint}disassociateRecords/"
+        return self.api.post(
+            endpoint,
+            clean_data(data),
+            is_json=False,
+        )
+
 
 class Table(Base):
 
@@ -421,7 +1025,7 @@ class Table(Base):
     @classmethod
     def get_tables(cls, api: 'GeoboxClient', **kwargs) -> Union[List['Table'], int]:
         """
-        Get list of tables with optional filtering and pagination.
+        Get a list of tables with optional filtering and pagination.
 
         Args:
             api (GeoboxClient): The GeoboxClient instance for making requests.
@@ -590,7 +1194,7 @@ class Table(Base):
             >>> from geobox.table import Table
             >>> client = GeoboxClient()
             >>> table = Table.get_table(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> table.update_table(display_name="New Display Name")
+            >>> table.update(display_name="New Display Name")
         """
         data = {
             "name": kwargs.get('name'),
@@ -738,7 +1342,7 @@ class Table(Base):
             data (Dict, optional): Additional field properties (display_name, description, etc.).
             
         Returns:
-            Field: The newly created field instance.
+            TableField: The newly created field instance.
             
         Raises:
             ValidationError: If the field data is invalid.
@@ -815,6 +1419,8 @@ class Table(Base):
         Query rows of a table
 
         Keyword Args:
+            relationship_uuid (str): The uuid of relationship
+            related_record_id (int): This is the id of the feature/row that these rows are related to. This id belongs to the related layer/table not this table
             q (str): Advanced filtering expression, e.g., 'status = "active" and age > 20'
             search (str): Search term for keyword-based searching among fields/columns
             search_fields (str): Comma separated column names to search in
@@ -842,6 +1448,8 @@ class Table(Base):
         """
         params = {
             'f': 'json',
+            'relationship_uuid': kwargs.get('relationship_uuid'),
+            'related_record_id': kwargs.get('related_record_id'),
             'q': kwargs.get('q'),
             'search': kwargs.get('search'),
             'search_fields': kwargs.get('search_fields'),
@@ -1109,26 +1717,3 @@ class Table(Base):
             'limit': limit
         }
         return super()._get_shared_users(self.endpoint, params)
-
-
-    def to_async(self, async_client: 'AsyncGeoboxClient') -> 'AsyncTable':
-        """
-        Switch to async version of the table instance to have access to the async methods
-
-        Args:
-            async_client (AsyncGeoboxClient): The async version of the GeoboxClient instance for making requests.
-
-        Returns:
-            AsyncTable: the async instance of the table.
-
-        Example:
-            >>> from geobox import Geoboxclient
-            >>> from geobox.aio import AsyncGeoboxClient
-            >>> client = GeoboxClient()
-            >>> table = Table.get_table(client, uuid="12345678-1234-5678-1234-567812345678")
-            >>> async with AsyncGeoboxClient() as async_client:
-            >>>     async_table = table.to_async(async_client)
-        """
-        from .aio.table import AsyncTable
-
-        return AsyncTable(api=async_client, uuid=self.uuid, data=self.data)