sqlframe 3.13.4__py3-none-any.whl → 3.14.1__py3-none-any.whl

sqlframe/base/table.py

@@ -0,0 +1,238 @@
+import sys
+import typing as t
+from enum import IntEnum
+from uuid import uuid4
+
+from sqlglot import exp
+from sqlglot.expressions import _to_s
+from sqlglot.helper import object_to_dict
+
+from sqlframe.base.dataframe import DF, SESSION, BaseDataFrame
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+if t.TYPE_CHECKING:
+    from sqlframe.base._typing import ColumnOrLiteral
+    from sqlframe.base.column import Column
+    from sqlframe.base.types import Row
+
+
+class Clause(IntEnum):
+    UPDATE = 1
+    UPDATE_ALL = 2
+    DELETE = 3
+    INSERT = 4
+    INSERT_ALL = 5
+
+
+class MergeClause:
+    def __init__(
+        self,
+        clause_type: Clause,
+        condition: t.Optional[t.Union[str, t.List[str], "Column", t.List["Column"], bool]] = None,
+        assignments: t.Optional[
+            t.Dict[t.Union["Column", str], t.Union["Column", "ColumnOrLiteral", exp.Expression]]
+        ] = None,
+        matched: bool = True,
+        by_source: bool = False,
+    ):
+        self.clause_type = clause_type
+        self.condition = condition
+        self.assignments = assignments
+        self.matched = matched
+        self.by_source = by_source
+
+
+class WhenMatched:
+    def __init__(
+        self,
+        condition: t.Optional[t.Union[str, t.List[str], "Column", t.List["Column"], bool]] = None,
+    ):
+        self._condition = condition
+        self._clause: t.Union[MergeClause, None] = None
+
+    def update(
+        self,
+        set_: t.Dict[t.Union["Column", str], t.Union["Column", "ColumnOrLiteral", exp.Expression]],
+    ) -> Self:
+        if self._clause:
+            clause = self._clause.clause_type.name.lower()
+            raise ValueError(f"WhenMatched already has an '{clause}' clause")
+        self._clause = MergeClause(
+            Clause.UPDATE,
+            self._condition,
+            {k: v for k, v in set_.items()},
+            matched=True,
+            by_source=False,
+        )
+        return self
+
+    def update_all(self) -> Self:
+        if self._clause:
+            clause = self._clause.clause_type.name.lower()
+            raise ValueError(f"WhenMatched already has an '{clause}' clause")
+        self._clause = MergeClause(
+            Clause.UPDATE_ALL,
+            self._condition,
+            {},
+            matched=True,
+            by_source=False,
+        )
+        return self
+
+    def delete(self) -> Self:
+        if self._clause:
+            clause = self._clause.clause_type.name.lower()
+            raise ValueError(f"WhenMatched already has an '{clause}' clause")
+        self._clause = MergeClause(Clause.DELETE, self._condition, matched=True, by_source=False)
+        return self
+
+    @property
+    def clause(self):
+        return self._clause
+
+
+class WhenNotMatched:
+    def __init__(
+        self,
+        condition: t.Optional[t.Union[str, t.List[str], "Column", t.List["Column"], bool]] = None,
+    ):
+        self._condition = condition
+        self._clause: t.Union[MergeClause, None] = None
+
+    def insert(
+        self,
+        values: t.Dict[
+            t.Union["Column", str], t.Union["Column", "ColumnOrLiteral", exp.Expression]
+        ],
+    ) -> Self:
+        if self._clause:
+            clause = self._clause.clause_type.name.lower()
+            raise ValueError(f"WhenNotMatched already has an '{clause}' clause")
+        self._clause = MergeClause(
+            Clause.INSERT,
+            self._condition,
+            {k: v for k, v in values.items()},
+            matched=False,
+            by_source=False,
+        )
+        return self
+
+    def insert_all(self) -> Self:
+        if self._clause:
+            clause = self._clause.clause_type.name.lower()
+            raise ValueError(f"WhenNotMatched already has an '{clause}' clause")
+        self._clause = MergeClause(
+            Clause.INSERT_ALL,
+            self._condition,
+            {},
+            matched=False,
+            by_source=False,
+        )
+        return self
+
+    @property
+    def clause(self):
+        return self._clause
+
+
+class WhenNotMatchedBySource(object):
+    def __init__(
+        self,
+        condition: t.Optional[t.Union[str, t.List[str], "Column", t.List["Column"], bool]] = None,
+    ):
+        self._condition = condition
+        self._clause: t.Union[MergeClause, None] = None
+
+    def update(
+        self,
+        set_: t.Dict[t.Union["Column", str], t.Union["Column", "ColumnOrLiteral", exp.Expression]],
+    ) -> Self:
+        if self._clause:
+            clause = self._clause.clause_type.name.lower()
+            raise ValueError(f"WhenNotMatchedBySource already has an '{clause}' clause")
+        self._clause = MergeClause(
+            Clause.UPDATE,
+            self._condition,
+            {k: v for k, v in set_.items()},
+            matched=False,
+            by_source=True,
+        )
+        return self
+
+    def delete(self) -> Self:
+        if self._clause:
+            clause = self._clause.clause_type.name.lower()
+            raise ValueError(f"WhenNotMatchedBySource already has an '{clause}' clause")
+        self._clause = MergeClause(Clause.DELETE, self._condition, matched=False, by_source=True)
+        return self
+
+    @property
+    def clause(self):
+        return self._clause
+
+
+class LazyExpression:
+    def __init__(
+        self,
+        expression: exp.Expression,
+        session: SESSION,
+    ):
+        self._expression = expression
+        self._session = session
+
+    def execute(self) -> t.List["Row"]:
+        return self._session._collect(self._expression)
+
+    @property
+    def expression(self) -> exp.Expression:
+        return self._expression
+
+    def __str__(self) -> str:
+        return self._expression.sql()
+
+    def __repr__(self) -> str:
+        return _to_s(self._expression)
+
+
+class _BaseTable(BaseDataFrame, t.Generic[DF]):
+    _df: t.Type[DF]
+
+    def copy(self, **kwargs):
+        kwargs["join_on_uuid"] = str(uuid4())
+        return self._df(**object_to_dict(self, **kwargs))
+
+    def __copy__(self):
+        return self.copy()
+
+    def table_copy(self):
+        return self.__class__(**object_to_dict(self))
+
+    def alias(self, name: str, **kwargs) -> Self:
+        df = BaseDataFrame.alias(self, name, **kwargs)
+        new_df = self.__class__(**object_to_dict(df))
+        return new_df
+
+    def update(
+        self,
+        set_: t.Dict[t.Union["Column", str], t.Union["Column", "ColumnOrLiteral", exp.Expression]],
+        where: t.Optional[t.Union["Column", str, bool]] = None,
+    ) -> LazyExpression:
+        raise NotImplementedError()
+
+    def merge(
+        self,
+        source: DF,
+        condition: t.Union[str, t.List[str], "Column", t.List["Column"], bool],
+        clauses: t.Iterable[t.Union[WhenMatched, WhenNotMatched, WhenNotMatchedBySource]],
+    ) -> LazyExpression:
+        raise NotImplementedError()
+
+    def delete(
+        self,
+        where: t.Optional[t.Union["Column", str, bool]] = None,
+    ) -> LazyExpression:
+        raise NotImplementedError()

sqlframe/bigquery/catalog.py

@@ -51,6 +51,7 @@ class BigQueryCatalog(
             from_dialect=self.session.execution_dialect,
             to_dialect=self.session.output_dialect,
             is_schema=True,
+            quote_identifiers=True,
         )
         return to_schema(current_database, dialect=self.session.output_dialect).db
 

sqlframe/bigquery/readwriter.py

@@ -13,11 +13,12 @@ from sqlframe.base.readerwriter import (
 if t.TYPE_CHECKING:
     from sqlframe.bigquery.session import BigQuerySession  # noqa
     from sqlframe.bigquery.dataframe import BigQueryDataFrame  # noqa
+    from sqlframe.bigquery.table import BigQueryTable  # noqa
 
 
 class BigQueryDataFrameReader(
     PandasLoaderMixin["BigQuerySession", "BigQueryDataFrame"],
-    _BaseDataFrameReader["BigQuerySession", "BigQueryDataFrame"],
+    _BaseDataFrameReader["BigQuerySession", "BigQueryDataFrame", "BigQueryTable"],
 ):
     pass
 

sqlframe/bigquery/session.py

@@ -9,6 +9,7 @@ from sqlframe.bigquery.readwriter import (
     BigQueryDataFrameReader,
     BigQueryDataFrameWriter,
 )
+from sqlframe.bigquery.table import BigQueryTable
 from sqlframe.bigquery.udf import BigQueryUDFRegistration
 
 if t.TYPE_CHECKING:
@@ -25,6 +26,7 @@ class BigQuerySession(
         BigQueryDataFrameReader,
         BigQueryDataFrameWriter,
         BigQueryDataFrame,
+        BigQueryTable,
         BigQueryConnection,
         BigQueryUDFRegistration,
     ],
@@ -33,6 +35,7 @@ class BigQuerySession(
     _reader = BigQueryDataFrameReader
     _writer = BigQueryDataFrameWriter
     _df = BigQueryDataFrame
+    _table = BigQueryTable
     _udf_registration = BigQueryUDFRegistration
 
     QUALIFY_INFO_SCHEMA_WITH_DATABASE = True

sqlframe/bigquery/table.py

@@ -0,0 +1,24 @@
+from sqlframe.base.mixins.table_mixins import (
+    DeleteSupportMixin,
+    MergeSupportMixin,
+    UpdateSupportMixin,
+)
+from sqlframe.base.table import (
+    WhenMatched,
+    WhenNotMatched,
+    WhenNotMatchedBySource,
+    _BaseTable,
+)
+from sqlframe.bigquery.dataframe import BigQueryDataFrame
+
+
+class BigQueryTable(
+    BigQueryDataFrame,
+    UpdateSupportMixin["BigQueryDataFrame"],
+    DeleteSupportMixin["BigQueryDataFrame"],
+    MergeSupportMixin["BigQueryDataFrame"],
+    _BaseTable["BigQueryDataFrame"],
+):
+    _df = BigQueryDataFrame
+    _merge_supported_clauses = [WhenMatched, WhenNotMatched, WhenNotMatchedBySource]
+    _merge_support_star = False

sqlframe/databricks/readwriter.py

@@ -23,11 +23,12 @@ from sqlframe.base.util import normalize_string
 if t.TYPE_CHECKING:
     from sqlframe.databricks.session import DatabricksSession  # noqa
     from sqlframe.databricks.dataframe import DatabricksDataFrame  # noqa
+    from sqlframe.databricks.table import DatabricksTable  # noqa
 
 
 class DatabricksDataFrameReader(
     PandasLoaderMixin["DatabricksSession", "DatabricksDataFrame"],
-    _BaseDataFrameReader["DatabricksSession", "DatabricksDataFrame"],
+    _BaseDataFrameReader["DatabricksSession", "DatabricksDataFrame", "DatabricksTable"],
 ):
     pass
 

sqlframe/databricks/session.py

@@ -10,6 +10,7 @@ from sqlframe.databricks.readwriter import (
     DatabricksDataFrameReader,
     DatabricksDataFrameWriter,
 )
+from sqlframe.databricks.table import DatabricksTable
 from sqlframe.databricks.udf import DatabricksUDFRegistration
 
 if t.TYPE_CHECKING:
@@ -24,6 +25,7 @@ class DatabricksSession(
         DatabricksDataFrameReader,
         DatabricksDataFrameWriter,
         DatabricksDataFrame,
+        DatabricksTable,
         DatabricksConnection,
         DatabricksUDFRegistration,
     ],
@@ -32,6 +34,7 @@ class DatabricksSession(
     _reader = DatabricksDataFrameReader
     _writer = DatabricksDataFrameWriter
     _df = DatabricksDataFrame
+    _table = DatabricksTable
     _udf_registration = DatabricksUDFRegistration
 
     def __init__(

sqlframe/databricks/table.py

@@ -0,0 +1,24 @@
+from sqlframe.base.mixins.table_mixins import (
+    DeleteSupportMixin,
+    MergeSupportMixin,
+    UpdateSupportMixin,
+)
+from sqlframe.base.table import (
+    WhenMatched,
+    WhenNotMatched,
+    WhenNotMatchedBySource,
+    _BaseTable,
+)
+from sqlframe.databricks.dataframe import DatabricksDataFrame
+
+
+class DatabricksTable(
+    DatabricksDataFrame,
+    UpdateSupportMixin["DatabricksDataFrame"],
+    DeleteSupportMixin["DatabricksDataFrame"],
+    MergeSupportMixin["DatabricksDataFrame"],
+    _BaseTable["DatabricksDataFrame"],
+):
+    _df = DatabricksDataFrame
+    _merge_supported_clauses = [WhenMatched, WhenNotMatched, WhenNotMatchedBySource]
+    _merge_support_star = True

sqlframe/duckdb/readwriter.py

@@ -16,11 +16,14 @@ if t.TYPE_CHECKING:
     from sqlframe.base.types import StructType
     from sqlframe.duckdb.dataframe import DuckDBDataFrame
     from sqlframe.duckdb.session import DuckDBSession  # noqa
+    from sqlframe.duckdb.table import DuckDBTable  # noqa
 
 logger = logging.getLogger(__name__)
 
 
-class DuckDBDataFrameReader(_BaseDataFrameReader["DuckDBSession", "DuckDBDataFrame"]):
+class DuckDBDataFrameReader(
+    _BaseDataFrameReader["DuckDBSession", "DuckDBDataFrame", "DuckDBTable"]
+):
     def load(
         self,
         path: t.Optional[PathOrPaths] = None,

sqlframe/duckdb/session.py

@@ -11,6 +11,7 @@ from sqlframe.duckdb.readwriter import (
     DuckDBDataFrameReader,
     DuckDBDataFrameWriter,
 )
+from sqlframe.duckdb.table import DuckDBTable
 from sqlframe.duckdb.udf import DuckDBUDFRegistration
 
 if t.TYPE_CHECKING:
@@ -26,6 +27,7 @@ class DuckDBSession(
         DuckDBDataFrameReader,
         DuckDBDataFrameWriter,
         DuckDBDataFrame,
+        DuckDBTable,
         DuckDBPyConnection,
         DuckDBUDFRegistration,
     ]
@@ -34,6 +36,7 @@ class DuckDBSession(
     _reader = DuckDBDataFrameReader
     _writer = DuckDBDataFrameWriter
     _df = DuckDBDataFrame
+    _table = DuckDBTable
     _udf_registration = DuckDBUDFRegistration
 
     def __init__(self, conn: t.Optional[DuckDBPyConnection] = None, *args, **kwargs):

sqlframe/duckdb/table.py

@@ -0,0 +1,16 @@
+from sqlframe.base.mixins.table_mixins import (
+    DeleteSupportMixin,
+    MergeSupportMixin,
+    UpdateSupportMixin,
+)
+from sqlframe.base.table import _BaseTable
+from sqlframe.duckdb.dataframe import DuckDBDataFrame
+
+
+class DuckDBTable(
+    DuckDBDataFrame,
+    UpdateSupportMixin["DuckDBDataFrame"],
+    DeleteSupportMixin["DuckDBDataFrame"],
+    _BaseTable["DuckDBDataFrame"],
+):
+    _df = DuckDBDataFrame

sqlframe/postgres/readwriter.py

@@ -13,11 +13,12 @@ from sqlframe.base.readerwriter import (
 if t.TYPE_CHECKING:
     from sqlframe.postgres.session import PostgresSession  # noqa
     from sqlframe.postgres.dataframe import PostgresDataFrame  # noqa
+    from sqlframe.postgres.table import PostgresTable  # noqa
 
 
 class PostgresDataFrameReader(
     PandasLoaderMixin["PostgresSession", "PostgresDataFrame"],
-    _BaseDataFrameReader["PostgresSession", "PostgresDataFrame"],
+    _BaseDataFrameReader["PostgresSession", "PostgresDataFrame", "PostgresTable"],
 ):
     pass
 

sqlframe/postgres/session.py

@@ -11,6 +11,7 @@ from sqlframe.postgres.readwriter import (
     PostgresDataFrameReader,
     PostgresDataFrameWriter,
 )
+from sqlframe.postgres.table import PostgresTable
 from sqlframe.postgres.udf import PostgresUDFRegistration
 
 if t.TYPE_CHECKING:
@@ -27,6 +28,7 @@ class PostgresSession(
         PostgresDataFrameReader,
         PostgresDataFrameWriter,
         PostgresDataFrame,
+        PostgresTable,
         psycopg2_connection,
         PostgresUDFRegistration,
     ],
@@ -35,6 +37,7 @@ class PostgresSession(
     _reader = PostgresDataFrameReader
     _writer = PostgresDataFrameWriter
     _df = PostgresDataFrame
+    _table = PostgresTable
     _udf_registration = PostgresUDFRegistration
 
     def __init__(self, conn: t.Optional[psycopg2_connection] = None):

sqlframe/postgres/table.py

@@ -0,0 +1,24 @@
+from sqlframe.base.mixins.table_mixins import (
+    DeleteSupportMixin,
+    MergeSupportMixin,
+    UpdateSupportMixin,
+)
+from sqlframe.base.table import (
+    WhenMatched,
+    WhenNotMatched,
+    WhenNotMatchedBySource,
+    _BaseTable,
+)
+from sqlframe.postgres.dataframe import PostgresDataFrame
+
+
+class PostgresTable(
+    PostgresDataFrame,
+    UpdateSupportMixin["PostgresDataFrame"],
+    DeleteSupportMixin["PostgresDataFrame"],
+    MergeSupportMixin["PostgresDataFrame"],
+    _BaseTable["PostgresDataFrame"],
+):
+    _df = PostgresDataFrame
+    _merge_supported_clauses = [WhenMatched, WhenNotMatched, WhenNotMatchedBySource]
+    _merge_support_star = False

sqlframe/redshift/readwriter.py

@@ -13,11 +13,12 @@ from sqlframe.base.readerwriter import (
 if t.TYPE_CHECKING:
     from sqlframe.redshift.session import RedshiftSession  # noqa
     from sqlframe.redshift.dataframe import RedshiftDataFrame  # noqa
+    from sqlframe.redshift.table import RedshiftTable  # noqa
 
 
 class RedshiftDataFrameReader(
     PandasLoaderMixin["RedshiftSession", "RedshiftDataFrame"],
-    _BaseDataFrameReader["RedshiftSession", "RedshiftDataFrame"],
+    _BaseDataFrameReader["RedshiftSession", "RedshiftDataFrame", "RedshiftTable"],
 ):
     pass
 

sqlframe/redshift/session.py

@@ -10,6 +10,7 @@ from sqlframe.redshift.readwriter import (
     RedshiftDataFrameReader,
     RedshiftDataFrameWriter,
 )
+from sqlframe.redshift.table import RedshiftTable
 from sqlframe.redshift.udf import RedshiftUDFRegistration
 
 if t.TYPE_CHECKING:
@@ -24,6 +25,7 @@ class RedshiftSession(
         RedshiftDataFrameReader,
         RedshiftDataFrameWriter,
         RedshiftDataFrame,
+        RedshiftTable,
         RedshiftConnection,
         RedshiftUDFRegistration,
     ],
@@ -32,6 +34,7 @@ class RedshiftSession(
     _reader = RedshiftDataFrameReader
     _writer = RedshiftDataFrameWriter
     _df = RedshiftDataFrame
+    _table = RedshiftTable
     _udf_registration = RedshiftUDFRegistration
 
     def __init__(self, conn: t.Optional[RedshiftConnection] = None):

sqlframe/redshift/table.py

@@ -0,0 +1,15 @@
+from sqlframe.base.mixins.table_mixins import (
+    DeleteSupportMixin,
+    UpdateSupportMixin,
+)
+from sqlframe.base.table import _BaseTable
+from sqlframe.redshift.dataframe import RedshiftDataFrame
+
+
+class RedshiftTable(
+    RedshiftDataFrame,
+    UpdateSupportMixin["RedshiftDataFrame"],
+    DeleteSupportMixin["RedshiftDataFrame"],
+    _BaseTable["RedshiftDataFrame"],
+):
+    _df = RedshiftDataFrame

sqlframe/snowflake/readwriter.py

@@ -13,11 +13,12 @@ from sqlframe.base.readerwriter import (
 if t.TYPE_CHECKING:
     from sqlframe.snowflake.session import SnowflakeSession  # noqa
     from sqlframe.snowflake.dataframe import SnowflakeDataFrame  # noqa
+    from sqlframe.snowflake.table import SnowflakeTable  # noqa
 
 
 class SnowflakeDataFrameReader(
     PandasLoaderMixin["SnowflakeSession", "SnowflakeDataFrame"],
-    _BaseDataFrameReader["SnowflakeSession", "SnowflakeDataFrame"],
+    _BaseDataFrameReader["SnowflakeSession", "SnowflakeDataFrame", "SnowflakeTable"],
 ):
     pass
 

sqlframe/snowflake/session.py

@@ -18,6 +18,7 @@ from sqlframe.snowflake.readwriter import (
     SnowflakeDataFrameReader,
     SnowflakeDataFrameWriter,
 )
+from sqlframe.snowflake.table import SnowflakeTable
 
 if t.TYPE_CHECKING:
     from snowflake.connector import SnowflakeConnection
@@ -51,6 +52,7 @@ class SnowflakeSession(
         SnowflakeDataFrameReader,
         SnowflakeDataFrameWriter,
         SnowflakeDataFrame,
+        SnowflakeTable,
         SnowflakeConnection,
         SnowflakeUDFRegistration,
     ],
@@ -59,6 +61,7 @@ class SnowflakeSession(
     _reader = SnowflakeDataFrameReader
     _writer = SnowflakeDataFrameWriter
     _df = SnowflakeDataFrame
+    _table = SnowflakeTable
     _udf_registration = SnowflakeUDFRegistration
 
     def __init__(self, conn: t.Optional[SnowflakeConnection] = None):

sqlframe/snowflake/table.py

@@ -0,0 +1,23 @@
+from sqlframe.base.mixins.table_mixins import (
+    DeleteSupportMixin,
+    MergeSupportMixin,
+    UpdateSupportMixin,
+)
+from sqlframe.base.table import (
+    WhenMatched,
+    WhenNotMatched,
+    _BaseTable,
+)
+from sqlframe.snowflake.dataframe import SnowflakeDataFrame
+
+
+class SnowflakeTable(
+    SnowflakeDataFrame,
+    UpdateSupportMixin["SnowflakeDataFrame"],
+    DeleteSupportMixin["SnowflakeDataFrame"],
+    MergeSupportMixin["SnowflakeDataFrame"],
+    _BaseTable["SnowflakeDataFrame"],
+):
+    _df = SnowflakeDataFrame
+    _merge_supported_clauses = [WhenMatched, WhenNotMatched]
+    _merge_support_star = False

sqlframe/spark/readwriter.py

@@ -13,11 +13,12 @@ from sqlframe.base.readerwriter import (
 if t.TYPE_CHECKING:
     from sqlframe.spark.dataframe import SparkDataFrame
     from sqlframe.spark.session import SparkSession
+    from sqlframe.spark.table import SparkTable
 
 
 class SparkDataFrameReader(
     PandasLoaderMixin["SparkSession", "SparkDataFrame"],
-    _BaseDataFrameReader["SparkSession", "SparkDataFrame"],
+    _BaseDataFrameReader["SparkSession", "SparkDataFrame", "SparkTable"],
 ):
     pass
 

sqlframe/spark/session.py

@@ -13,6 +13,7 @@ from sqlframe.spark.readwriter import (
     SparkDataFrameReader,
     SparkDataFrameWriter,
 )
+from sqlframe.spark.table import SparkTable
 from sqlframe.spark.types import Row
 from sqlframe.spark.udf import SparkUDFRegistration
 
@@ -32,6 +33,7 @@ class SparkSession(
         SparkDataFrameReader,
         SparkDataFrameWriter,
         SparkDataFrame,
+        SparkTable,
         PySparkSession,
         SparkUDFRegistration,
     ],
@@ -40,6 +42,7 @@ class SparkSession(
     _reader = SparkDataFrameReader
     _writer = SparkDataFrameWriter
     _df = SparkDataFrame
+    _table = SparkTable
     _udf_registration = SparkUDFRegistration
 
     def __init__(self, conn: t.Optional[PySparkSession] = None, *args, **kwargs):

sqlframe/spark/table.py

@@ -0,0 +1,6 @@
+from sqlframe.base.table import _BaseTable
+from sqlframe.spark.dataframe import SparkDataFrame
+
+
+class SparkTable(SparkDataFrame, _BaseTable["SparkDataFrame"]):
+    _df = SparkDataFrame

sqlframe/standalone/readwriter.py

@@ -9,9 +9,12 @@ from sqlframe.base.readerwriter import _BaseDataFrameReader, _BaseDataFrameWrite
 if t.TYPE_CHECKING:
     from sqlframe.standalone.dataframe import StandaloneDataFrame
     from sqlframe.standalone.session import StandaloneSession
+    from sqlframe.standalone.table import StandaloneTable
 
 
-class StandaloneDataFrameReader(_BaseDataFrameReader["StandaloneSession", "StandaloneDataFrame"]):
+class StandaloneDataFrameReader(
+    _BaseDataFrameReader["StandaloneSession", "StandaloneDataFrame", "StandaloneTable"]
+):
     pass