kumoai 2.13.0.dev202512040649__cp313-cp313-win_amd64.whl → 2.14.0.dev202601081732__cp313-cp313-win_amd64.whl

kumoai/experimental/rfm/base/table.py

@@ -1,25 +1,33 @@
+import warnings
 from abc import ABC, abstractmethod
-from collections import defaultdict
+from collections.abc import Sequence
 from functools import cached_property
-from typing import Dict, List, Optional, Sequence, Set
 
+import numpy as np
 import pandas as pd
+import pyarrow as pa
+from kumoapi.model_plan import MissingType
 from kumoapi.source_table import UnavailableSourceTable
 from kumoapi.table import Column as ColumnDefinition
 from kumoapi.table import TableDefinition
-from kumoapi.typing import Stype
+from kumoapi.typing import Dtype, Stype
 from typing_extensions import Self
 
-from kumoai import in_notebook
-from kumoai.experimental.rfm.base import Column, SourceColumn, SourceForeignKey
+from kumoai.experimental.rfm.base import (
+    Column,
+    ColumnSpec,
+    ColumnSpecType,
+    DataBackend,
+    SourceColumn,
+    SourceForeignKey,
+)
 from kumoai.experimental.rfm.infer import (
-    contains_categorical,
-    contains_id,
-    contains_multicategorical,
-    contains_timestamp,
+    infer_dtype,
     infer_primary_key,
+    infer_stype,
     infer_time_column,
 )
+from kumoai.utils import display, quote_ident
 
 
 class Table(ABC):
@@ -29,53 +37,48 @@ class Table(ABC):
 
     Args:
         name: The name of this table.
+        source_name: The source name of this table. If set to ``None``,
+            ``name`` is being used.
         columns: The selected columns of this table.
         primary_key: The name of the primary key of this table, if it exists.
         time_column: The name of the time column of this table, if it exists.
         end_time_column: The name of the end time column of this table, if it
             exists.
     """
+    _NUM_SAMPLE_ROWS = 1_000
+
     def __init__(
         self,
         name: str,
-        columns: Optional[Sequence[str]] = None,
-        primary_key: Optional[str] = None,
-        time_column: Optional[str] = None,
-        end_time_column: Optional[str] = None,
+        source_name: str | None = None,
+        columns: Sequence[ColumnSpecType] | None = None,
+        primary_key: MissingType | str | None = MissingType.VALUE,
+        time_column: str | None = None,
+        end_time_column: str | None = None,
     ) -> None:
 
         self._name = name
-        self._primary_key: Optional[str] = None
-        self._time_column: Optional[str] = None
-        self._end_time_column: Optional[str] = None
-
-        if len(self._source_column_dict) == 0:
-            raise ValueError(f"Table '{name}' does not hold any column with "
-                             f"a supported data type")
-
-        primary_keys = [
-            column.name for column in self._source_column_dict.values()
-            if column.is_primary_key
-        ]
-        if len(primary_keys) == 1:  # NOTE No composite keys yet.
-            if primary_key is not None and primary_key != primary_keys[0]:
-                raise ValueError(f"Found duplicate primary key "
-                                 f"definition '{primary_key}' and "
-                                 f"'{primary_keys[0]}' in table '{name}'")
-            primary_key = primary_keys[0]
-
-        unique_keys = [
-            column.name for column in self._source_column_dict.values()
-            if column.is_unique_key
-        ]
-        if primary_key is None and len(unique_keys) == 1:
-            primary_key = unique_keys[0]
-
-        self._columns: Dict[str, Column] = {}
-        for column_name in columns or list(self._source_column_dict.keys()):
-            self.add_column(column_name)
-
-        if primary_key is not None:
+        self._source_name = source_name or name
+        self._column_dict: dict[str, Column] = {}
+        self._primary_key: str | None = None
+        self._time_column: str | None = None
+        self._end_time_column: str | None = None
+        self._expr_sample_df = pd.DataFrame(index=range(self._NUM_SAMPLE_ROWS))
+
+        if columns is None:
+            columns = list(self._source_column_dict.keys())
+
+        self.add_columns(columns)
+
+        if isinstance(primary_key, MissingType):
+            # Infer primary key from source metadata, but only set it in case
+            # it is already part of the column set (don't magically add it):
+            if any(column.is_source for column in self.columns):
+                primary_key = self._source_primary_key
+                if (primary_key is not None and primary_key in self
+                        and self[primary_key].is_source):
+                    self.primary_key = primary_key
+        elif primary_key is not None:
             if primary_key not in self:
                 self.add_column(primary_key)
             self.primary_key = primary_key
@@ -95,13 +98,22 @@ class Table(ABC):
         r"""The name of this table."""
         return self._name
 
-    # Data column #############################################################
+    @property
+    def source_name(self) -> str:
+        r"""The source name of this table."""
+        return self._source_name
+
+    @property
+    def _quoted_source_name(self) -> str:
+        return quote_ident(self._source_name)
+
+    # Column ##################################################################
 
     def has_column(self, name: str) -> bool:
         r"""Returns ``True`` if this table holds a column with name ``name``;
         ``False`` otherwise.
         """
-        return name in self._columns
+        return name in self._column_dict
 
     def column(self, name: str) -> Column:
         r"""Returns the data column named with name ``name`` in this table.
@@ -114,65 +126,113 @@ class Table(ABC):
         """
         if not self.has_column(name):
             raise KeyError(f"Column '{name}' not found in table '{self.name}'")
-        return self._columns[name]
+        return self._column_dict[name]
 
     @property
-    def columns(self) -> List[Column]:
+    def columns(self) -> list[Column]:
         r"""Returns a list of :class:`Column` objects that represent the
         columns in this table.
         """
-        return list(self._columns.values())
+        return list(self._column_dict.values())
 
-    def add_column(self, name: str) -> Column:
-        r"""Adds a column to this table.
+    def add_columns(self, columns: Sequence[ColumnSpecType]) -> None:
+        r"""Adds a set of columns to this table.
 
         Args:
-            name: The name of the column.
+            columns: The columns to add.
 
         Raises:
-            KeyError: If ``name`` is already present in this table.
+            KeyError: If any of the column names already exist in this table.
         """
-        if name in self:
-            raise KeyError(f"Column '{name}' already exists in table "
-                           f"'{self.name}'")
-
-        if name not in self._source_column_dict:
-            raise KeyError(f"Column '{name}' does not exist in the underlying "
-                           f"source table")
-
-        try:
-            dtype = self._source_column_dict[name].dtype
-        except Exception as e:
-            raise RuntimeError(f"Could not obtain data type for column "
-                               f"'{name}' in table '{self.name}'. Change "
-                               f"the data type of the column in the source "
-                               f"table or remove it from the table.") from e
-
-        try:
-            ser = self._sample_df[name]
-            if contains_id(ser, name, dtype):
-                stype = Stype.ID
-            elif contains_timestamp(ser, name, dtype):
-                stype = Stype.timestamp
-            elif contains_multicategorical(ser, name, dtype):
-                stype = Stype.multicategorical
-            elif contains_categorical(ser, name, dtype):
-                stype = Stype.categorical
-            else:
-                stype = dtype.default_stype
-        except Exception as e:
-            raise RuntimeError(f"Could not obtain semantic type for column "
-                               f"'{name}' in table '{self.name}'. Change "
-                               f"the data type of the column in the source "
-                               f"table or remove it from the table.") from e
-
-        self._columns[name] = Column(
-            name=name,
-            dtype=dtype,
-            stype=stype,
-        )
+        if len(columns) == 0:
+            return
 
-        return self._columns[name]
+        column_specs = [ColumnSpec.coerce(column) for column in columns]
+
+        # Obtain a batch-wise sample for all column expressions:
+        expr_specs = [spec for spec in column_specs if not spec.is_source]
+        if len(expr_specs) > 0:
+            dfs = [
+                self._expr_sample_df,
+                self._get_expr_sample_df(expr_specs).reset_index(drop=True),
+            ]
+            size = min(map(len, dfs))
+            df = pd.concat([dfs[0].iloc[:size], dfs[1].iloc[:size]], axis=1)
+            df = df.loc[:, ~df.columns.duplicated(keep='last')]
+            self._expr_sample_df = df
+
+        for column_spec in column_specs:
+            if column_spec.name in self:
+                raise KeyError(f"Column '{column_spec.name}' already exists "
+                               f"in table '{self.name}'")
+
+            dtype = column_spec.dtype
+            stype = column_spec.stype
+
+            if column_spec.is_source:
+                if column_spec.name not in self._source_column_dict:
+                    raise ValueError(
+                        f"Column '{column_spec.name}' does not exist in the "
+                        f"underlying source table")
+
+                if dtype is None:
+                    dtype = self._source_column_dict[column_spec.name].dtype
+
+                if dtype == Dtype.unsupported:
+                    raise ValueError(
+                        f"Encountered unsupported data type for column "
+                        f"'{column_spec.name}' in table '{self.name}'. Please "
+                        f"either change the column's data type or remove the "
+                        f"column from this table.")
+
+            if dtype is None:
+                if column_spec.is_source:
+                    ser = self._source_sample_df[column_spec.name]
+                else:
+                    ser = self._expr_sample_df[column_spec.name]
+                try:
+                    dtype = infer_dtype(ser)
+                except Exception as e:
+                    raise RuntimeError(
+                        f"Encountered unsupported data type '{ser.dtype}' for "
+                        f"column '{column_spec.name}' in table '{self.name}'. "
+                        f"Please either manually override the columns's data "
+                        f"type or remove the column from this table.") from e
+
+            if stype is None:
+                if column_spec.is_source:
+                    ser = self._source_sample_df[column_spec.name]
+                else:
+                    ser = self._expr_sample_df[column_spec.name]
+                try:
+                    stype = infer_stype(ser, column_spec.name, dtype)
+                except Exception as e:
+                    raise RuntimeError(
+                        f"Could not determine semantic type for column "
+                        f"'{column_spec.name}' with data type '{dtype}' in "
+                        f"table '{self.name}'. Please either change the "
+                        f"column's data type or remove the column from this "
+                        f"table.") from e
+
+            self._column_dict[column_spec.name] = Column(
+                name=column_spec.name,
+                expr=column_spec.expr,
+                dtype=dtype,
+                stype=stype,
+            )
+
+    def add_column(self, column: ColumnSpecType) -> Column:
+        r"""Adds a column to this table.
+
+        Args:
+            column: The column to add.
+
+        Raises:
+            KeyError: If the column name already exists in this table.
+        """
+        column_spec = ColumnSpec.coerce(column)
+        self.add_columns([column_spec])
+        return self[column_spec.name]
 
     def remove_column(self, name: str) -> Self:
         r"""Removes a column from this table.
@@ -192,7 +252,7 @@ class Table(ABC):
             self.time_column = None
         if self._end_time_column == name:
             self.end_time_column = None
-        del self._columns[name]
+        del self._column_dict[name]
 
         return self
 
@@ -205,22 +265,22 @@ class Table(ABC):
         return self._primary_key is not None
 
     @property
-    def primary_key(self) -> Optional[Column]:
+    def primary_key(self) -> Column | None:
         r"""The primary key column of this table.
 
         The getter returns the primary key column of this table, or ``None`` if
         no such primary key is present.
 
         The setter sets a column as a primary key on this table, and raises a
-        :class:`ValueError` if the primary key has a non-ID semantic type or
-        if the column name does not match a column in the data frame.
+        :class:`ValueError` if the primary key has a non-ID compatible data
+        type or if the column name does not match a column in the data frame.
         """
         if self._primary_key is None:
             return None
         return self[self._primary_key]
 
     @primary_key.setter
-    def primary_key(self, name: Optional[str]) -> None:
+    def primary_key(self, name: str | None) -> None:
         if name is not None and name == self._time_column:
             raise ValueError(f"Cannot specify column '{name}' as a primary "
                              f"key since it is already defined to be a time "
@@ -250,22 +310,23 @@ class Table(ABC):
         return self._time_column is not None
 
     @property
-    def time_column(self) -> Optional[Column]:
+    def time_column(self) -> Column | None:
         r"""The time column of this table.
 
         The getter returns the time column of this table, or ``None`` if no
         such time column is present.
 
         The setter sets a column as a time column on this table, and raises a
-        :class:`ValueError` if the time column has a non-timestamp semantic
-        type or if the column name does not match a column in the data frame.
+        :class:`ValueError` if the time column has a non-timestamp compatible
+        data type or if the column name does not match a column in the data
+        frame.
         """
         if self._time_column is None:
             return None
         return self[self._time_column]
 
     @time_column.setter
-    def time_column(self, name: Optional[str]) -> None:
+    def time_column(self, name: str | None) -> None:
         if name is not None and name == self._primary_key:
             raise ValueError(f"Cannot specify column '{name}' as a time "
                              f"column since it is already defined to be a "
@@ -295,7 +356,7 @@ class Table(ABC):
         return self._end_time_column is not None
 
     @property
-    def end_time_column(self) -> Optional[Column]:
+    def end_time_column(self) -> Column | None:
         r"""The end time column of this table.
 
         The getter returns the end time column of this table, or ``None`` if no
@@ -303,15 +364,15 @@ class Table(ABC):
 
         The setter sets a column as an end time column on this table, and
         raises a :class:`ValueError` if the end time column has a non-timestamp
-        semantic type or if the column name does not match a column in the data
-        frame.
+        compatible data type or if the column name does not match a column in
+        the data frame.
         """
         if self._end_time_column is None:
             return None
         return self[self._end_time_column]
 
     @end_time_column.setter
-    def end_time_column(self, name: Optional[str]) -> None:
+    def end_time_column(self, name: str | None) -> None:
         if name is not None and name == self._primary_key:
             raise ValueError(f"Cannot specify column '{name}' as an end time "
                              f"column since it is already defined to be a "
@@ -339,39 +400,39 @@ class Table(ABC):
         r"""Returns a :class:`pandas.DataFrame` object containing metadata
         information about the columns in this table.
 
-        The returned dataframe has columns ``name``, ``dtype``, ``stype``,
-        ``is_primary_key``, ``is_time_column`` and ``is_end_time_column``,
-        which provide an aggregate view of the properties of the columns of
-        this table.
+        The returned dataframe has columns ``"Name"``, ``"Data Type"``,
+        ``"Semantic Type"``, ``"Primary Key"``, ``"Time Column"`` and
+        ``"End Time Column"``, which provide an aggregated view of the
+        properties of the columns of this table.
 
         Example:
             >>> # doctest: +SKIP
             >>> import kumoai.experimental.rfm as rfm
             >>> table = rfm.LocalTable(df=..., name=...).infer_metadata()
             >>> table.metadata
-                name        dtype    stype  is_primary_key  is_time_column  is_end_time_column
-            0   CustomerID  float64  ID     True            False           False
+                Name        Data Type  Semantic Type  Primary Key  Time Column  End Time Column
+            0   CustomerID  float64    ID             True         False        False
         """  # noqa: E501
         cols = self.columns
 
         return pd.DataFrame({
-            'name':
+            'Name':
             pd.Series(dtype=str, data=[c.name for c in cols]),
-            'dtype':
+            'Data Type':
             pd.Series(dtype=str, data=[c.dtype for c in cols]),
-            'stype':
+            'Semantic Type':
             pd.Series(dtype=str, data=[c.stype for c in cols]),
-            'is_primary_key':
+            'Primary Key':
             pd.Series(
                 dtype=bool,
                 data=[self._primary_key == c.name for c in cols],
             ),
-            'is_time_column':
+            'Time Column':
             pd.Series(
                 dtype=bool,
                 data=[self._time_column == c.name for c in cols],
             ),
-            'is_end_time_column':
+            'End Time Column':
             pd.Series(
                 dtype=bool,
                 data=[self._end_time_column == c.name for c in cols],
@@ -380,28 +441,98 @@ class Table(ABC):
 
     def print_metadata(self) -> None:
         r"""Prints the :meth:`~metadata` of this table."""
-        num_rows_repr = ''
-        if self._num_rows is not None:
-            num_rows_repr = ' ({self._num_rows:,} rows)'
-
-        if in_notebook():
-            from IPython.display import Markdown, display
-            md_repr = f"### 🏷️ Metadata of Table `{self.name}`{num_rows_repr}"
-            display(Markdown(md_repr))
-            df = self.metadata
-            try:
-                if hasattr(df.style, 'hide'):
-                    display(df.style.hide(axis='index'))  # pandas=2
-                else:
-                    display(df.style.hide_index())  # pandas<1.3
-            except ImportError:
-                print(df.to_string(index=False))  # missing jinja2
-        else:
-            print(f"🏷️ Metadata of Table '{self.name}'{num_rows_repr}")
-            print(self.metadata.to_string(index=False))
+        msg = f"🏷️ Metadata of Table `{self.name}`"
+        if num := self._num_rows:
+            msg += " (1 row)" if num == 1 else f" ({num:,} rows)"
+
+        display.title(msg)
+        display.dataframe(self.metadata)
+
+    def infer_primary_key(self, verbose: bool = True) -> Self:
+        r"""Infers the primary key in this table.
+
+        Args:
+            verbose: Whether to print verbose output.
+        """
+        if self.has_primary_key():
+            return self
+
+        def _set_primary_key(primary_key: str) -> None:
+            self.primary_key = primary_key
+            if verbose:
+                display.message(f"Inferred primary key `{primary_key}` for "
+                                f"table `{self.name}`")
+
+        # Inference from source column metadata:
+        if any(column.is_source for column in self.columns):
+            primary_key = self._source_primary_key
+            if (primary_key is not None and primary_key in self
+                    and self[primary_key].is_source):
+                _set_primary_key(primary_key)
+                return self
+
+            unique_keys = [
+                column.name for column in self._source_column_dict.values()
+                if column.is_unique_key
+            ]
+            if (len(unique_keys) == 1  # NOTE No composite keys yet.
+                    and unique_keys[0] in self
+                    and self[unique_keys[0]].is_source):
+                _set_primary_key(unique_keys[0])
+                return self
+
+        # Heuristic-based inference:
+        candidates = [
+            column.name for column in self.columns if column.stype == Stype.ID
+        ]
+        if len(candidates) == 0:
+            for column in self.columns:
+                if self.name.lower() == column.name.lower():
+                    candidates.append(column.name)
+                elif (self.name.lower().endswith('s')
+                      and self.name.lower()[:-1] == column.name.lower()):
+                    candidates.append(column.name)
+
+        if primary_key := infer_primary_key(
+                table_name=self.name,
+                df=self._get_sample_df(),
+                candidates=candidates,
+        ):
+            _set_primary_key(primary_key)
+            return self
+
+        return self
+
+    def infer_time_column(self, verbose: bool = True) -> Self:
+        r"""Infers the time column in this table.
+
+        Args:
+            verbose: Whether to print verbose output.
+        """
+        if self.has_time_column():
+            return self
+
+        # Heuristic-based inference:
+        candidates = [
+            column.name for column in self.columns
+            if column.stype == Stype.timestamp
+            and column.name != self._end_time_column
+        ]
+
+        if time_column := infer_time_column(
+                df=self._get_sample_df(),
+                candidates=candidates,
+        ):
+            self.time_column = time_column
+
+            if verbose:
+                display.message(f"Inferred time column `{time_column}` for "
+                                f"table `{self.name}`")
+
+        return self
 
     def infer_metadata(self, verbose: bool = True) -> Self:
-        r"""Infers metadata, *i.e.*, primary keys and time columns, in the
+        r"""Infers metadata, *i.e.*, primary keys and time columns, in this
         table.
 
         Args:
@@ -409,48 +540,19 @@ class Table(ABC):
         """
         logs = []
 
-        # Try to detect primary key if not set:
         if not self.has_primary_key():
+            self.infer_primary_key(verbose=False)
+            if self.has_primary_key():
+                logs.append(f"primary key `{self._primary_key}`")
 
-            def is_candidate(column: Column) -> bool:
-                if column.stype == Stype.ID:
-                    return True
-                if all(column.stype != Stype.ID for column in self.columns):
-                    if self.name == column.name:
-                        return True
-                    if (self.name.endswith('s')
-                            and self.name[:-1] == column.name):
-                        return True
-                return False
-
-            candidates = [
-                column.name for column in self.columns if is_candidate(column)
-            ]
-
-            if primary_key := infer_primary_key(
-                    table_name=self.name,
-                    df=self._sample_df,
-                    candidates=candidates,
-            ):
-                self.primary_key = primary_key
-                logs.append(f"primary key '{primary_key}'")
-
-        # Try to detect time column if not set:
         if not self.has_time_column():
-            candidates = [
-                column.name for column in self.columns
-                if column.stype == Stype.timestamp
-                and column.name != self._end_time_column
-            ]
-            if time_column := infer_time_column(
-                    df=self._sample_df,
-                    candidates=candidates,
-            ):
-                self.time_column = time_column
-                logs.append(f"time column '{time_column}'")
+            self.infer_time_column(verbose=False)
+            if self.has_time_column():
+                logs.append(f"time column `{self._time_column}`")
 
         if verbose and len(logs) > 0:
-            print(f"Detected {' and '.join(logs)} in table '{self.name}'")
+            display.message(f"Inferred {' and '.join(logs)} for table "
+                            f"`{self.name}`")
 
         return self
 
@@ -468,6 +570,118 @@ class Table(ABC):
             end_time_col=self._end_time_column,
         )
 
+    @cached_property
+    def _source_column_dict(self) -> dict[str, SourceColumn]:
+        source_columns = self._get_source_columns()
+        if len(source_columns) == 0:
+            raise ValueError(f"Table '{self.name}' has no columns")
+        return {column.name: column for column in source_columns}
+
+    @cached_property
+    def _source_primary_key(self) -> str | None:
+        primary_keys = [
+            column.name for column in self._source_column_dict.values()
+            if column.is_primary_key
+        ]
+        # NOTE No composite keys yet.
+        return primary_keys[0] if len(primary_keys) == 1 else None
+
+    @cached_property
+    def _source_foreign_key_dict(self) -> dict[str, SourceForeignKey]:
+        return {key.name: key for key in self._get_source_foreign_keys()}
+
+    @cached_property
+    def _source_sample_df(self) -> pd.DataFrame:
+        return self._get_source_sample_df().reset_index(drop=True)
+
+    @cached_property
+    def _num_rows(self) -> int | None:
+        return self._get_num_rows()
+
+    def _get_sample_df(self) -> pd.DataFrame:
+        dfs: list[pd.DataFrame] = []
+        if any(column.is_source for column in self.columns):
+            dfs.append(self._source_sample_df)
+        if any(not column.is_source for column in self.columns):
+            dfs.append(self._expr_sample_df)
+
+        if len(dfs) == 0:
+            return pd.DataFrame(index=range(1000))
+        if len(dfs) == 1:
+            return dfs[0]
+
+        size = min(map(len, dfs))
+        df = pd.concat([dfs[0].iloc[:size], dfs[1].iloc[:size]], axis=1)
+        df = df.loc[:, ~df.columns.duplicated(keep='last')]
+        return df
+
+    @staticmethod
+    def _sanitize(
+        df: pd.DataFrame,
+        dtype_dict: dict[str, Dtype | None] | None = None,
+        stype_dict: dict[str, Stype | None] | None = None,
+    ) -> pd.DataFrame:
+        r"""Sanitzes a :class:`pandas.DataFrame` in-place such that its data
+        types match table data and semantic type specification.
+        """
+        def _to_datetime(ser: pd.Series) -> pd.Series:
+            if (not pd.api.types.is_datetime64_any_dtype(ser)
+                    and not (isinstance(ser.dtype, pd.ArrowDtype) and
+                             pa.types.is_timestamp(ser.dtype.pyarrow_dtype))):
+                with warnings.catch_warnings():
+                    warnings.filterwarnings(
+                        'ignore',
+                        message='Could not infer format',
+                    )
+                    ser = pd.to_datetime(ser, errors='coerce')
+            if (isinstance(ser.dtype, pd.DatetimeTZDtype)
+                    or (isinstance(ser.dtype, pd.ArrowDtype)
+                        and ser.dtype.pyarrow_dtype.tz is not None)):
+                ser = ser.dt.tz_localize(None)
+            if ser.dtype != 'datetime64[ns]':
+                ser = ser.astype('datetime64[ns]')
+            return ser
+
+        def _to_list(ser: pd.Series, dtype: Dtype | None) -> pd.Series:
+            if (pd.api.types.is_string_dtype(ser)
+                    and dtype in {Dtype.intlist, Dtype.floatlist}):
+                try:
+                    ser = ser.map(lambda row: np.fromstring(
+                        row.strip('[]'),
+                        sep=',',
+                        dtype=int if dtype == Dtype.intlist else np.float32,
+                    ) if row is not None else None)
+                except Exception:
+                    pass
+
+            if pd.api.types.is_string_dtype(ser):
+                try:
+                    import orjson as json
+                except ImportError:
+                    import json
+                try:
+                    ser = ser.map(lambda row: json.loads(row)
+                                  if row is not None else None)
+                except Exception:
+                    pass
+
+            return ser
+
+        for column_name in df.columns:
+            dtype = (dtype_dict or {}).get(column_name)
+            stype = (stype_dict or {}).get(column_name)
+
+            if dtype == Dtype.time:
+                df[column_name] = _to_datetime(df[column_name])
+            elif stype == Stype.timestamp:
+                df[column_name] = _to_datetime(df[column_name])
+            elif dtype is not None and dtype.is_list():
+                df[column_name] = _to_list(df[column_name], dtype)
+            elif stype == Stype.sequence:
+                df[column_name] = _to_list(df[column_name], Dtype.floatlist)
+
+        return df
+
     # Python builtins #########################################################
 
     def __hash__(self) -> int:
@@ -496,45 +710,32 @@ class Table(ABC):
                 f'  end_time_column={self._end_time_column},\n'
                 f')')
 
-    # Abstract method #########################################################
+    # Abstract Methods ########################################################
 
-    @cached_property
-    def _source_column_dict(self) -> Dict[str, SourceColumn]:
-        return {col.name: col for col in self._get_source_columns()}
+    @property
+    @abstractmethod
+    def backend(self) -> DataBackend:
+        r"""The data backend of this table."""
 
     @abstractmethod
-    def _get_source_columns(self) -> List[SourceColumn]:
+    def _get_source_columns(self) -> list[SourceColumn]:
         pass
 
-    @cached_property
-    def _source_foreign_key_dict(self) -> Dict[str, SourceForeignKey]:
-        fkeys = self._get_source_foreign_keys()
-        # NOTE Drop all keys that link to different primary keys in the same
-        # table since we don't support composite keys yet:
-        table_pkeys: Dict[str, Set[str]] = defaultdict(set)
-        for fkey in fkeys:
-            table_pkeys[fkey.dst_table].add(fkey.primary_key)
-        return {
-            fkey.name: fkey
-            for fkey in fkeys if len(table_pkeys[fkey.dst_table]) == 1
-        }
-
     @abstractmethod
-    def _get_source_foreign_keys(self) -> List[SourceForeignKey]:
+    def _get_source_foreign_keys(self) -> list[SourceForeignKey]:
         pass
 
-    @cached_property
-    def _sample_df(self) -> pd.DataFrame:
-        return self._get_sample_df()
-
     @abstractmethod
-    def _get_sample_df(self) -> pd.DataFrame:
+    def _get_source_sample_df(self) -> pd.DataFrame:
         pass
 
-    @cached_property
-    def _num_rows(self) -> Optional[int]:
-        return self._get_num_rows()
+    @abstractmethod
+    def _get_expr_sample_df(
+        self,
+        columns: Sequence[ColumnSpec],
+    ) -> pd.DataFrame:
+        pass
 
     @abstractmethod
-    def _get_num_rows(self) -> Optional[int]:
+    def _get_num_rows(self) -> int | None:
         pass