linkml-store 0.1.8__tar.gz → 0.1.9__tar.gz

{linkml_store-0.1.8 → linkml_store-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: linkml-store
-Version: 0.1.8
+Version: 0.1.9
 Summary: linkml-store
 License: MIT
 Author: Author 1
@@ -19,6 +19,7 @@ Provides-Extra: h5py
 Provides-Extra: llm
 Provides-Extra: map
 Provides-Extra: mongodb
+Provides-Extra: pyarrow
 Provides-Extra: tests
 Provides-Extra: validation
 Requires-Dist: black (>=24.0.0) ; extra == "tests"
@@ -28,6 +29,7 @@ Requires-Dist: duckdb (>=0.10.1,<0.11.0)
 Requires-Dist: duckdb-engine (>=0.11.2)
 Requires-Dist: h5py ; extra == "h5py"
 Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
+Requires-Dist: jsonlines (>=4.0.0,<5.0.0)
 Requires-Dist: linkml ; extra == "validation"
 Requires-Dist: linkml-runtime (>=1.7.5,<2.0.0)
 Requires-Dist: linkml_map ; extra == "map"
@@ -35,6 +37,7 @@ Requires-Dist: llm ; extra == "llm"
 Requires-Dist: matplotlib ; extra == "analytics"
 Requires-Dist: pandas (>=2.2.1) ; extra == "analytics"
 Requires-Dist: plotly ; extra == "analytics"
+Requires-Dist: pyarrow ; extra == "pyarrow"
 Requires-Dist: pydantic (>=2.0.0,<3.0.0)
 Requires-Dist: pymongo ; extra == "mongodb"
 Requires-Dist: pystow (>=0.5.4,<0.6.0)

{linkml_store-0.1.8 → linkml_store-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "linkml-store"
-version = "0.1.8"
+version = "0.1.9"
 description = "linkml-store"
 authors = ["Author 1 <author@org.org>"]
 license = "MIT"
@@ -23,11 +23,13 @@ black = { version=">=24.0.0", optional = true }
 llm = { version="*", optional = true }
 pymongo = { version="*", optional = true }
 chromadb = { version="*", optional = true }
+pyarrow = { version="*", optional = true }
 h5py = { version="*", optional = true }
 linkml = { version="*", optional = true }
 linkml_map = { version="*", optional = true }
 pandas = ">=2.2.1"
 jinja2 = "^3.1.4"
+jsonlines = "^4.0.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = {version = ">=7.1.2"}
@@ -43,6 +45,7 @@ furo = {version = "*"}
 nbsphinx = "*"
 jupyter = "*"
 jupysql = "*"
+papermill = "*"
 
 [tool.poetry.group.tests.dependencies]
 pytest = "^7.4.0"
@@ -60,6 +63,7 @@ llm = ["llm"]
 mongodb = ["pymongo"]
 chromadb = ["chromadb"]
 h5py = ["h5py"]
+pyarrow = ["pyarrow"]
 validation = ["linkml"]
 map = ["linkml_map"]
 
@@ -127,7 +131,7 @@ skip = '.git,*.pdf,*.svg,./tests,pyproject.toml,*.dill,poetry.lock,*.ipynb'
 # Ignore table where words could be split across rows
 # Ignore shortcut specifications like [Ff]alse
 ignore-regex = '(\|.*\|.*\|.*\||\[[A-Z][a-z]\][a-z][a-z])'
-ignore-words-list = 'mater,connexion,infarction'
+ignore-words-list = 'mater,connexion,infarction,nin'
 count = ""
 quiet-level = 3
 

{linkml_store-0.1.8 → linkml_store-0.1.9}/src/linkml_store/api/client.py

@@ -9,6 +9,7 @@ from linkml_store.api import Database
 from linkml_store.api.config import ClientConfig
 from linkml_store.api.stores.chromadb.chromadb_database import ChromaDBDatabase
 from linkml_store.api.stores.duckdb.duckdb_database import DuckDBDatabase
+from linkml_store.api.stores.filesystem.filesystem_database import FileSystemDatabase
 from linkml_store.api.stores.mongodb.mongodb_database import MongoDBDatabase
 from linkml_store.api.stores.solr.solr_database import SolrDatabase
 
@@ -20,6 +21,7 @@ HANDLE_MAP = {
     "solr": SolrDatabase,
     "mongodb": MongoDBDatabase,
     "chromadb": ChromaDBDatabase,
+    "file": FileSystemDatabase,
 }
 
 

{linkml_store-0.1.8 → linkml_store-0.1.9}/src/linkml_store/api/collection.py

@@ -4,16 +4,19 @@ import hashlib
 import logging
 from collections import defaultdict
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, TextIO, Type, Union
+from typing import TYPE_CHECKING, Any, Dict, Generic, Iterator, List, Optional, TextIO, Tuple, Type, Union
 
 import numpy as np
+from linkml_runtime import SchemaView
 from linkml_runtime.linkml_model import ClassDefinition, SlotDefinition
 from linkml_runtime.linkml_model.meta import ArrayExpression
 from pydantic import BaseModel
 
+from linkml_store.api.types import DatabaseType
 from linkml_store.index import get_indexer
 from linkml_store.utils.format_utils import load_objects
 from linkml_store.utils.object_utils import clean_empties
+from linkml_store.utils.patch_utils import PatchDict, apply_patches_to_list, patches_from_objects_lists
 
 try:
     from linkml.validator.report import ValidationResult
@@ -36,7 +39,7 @@ IDENTIFIER = str
 FIELD_NAME = str
 
 
-class Collection:
+class Collection(Generic[DatabaseType]):
     """
     A collection is an organized set of objects of the same or similar type.
 
@@ -56,7 +59,7 @@ class Collection:
     """
 
     # name: str
-    parent: Optional["Database"] = None
+    parent: Optional[DatabaseType] = None
     _indexers: Optional[Dict[str, Indexer]] = None
     # hidden: Optional[bool] = False
 
@@ -197,6 +200,10 @@ class Collection:
         """
         raise NotImplementedError
 
+    def _post_insert_hook(self, objs: List[OBJECT], **kwargs):
+        patches = [{"op": "add", "path": "/0", "value": obj} for obj in objs]
+        self._broadcast(patches, **kwargs)
+
     def delete(self, objs: Union[OBJECT, List[OBJECT]], **kwargs) -> Optional[int]:
         """
         Delete one or more objects from the collection.
@@ -301,7 +308,7 @@ class Collection:
 
     def query_facets(
         self, where: Optional[Dict] = None, facet_columns: List[str] = None, facet_limit=DEFAULT_FACET_LIMIT, **kwargs
-    ) -> Dict[str, Dict[str, int]]:
+    ) -> Dict[str, List[Tuple[Any, int]]]:
         """
         Run a query to get facet counts for one or more columns.
 
@@ -319,7 +326,7 @@ class Collection:
         :param query: A Query object representing the base query.
         :param facet_columns: A list of column names to get facet counts for.
         :param facet_limit:
-        :return: A dictionary where keys are column names and values are pandas DataFrames
+        :return: A dictionary where keys are column names and values are tuples
                  containing the facet counts for each unique value in the respective column.
         """
         raise NotImplementedError
@@ -523,6 +530,7 @@ class Collection:
                 ix_coll.delete_where()
 
         ix_coll.insert(objects_with_ix, **kwargs)
+        ix_coll.commit()
 
     def list_index_names(self) -> List[str]:
         """
@@ -557,12 +565,22 @@ class Collection:
 
         :return:
         """
-        sv = self.parent.schema_view
+        sv: SchemaView = self.parent.schema_view
         if sv:
             cls = sv.get_class(self.target_class_name)
+            if cls and not cls.attributes:
+                if not sv.class_induced_slots(cls.name):
+                    for att in self._induce_attributes():
+                        cls.attributes[att.name] = att
+                    sv.set_modified()
             return cls
         return None
 
+    def _induce_attributes(self) -> List[SlotDefinition]:
+        result = self.find({}, limit=-1)
+        cd = self.induce_class_definition_from_objects(result.rows, max_sample_size=None)
+        return list(cd.attributes.values())
+
     @property
     def identifier_attribute_name(self) -> Optional[str]:
         """
@@ -579,6 +597,37 @@ class Collection:
                     return att.name
         return None
 
+    def set_identifier_attribute_name(self, name: str):
+        """
+        Set the name of the identifier attribute for the collection.
+
+        AKA the primary key.
+
+        :param name: The name of the identifier attribute.
+        """
+        cd = self.class_definition()
+        if not cd:
+            raise ValueError(f"Cannot find class definition for {self.target_class_name}")
+        id_att = None
+        candidates = []
+        sv: SchemaView = self.parent.schema_view
+        cls = sv.get_class(cd.name)
+        existing_id_slot = sv.get_identifier_slot(cls.name)
+        if existing_id_slot:
+            if existing_id_slot.name == name:
+                return
+            existing_id_slot.identifier = False
+        for att in cls.attributes.values():
+            candidates.append(att.name)
+            if att.name == name:
+                att.identifier = True
+                id_att = att
+            else:
+                att.identifier = False
+        if not id_att:
+            raise ValueError(f"No attribute found with name {name} in {candidates}")
+        sv.set_modified()
+
     def object_identifier(self, obj: OBJECT, auto=True) -> Optional[IDENTIFIER]:
         """
         Return the identifier for an object.
@@ -622,6 +671,8 @@ class Collection:
             for k, v in obj.items():
                 keys[k].append(v)
         for k, vs in keys.items():
+            if k == "_id":
+                continue
             multivalueds = []
             inlineds = []
             rngs = []
@@ -698,6 +749,39 @@ class Collection:
         """
         raise NotImplementedError
 
+    def apply_patches(self, patches: List[PatchDict], **kwargs):
+        """
+        Apply a patch to the collection.
+
+        Patches conform to the JSON Patch format,
+
+        :param patches:
+        :param kwargs:
+        :return:
+        """
+        all_objs = self.find(limit=-1).rows
+        primary_key = self.identifier_attribute_name
+        if not primary_key:
+            raise ValueError(f"No primary key for {self.target_class_name}")
+        new_objs = apply_patches_to_list(all_objs, patches, primary_key=primary_key, **kwargs)
+        self.replace(new_objs)
+
+    def diff(self, other: "Collection", **kwargs):
+        """
+        Diff two collections.
+
+        :param other:
+        :param kwargs:
+        :return:
+        """
+        src_objs = self.find(limit=-1).rows
+        tgt_objs = other.find(limit=-1).rows
+        primary_key = self.identifier_attribute_name
+        if not primary_key:
+            raise ValueError(f"No primary key for {self.target_class_name}")
+        patches_from_objects_lists(src_objs, tgt_objs, primary_key=primary_key)
+        return patches_from_objects_lists(src_objs, tgt_objs, primary_key=primary_key)
+
     def iter_validate_collection(self, **kwargs) -> Iterator["ValidationResult"]:
         """
         Validate the contents of the collection
@@ -717,3 +801,14 @@ class Collection:
         for obj in result.rows:
             obj = clean_empties(obj)
             yield from validator.iter_results(obj, class_name)
+
+    def commit(self):
+        """
+        Commit changes to the collection.
+
+        :return:
+        """
+        pass
+
+    def _broadcast(self, *args, **kwargs):
+        self.parent.broadcast(self, *args, **kwargs)

{linkml_store-0.1.8 → linkml_store-0.1.9}/src/linkml_store/api/database.py

@@ -3,9 +3,24 @@ from abc import ABC
 from collections import defaultdict
 from copy import copy
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, Iterator, Optional, Sequence, Type, Union
-
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    Generic,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Type,
+    Union,
+)
+
+from linkml_store.api.types import CollectionType
 from linkml_store.utils.format_utils import load_objects, render_output
+from linkml_store.utils.patch_utils import PatchDict
 
 try:
     from linkml.validator.report import Severity, ValidationResult
@@ -24,8 +39,10 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+LISTENER = Callable[[Collection, List[PatchDict]], None]
+
 
-class Database(ABC):
+class Database(ABC, Generic[CollectionType]):
     """
     A Database provides access to named collections of data.
 
@@ -89,6 +106,8 @@ class Database(ABC):
     metadata: Optional[DatabaseConfig] = None
     collection_class: ClassVar[Optional[Type[Collection]]] = None
 
+    listeners: Optional[List[LISTENER]] = None
+
     def __init__(self, handle: Optional[str] = None, metadata: Optional[DatabaseConfig] = None, **kwargs):
         if metadata:
             self.metadata = metadata
@@ -233,7 +252,8 @@ class Database(ABC):
         :param kwargs:
         :return:
         """
-        raise NotImplementedError()
+        for coll in self.list_collections():
+            coll.commit()
 
     def close(self, **kwargs):
         """
@@ -301,6 +321,7 @@ class Database(ABC):
             alias = name
         self._collections[alias] = collection
         if recreate_if_exists:
+            logger.debug(f"Recreating collection {collection.name}")
             collection.delete_where({}, missing_ok=True)
         return collection
 
@@ -418,7 +439,11 @@ class Database(ABC):
         :return:
 
         """
-        raise NotImplementedError
+        if query.from_table:
+            collection = self.get_collection(query.from_table)
+            return collection.query(query, **kwargs)
+        else:
+            raise NotImplementedError(f"Querying without a table is not supported in {self.__class__.__name__}")
 
     @property
     def schema_view(self) -> SchemaView:
@@ -689,3 +714,9 @@ class Database(ABC):
         logger.info(f"Exporting object with {len(obj)} collections to {location} in {target_format} format")
         with open(location, "w", encoding="utf-8") as stream:
             stream.write(render_output(obj, format=target_format))
+
+    def broadcast(self, source: Collection, patches: List[PatchDict]):
+        if not self.listeners:
+            return
+        for listener in self.listeners:
+            listener(source, patches)

{linkml_store-0.1.8 → linkml_store-0.1.9}/src/linkml_store/api/stores/duckdb/duckdb_collection.py

@@ -38,6 +38,7 @@ class DuckDBCollection(Collection):
             with conn.begin():
                 conn.execute(insert(table), objs)
             conn.commit()
+        self._post_insert_hook(objs)
 
     def delete(self, objs: Union[OBJECT, List[OBJECT]], **kwargs) -> Optional[int]:
         if not isinstance(objs, list):

linkml_store-0.1.9/src/linkml_store/api/stores/filesystem/__init__.py

@@ -0,0 +1,15 @@
+"""
+Adapter for FileSystem wrapper
+
+Handles have the form:
+
+ - ``file:<path>`` for a local file
+ """
+
+from linkml_store.api.stores.filesystem.filesystem_collection import FileSystemCollection
+from linkml_store.api.stores.filesystem.filesystem_database import FileSystemDatabase
+
+__all__ = [
+    "FileSystemCollection",
+    "FileSystemDatabase",
+]

linkml_store-0.1.9/src/linkml_store/api/stores/filesystem/filesystem_collection.py

@@ -0,0 +1,177 @@
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from linkml_store.api import Collection
+from linkml_store.api.collection import DEFAULT_FACET_LIMIT, OBJECT
+from linkml_store.api.queries import Query, QueryResult
+from linkml_store.api.types import DatabaseType
+from linkml_store.utils.query_utils import mongo_query_to_match_function
+
+logger = logging.getLogger(__name__)
+
+
+class FileSystemCollection(Collection[DatabaseType]):
+    path: Optional[Path] = None
+    file_format: Optional[str] = None
+    encoding: Optional[str] = None
+    _objects_list: List[OBJECT] = None
+    _object_map: Dict[str, OBJECT] = None
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        parent: DatabaseType = self.parent
+        if not self.path:
+            if self.parent:
+                self.path = Path(parent.directory_path)
+        self._objects_list = []
+        self._object_map = {}
+        if not self.file_format:
+            self.file_format = "json"
+
+    @property
+    def path_to_file(self):
+        return Path(self.parent.directory_path) / f"{self.name}.{self.file_format}"
+
+    @property
+    def objects_as_list(self) -> List[OBJECT]:
+        if self._object_map:
+            return list(self._object_map.values())
+        else:
+            return self._objects_list
+
+    def _set_objects(self, objs: List[OBJECT]):
+        pk = self.identifier_attribute_name
+        if pk:
+            self._object_map = {obj[pk]: obj for obj in objs}
+            self._objects_list = []
+        else:
+            self._objects_list = objs
+            self._object_map = {}
+
+    def commit(self):
+        path = self.path_to_file
+        if not path:
+            raise ValueError("Path not set")
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self._save(path)
+
+    def _save(self, path: Path):
+        encoding = self.encoding or "utf-8"
+        fmt = self.file_format or "json"
+        mode = "w"
+        if fmt == "parquet":
+            mode = "wb"
+            encoding = None
+        with open(path, mode, encoding=encoding) as stream:
+            if fmt == "json":
+                import json
+
+                json.dump(self.objects_as_list, stream, indent=2)
+            elif fmt == "jsonl":
+                import jsonlines
+
+                writer = jsonlines.Writer(stream)
+                writer.write_all(self.objects_as_list)
+            elif fmt == "yaml":
+                import yaml
+
+                yaml.dump_all(self.objects_as_list, stream)
+            elif fmt == "parquet":
+                import pandas as pd
+                import pyarrow
+                import pyarrow.parquet as pq
+
+                df = pd.DataFrame(self.objects_as_list)
+                table = pyarrow.Table.from_pandas(df)
+                pq.write_table(table, stream)
+            elif fmt in {"csv", "tsv"}:
+                import csv
+
+                delimiter = "\t" if fmt == "tsv" else ","
+                fieldnames = list(self.objects_as_list[0].keys())
+                for obj in self.objects_as_list[1:]:
+                    fieldnames.extend([k for k in obj.keys() if k not in fieldnames])
+                writer = csv.DictWriter(stream, fieldnames=fieldnames, delimiter=delimiter)
+                writer.writeheader()
+                for obj in self.objects_as_list:
+                    writer.writerow(obj)
+            else:
+                raise ValueError(f"Unsupported file format: {fmt}")
+
+    def insert(self, objs: Union[OBJECT, List[OBJECT]], **kwargs):
+        if not isinstance(objs, list):
+            objs = [objs]
+        if not objs:
+            return
+        pk = self.identifier_attribute_name
+        if pk:
+            for obj in objs:
+                if pk not in obj:
+                    raise ValueError(f"Primary key {pk} not found in object {obj}")
+                pk_val = obj[pk]
+                self._object_map[pk_val] = obj
+        else:
+            self._objects_list.extend(objs)
+
+    def delete(self, objs: Union[OBJECT, List[OBJECT]], **kwargs) -> Optional[int]:
+        if not isinstance(objs, list):
+            objs = [objs]
+        if not objs:
+            return 0
+        pk = self.identifier_attribute_name
+        n = 0
+        if pk:
+            for obj in objs:
+                pk_val = obj[pk]
+                if pk_val in self._object_map:
+                    del self._object_map[pk_val]
+                    n += 1
+        else:
+            n = len(objs)
+            self._objects_list = [o for o in self._objects_list if o not in objs]
+            n = n - len(objs)
+        return n
+
+    def delete_where(self, where: Optional[Dict[str, Any]] = None, missing_ok=True, **kwargs) -> Optional[int]:
+        logger.info(f"Deleting from {self.target_class_name} where: {where}")
+        if where is None:
+            where = {}
+
+        def matches(obj: OBJECT):
+            for k, v in where.items():
+                if obj.get(k) != v:
+                    return False
+            return True
+
+        print(type(self))
+        print(self)
+        print(vars(self))
+        curr_objects = [o for o in self.objects_as_list if not matches(o)]
+        self._set_objects(curr_objects)
+
+    def query(self, query: Query, **kwargs) -> QueryResult:
+
+        where = query.where_clause or {}
+        match = mongo_query_to_match_function(where)
+        rows = [o for o in self.objects_as_list if match(o)]
+        count = len(rows)
+        return QueryResult(query=query, num_rows=count, rows=rows)
+
+    def query_facets(
+        self, where: Dict = None, facet_columns: List[str] = None, facet_limit=DEFAULT_FACET_LIMIT, **kwargs
+    ) -> Dict[str, Dict[str, int]]:
+        match = mongo_query_to_match_function(where)
+        rows = [o for o in self.objects_as_list if match(o)]
+        if not facet_columns:
+            facet_columns = self.class_definition().attributes.keys()
+        facet_results = {c: {} for c in facet_columns}
+        for row in rows:
+            for fc in facet_columns:
+                if fc in row:
+                    v = row[fc]
+                    if v not in facet_results[fc]:
+                        facet_results[fc][v] = 1
+                    else:
+                        facet_results[fc][v] += 1
+        return {fc: list(facet_results[fc].items()) for fc in facet_results}

linkml_store-0.1.9/src/linkml_store/api/stores/filesystem/filesystem_database.py

@@ -0,0 +1,72 @@
+import logging
+from pathlib import Path
+from typing import Optional
+
+import yaml
+from linkml.utils.schema_builder import SchemaBuilder
+from linkml_runtime import SchemaView
+
+from linkml_store.api import Database
+from linkml_store.api.config import DatabaseConfig
+from linkml_store.api.stores.filesystem.filesystem_collection import FileSystemCollection
+from linkml_store.utils.format_utils import Format, load_objects
+
+logger = logging.getLogger(__name__)
+
+
+class FileSystemDatabase(Database):
+    collection_class = FileSystemCollection
+
+    directory_path: Optional[Path] = None
+    default_file_format: Optional[str] = None
+
+    def __init__(self, handle: Optional[str] = None, **kwargs):
+        handle = handle.replace("file:", "")
+        if handle.startswith("//"):
+            handle = handle[2:]
+        self.directory_path = Path(handle)
+        self.load_metadata()
+        super().__init__(handle=handle, **kwargs)
+
+    @property
+    def metadata_path(self) -> Path:
+        return self.directory_path / ".linkml_metadata.yaml"
+
+    def load_metadata(self):
+        if self.metadata_path.exists():
+            md_dict = yaml.safe_load(open(self.metadata_path))
+            metadata = DatabaseConfig(**md_dict)
+        else:
+            metadata = DatabaseConfig()
+        self.metadata = metadata
+
+    def close(self, **kwargs):
+        pass
+
+    def init_collections(self):
+        metadata = self.metadata
+        if self._collections is None:
+            self._collections = {}
+        for name, collection_config in metadata.collections.items():
+            collection = FileSystemCollection(parent=self, **collection_config.dict())
+            self._collections[name] = collection
+        path = self.directory_path
+        if path.exists():
+            for fmt in Format:
+                suffix = fmt.value
+                logger.info(f"Looking for {suffix} files in {path}")
+                for f in path.glob(f"*.{suffix}"):
+                    logger.info(f"Found {f}")
+                    n = f.stem
+                    objs = load_objects(f, suffix, expected_type=list)
+                    collection = FileSystemCollection(parent=self, name=n)
+                    self._collections[n] = collection
+                    collection._set_objects(objs)
+
+    def induce_schema_view(self) -> SchemaView:
+        logger.info(f"Inducing schema view for {self.handle}")
+        sb = SchemaBuilder()
+
+        for collection_name in self.list_collection_names():
+            sb.add_class(collection_name)
+        return SchemaView(sb.schema)

{linkml_store-0.1.8 → linkml_store-0.1.9}/src/linkml_store/api/stores/mongodb/mongodb_collection.py

@@ -26,17 +26,23 @@ class MongoDBCollection(Collection):
     def mongo_collection(self) -> MongoCollection:
         if not self.name:
             raise ValueError("Collection name not set")
-        return self.parent.native_db[self.name]
+        collection_name = self.alias or self.name
+        return self.parent.native_db[collection_name]
 
     def insert(self, objs: Union[OBJECT, List[OBJECT]], **kwargs):
         if not isinstance(objs, list):
             objs = [objs]
         self.mongo_collection.insert_many(objs)
+        # TODO: allow mapping of _id to id for efficiency
+        for obj in objs:
+            del obj["_id"]
+        self._post_insert_hook(objs)
 
-    def query(self, query: Query, **kwargs) -> QueryResult:
+    def query(self, query: Query, limit: Optional[int] = None, **kwargs) -> QueryResult:
         mongo_filter = self._build_mongo_filter(query.where_clause)
-        if query.limit:
-            cursor = self.mongo_collection.find(mongo_filter).limit(query.limit)
+        limit = limit or query.limit
+        if limit and limit >= 0:
+            cursor = self.mongo_collection.find(mongo_filter).limit(limit)
         else:
             cursor = self.mongo_collection.find(mongo_filter)