pixeltable 0.4.0rc2__py3-none-any.whl → 0.4.1__py3-none-any.whl

pixeltable/catalog/table_version.py

@@ -167,18 +167,6 @@ class TableVersion:
         self.idxs_by_name = {}
         self.external_stores = {}
 
-    def init(self) -> None:
-        """
-        Initialize schema-related in-memory metadata separately, now that this TableVersion instance is visible
-        in Catalog.
-        """
-        from .catalog import Catalog
-
-        assert (self.id, self.effective_version) in Catalog.get()._tbl_versions
-        self._init_schema()
-        # init external stores; this needs to happen after the schema is created
-        self._init_external_stores()
-
     def __hash__(self) -> int:
         return hash(self.id)
 
@@ -234,6 +222,7 @@ class TableVersion:
             next_col_id=len(cols),
             next_idx_id=0,
             next_row_id=0,
+            view_sn=0,
             column_md=column_md,
             index_md={},
             external_stores=[],
@@ -342,24 +331,39 @@ class TableVersion:
         return tbl_version
 
     def drop(self) -> None:
-        from .catalog import Catalog
-
         if self.is_view and self.is_mutable:
             # update mutable_views
+            # TODO: invalidate base to force reload
             from .table_version_handle import TableVersionHandle
 
             assert self.base is not None
             if self.base.get().is_mutable:
                 self.base.get().mutable_views.remove(TableVersionHandle.create(self))
 
-        cat = Catalog.get()
+        # cat = Catalog.get()
         # delete this table and all associated data
         MediaStore.delete(self.id)
         FileCache.get().clear(tbl_id=self.id)
-        cat.delete_tbl_md(self.id)
+        # cat.delete_tbl_md(self.id)
         self.store_tbl.drop()
         # de-register table version from catalog
-        cat.remove_tbl_version(self)
+        # cat.remove_tbl_version(self)
+
+    def init(self) -> None:
+        """
+        Initialize schema-related in-memory metadata separately, now that this TableVersion instance is visible
+        in Catalog.
+        """
+        from .catalog import Catalog
+
+        cat = Catalog.get()
+        assert (self.id, self.effective_version) in cat._tbl_versions
+        self._init_schema()
+        if not self.is_snapshot:
+            cat.record_column_dependencies(self)
+
+        # init external stores; this needs to happen after the schema is created
+        self._init_external_stores()
 
     def _init_schema(self) -> None:
         # create columns first, so the indices can reference them
@@ -369,6 +373,10 @@ class TableVersion:
         # create the sa schema only after creating the columns and indices
         self._init_sa_schema()
 
+        # created value_exprs after everything else has been initialized
+        for col in self.cols_by_id.values():
+            col.init_value_expr()
+
     def _init_cols(self) -> None:
         """Initialize self.cols with the columns visible in our effective version"""
         self.cols = []
@@ -395,6 +403,7 @@ class TableVersion:
                 schema_version_add=col_md.schema_version_add,
                 schema_version_drop=col_md.schema_version_drop,
                 value_expr_dict=col_md.value_expr,
+                tbl=self,
             )
             col.tbl = self
             self.cols.append(col)
@@ -410,10 +419,10 @@ class TableVersion:
                 self.cols_by_name[col.name] = col
             self.cols_by_id[col.id] = col
 
-            # make sure to traverse columns ordered by position = order in which cols were created;
-            # this guarantees that references always point backwards
-            if not self.is_snapshot and col_md.value_expr is not None:
-                self._record_refd_columns(col)
+            # # make sure to traverse columns ordered by position = order in which cols were created;
+            # # this guarantees that references always point backwards
+            # if not self.is_snapshot and col_md.value_expr is not None:
+            #     self._record_refd_columns(col)
 
     def _init_idxs(self) -> None:
         # self.idx_md = tbl_md.index_md
@@ -482,11 +491,6 @@ class TableVersion:
             self.id, self._tbl_md, version_md, self._schema_version_md if new_schema_version else None
         )
 
-    def ensure_md_loaded(self) -> None:
-        """Ensure that table metadata is loaded."""
-        for col in self.cols_by_id.values():
-            _ = col.value_expr
-
     def _store_idx_name(self, idx_id: int) -> str:
         """Return name of index in the store, which needs to be globally unique"""
         return f'idx_{self.id.hex}_{idx_id}'
@@ -700,9 +704,6 @@ class TableVersion:
             if col.name is not None:
                 self.cols_by_name[col.name] = col
             self.cols_by_id[col.id] = col
-            if col.value_expr is not None:
-                col.check_value_expr()
-                self._record_refd_columns(col)
 
             # also add to stored md
             self._tbl_md.column_md[col.id] = schema.ColumnMd(
@@ -760,9 +761,11 @@ class TableVersion:
                 run_cleanup_on_exception(cleanup_on_error)
                 plan.close()
 
+        pxt.catalog.Catalog.get().record_column_dependencies(self)
+
         if print_stats:
             plan.ctx.profile.print(num_rows=row_count)
-        # TODO(mkornacker): what to do about system columns with exceptions?
+        # TODO: what to do about system columns with exceptions?
         return UpdateStatus(
             num_rows=row_count,
             num_computed_values=row_count,
@@ -805,13 +808,6 @@ class TableVersion:
         assert not self.is_snapshot
 
         for col in cols:
-            if col.value_expr is not None:
-                # update Column.dependent_cols
-                for c in self.cols:
-                    if c == col:
-                        break
-                    c.dependent_cols.discard(col)
-
             col.schema_version_drop = self.schema_version
             if col.name is not None:
                 assert col.name in self.cols_by_name
@@ -828,6 +824,7 @@ class TableVersion:
             schema_col.pos = pos
 
         self.store_tbl.create_sa_tbl()
+        pxt.catalog.Catalog.get().record_column_dependencies(self)
 
     def rename_column(self, old_name: str, new_name: str) -> None:
         """Rename a column."""
@@ -1458,18 +1455,6 @@ class TableVersion:
         names = [c.name for c in self.cols_by_name.values() if c.is_computed]
         return names
 
-    def _record_refd_columns(self, col: Column) -> None:
-        """Update Column.dependent_cols for all cols referenced in col.value_expr."""
-        from pixeltable import exprs
-
-        if col.value_expr_dict is not None:
-            # if we have a value_expr_dict, use that instead of instantiating the value_expr
-            refd_cols = exprs.Expr.get_refd_columns(col.value_expr_dict)
-        else:
-            refd_cols = [e.col for e in col.value_expr.subexprs(expr_class=exprs.ColumnRef)]
-        for refd_col in refd_cols:
-            refd_col.dependent_cols.add(col)
-
     def get_idx_val_columns(self, cols: Iterable[Column]) -> set[Column]:
         result = {info.val_col for col in cols for info in col.get_idx_info().values()}
         return result
@@ -1478,7 +1463,8 @@ class TableVersion:
         """
         Return the set of columns that transitively depend on any of the given ones.
         """
-        result = {dependent_col for col in cols for dependent_col in col.dependent_cols}
+        cat = pxt.catalog.Catalog.get()
+        result = set().union(*[cat.get_column_dependents(col.tbl.id, col.id) for col in cols])
         if len(result) > 0:
             result.update(self.get_dependent_columns(result))
         return result

pixeltable/catalog/table_version_handle.py

@@ -34,6 +34,10 @@ class TableVersionHandle:
     def __hash__(self) -> int:
         return hash((self.id, self.effective_version))
 
+    @property
+    def is_snapshot(self) -> bool:
+        return self.effective_version is not None
+
     @classmethod
     def create(cls, tbl_version: TableVersion) -> TableVersionHandle:
         return cls(tbl_version.id, tbl_version.effective_version, tbl_version)
@@ -53,7 +57,6 @@ class TableVersionHandle:
             else:
                 self._tbl_version = Catalog.get().get_tbl_version(self.id, self.effective_version)
         if self.effective_version is None:
-            # make sure we don't see a discarded instance of a live TableVersion
             tvs = list(Catalog.get()._tbl_versions.values())
             assert self._tbl_version in tvs
         return self._tbl_version

pixeltable/catalog/table_version_path.py

@@ -8,6 +8,7 @@ from pixeltable.env import Env
 from pixeltable.metadata import schema
 
 from .column import Column
+from .globals import MediaValidation
 from .table_version import TableVersion
 from .table_version_handle import TableVersionHandle
 
@@ -83,6 +84,7 @@ class TableVersionPath:
         if self.base is not None:
             self.base.clear_cached_md()
 
+    @property
     def tbl_id(self) -> UUID:
         """Return the id of the table/view that this path represents"""
         return self.tbl_version.id
@@ -92,6 +94,11 @@ class TableVersionPath:
         self.refresh_cached_md()
         return self._cached_tbl_version.version
 
+    def schema_version(self) -> int:
+        """Return the version of the table/view that this path represents"""
+        self.refresh_cached_md()
+        return self._cached_tbl_version.schema_version
+
     def tbl_name(self) -> str:
         """Return the name of the table/view that this path represents"""
         self.refresh_cached_md()
@@ -103,10 +110,7 @@ class TableVersionPath:
 
     def is_snapshot(self) -> bool:
         """Return True if this is a path of snapshot versions"""
-        self.refresh_cached_md()
-        if not self._cached_tbl_version.is_snapshot:
-            return False
-        return self.base.is_snapshot() if self.base is not None else True
+        return self.tbl_version.is_snapshot
 
     def is_view(self) -> bool:
         self.refresh_cached_md()
@@ -116,10 +120,30 @@ class TableVersionPath:
         self.refresh_cached_md()
         return self._cached_tbl_version.is_component_view
 
+    def is_replica(self) -> bool:
+        self.refresh_cached_md()
+        return self._cached_tbl_version.is_replica
+
+    def is_mutable(self) -> bool:
+        self.refresh_cached_md()
+        return self._cached_tbl_version.is_mutable
+
     def is_insertable(self) -> bool:
         self.refresh_cached_md()
         return self._cached_tbl_version.is_insertable
 
+    def comment(self) -> str:
+        self.refresh_cached_md()
+        return self._cached_tbl_version.comment
+
+    def num_retained_versions(self) -> int:
+        self.refresh_cached_md()
+        return self._cached_tbl_version.num_retained_versions
+
+    def media_validation(self) -> MediaValidation:
+        self.refresh_cached_md()
+        return self._cached_tbl_version.media_validation
+
     def get_tbl_versions(self) -> list[TableVersionHandle]:
         """Return all tbl versions"""
         if self.base is None:

pixeltable/catalog/view.py

@@ -41,6 +41,8 @@ class View(Table):
     def __init__(self, id: UUID, dir_id: UUID, name: str, tbl_version_path: TableVersionPath, snapshot_only: bool):
         super().__init__(id, dir_id, name, tbl_version_path)
         self._snapshot_only = snapshot_only
+        if not snapshot_only:
+            self._tbl_version = tbl_version_path.tbl_version
 
     @classmethod
     def _display_name(cls) -> str:
@@ -267,17 +269,8 @@ class View(Table):
             base=cls._get_snapshot_path(tbl_version_path.base) if tbl_version_path.base is not None else None,
         )
 
-    def _drop(self) -> None:
-        if self._snapshot_only:
-            # there is not TableVersion to drop
-            self._check_is_dropped()
-            self.is_dropped = True
-            catalog.Catalog.get().delete_tbl_md(self._id)
-        else:
-            super()._drop()
-
-    def get_metadata(self) -> dict[str, Any]:
-        md = super().get_metadata()
+    def _get_metadata(self) -> dict[str, Any]:
+        md = super()._get_metadata()
         md['is_view'] = True
         md['is_snapshot'] = self._tbl_version_path.is_snapshot()
         return md
@@ -298,11 +291,10 @@ class View(Table):
     def delete(self, where: Optional[exprs.Expr] = None) -> UpdateStatus:
         raise excs.Error(f'{self._display_name()} {self._name!r}: cannot delete from view')
 
-    @property
-    def _base_table(self) -> Optional['Table']:
+    def _get_base_table(self) -> Optional['Table']:
         # if this is a pure snapshot, our tbl_version_path only reflects the base (there is no TableVersion instance
         # for the snapshot itself)
-        base_id = self._tbl_version.id if self._snapshot_only else self._tbl_version_path.base.tbl_version.id
+        base_id = self._tbl_version_path.tbl_id if self._snapshot_only else self._tbl_version_path.base.tbl_id
         return catalog.Catalog.get().get_table_by_id(base_id)
 
     @property
@@ -317,7 +309,7 @@ class View(Table):
         display_name = 'Snapshot' if self._snapshot_only else 'View'
         result = [f'{display_name} {self._path()!r}']
         bases_descrs: list[str] = []
-        for base, effective_version in zip(self._base_tables, self._effective_base_versions):
+        for base, effective_version in zip(self._get_base_tables(), self._effective_base_versions):
             if effective_version is None:
                 bases_descrs.append(f'{base._path()!r}')
             else:
@@ -325,8 +317,8 @@ class View(Table):
                 bases_descrs.append(f'{base_descr!r}')
         result.append(f' (of {", ".join(bases_descrs)})')
 
-        if self._tbl_version.get().predicate is not None:
-            result.append(f'\nWhere: {self._tbl_version.get().predicate!s}')
-        if self._tbl_version.get().sample_clause is not None:
+        if self._tbl_version_path.tbl_version.get().predicate is not None:
+            result.append(f'\nWhere: {self._tbl_version_path.tbl_version.get().predicate!s}')
+        if self._tbl_version_path.tbl_version.get().sample_clause is not None:
             result.append(f'\nSample: {self._tbl_version.get().sample_clause!s}')
         return ''.join(result)

pixeltable/config.py

@@ -86,6 +86,10 @@ class Config:
             return None
 
         try:
+            if expected_type is bool and isinstance(value, str):
+                if value.lower() not in ('true', 'false'):
+                    raise excs.Error(f'Invalid value for configuration parameter {section}.{key}: {value}')
+                return value.lower() == 'true'  # type: ignore[return-value]
             return expected_type(value)  # type: ignore[call-arg]
         except ValueError as exc:
             raise excs.Error(f'Invalid value for configuration parameter {section}.{key}: {value}') from exc

pixeltable/dataframe.py

@@ -475,7 +475,9 @@ class DataFrame:
         raise excs.Error(msg) from e
 
     def _output_row_iterator(self) -> Iterator[list]:
-        with Catalog.get().begin_xact(for_write=False):
+        # TODO: extend begin_xact() to accept multiple TVPs for joins
+        single_tbl = self._first_tbl if len(self._from_clause.tbls) == 1 else None
+        with Catalog.get().begin_xact(tbl=single_tbl, for_write=False):
             try:
                 for data_row in self._exec():
                     yield [data_row[e.slot_idx] for e in self._select_list_exprs]
@@ -507,7 +509,7 @@ class DataFrame:
 
         from pixeltable.plan import Planner
 
-        with Catalog.get().begin_xact(for_write=False) as conn:
+        with Catalog.get().begin_xact(tbl=self._first_tbl, for_write=False) as conn:
             stmt = Planner.create_count_stmt(self._first_tbl, self.where_clause)
             result: int = conn.execute(stmt).scalar_one()
             assert isinstance(result, int)
@@ -903,7 +905,7 @@ class DataFrame:
                 grouping_tbl = item if isinstance(item, catalog.TableVersion) else item._tbl_version.get()
                 # we need to make sure that the grouping table is a base of self.tbl
                 base = self._first_tbl.find_tbl_version(grouping_tbl.id)
-                if base is None or base.id == self._first_tbl.tbl_id():
+                if base is None or base.id == self._first_tbl.tbl_id:
                     raise excs.Error(
                         f'group_by(): {grouping_tbl.name} is not a base table of {self._first_tbl.tbl_name()}'
                     )
@@ -1161,8 +1163,7 @@ class DataFrame:
             >>> df = person.where(t.year == 2014).update({'age': 30})
         """
         self._validate_mutable('update', False)
-        tbl_id = self._first_tbl.tbl_id()
-        with Catalog.get().begin_xact(tbl_id=tbl_id, for_write=True):
+        with Catalog.get().begin_xact(tbl=self._first_tbl, for_write=True, lock_mutable_tree=True):
             return self._first_tbl.tbl_version.get().update(value_spec, where=self.where_clause, cascade=cascade)
 
     def delete(self) -> UpdateStatus:
@@ -1185,8 +1186,7 @@ class DataFrame:
         self._validate_mutable('delete', False)
         if not self._first_tbl.is_insertable():
             raise excs.Error('Cannot delete from view')
-        tbl_id = self._first_tbl.tbl_id()
-        with Catalog.get().begin_xact(tbl_id=tbl_id, for_write=True):
+        with Catalog.get().begin_xact(tbl=self._first_tbl, for_write=True, lock_mutable_tree=True):
             return self._first_tbl.tbl_version.get().delete(where=self.where_clause)
 
     def _validate_mutable(self, op_name: str, allow_select: bool) -> None:
@@ -1307,7 +1307,8 @@ class DataFrame:
             assert data_file_path.is_file()
             return data_file_path
         else:
-            with Catalog.get().begin_xact(for_write=False):
+            # TODO: extend begin_xact() to accept multiple TVPs for joins
+            with Catalog.get().begin_xact(tbl=self._first_tbl, for_write=False):
                 return write_coco_dataset(self, dest_path)
 
     def to_pytorch_dataset(self, image_format: str = 'pt') -> 'torch.utils.data.IterableDataset':
@@ -1352,7 +1353,7 @@ class DataFrame:
         if dest_path.exists():  # fast path: use cache
             assert dest_path.is_dir()
         else:
-            with Catalog.get().begin_xact(for_write=False):
+            with Catalog.get().begin_xact(tbl=self._first_tbl, for_write=False):
                 export_parquet(self, dest_path, inline_images=True)
 
         return PixeltablePytorchDataset(path=dest_path, image_format=image_format)

pixeltable/env.py

@@ -10,7 +10,6 @@ import logging
 import os
 import platform
 import shutil
-import subprocess
 import sys
 import threading
 import uuid
@@ -611,9 +610,11 @@ class Env:
         self.__register_package('fiftyone')
         self.__register_package('fireworks', library_name='fireworks-ai')
         self.__register_package('google.genai', library_name='google-genai')
+        self.__register_package('groq')
         self.__register_package('huggingface_hub', library_name='huggingface-hub')
         self.__register_package('label_studio_sdk', library_name='label-studio-sdk')
         self.__register_package('llama_cpp', library_name='llama-cpp-python')
+        self.__register_package('mcp')
         self.__register_package('mistralai')
         self.__register_package('mistune')
         self.__register_package('ollama')
@@ -746,18 +747,11 @@ class Env:
         have no sub-dependencies (in fact, this is how spaCy normally manages its model resources).
         """
         import spacy
-        from spacy.cli.download import get_model_filename
+        from spacy.cli.download import download
 
         spacy_model = 'en_core_web_sm'
-        spacy_model_version = '3.7.1'
-        filename = get_model_filename(spacy_model, spacy_model_version, sdist=False)
-        url = f'{spacy.about.__download_url__}/{filename}'
-        # Try to `pip install` the model. We set check=False; if the pip command fails, it's not necessarily
-        # a problem, because the model might have been installed on a previous attempt.
-        self._logger.info(f'Ensuring spaCy model is installed: {filename}')
-        ret = subprocess.run([sys.executable, '-m', 'pip', 'install', '-qU', url], check=False)
-        if ret.returncode != 0:
-            self._logger.warning(f'pip install failed for spaCy model: {filename}')
+        self._logger.info(f'Ensuring spaCy model is installed: {spacy_model}')
+        download(spacy_model)
         self._logger.info(f'Loading spaCy model: {spacy_model}')
         try:
             self._spacy_nlp = spacy.load(spacy_model)

pixeltable/exceptions.py

@@ -10,6 +10,12 @@ class Error(Exception):
 
 
 class ExprEvalError(Exception):
+    """
+    Used during query execution to signal expr evaluation failures.
+
+    NOT A USER-FACING EXCEPTION. All ExprEvalError instances need to be converted into Error instances.
+    """
+
     expr: 'exprs.Expr'
     expr_msg: str
     exc: Exception

pixeltable/exec/exec_node.py

@@ -73,6 +73,8 @@ class ExecNode(abc.ABC):
         except RuntimeError:
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
+            # we set a deliberately long duration to avoid warnings getting printed to the console in debug mode
+            loop.slow_callback_duration = 3600
 
         if _logger.isEnabledFor(logging.DEBUG):
             loop.set_debug(True)

pixeltable/exec/expr_eval/expr_eval_node.py

@@ -49,7 +49,7 @@ class ExprEvalNode(ExecNode):
     # execution state
     tasks: set[asyncio.Task]  # collects all running tasks to prevent them from getting gc'd
     exc_event: asyncio.Event  # set if an exception needs to be propagated
-    error: Optional[Union[excs.Error, excs.ExprEvalError]]  # exception that needs to be propagated
+    error: Optional[Union[Exception]]  # exception that needs to be propagated
     completed_rows: asyncio.Queue[exprs.DataRow]  # rows that have completed evaluation
     completed_event: asyncio.Event  # set when completed_rows is non-empty
     input_iter: AsyncIterator[DataRowBatch]
@@ -133,10 +133,10 @@ class ExprEvalNode(ExecNode):
         except StopAsyncIteration:
             self.input_complete = True
             _logger.debug(f'finished input: #input_rows={self.num_input_rows}, #avail={self.avail_input_rows}')
-        except excs.Error as err:
-            self.error = err
+        # make sure to pass DBAPIError through, so the transaction handling logic sees it
+        except Exception as exc:
+            self.error = exc
             self.exc_event.set()
-        # TODO: should we also handle Exception here and create an excs.Error from it?
 
     @property
     def total_buffered(self) -> int:

pixeltable/exec/sql_node.py

@@ -308,8 +308,7 @@ class SqlNode(ExecNode):
                 _logger.debug(f'SqlLookupNode stmt:\n{stmt_str}')
             except Exception:
                 # log something if we can't log the compiled stmt
-                stmt_str = repr(stmt)
-                _logger.debug(f'SqlLookupNode proto-stmt:\n{stmt_str}')
+                _logger.debug(f'SqlLookupNode proto-stmt:\n{stmt}')
             self._log_explain(stmt)
 
             conn = Env.get().conn
@@ -530,40 +529,39 @@ class SqlJoinNode(SqlNode):
 
 class SqlSampleNode(SqlNode):
     """
-    Returns rows from a stratified sample with N samples per strata.
+    Returns rows sampled from the input node.
     """
 
-    stratify_exprs: Optional[list[exprs.Expr]]
-    n_samples: Optional[int]
-    fraction_samples: Optional[float]
-    seed: int
     input_cte: Optional[sql.CTE]
     pk_count: int
+    stratify_exprs: Optional[list[exprs.Expr]]
+    sample_clause: 'SampleClause'
 
     def __init__(
         self,
         row_builder: exprs.RowBuilder,
         input: SqlNode,
         select_list: Iterable[exprs.Expr],
-        stratify_exprs: Optional[list[exprs.Expr]] = None,
-        sample_clause: Optional['SampleClause'] = None,
+        sample_clause: 'SampleClause',
+        stratify_exprs: list[exprs.Expr],
     ):
         """
         Args:
+            input: SqlNode to sample from
             select_list: can contain calls to AggregateFunctions
-            stratify_exprs: list of expressions to group by
-            n: number of samples per strata
+            sample_clause: specifies the sampling method
+            stratify_exprs: Analyzer processed list of expressions to stratify by.
         """
+        assert isinstance(input, SqlNode)
         self.input_cte, input_col_map = input.to_cte(keep_pk=True)
         self.pk_count = input.num_pk_cols
         assert self.pk_count > 1
         sql_elements = exprs.SqlElementCache(input_col_map)
+        assert sql_elements.contains_all(stratify_exprs)
         super().__init__(input.tbl, row_builder, select_list, sql_elements, set_pk=True)
         self.stratify_exprs = stratify_exprs
-        self.n_samples = sample_clause.n
-        self.n_per_stratum = sample_clause.n_per_stratum
-        self.fraction_samples = sample_clause.fraction
-        self.seed = sample_clause.seed if sample_clause.seed is not None else 0
+        self.sample_clause = sample_clause
+        assert isinstance(self.sample_clause.seed, int)
 
     @classmethod
     def key_sql_expr(cls, seed: sql.ColumnElement, sql_cols: Iterable[sql.ColumnElement]) -> sql.ColumnElement:
@@ -573,25 +571,44 @@ class SqlSampleNode(SqlNode):
         """
         sql_expr: sql.ColumnElement = sql.cast(seed, sql.Text)
         for e in sql_cols:
-            sql_expr = sql_expr + sql.literal_column("'___'") + sql.cast(e, sql.Text)
+            # Quotes are required below to guarantee that the string is properly presented in SQL
+            sql_expr = sql_expr + sql.literal_column("'___'", sql.Text) + sql.cast(e, sql.Text)
         sql_expr = sql.func.md5(sql_expr)
         return sql_expr
 
-    def _create_order_by(self, cte: sql.CTE) -> sql.ColumnElement:
+    def _create_key_sql(self, cte: sql.CTE) -> sql.ColumnElement:
         """Create an expression for randomly ordering rows with a given seed"""
         rowid_cols = [*cte.c[-self.pk_count : -1]]  # exclude the version column
         assert len(rowid_cols) > 0
-        return self.key_sql_expr(sql.literal_column(str(self.seed)), rowid_cols)
+        return self.key_sql_expr(sql.literal_column(str(self.sample_clause.seed)), rowid_cols)
 
     def _create_stmt(self) -> sql.Select:
-        if self.fraction_samples is not None:
-            return self._create_stmt_fraction(self.fraction_samples)
-        return self._create_stmt_n(self.n_samples, self.n_per_stratum)
+        from pixeltable.plan import SampleClause
+
+        if self.sample_clause.fraction is not None:
+            if len(self.stratify_exprs) == 0:
+                # If non-stratified sampling, construct a where clause, order_by, and limit clauses
+                s_key = self._create_key_sql(self.input_cte)
+
+                # Construct a suitable where clause
+                fraction_sql = sql.cast(SampleClause.fraction_to_md5_hex(float(self.sample_clause.fraction)), sql.Text)
+                order_by = self._create_key_sql(self.input_cte)
+                return sql.select(*self.input_cte.c).where(s_key < fraction_sql).order_by(order_by)
+
+            return self._create_stmt_stratified_fraction(self.sample_clause.fraction)
+        else:
+            if len(self.stratify_exprs) == 0:
+                # No stratification, just return n samples from the input CTE
+                order_by = self._create_key_sql(self.input_cte)
+                return sql.select(*self.input_cte.c).order_by(order_by).limit(self.sample_clause.n)
+
+            return self._create_stmt_stratified_n(self.sample_clause.n, self.sample_clause.n_per_stratum)
+
+    def _create_stmt_stratified_n(self, n: Optional[int], n_per_stratum: Optional[int]) -> sql.Select:
+        """Create a Select stmt that returns n samples across all strata or n_per_stratum samples per stratum"""
 
-    def _create_stmt_n(self, n: Optional[int], n_per_stratum: Optional[int]) -> sql.Select:
-        """Create a Select stmt that returns n samples across all strata"""
         sql_strata_exprs = [self.sql_elements.get(e) for e in self.stratify_exprs]
-        order_by = self._create_order_by(self.input_cte)
+        order_by = self._create_key_sql(self.input_cte)
 
         # Create a list of all columns plus the rank
         # Get all columns from the input CTE dynamically
@@ -605,15 +622,15 @@ class SqlSampleNode(SqlNode):
         if n_per_stratum is not None:
             return sql.select(*final_columns).filter(row_rank_cte.c.rank <= n_per_stratum)
         else:
-            secondary_order = self._create_order_by(row_rank_cte)
+            secondary_order = self._create_key_sql(row_rank_cte)
             return sql.select(*final_columns).order_by(row_rank_cte.c.rank, secondary_order).limit(n)
 
-    def _create_stmt_fraction(self, fraction_samples: float) -> sql.Select:
+    def _create_stmt_stratified_fraction(self, fraction_samples: float) -> sql.Select:
         """Create a Select stmt that returns a fraction of the rows per strata"""
 
         # Build the strata count CTE
         # Produces a table of the form:
-        #   ([stratify_exprs], s_s_size)
+        #   (*stratify_exprs, s_s_size)
         # where s_s_size is the number of samples to take from each stratum
         sql_strata_exprs = [self.sql_elements.get(e) for e in self.stratify_exprs]
         per_strata_count_cte = (
@@ -628,19 +645,19 @@ class SqlSampleNode(SqlNode):
 
         # Build a CTE that ranks the rows within each stratum
         # Include all columns from the input CTE dynamically
-        order_by = self._create_order_by(self.input_cte)
+        order_by = self._create_key_sql(self.input_cte)
         select_columns = [*self.input_cte.c]
         select_columns.append(
             sql.func.row_number().over(partition_by=sql_strata_exprs, order_by=order_by).label('rank')
         )
         row_rank_cte = sql.select(*select_columns).select_from(self.input_cte).cte('row_rank_cte')
 
-        # Build the join criterion dynamically to accommodate any number of group by columns
+        # Build the join criterion dynamically to accommodate any number of stratify_by expressions
         join_c = sql.true()
         for col in per_strata_count_cte.c[:-1]:
             join_c &= row_rank_cte.c[col.name].isnot_distinct_from(col)
 
-        # Join srcp with per_strata_count_cte to limit returns to the requested fraction of rows
+        # Join with per_strata_count_cte to limit returns to the requested fraction of rows
         final_columns = [*row_rank_cte.c[:-1]]  # exclude the rank column
         stmt = (
             sql.select(*final_columns)