pixeltable 0.2.26__py3-none-any.whl → 0.5.7__py3-none-any.whl

pixeltable/utils/azure_store.py

@@ -0,0 +1,346 @@
+import datetime
+import logging
+import re
+import threading
+import uuid
+from datetime import timezone
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterator
+from urllib.parse import quote
+
+from azure.core.exceptions import AzureError
+from azure.storage.blob import BlobSasPermissions, generate_blob_sas
+
+from pixeltable import env, exceptions as excs
+from pixeltable.config import Config
+from pixeltable.utils.object_stores import ObjectPath, ObjectStoreBase, StorageObjectAddress
+
+if TYPE_CHECKING:
+    from azure.storage.blob import BlobProperties, BlobServiceClient
+
+    from pixeltable.catalog import Column
+
+
+_logger = logging.getLogger('pixeltable')
+
+
+client_lock = threading.Lock()
+
+
+@env.register_client('azure_blob')
+def _() -> dict[str, 'BlobServiceClient']:
+    return {}
+
+
+class AzureBlobStore(ObjectStoreBase):
+    """Class to handle Azure Blob Storage operations."""
+
+    # TODO: This needs to be redesigned to use asyncio.
+
+    # URI of the Azure Blob Storage container
+    # Always ends with a slash
+    __base_uri: str
+
+    # Storage account name
+    __account_name: str
+
+    # Container name extracted from the URI
+    __container_name: str
+
+    # Prefix path within the container, either empty or ending with a slash
+    __prefix_name: str
+
+    # URI scheme (wasb, wasbs, abfs, abfss, https)
+    __scheme: str
+
+    soa: StorageObjectAddress
+
+    def __init__(self, soa: StorageObjectAddress):
+        self.soa = soa
+        self.__scheme = soa.scheme
+        self.__account_name = soa.account
+        self.__container_name = soa.container
+        self.__prefix_name = soa.prefix
+
+        # Reconstruct base URI in normalized format
+        self.__base_uri = self.soa.prefix_free_uri + self.__prefix_name
+        _logger.info(
+            f'Initialized AzureBlobStore with base URI: {self.__base_uri}, '
+            f'account: {self.__account_name}, container: {self.__container_name}, prefix: {self.__prefix_name}'
+        )
+
+    def client(self) -> 'BlobServiceClient':
+        """Return the Azure Blob Storage client."""
+        client_dict: dict[str, 'BlobServiceClient'] = env.Env.get().get_client('azure_blob')
+        with client_lock:
+            uri = self.soa.container_free_uri
+            if uri not in client_dict:
+                storage_account_name = Config.get().get_string_value('storage_account_name', section='azure')
+                storage_account_key = Config.get().get_string_value('storage_account_key', section='azure')
+                if (storage_account_name is None) != (storage_account_key is None):
+                    raise excs.Error(
+                        "Azure 'storage_account_name' and 'storage_account_key' must be specified together."
+                    )
+                if storage_account_name is None or storage_account_name != self.__account_name:
+                    # Attempt a connection to a public resource, with no account key
+                    client_dict[uri] = self.create_client(endpoint_url=uri)
+                else:
+                    client_dict[uri] = self.create_client(
+                        endpoint_url=uri, account_name=self.__account_name, account_key=storage_account_key
+                    )
+            return client_dict[uri]
+
+    @property
+    def account_name(self) -> str:
+        """Return the storage account name."""
+        return self.__account_name
+
+    @property
+    def container_name(self) -> str:
+        """Return the container name from the base URI."""
+        return self.__container_name
+
+    @property
+    def prefix(self) -> str:
+        """Return the prefix from the base URI."""
+        return self.__prefix_name
+
+    def validate(self, error_col_name: str) -> str | None:
+        """
+        Checks if the URI exists and is accessible.
+
+        Returns:
+            str: The base URI if the container exists and is accessible, None otherwise.
+        """
+        try:
+            container_client = self.client().get_container_client(self.container_name)
+            # Check if container exists by trying to get its properties
+            container_client.get_container_properties()
+            return self.__base_uri
+        except AzureError as e:
+            self.handle_azure_error(e, self.container_name, f'validate container {error_col_name}')
+        return None
+
+    def copy_object_to_local_file(self, src_path: str, dest_path: Path) -> None:
+        """Copies a blob to a local file. Thread safe."""
+        try:
+            blob_client = self.client().get_blob_client(container=self.container_name, blob=self.prefix + src_path)
+            with open(dest_path, 'wb') as download_file:
+                download_stream = blob_client.download_blob()
+                download_file.write(download_stream.readall())
+        except AzureError as e:
+            self.handle_azure_error(e, self.container_name, f'download file {src_path}')
+            raise
+
+    # TODO: utils package should not include back-references to `Column`
+    def copy_local_file(self, col: 'Column', src_path: Path) -> str:
+        """Copy a local file to Azure Blob Storage, and return its new URL"""
+        prefix, filename = ObjectPath.create_prefix_raw(
+            col.get_tbl().id, col.id, col.get_tbl().version, ext=src_path.suffix
+        )
+        blob_name = f'{self.prefix}{prefix}/{filename}'
+        new_file_uri = f'{self.__base_uri}{prefix}/{filename}'
+
+        try:
+            blob_client = self.client().get_blob_client(container=self.container_name, blob=blob_name)
+            with open(src_path, 'rb') as data:
+                blob_client.upload_blob(data, overwrite=True)
+            _logger.debug(f'Media Storage: copied {src_path} to {new_file_uri}')
+            return new_file_uri
+        except AzureError as e:
+            self.handle_azure_error(e, self.container_name, f'upload file {src_path}')
+            raise
+
+    def _get_filtered_blobs(
+        self, tbl_id: uuid.UUID | None, tbl_version: int | None = None
+    ) -> Iterator['BlobProperties']:
+        """Private method to get filtered blobs for a table, optionally filtered by version.
+
+        Args:
+            tbl_id: Table UUID to filter by
+            tbl_version: Optional table version to filter by
+
+        Returns:
+            Iterator over blob objects matching the criteria
+        """
+        # Use ObjectPath to construct the prefix for this table
+        if tbl_id is None:
+            prefix = self.prefix
+            assert tbl_version is None, 'tbl_version must be None if tbl_id is None'
+        else:
+            table_prefix = ObjectPath.table_prefix(tbl_id)
+            prefix = f'{self.prefix}{table_prefix}/'
+
+        try:
+            container_client = self.client().get_container_client(self.container_name)
+
+            blob_iterator: Iterator['BlobProperties']
+            if tbl_version is None:
+                # Return all blobs with the table prefix
+                blob_iterator = container_client.list_blobs(name_starts_with=prefix)
+            else:
+                # Filter by both table_id and table_version using the ObjectPath pattern
+                # Pattern: tbl_id_col_id_version_uuid
+                version_pattern = re.compile(
+                    rf'{re.escape(table_prefix)}_\d+_{re.escape(str(tbl_version))}_[0-9a-fA-F]+.*'
+                )
+                # Get all blobs with the prefix and filter by version pattern
+                all_blobs = container_client.list_blobs(name_starts_with=prefix)
+                blob_iterator = (blob for blob in all_blobs if version_pattern.match(blob.name.split('/')[-1]))
+
+            return blob_iterator
+
+        except AzureError as e:
+            self.handle_azure_error(e, self.container_name, f'setup iterator {self.prefix}')
+            raise
+
+    def count(self, tbl_id: uuid.UUID | None, tbl_version: int | None = None) -> int:
+        """Count the number of files belonging to tbl_id. If tbl_version is not None,
+        count only those files belonging to the specified tbl_version.
+
+        Args:
+            tbl_id: Table UUID to count blobs for
+            tbl_version: Optional table version to filter by
+
+        Returns:
+            Number of blobs matching the criteria
+        """
+        blob_iterator = self._get_filtered_blobs(tbl_id, tbl_version)
+        return sum(1 for _ in blob_iterator)
+
+    def delete(self, tbl_id: uuid.UUID, tbl_version: int | None = None) -> int:
+        """Delete all files belonging to tbl_id. If tbl_version is not None, delete
+        only those files belonging to the specified tbl_version.
+
+        Args:
+            tbl_id: Table UUID to delete blobs for
+            tbl_version: Optional table version to filter by
+
+        Returns:
+            Number of blobs deleted
+        """
+        assert tbl_id is not None
+        blob_iterator = self._get_filtered_blobs(tbl_id, tbl_version)
+        total_deleted = 0
+
+        try:
+            container_client = self.client().get_container_client(self.container_name)
+
+            for blob in blob_iterator:
+                # TODO: Figure out now to properly use batch method delete_blobs(), it doesn't seem to work properly
+                container_client.delete_blob(blob.name)
+                total_deleted += 1
+
+            # print(f"Deleted {total_deleted} blobs from container '{self.container_name}'.")
+            return total_deleted
+
+        except AzureError as e:
+            self.handle_azure_error(e, self.container_name, f'deleting with {self.prefix}')
+            raise
+
+    def list_objects(self, return_uri: bool, n_max: int = 10) -> list[str]:
+        """Return a list of objects found in the specified destination bucket.
+        Each returned object includes the full set of prefixes.
+        if return_uri is True, full URI's are returned; otherwise, just the object keys.
+        """
+        p = self.soa.prefix_free_uri if return_uri else ''
+        r: list[str] = []
+        try:
+            blob_iterator = self._get_filtered_blobs(tbl_id=None, tbl_version=None)
+            for blob in blob_iterator:
+                r.append(f'{p}{blob.name}')
+                if len(r) >= n_max:
+                    return r
+
+        except AzureError as e:
+            self.handle_azure_error(e, self.__container_name, f'list objects from {self.__base_uri}')
+        return r
+
+    @classmethod
+    def handle_azure_error(
+        cls, e: 'AzureError', container_name: str, operation: str = '', *, ignore_404: bool = False
+    ) -> None:
+        from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceNotFoundError
+
+        if ignore_404 and isinstance(e, ResourceNotFoundError):
+            return
+
+        if isinstance(e, ResourceNotFoundError):
+            raise excs.Error(f'Container {container_name} or blob not found during {operation}: {str(e)!r}')
+        elif isinstance(e, ClientAuthenticationError):
+            raise excs.Error(f'Authentication failed for container {container_name} during {operation}: {str(e)!r}')
+        elif isinstance(e, HttpResponseError):
+            if e.status_code == 403:
+                raise excs.Error(f'Access denied to container {container_name} during {operation}: {str(e)!r}')
+            elif e.status_code == 412:
+                raise excs.Error(f'Precondition failed for container {container_name} during {operation}: {str(e)!r}')
+            else:
+                raise excs.Error(
+                    f'HTTP error during {operation} in container {container_name}: {e.status_code} - {str(e)!r}'
+                )
+        else:
+            raise excs.Error(f'Error during {operation} in container {container_name}: {str(e)!r}')
+
+    def create_presigned_url(self, soa: StorageObjectAddress, expiration_seconds: int) -> str:
+        """Create a presigned URL for downloading an object from Azure Blob Storage."""
+        if not soa.has_object:
+            raise excs.Error(f'StorageObjectAddress does not contain an object name: {soa}')
+
+        azure_client = self.client()
+        account_name = azure_client.account_name if azure_client.account_name else self.__account_name
+
+        # Account key cannot be extracted from client for security reasons, get from config
+        storage_account_key = Config.get().get_string_value('storage_account_key', section='azure')
+
+        if not account_name or not storage_account_key:
+            raise excs.Error(
+                'Azure storage_account_name and storage_account_key must be configured '
+                'to generate presigned URLs. Set them in the config under the [azure] section, '
+                'or include the account name in the Azure URL.'
+            )
+
+        # Use datetime.now(timezone.utc) + timedelta like in pixeltable cloud
+        expiry_time = datetime.datetime.now(timezone.utc) + datetime.timedelta(seconds=expiration_seconds)
+
+        sas_token = generate_blob_sas(
+            account_name=account_name,
+            container_name=soa.container,
+            blob_name=soa.key,
+            account_key=storage_account_key,
+            permission=BlobSasPermissions(read=True),
+            expiry=expiry_time,
+            version='2022-11-02',  # Specify API version to avoid version mismatch issues
+        )
+
+        # Build URL directly - URL encode the blob key to handle special characters
+        # Use safe='/' to preserve path separators in the blob key
+        encoded_key = quote(soa.key, safe='/')
+        blob_url = f'https://{account_name}.blob.core.windows.net/{soa.container}/{encoded_key}?{sas_token}'
+        return blob_url
+
+    @classmethod
+    def create_client(
+        cls, endpoint_url: str, account_name: str | None = None, account_key: str | None = None
+    ) -> 'BlobServiceClient':
+        from azure.core.credentials import AzureNamedKeyCredential
+        from azure.storage.blob import BlobServiceClient  # TODO: Use azure.storage.blob.aio instead
+
+        assert (account_name is None) == (account_key is None)
+        try:
+            #  e.g. endpoint_url: str = f'https://{account_name}.blob.core.windows.net'
+            assert endpoint_url is not None, 'No Azure Storage account information provided'
+
+            # Use empty SAS token for anonymous authentication
+            credential = None
+            if account_name is not None:
+                credential = AzureNamedKeyCredential(name=account_name, key=account_key)
+            return BlobServiceClient(
+                account_url=endpoint_url,
+                credential=credential,
+                max_single_get_size=(32 * 2**20),
+                max_chunk_get_size=(4 * 2**20),
+                connection_timeout=15,
+                read_timeout=30,
+            )
+        except Exception as e:
+            raise excs.Error(f'Failed to create Azure Blob Storage client: {str(e)!r}') from e

pixeltable/utils/coco.py

@@ -22,6 +22,7 @@ Required format:
 }
 """
 
+
 def _verify_input_dict(input_dict: dict[str, Any]) -> None:
     """Verify that input_dict is a valid input dict for write_coco_dataset()"""
     if not isinstance(input_dict, dict):
@@ -30,7 +31,7 @@ def _verify_input_dict(input_dict: dict[str, Any]) -> None:
         raise excs.Error(f'Missing key "image" in input dict: {input_dict}{format_msg}')
     if not isinstance(input_dict['image'], PIL.Image.Image):
         raise excs.Error(f'Value for "image" is not a PIL.Image.Image: {input_dict}{format_msg}')
-    if  'annotations' not in input_dict:
+    if 'annotations' not in input_dict:
         raise excs.Error(f'Missing key "annotations" in input dict: {input_dict}{format_msg}')
     if not isinstance(input_dict['annotations'], list):
         raise excs.Error(f'Value for "annotations" is not a list: {input_dict}{format_msg}')
@@ -48,11 +49,12 @@ def _verify_input_dict(input_dict: dict[str, Any]) -> None:
         if not isinstance(annotation['category'], (str, int)):
             raise excs.Error(f'Value for "category" is not a str or int: {annotation}{format_msg}')
 
-def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
-    """Export a DataFrame result set as a COCO dataset in dest_path and return the path of the data.json file."""
+
+def write_coco_dataset(query: pxt.Query, dest_path: Path) -> Path:
+    """Export a ResultSet as a COCO dataset in dest_path and return the path of the data.json file."""
     # TODO: validate schema
-    if len(df._select_list_exprs) != 1 or not df._select_list_exprs[0].col_type.is_json_type():
-        raise excs.Error(f'Expected exactly one json-typed column in select list: {df._select_list_exprs}')
+    if len(query._select_list_exprs) != 1 or not query._select_list_exprs[0].col_type.is_json_type():
+        raise excs.Error(f'Expected exactly one json-typed column in select list: {query._select_list_exprs}')
     input_dict_slot_idx = -1  # df._select_list_exprs[0].slot_idx isn't valid until _exec()
 
     # create output dir
@@ -66,9 +68,9 @@ def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
     annotations: list[dict[str, Any]] = []
     ann_id = -1
     categories: set[Any] = set()
-    for input_row in df._exec():
+    for input_row in query._exec():
         if input_dict_slot_idx == -1:
-            input_dict_expr = df._select_list_exprs[0]
+            input_dict_expr = query._select_list_exprs[0]
             input_dict_slot_idx = input_dict_expr.slot_idx
             input_dict = input_row[input_dict_slot_idx]
             _verify_input_dict(input_dict)
@@ -96,31 +98,28 @@ def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
             img_path = images_dir / f'{img_id}.jpg'
             img.save(img_path)
 
-        images.append({
-            'id': img_id,
-            'file_name': str(img_path),
-            'width': img.width,
-            'height': img.height,
-        })
+        images.append({'id': img_id, 'file_name': str(img_path), 'width': img.width, 'height': img.height})
 
         # create annotation records for this image
         for annotation in input_dict['annotations']:
             ann_id += 1
-            x, y, w, h = annotation['bbox']
+            _, _, w, h = annotation['bbox']
             category = annotation['category']
             categories.add(category)
-            annotations.append({
-                'id': ann_id,
-                'image_id': img_id,
-                # we use the category name here and fix it up at the end, when we have assigned category ids
-                'category_id': category,
-                'bbox': annotation['bbox'],
-                'area': w * h,
-                'iscrowd': 0,
-            })
+            annotations.append(
+                {
+                    'id': ann_id,
+                    'image_id': img_id,
+                    # we use the category name here and fix it up at the end, when we have assigned category ids
+                    'category_id': category,
+                    'bbox': annotation['bbox'],
+                    'area': w * h,
+                    'iscrowd': 0,
+                }
+            )
 
     # replace category names with ids
-    category_ids = {category: id for id, category in enumerate(sorted(list(categories)))}
+    category_ids = {category: id for id, category in enumerate(sorted(categories))}
     for annotation in annotations:
         annotation['category_id'] = category_ids[annotation['category_id']]
 
@@ -130,8 +129,8 @@ def write_coco_dataset(df: pxt.DataFrame, dest_path: Path) -> Path:
         'categories': [{'id': id, 'name': category} for category, id in category_ids.items()],
     }
     output_path = dest_path / 'data.json'
-    with open(output_path, 'w') as f:
-        json.dump(result, f)
+    with open(output_path, 'w', encoding='utf-8') as fp:
+        json.dump(result, fp)
     return output_path
 
 
@@ -226,5 +225,5 @@ COCO_2017_CATEGORIES = {
     87: 'scissors',
     88: 'teddy bear',
     89: 'hair drier',
-    90: 'toothbrush'
+    90: 'toothbrush',
 }

pixeltable/utils/code.py

@@ -1,12 +1,11 @@
 import types
-from typing import Optional
 
 from pixeltable.func import Function
 
-
 # Utilities related to the organization of the Pixeltable codebase.
 
-def local_public_names(mod_name: str, exclude: Optional[list[str]] = None) -> list[str]:
+
+def local_public_names(mod_name: str, exclude: list[str] | None = None) -> list[str]:
     """
     Returns a list of all functions and submodules that are local to the specified module and are
     publicly accessible. Intended to facilitate implementation of module __dir__() methods for
@@ -21,7 +20,8 @@ def local_public_names(mod_name: str, exclude: Optional[list[str]] = None) -> li
     for obj in mod.__dict__.values():
         if isinstance(obj, Function):
             # Pixeltable function
-            names.append(obj.name)
+            if not obj.name.startswith('_'):
+                names.append(obj.name)
         elif isinstance(obj, types.FunctionType):
             # Python function
             if obj.__module__ == mod.__name__ and not obj.__name__.startswith('_'):

pixeltable/utils/console_output.py

@@ -0,0 +1,46 @@
+import logging
+from typing import TextIO
+
+from pixeltable import exceptions as excs
+
+
+def map_level(verbosity: int) -> int:
+    """
+        Map verbosity level to logging level.
+        0 - minimum logging - warn and above
+        1 - default logging - info and above
+        2 - more logging - debug and above
+    Args:
+
+    Returns:
+        Logging level as integer
+    """
+    if verbosity == 0:
+        return logging.WARN
+    if verbosity == 1:
+        return logging.INFO
+    if verbosity == 2:
+        return logging.DEBUG
+
+    raise excs.Error(f'Invalid verbosity level: {verbosity}')
+
+
+class ConsoleOutputHandler(logging.StreamHandler):
+    def __init__(self, stream: TextIO):
+        super().__init__(stream)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        if record.msg.endswith('\n'):
+            self.stream.write(record.msg)
+        else:
+            self.stream.write(record.msg + '\n')
+
+
+class ConsoleMessageFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        return getattr(record, 'user_visible', False)
+
+
+class ConsoleLogger(logging.LoggerAdapter):
+    def __init__(self, logger: logging.Logger):
+        super().__init__(logger, extra={'user_visible': True})

pixeltable/utils/coroutine.py

@@ -0,0 +1,24 @@
+import asyncio
+import threading
+from typing import Any, Coroutine, TypeVar
+
+from pixeltable.env import Env
+
+T = TypeVar('T')
+
+# TODO This is a temporary hack to be able to run async UDFs in contexts that are not properly handled by the existing
+#   scheduler logic (e.g., as an embedding function as part of a similarity lookup). Once the scheduler is fully
+#   general, it can be removed.
+
+
+def run_coroutine_synchronously(coroutine: Coroutine[Any, Any, T], timeout: float = 30) -> T:
+    """
+    Runs the given coroutine synchronously, even if called in the context of a running event loop.
+    """
+    loop = Env.get().event_loop
+
+    if threading.current_thread() is threading.main_thread():
+        return loop.run_until_complete(coroutine)
+    else:
+        # Not in main thread, use run_coroutine_threadsafe
+        return asyncio.run_coroutine_threadsafe(coroutine, loop).result(timeout)

pixeltable/utils/dbms.py

@@ -0,0 +1,92 @@
+import abc
+
+import sqlalchemy as sql
+
+
+class Dbms(abc.ABC):
+    """
+    Provides abstractions for utilities to interact with a database system.
+    """
+
+    name: str
+    transaction_isolation_level: str
+    version_index_type: str
+    db_url: sql.URL
+
+    def __init__(self, name: str, transaction_isolation_level: str, version_index_type: str, db_url: sql.URL) -> None:
+        self.name = name
+        self.transaction_isolation_level = transaction_isolation_level
+        self.version_index_type = version_index_type
+        self.db_url = db_url
+
+    @abc.abstractmethod
+    def drop_db_stmt(self, database: str) -> str: ...
+
+    @abc.abstractmethod
+    def create_db_stmt(self, database: str) -> str: ...
+
+    @abc.abstractmethod
+    def default_system_db_url(self) -> str: ...
+
+    @abc.abstractmethod
+    def create_vector_index_stmt(
+        self, store_index_name: str, sa_value_col: sql.Column, metric: str
+    ) -> sql.Compiled: ...
+
+
+class PostgresqlDbms(Dbms):
+    """
+    Implements utilities to interact with Postgres database.
+    """
+
+    def __init__(self, db_url: sql.URL):
+        super().__init__('postgresql', 'SERIALIZABLE', 'brin', db_url)
+
+    def drop_db_stmt(self, database: str) -> str:
+        return f'DROP DATABASE {database}'
+
+    def create_db_stmt(self, database: str) -> str:
+        return f"CREATE DATABASE {database} ENCODING 'utf-8' LC_COLLATE 'C' LC_CTYPE 'C' TEMPLATE template0"
+
+    def default_system_db_url(self) -> str:
+        a = self.db_url.set(database='postgres').render_as_string(hide_password=False)
+        return a
+
+    def create_vector_index_stmt(self, store_index_name: str, sa_value_col: sql.Column, metric: str) -> sql.Compiled:
+        from sqlalchemy.dialects import postgresql
+
+        sa_idx = sql.Index(
+            store_index_name,
+            sa_value_col,
+            postgresql_using='hnsw',
+            postgresql_with={'m': 16, 'ef_construction': 64},
+            postgresql_ops={sa_value_col.name: metric},
+        )
+        return sql.schema.CreateIndex(sa_idx, if_not_exists=True).compile(dialect=postgresql.dialect())
+
+
+class CockroachDbms(Dbms):
+    """
+    Implements utilities to interact with CockroachDb database.
+    """
+
+    def __init__(self, db_url: sql.URL):
+        super().__init__('cockroachdb', 'SERIALIZABLE', 'btree', db_url)
+
+    def drop_db_stmt(self, database: str) -> str:
+        return f'DROP DATABASE {database} CASCADE'
+
+    def create_db_stmt(self, database: str) -> str:
+        return f"CREATE DATABASE {database} TEMPLATE template0 ENCODING 'utf-8' LC_COLLATE 'C' LC_CTYPE 'C'"
+
+    def default_system_db_url(self) -> str:
+        return self.db_url.set(database='defaultdb').render_as_string(hide_password=False)
+
+    def sa_vector_index(self, store_index_name: str, sa_value_col: sql.schema.Column, metric: str) -> sql.Index | None:
+        return None
+
+    def create_vector_index_stmt(self, store_index_name: str, sa_value_col: sql.Column, metric: str) -> sql.Compiled:
+        return sql.text(
+            f'CREATE VECTOR INDEX IF NOT EXISTS {store_index_name} ON {sa_value_col.table.name}'
+            f'({sa_value_col.name} {metric})'
+        ).compile()