kumoai 2.10.0.dev202509231831__cp313-cp313-macosx_11_0_arm64.whl → 2.14.0.dev202512161731__cp313-cp313-macosx_11_0_arm64.whl

kumoai/experimental/rfm/{local_graph.py → graph.py}

@@ -2,8 +2,9 @@ import contextlib
 import io
 import warnings
 from collections import defaultdict
-from importlib.util import find_spec
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, Union
 
 import pandas as pd
 from kumoapi.graph import ColumnKey, ColumnKeyGroup, GraphDefinition
@@ -11,160 +12,401 @@ from kumoapi.table import TableDefinition
 from kumoapi.typing import Stype
 from typing_extensions import Self
 
-from kumoai import in_notebook
-from kumoai.experimental.rfm import LocalTable
+from kumoai import in_notebook, in_snowflake_notebook
+from kumoai.experimental.rfm.base import DataBackend, Table
 from kumoai.graph import Edge
+from kumoai.mixin import CastMixin
 
 if TYPE_CHECKING:
     import graphviz
+    from adbc_driver_sqlite.dbapi import AdbcSqliteConnection
+    from snowflake.connector import SnowflakeConnection
 
 
-class LocalGraph:
-    r"""A graph of :class:`LocalTable` objects, akin to relationships between
+@dataclass
+class SqliteConnectionConfig(CastMixin):
+    uri: Union[str, Path]
+    kwargs: Dict[str, Any] = field(default_factory=dict)
+
+
+class Graph:
+    r"""A graph of :class:`Table` objects, akin to relationships between
     tables in a relational database.
 
     Creating a graph is the final step of data definition; after a
-    :class:`LocalGraph` is created, you can use it to initialize the
+    :class:`Graph` is created, you can use it to initialize the
     Kumo Relational Foundation Model (:class:`KumoRFM`).
 
     .. code-block:: python
 
-        import pandas as pd
-        import kumoai.experimental.rfm as rfm
+        >>> # doctest: +SKIP
+        >>> import pandas as pd
+        >>> import kumoai.experimental.rfm as rfm
 
-        # Load data frames into memory:
-        df1 = pd.DataFrame(...)
-        df2 = pd.DataFrame(...)
-        df3 = pd.DataFrame(...)
+        >>> # Load data frames into memory:
+        >>> df1 = pd.DataFrame(...)
+        >>> df2 = pd.DataFrame(...)
+        >>> df3 = pd.DataFrame(...)
 
-        # Define tables from data frames:
-        table1 = rfm.LocalTable(name="table1", data=df1)
-        table2 = rfm.LocalTable(name="table2", data=df2)
-        table3 = rfm.LocalTable(name="table3", data=df3)
+        >>> # Define tables from data frames:
+        >>> table1 = rfm.LocalTable(name="table1", data=df1)
+        >>> table2 = rfm.LocalTable(name="table2", data=df2)
+        >>> table3 = rfm.LocalTable(name="table3", data=df3)
 
-        # Create a graph from a dictionary of tables:
-        graph = rfm.LocalGraph({
-            "table1": table1,
-            "table2": table2,
-            "table3": table3,
-        })
+        >>> # Create a graph from a dictionary of tables:
+        >>> graph = rfm.Graph({
+        ...     "table1": table1,
+        ...     "table2": table2,
+        ...     "table3": table3,
+        ... })
 
-        # Infer table metadata:
-        graph.infer_metadata()
+        >>> # Infer table metadata:
+        >>> graph.infer_metadata()
 
-        # Infer links/edges:
-        graph.infer_links()
+        >>> # Infer links/edges:
+        >>> graph.infer_links()
 
-        # Inspect table metadata:
-        for table in graph.tables.values():
-            table.print_metadata()
+        >>> # Inspect table metadata:
+        >>> for table in graph.tables.values():
+        ...     table.print_metadata()
 
-        # Visualize graph (if graphviz is installed):
-        graph.visualize()
+        >>> # Visualize graph (if graphviz is installed):
+        >>> graph.visualize()
 
-        # Add/Remove edges between tables:
-        graph.link(src_table="table1", fkey="id1", dst_table="table2")
-        graph.unlink(src_table="table1", fkey="id1", dst_table="table2")
+        >>> # Add/Remove edges between tables:
+        >>> graph.link(src_table="table1", fkey="id1", dst_table="table2")
+        >>> graph.unlink(src_table="table1", fkey="id1", dst_table="table2")
 
-        # Validate graph:
-        graph.validate()
+        >>> # Validate graph:
+        >>> graph.validate()
     """
 
     # Constructors ############################################################
 
     def __init__(
         self,
-        tables: List[LocalTable],
-        edges: Optional[List[Edge]] = None,
+        tables: Sequence[Table],
+        edges: Optional[Sequence[Edge]] = None,
     ) -> None:
 
-        self._tables: Dict[str, LocalTable] = {}
+        self._tables: Dict[str, Table] = {}
         self._edges: List[Edge] = []
 
         for table in tables:
             self.add_table(table)
 
+        for table in tables:
+            for fkey in table._source_foreign_key_dict.values():
+                if fkey.name not in table or fkey.dst_table not in self:
+                    continue
+                if self[fkey.dst_table].primary_key is None:
+                    self[fkey.dst_table].primary_key = fkey.primary_key
+                elif self[fkey.dst_table]._primary_key != fkey.primary_key:
+                    raise ValueError(f"Found duplicate primary key definition "
+                                     f"'{self[fkey.dst_table]._primary_key}' "
+                                     f"and '{fkey.primary_key}' in table "
+                                     f"'{fkey.dst_table}'.")
+                self.link(table.name, fkey.name, fkey.dst_table)
+
         for edge in (edges or []):
             _edge = Edge._cast(edge)
             assert _edge is not None
-            self.link(*_edge)
+            if _edge not in self._edges:
+                self.link(*_edge)
 
     @classmethod
     def from_data(
         cls,
         df_dict: Dict[str, pd.DataFrame],
-        edges: Optional[List[Edge]] = None,
+        edges: Optional[Sequence[Edge]] = None,
         infer_metadata: bool = True,
         verbose: bool = True,
     ) -> Self:
-        r"""Creates a :class:`LocalGraph` from a dictionary of
+        r"""Creates a :class:`Graph` from a dictionary of
         :class:`pandas.DataFrame` objects.
 
-        Automatically infers table metadata and links.
+        Automatically infers table metadata and links by default.
 
         .. code-block:: python
 
-            import pandas as pd
-            import kumoai.experimental.rfm as rfm
-
-            # Load data frames into memory:
-            df1 = pd.DataFrame(...)
-            df2 = pd.DataFrame(...)
-            df3 = pd.DataFrame(...)
-
-            # Create a graph from a dictionary of data frames:
-            graph = rfm.LocalGraph.from_data({
-                "table1": df1,
-                "table2": df2,
-                "table3": df3,
-            })
+            >>> # doctest: +SKIP
+            >>> import pandas as pd
+            >>> import kumoai.experimental.rfm as rfm
 
-            # Inspect table metadata:
-            for table in graph.tables.values():
-                table.print_metadata()
+            >>> # Load data frames into memory:
+            >>> df1 = pd.DataFrame(...)
+            >>> df2 = pd.DataFrame(...)
+            >>> df3 = pd.DataFrame(...)
 
-            # Visualize graph (if graphviz is installed):
-            graph.visualize()
+            >>> # Create a graph from a dictionary of data frames:
+            >>> graph = rfm.Graph.from_data({
+            ...     "table1": df1,
+            ...     "table2": df2,
+            ...     "table3": df3,
+            ... })
 
         Args:
             df_dict: A dictionary of data frames, where the keys are the names
                 of the tables and the values hold table data.
+            edges: An optional list of :class:`~kumoai.graph.Edge` objects to
+                add to the graph. If not provided, edges will be automatically
+                inferred from the data in case ``infer_metadata=True``.
             infer_metadata: Whether to infer metadata for all tables in the
                 graph.
+            verbose: Whether to print verbose output.
+        """
+        from kumoai.experimental.rfm.backend.local import LocalTable
+        tables = [LocalTable(df, name) for name, df in df_dict.items()]
+
+        graph = cls(tables, edges=edges or [])
+
+        if infer_metadata:
+            graph.infer_metadata(False)
+
+            if edges is None:
+                graph.infer_links(False)
+
+        if verbose:
+            graph.print_metadata()
+            graph.print_links()
+
+        return graph
+
+    @classmethod
+    def from_sqlite(
+        cls,
+        connection: Union[
+            'AdbcSqliteConnection',
+            SqliteConnectionConfig,
+            str,
+            Path,
+            Dict[str, Any],
+        ],
+        table_names: Optional[Sequence[str]] = None,
+        edges: Optional[Sequence[Edge]] = None,
+        infer_metadata: bool = True,
+        verbose: bool = True,
+    ) -> Self:
+        r"""Creates a :class:`Graph` from a :class:`sqlite` database.
+
+        Automatically infers table metadata and links by default.
+
+        .. code-block:: python
+
+            >>> # doctest: +SKIP
+            >>> import kumoai.experimental.rfm as rfm
+
+            >>> # Create a graph from a SQLite database:
+            >>> graph = rfm.Graph.from_sqlite('data.db')
+
+        Args:
+            connection: An open connection from
+                :meth:`~kumoai.experimental.rfm.backend.sqlite.connect` or the
+                path to the database file.
+            table_names: Set of table names to include. If ``None``, will add
+                all tables present in the database.
             edges: An optional list of :class:`~kumoai.graph.Edge` objects to
                 add to the graph. If not provided, edges will be automatically
-                inferred from the data.
+                inferred from the data in case ``infer_metadata=True``.
+            infer_metadata: Whether to infer metadata for all tables in the
+                graph.
             verbose: Whether to print verbose output.
+        """
+        from kumoai.experimental.rfm.backend.sqlite import (
+            Connection,
+            SQLiteTable,
+            connect,
+        )
+
+        internal_connection = False
+        if not isinstance(connection, Connection):
+            connection = SqliteConnectionConfig._cast(connection)
+            assert isinstance(connection, SqliteConnectionConfig)
+            connection = connect(connection.uri, **connection.kwargs)
+            internal_connection = True
+        assert isinstance(connection, Connection)
+
+        if table_names is None:
+            with connection.cursor() as cursor:
+                cursor.execute("SELECT name FROM sqlite_master "
+                               "WHERE type='table'")
+                table_names = [row[0] for row in cursor.fetchall()]
+
+        tables = [SQLiteTable(connection, name) for name in table_names]
 
-        Note:
-            This method will automatically infer metadata and links for the
-            graph.
+        graph = cls(tables, edges=edges or [])
 
-        Example:
+        if internal_connection:
+            graph._connection = connection  # type: ignore
+
+        if infer_metadata:
+            graph.infer_metadata(False)
+
+            if edges is None:
+                graph.infer_links(False)
+
+        if verbose:
+            graph.print_metadata()
+            graph.print_links()
+
+        return graph
+
+    @classmethod
+    def from_snowflake(
+        cls,
+        connection: Union['SnowflakeConnection', Dict[str, Any], None] = None,
+        database: Optional[str] = None,
+        schema: Optional[str] = None,
+        table_names: Optional[Sequence[str]] = None,
+        edges: Optional[Sequence[Edge]] = None,
+        infer_metadata: bool = True,
+        verbose: bool = True,
+    ) -> Self:
+        r"""Creates a :class:`Graph` from a :class:`snowflake` database and
+        schema.
+
+        Automatically infers table metadata and links by default.
+
+        .. code-block:: python
+
+            >>> # doctest: +SKIP
             >>> import kumoai.experimental.rfm as rfm
-            >>> df1 = pd.DataFrame(...)
-            >>> df2 = pd.DataFrame(...)
-            >>> df3 = pd.DataFrame(...)
-            >>> graph = rfm.LocalGraph.from_data(data={
-            ...     "table1": df1,
-            ...     "table2": df2,
-            ...     "table3": df3,
-            ... })
-            ... graph.validate()
+
+            >>> # Create a graph directly in a Snowflake notebook:
+            >>> graph = rfm.Graph.from_snowflake(schema='my_schema')
+
+        Args:
+            connection: An open connection from
+                :meth:`~kumoai.experimental.rfm.backend.snow.connect` or the
+                :class:`snowflake` connector keyword arguments to open a new
+                connection. If ``None``, will re-use an active session in case
+                it exists, or create a new connection from credentials stored
+                in environment variables.
+            database: The database.
+            schema: The schema.
+            table_names: Set of table names to include. If ``None``, will add
+                all tables present in the database.
+            edges: An optional list of :class:`~kumoai.graph.Edge` objects to
+                add to the graph. If not provided, edges will be automatically
+                inferred from the data in case ``infer_metadata=True``.
+            infer_metadata: Whether to infer metadata for all tables in the
+                graph.
+            verbose: Whether to print verbose output.
         """
-        tables = [LocalTable(df, name) for name, df in df_dict.items()]
+        from kumoai.experimental.rfm.backend.snow import (
+            Connection,
+            SnowTable,
+            connect,
+        )
+
+        if not isinstance(connection, Connection):
+            connection = connect(**(connection or {}))
+        assert isinstance(connection, Connection)
+
+        if table_names is None:
+            with connection.cursor() as cursor:
+                if database is None and schema is None:
+                    cursor.execute("SELECT CURRENT_DATABASE(), "
+                                   "CURRENT_SCHEMA()")
+                    result = cursor.fetchone()
+                    database = database or result[0]
+                    schema = schema or result[1]
+                cursor.execute(f"""
+                SELECT TABLE_NAME
+                FROM {database}.INFORMATION_SCHEMA.TABLES
+                WHERE TABLE_SCHEMA = '{schema}'
+                """)
+                table_names = [row[0] for row in cursor.fetchall()]
+
+        tables = [
+            SnowTable(
+                connection,
+                name=table_name,
+                database=database,
+                schema=schema,
+            ) for table_name in table_names
+        ]
 
         graph = cls(tables, edges=edges or [])
 
         if infer_metadata:
-            graph.infer_metadata(verbose)
+            graph.infer_metadata(False)
 
             if edges is None:
-                graph.infer_links(verbose)
+                graph.infer_links(False)
+
+        if verbose:
+            graph.print_metadata()
+            graph.print_links()
 
         return graph
 
-    # Tables ##############################################################
+    @classmethod
+    def from_snowflake_semantic_view(
+        cls,
+        semantic_view_name: str,
+        connection: Union['SnowflakeConnection', Dict[str, Any], None] = None,
+        verbose: bool = True,
+    ) -> Self:
+        import yaml
+
+        from kumoai.experimental.rfm.backend.snow import (
+            Connection,
+            SnowTable,
+            connect,
+        )
+
+        if not isinstance(connection, Connection):
+            connection = connect(**(connection or {}))
+        assert isinstance(connection, Connection)
+
+        with connection.cursor() as cursor:
+            cursor.execute(f"SELECT SYSTEM$READ_YAML_FROM_SEMANTIC_VIEW("
+                           f"'{semantic_view_name}')")
+            view = yaml.safe_load(cursor.fetchone()[0])
+
+        graph = cls(tables=[])
+
+        for table_desc in view['tables']:
+            primary_key: Optional[str] = None
+            if ('primary_key' in table_desc  # NOTE No composite keys yet.
+                    and len(table_desc['primary_key']['columns']) == 1):
+                primary_key = table_desc['primary_key']['columns'][0]
+
+            table = SnowTable(
+                connection,
+                name=table_desc['base_table']['table'],
+                database=table_desc['base_table']['database'],
+                schema=table_desc['base_table']['schema'],
+                primary_key=primary_key,
+            )
+            graph.add_table(table)
+
+        # TODO Find a solution to register time columns!
+
+        for relations in view['relationships']:
+            if len(relations['relationship_columns']) != 1:
+                continue  # NOTE No composite keys yet.
+            graph.link(
+                src_table=relations['left_table'],
+                fkey=relations['relationship_columns'][0]['left_column'],
+                dst_table=relations['right_table'],
+            )
+
+        if verbose:
+            graph.print_metadata()
+            graph.print_links()
+
+        return graph
+
+    # Backend #################################################################
+
+    @property
+    def backend(self) -> DataBackend | None:
+        backends = [table.backend for table in self._tables.values()]
+        return backends[0] if len(backends) > 0 else None
+
+    # Tables ##################################################################
 
     def has_table(self, name: str) -> bool:
         r"""Returns ``True`` if the graph has a table with name ``name``;
@@ -172,7 +414,7 @@ class LocalGraph:
         """
         return name in self.tables
 
-    def table(self, name: str) -> LocalTable:
+    def table(self, name: str) -> Table:
         r"""Returns the table with name ``name`` in the graph.
 
         Raises:
@@ -183,11 +425,11 @@ class LocalGraph:
         return self.tables[name]
 
     @property
-    def tables(self) -> Dict[str, LocalTable]:
+    def tables(self) -> Dict[str, Table]:
         r"""Returns the dictionary of table objects."""
         return self._tables
 
-    def add_table(self, table: LocalTable) -> Self:
+    def add_table(self, table: Table) -> Self:
         r"""Adds a table to the graph.
 
         Args:
@@ -196,11 +438,18 @@ class LocalGraph:
         Raises:
             KeyError: If a table with the same name already exists in the
                 graph.
+            ValueError: If the table belongs to a different backend than the
+                rest of the tables in the graph.
         """
         if table.name in self._tables:
             raise KeyError(f"Cannot add table with name '{table.name}' to "
                            f"this graph; table names must be globally unique.")
 
+        if self.backend is not None and table.backend != self.backend:
+            raise ValueError(f"Cannot register a table with backend "
+                             f"'{table.backend}' to this graph since other "
+                             f"tables have backend '{self.backend}'.")
+
         self._tables[table.name] = table
 
         return self
@@ -231,16 +480,17 @@ class LocalGraph:
         r"""Returns a :class:`pandas.DataFrame` object containing metadata
         information about the tables in this graph.
 
-        The returned dataframe has columns ``name``, ``primary_key``, and
-        ``time_column``, which provide an aggregate view of the properties of
-        the tables of this graph.
+        The returned dataframe has columns ``name``, ``primary_key``,
+        ``time_column``, and ``end_time_column``, which provide an aggregate
+        view of the properties of the tables of this graph.
 
         Example:
+            >>> # doctest: +SKIP
             >>> import kumoai.experimental.rfm as rfm
-            >>> graph = rfm.LocalGraph(tables=...).infer_metadata()
-            >>> graph.metadata
-                name  primary_key time_column
-            0   users     user_id           -
+            >>> graph = rfm.Graph(tables=...).infer_metadata()
+            >>> graph.metadata  # doctest: +SKIP
+                name   primary_key  time_column  end_time_column
+            0   users      user_id            -                -
         """
         tables = list(self.tables.values())
 
@@ -251,13 +501,22 @@ class LocalGraph:
             pd.Series(dtype=str, data=[t._primary_key or '-' for t in tables]),
             'time_column':
             pd.Series(dtype=str, data=[t._time_column or '-' for t in tables]),
+            'end_time_column':
+            pd.Series(
+                dtype=str,
+                data=[t._end_time_column or '-' for t in tables],
+            ),
         })
 
     def print_metadata(self) -> None:
-        r"""Prints the :meth:`~LocalGraph.metadata` of the graph."""
-        if in_notebook():
+        r"""Prints the :meth:`~Graph.metadata` of the graph."""
+        if in_snowflake_notebook():
+            import streamlit as st
+            st.markdown("### 🗂️ Graph Metadata")
+            st.dataframe(self.metadata, hide_index=True)
+        elif in_notebook():
             from IPython.display import Markdown, display
-            display(Markdown('### 🗂️ Graph Metadata'))
+            display(Markdown("### 🗂️ Graph Metadata"))
             df = self.metadata
             try:
                 if hasattr(df.style, 'hide'):
@@ -278,7 +537,7 @@ class LocalGraph:
 
         Note:
             For more information, please see
-            :meth:`kumoai.experimental.rfm.LocalTable.infer_metadata`.
+            :meth:`kumoai.experimental.rfm.Table.infer_metadata`.
         """
         for table in self.tables.values():
             table.infer_metadata(verbose=False)
@@ -296,37 +555,47 @@ class LocalGraph:
         return self._edges
 
     def print_links(self) -> None:
-        r"""Prints the :meth:`~LocalGraph.edges` of the graph."""
+        r"""Prints the :meth:`~Graph.edges` of the graph."""
         edges = [(edge.dst_table, self[edge.dst_table]._primary_key,
                   edge.src_table, edge.fkey) for edge in self.edges]
         edges = sorted(edges)
 
-        if in_notebook():
+        if in_snowflake_notebook():
+            import streamlit as st
+            st.markdown("### 🕸️ Graph Links (FK ↔️ PK)")
+            if len(edges) > 0:
+                st.markdown('\n'.join([
+                    f"- {edge[2]}.{edge[3]} ↔️ {edge[0]}.{edge[1]}"
+                    for edge in edges
+                ]))
+            else:
+                st.markdown("*No links registered*")
+        elif in_notebook():
             from IPython.display import Markdown, display
-            display(Markdown('### 🕸️ Graph Links (FK ↔️ PK)'))
+            display(Markdown("### 🕸️ Graph Links (FK ↔️ PK)"))
             if len(edges) > 0:
                 display(
                     Markdown('\n'.join([
-                        f'- `{edge[2]}.{edge[3]}` ↔️ `{edge[0]}.{edge[1]}`'
+                        f"- `{edge[2]}.{edge[3]}` ↔️ `{edge[0]}.{edge[1]}`"
                         for edge in edges
                     ])))
             else:
-                display(Markdown('*No links registered*'))
+                display(Markdown("*No links registered*"))
         else:
             print("🕸️ Graph Links (FK ↔️ PK):")
             if len(edges) > 0:
                 print('\n'.join([
-                    f'• {edge[2]}.{edge[3]} ↔️ {edge[0]}.{edge[1]}'
+                    f"• {edge[2]}.{edge[3]} ↔️ {edge[0]}.{edge[1]}"
                     for edge in edges
                 ]))
             else:
-                print('No links registered')
+                print("No links registered")
 
     def link(
         self,
-        src_table: Union[str, LocalTable],
+        src_table: Union[str, Table],
         fkey: str,
-        dst_table: Union[str, LocalTable],
+        dst_table: Union[str, Table],
     ) -> Self:
         r"""Links two tables (``src_table`` and ``dst_table``) from the foreign
         key ``fkey`` in the source table to the primary key in the destination
@@ -349,11 +618,11 @@ class LocalGraph:
                 table does not exist in the graph, if the source key does not
                 exist in the source table.
         """
-        if isinstance(src_table, LocalTable):
+        if isinstance(src_table, Table):
             src_table = src_table.name
         assert isinstance(src_table, str)
 
-        if isinstance(dst_table, LocalTable):
+        if isinstance(dst_table, Table):
             dst_table = dst_table.name
         assert isinstance(dst_table, str)
 
@@ -387,9 +656,9 @@ class LocalGraph:
 
     def unlink(
         self,
-        src_table: Union[str, LocalTable],
+        src_table: Union[str, Table],
         fkey: str,
-        dst_table: Union[str, LocalTable],
+        dst_table: Union[str, Table],
     ) -> Self:
         r"""Removes an :class:`~kumoai.graph.Edge` from the graph.
 
@@ -401,11 +670,11 @@ class LocalGraph:
         Raises:
             ValueError: if the edge is not present in the graph.
         """
-        if isinstance(src_table, LocalTable):
+        if isinstance(src_table, Table):
             src_table = src_table.name
         assert isinstance(src_table, str)
 
-        if isinstance(dst_table, LocalTable):
+        if isinstance(dst_table, Table):
             dst_table = dst_table.name
         assert isinstance(dst_table, str)
 
@@ -419,17 +688,13 @@ class LocalGraph:
         return self
 
     def infer_links(self, verbose: bool = True) -> Self:
-        r"""Infers links for the tables and adds them as edges to the graph.
+        r"""Infers missing links for the tables and adds them as edges to the
+        graph.
 
         Args:
             verbose: Whether to print verbose output.
-
-        Note:
-            This function expects graph edges to be undefined upfront.
         """
-        if len(self.edges) > 0:
-            warnings.warn("Cannot infer links if graph edges already exist")
-            return self
+        known_edges = {(edge.src_table, edge.fkey) for edge in self.edges}
 
         # A list of primary key candidates (+score) for every column:
         candidate_dict: dict[
@@ -454,6 +719,9 @@ class LocalGraph:
                 src_table_name = src_table.name.lower()
 
                 for src_key in src_table.columns:
+                    if (src_table.name, src_key.name) in known_edges:
+                        continue
+
                     if src_key == src_table.primary_key:
                         continue  # Cannot link to primary key.
 
@@ -519,7 +787,9 @@ class LocalGraph:
                         score += 1.0
 
                     # Cardinality ratio:
-                    if len(src_table._data) > len(dst_table._data):
+                    if (src_table._num_rows is not None
+                            and dst_table._num_rows is not None
+                            and src_table._num_rows > dst_table._num_rows):
                         score += 1.0
 
                     if score < 5.0:
@@ -565,6 +835,10 @@ class LocalGraph:
             raise ValueError("At least one table needs to be added to the "
                              "graph")
 
+        backends = {table.backend for table in self._tables.values()}
+        if len(backends) != 1:
+            raise ValueError("Found multiple table backends in the graph")
+
         for edge in self.edges:
             src_table, fkey, dst_table = edge
 
@@ -602,8 +876,8 @@ class LocalGraph:
                 raise ValueError(f"{edge} is invalid as foreign key "
                                  f"'{fkey}' and primary key '{dst_key.name}' "
                                  f"have incompatible data types (got "
-                                 f"fkey.dtype '{dst_key.dtype}' and "
-                                 f"pkey.dtype '{src_key.dtype}')")
+                                 f"fkey.dtype '{src_key.dtype}' and "
+                                 f"pkey.dtype '{dst_key.dtype}')")
 
         return self
 
@@ -636,19 +910,19 @@ class LocalGraph:
 
             return True
 
-        # Check basic dependency:
-        if not find_spec('graphviz'):
-            raise ModuleNotFoundError("The 'graphviz' package is required for "
-                                      "visualization")
-        elif not has_graphviz_executables():
+        try:  # Check basic dependency:
+            import graphviz
+        except ImportError as e:
+            raise ImportError("The 'graphviz' package is required for "
+                              "visualization") from e
+
+        if not in_snowflake_notebook() and not has_graphviz_executables():
             raise RuntimeError("Could not visualize graph as 'graphviz' "
                                "executables are not installed. These "
                                "dependencies are required in addition to the "
                                "'graphviz' Python package. Please install "
                                "them as described at "
                                "https://graphviz.org/download/.")
-        else:
-            import graphviz
 
         format: Optional[str] = None
         if isinstance(path, str):
@@ -676,6 +950,11 @@ class LocalGraph:
             ]
             if time_column := table.time_column:
                 keys += [f'{time_column.name}: Time ({time_column.dtype})']
+            if end_time_column := table.end_time_column:
+                keys += [
+                    f'{end_time_column.name}: '
+                    f'End Time ({end_time_column.dtype})'
+                ]
             key_repr = left_align(keys)
 
             columns = []
@@ -683,9 +962,9 @@ class LocalGraph:
                 columns += [
                     f'{column.name}: {column.stype} ({column.dtype})'
                     for column in table.columns
-                    if column.name not in fkeys_dict[table_name]
-                    and column.name != table._primary_key
-                    and column.name != table._time_column
+                    if column.name not in fkeys_dict[table_name] and
+                    column.name != table._primary_key and column.name != table.
+                    _time_column and column.name != table._end_time_column
                 ]
             column_repr = left_align(columns)
 
@@ -727,6 +1006,9 @@ class LocalGraph:
             graph.render(path, cleanup=True)
         elif isinstance(path, io.BytesIO):
             path.write(graph.pipe())
+        elif in_snowflake_notebook():
+            import streamlit as st
+            st.graphviz_chart(graph)
         elif in_notebook():
             from IPython.display import display
             display(graph)
@@ -752,16 +1034,18 @@ class LocalGraph:
     def _to_api_graph_definition(self) -> GraphDefinition:
         tables: Dict[str, TableDefinition] = {}
         col_groups: List[ColumnKeyGroup] = []
-        for t_name, table in self.tables.items():
-            tables[t_name] = table._to_api_table_definition()
+        for table_name, table in self.tables.items():
+            tables[table_name] = table._to_api_table_definition()
             if table.primary_key is None:
                 continue
-            keys = [ColumnKey(t_name, table.primary_key.name)]
+            keys = [ColumnKey(table_name, table.primary_key.name)]
             for edge in self.edges:
-                if edge.dst_table == t_name:
+                if edge.dst_table == table_name:
                     keys.append(ColumnKey(edge.src_table, edge.fkey))
-            keys = sorted(list(set(keys)),
-                          key=lambda x: f'{x.table_name}.{x.col_name}')
+            keys = sorted(
+                list(set(keys)),
+                key=lambda x: f'{x.table_name}.{x.col_name}',
+            )
             if len(keys) > 1:
                 col_groups.append(ColumnKeyGroup(keys))
         return GraphDefinition(tables, col_groups)
@@ -774,7 +1058,7 @@ class LocalGraph:
     def __contains__(self, name: str) -> bool:
         return self.has_table(name)
 
-    def __getitem__(self, name: str) -> LocalTable:
+    def __getitem__(self, name: str) -> Table:
         return self.table(name)
 
     def __delitem__(self, name: str) -> None:
@@ -792,3 +1076,7 @@ class LocalGraph:
                 f'  tables={tables},\n'
                 f'  edges={edges},\n'
                 f')')
+
+    def __del__(self) -> None:
+        if hasattr(self, '_connection'):
+            self._connection.close()