linkml-store 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

linkml_store/api/database.py

@@ -149,26 +149,19 @@ class Database(ABC, Generic[CollectionType]):
     def _initialize_collections(self):
         if not self.metadata.collections:
             return
-        for name, collection_config in self.metadata.collections.items():
-            alias = collection_config.alias
-            typ = collection_config.type
-            # if typ and alias is None:
-            #    alias = name
-            # if typ is None:
-            #    typ = name
-            # collection = self.create_collection(
-            #    typ, alias=alias, metadata=collection_config.metadata
-            # )
-            if False and typ is not None:
-                if not alias:
-                    alias = name
-                name = typ
-            if not collection_config.name:
-                collection_config.name = name
-            _collection = self.create_collection(name, alias=alias, metadata=collection_config)
+        for k, collection_config in self.metadata.collections.items():
+            if collection_config.alias:
+                if collection_config.alias != k:
+                    raise ValueError(f"Alias mismatch: {collection_config.alias} != {k}")
+            alias = k
+            typ = collection_config.type or alias
+            _collection = self.create_collection(typ, alias=alias, metadata=collection_config)
+            assert _collection.alias == alias
+            assert _collection.target_class_name == typ
             if collection_config.attributes:
+                # initialize schema
                 sv = self.schema_view
-                cd = ClassDefinition(name, attributes=collection_config.attributes)
+                cd = ClassDefinition(typ, attributes=collection_config.attributes)
                 sv.schema.classes[cd.name] = cd
                 sv.set_modified()
                 # assert collection.class_definition() is not None
@@ -275,7 +268,7 @@ class Database(ABC, Generic[CollectionType]):
         metadata: Optional[CollectionConfig] = None,
         recreate_if_exists=False,
         **kwargs,
-    ) -> Collection:
+    ) -> CollectionType:
         """
         Create a new collection in the current database.
 
@@ -307,8 +300,10 @@ class Database(ABC, Generic[CollectionType]):
         if not name:
             raise ValueError(f"Collection name must be provided: alias: {alias} metadata: {metadata}")
         collection_cls = self.collection_class
-        collection = collection_cls(name=name, alias=alias, parent=self, metadata=metadata)
-        if metadata and metadata.source_location:
+        collection = collection_cls(name=name, parent=self, metadata=metadata)
+        if alias:
+            collection.metadata.alias = alias
+        if metadata and metadata.source:
             collection.load_from_source()
         if metadata and metadata.attributes:
             sv = self.schema_view
@@ -321,7 +316,7 @@ class Database(ABC, Generic[CollectionType]):
             alias = name
         self._collections[alias] = collection
         if recreate_if_exists:
-            logger.debug(f"Recreating collection {collection.name}")
+            logger.debug(f"Recreating collection {collection.alias}")
             collection.delete_where({}, missing_ok=True)
         return collection
 
@@ -339,7 +334,7 @@ class Database(ABC, Generic[CollectionType]):
         >>> collections = db.list_collections()
         >>> len(collections)
         2
-        >>> [c.name for c in collections]
+        >>> [c.target_class_name for c in collections]
         ['Person', 'Product']
 
         :param include_internal: include internal collections
@@ -367,7 +362,7 @@ class Database(ABC, Generic[CollectionType]):
         ['Person', 'Product']
 
         """
-        return [c.name for c in self.list_collections(**kwargs)]
+        return [c.alias for c in self.list_collections(**kwargs)]
 
     def get_collection(
         self, name: str, type: Optional[str] = None, create_if_not_exists=True, **kwargs
@@ -410,7 +405,7 @@ class Database(ABC, Generic[CollectionType]):
         """
         Initialize collections.
 
-        Not typically called directly: consider making hidden
+        TODO: Not typically called directly: consider making this private
         :return:
         """
         raise NotImplementedError
@@ -502,7 +497,7 @@ class Database(ABC, Generic[CollectionType]):
         >>> sorted(collection.class_definition().slots)
         ['capital', 'code', 'continent', 'languages', 'name']
 
-        :param schema_view:
+        :param schema_view: can be either a path to the schema, or a SchemaView object
         :return:
         """
         if isinstance(schema_view, Path):
@@ -585,7 +580,15 @@ class Database(ABC, Generic[CollectionType]):
 
         :return: A schema view
         """
-        raise NotImplementedError()
+        logger.info(f"Inducing schema view for {self.handle}")
+        from linkml_runtime.utils.schema_builder import SchemaBuilder
+
+        sb = SchemaBuilder()
+
+        for collection_name in self.list_collection_names():
+            coll = self.get_collection(collection_name)
+            sb.add_class(coll.target_class_name)
+        return SchemaView(sb.schema)
 
     def iter_validate_database(self, **kwargs) -> Iterator["ValidationResult"]:
         """
@@ -683,6 +686,21 @@ class Database(ABC, Generic[CollectionType]):
         """
         Drop the database and all collections.
 
+        >>> from linkml_store.api.client import Client
+        >>> client = Client()
+        >>> path = Path("/tmp/test.db")
+        >>> path.parent.mkdir(exist_ok=True, parents=True)
+        >>> db = client.attach_database(f"duckdb:///{path}")
+        >>> db.store({"persons": [{"id": "P1", "name": "John", "age_in_years": 30}]})
+        >>> coll = db.get_collection("persons")
+        >>> coll.find({}).num_rows
+        1
+        >>> db.drop()
+        >>> db = client.attach_database("duckdb:///tmp/test.db", alias="test")
+        >>> coll = db.get_collection("persons")
+        >>> coll.find({}).num_rows
+        0
+
         :param kwargs: additional arguments
         """
         raise NotImplementedError()

linkml_store/api/stores/duckdb/duckdb_collection.py

@@ -18,6 +18,9 @@ logger = logging.getLogger(__name__)
 class DuckDBCollection(Collection):
     _table_created: bool = None
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
     def insert(self, objs: Union[OBJECT, List[OBJECT]], **kwargs):
         logger.debug(f"Inserting {len(objs)}")
         if not isinstance(objs, list):
@@ -90,7 +93,9 @@ class DuckDBCollection(Collection):
         cd = self.class_definition()
         with self.parent.engine.connect() as conn:
             if not facet_columns:
-                facet_columns = list(self.class_definition().attributes.keys())
+                if not cd:
+                    raise ValueError(f"No class definition found for {self.target_class_name}")
+                facet_columns = list(cd.attributes.keys())
             for col in facet_columns:
                 logger.debug(f"Faceting on {col}")
                 if isinstance(col, tuple):
@@ -101,7 +106,7 @@ class DuckDBCollection(Collection):
                 facet_query_str = facet_count_sql(facet_query, col, multivalued=sd.multivalued)
                 logger.debug(f"Facet query: {facet_query_str}")
                 rows = list(conn.execute(text(facet_query_str)))
-                results[col] = rows
+                results[col] = [tuple(row) for row in rows]
             return results
 
     def _sqla_table(self, cd: ClassDefinition) -> Table:
@@ -110,7 +115,7 @@ class DuckDBCollection(Collection):
         cols = []
         for att in schema_view.class_induced_slots(cd.name):
             typ = TMAP.get(att.range, sqla.String)
-            if att.inlined:
+            if att.inlined or att.inlined_as_list:
                 typ = sqla.JSON
             if att.multivalued:
                 typ = sqla.ARRAY(typ, dimensions=1)
@@ -121,6 +126,17 @@ class DuckDBCollection(Collection):
         t = Table(self.alias, metadata_obj, *cols)
         return t
 
+    def _check_if_initialized(self) -> bool:
+        # if self._initialized:
+        #    return True
+        query = Query(
+            from_table="information_schema.tables", where_clause={"table_type": "BASE TABLE", "table_name": self.alias}
+        )
+        qr = self.parent.query(query)
+        if qr.num_rows > 0:
+            return True
+        return False
+
     def _create_table(self, cd: ClassDefinition):
         if self._table_created or self.metadata.is_prepopulated:
             logger.info(f"Already have table for: {cd.name}")
@@ -132,6 +148,7 @@ class DuckDBCollection(Collection):
         if qr.num_rows > 0:
             logger.info(f"Table already exists for {cd.name}")
             self._table_created = True
+            self._initialized = True
             self.metadata.is_prepopulated = True
             return
         logger.info(f"Creating table for {cd.name}")
@@ -142,4 +159,5 @@ class DuckDBCollection(Collection):
             conn.execute(text(ddl))
             conn.commit()
         self._table_created = True
+        self._initialized = True
         self.metadata.is_prepopulated = True

linkml_store/api/stores/duckdb/duckdb_database.py

@@ -26,18 +26,32 @@ TYPE_MAP = {
     "JSON": "Any",
 }
 
+MEMORY_HANDLE = "duckdb:///:memory:"
+
 
 logger = logging.getLogger(__name__)
 
 
 class DuckDBDatabase(Database):
+    """
+    An adapter for DuckDB databases.
+
+    Note that this adapter does not make use of a LinkML relational model transformation and
+    SQL Alchemy ORM layer. Instead, it attempts to map each collection (which is of type
+    some LinkML class) to a *single* DuckDB table. New tables are not created for nested references,
+    and linking tables are not created for many-to-many relationships.
+
+    Instead the native DuckDB ARRAY type is used to store multivalued attributes, and DuckDB JSON
+    types are used for nested inlined objects.
+    """
+
     _connection: DuckDBPyConnection = None
     _engine: sqlalchemy.Engine = None
     collection_class = DuckDBCollection
 
     def __init__(self, handle: Optional[str] = None, recreate_if_exists: bool = False, **kwargs):
         if handle is None:
-            handle = "duckdb:///:memory:"
+            handle = MEMORY_HANDLE
         if recreate_if_exists:
             path = Path(handle.replace("duckdb:///", ""))
             if path.exists():
@@ -64,6 +78,17 @@ class DuckDBDatabase(Database):
     def close(self, **kwargs):
         self.engine.dispose()
 
+    def drop(self, missing_ok=True, **kwargs):
+        self.close()
+        if self.handle == MEMORY_HANDLE:
+            return
+        path = Path(self.handle.replace("duckdb:///", ""))
+        if path.exists():
+            path.unlink()
+        else:
+            if not missing_ok:
+                raise FileNotFoundError(f"Database file not found: {path}")
+
     def query(self, query: Query, **kwargs) -> QueryResult:
         json_encoded_cols = []
         if query.from_table:
@@ -82,7 +107,8 @@ class DuckDBDatabase(Database):
             if sv:
                 cd = None
                 for c in self._collections.values():
-                    if c.name == query.from_table or c.metadata.alias == query.from_table:
+                    # if c.name == query.from_table or c.metadata.alias == query.from_table:
+                    if c.alias == query.from_table or c.target_class_name == query.from_table:
                         cd = c.class_definition()
                         break
                 if cd:
@@ -103,7 +129,14 @@ class DuckDBDatabase(Database):
                         if row[col]:
                             if isinstance(row[col], list):
                                 for i in range(len(row[col])):
-                                    row[col][i] = json.loads(row[col][i])
+                                    try:
+                                        parsed_val = json.loads(row[col][i])
+                                    except json.JSONDecodeError as e:
+                                        logger.error(f"Failed to parse col {col}[{i}] == {row[col][i]}")
+                                        raise e
+                                    row[col][i] = parsed_val
+                            elif isinstance(row[col], dict):
+                                pass
                             else:
                                 row[col] = json.loads(row[col])
             qr.set_rows(pd.DataFrame(rows))

linkml_store/api/stores/filesystem/filesystem_collection.py

@@ -31,7 +31,7 @@ class FileSystemCollection(Collection[DatabaseType]):
 
     @property
     def path_to_file(self):
-        return Path(self.parent.directory_path) / f"{self.name}.{self.file_format}"
+        return Path(self.parent.directory_path) / f"{self.alias}.{self.file_format}"
 
     @property
     def objects_as_list(self) -> List[OBJECT]:
@@ -150,13 +150,20 @@ class FileSystemCollection(Collection[DatabaseType]):
         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:
-
+    def query(self, query: Query, limit: Optional[int] = None, offset: Optional[int] = None, **kwargs) -> QueryResult:
+        limit = limit or query.limit
+        offset = offset or query.offset
+        if offset is None:
+            offset = 0
         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)
+        if limit is None or limit < 0:
+            limit = count
+        # TODO: avoid recalculating
+        returned_row = rows[offset : offset + limit]
+        return QueryResult(query=query, num_rows=count, rows=returned_row)
 
     def query_facets(
         self, where: Dict = None, facet_columns: List[str] = None, facet_limit=DEFAULT_FACET_LIMIT, **kwargs
@@ -170,6 +177,8 @@ class FileSystemCollection(Collection[DatabaseType]):
             for fc in facet_columns:
                 if fc in row:
                     v = row[fc]
+                    if not isinstance(v, str):
+                        v = str(v)
                     if v not in facet_results[fc]:
                         facet_results[fc][v] = 1
                     else:

linkml_store/api/stores/filesystem/filesystem_database.py

@@ -9,6 +9,7 @@ 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.file_utils import safe_remove_directory
 from linkml_store.utils.format_utils import Format, load_objects
 
 logger = logging.getLogger(__name__)
@@ -20,6 +21,8 @@ class FileSystemDatabase(Database):
     directory_path: Optional[Path] = None
     default_file_format: Optional[str] = None
 
+    no_backup_on_drop: bool = False
+
     def __init__(self, handle: Optional[str] = None, **kwargs):
         handle = handle.replace("file:", "")
         if handle.startswith("//"):
@@ -43,6 +46,12 @@ class FileSystemDatabase(Database):
     def close(self, **kwargs):
         pass
 
+    def drop(self, no_backup=False, **kwargs):
+        self.close()
+        path = self.directory_path
+        if path.exists():
+            safe_remove_directory(path, no_backup=self.no_backup_on_drop or no_backup)
+
     def init_collections(self):
         metadata = self.metadata
         if self._collections is None:
@@ -63,7 +72,7 @@ class FileSystemDatabase(Database):
                     self._collections[n] = collection
                     collection._set_objects(objs)
 
-    def induce_schema_view(self) -> SchemaView:
+    def xxxinduce_schema_view(self) -> SchemaView:
         logger.info(f"Inducing schema view for {self.handle}")
         sb = SchemaBuilder()
 

linkml_store/api/stores/mongodb/mongodb_collection.py

@@ -2,7 +2,6 @@ import logging
 from copy import copy
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-from linkml_runtime.linkml_model import SlotDefinition
 from pymongo.collection import Collection as MongoCollection
 
 from linkml_store.api import Collection
@@ -24,11 +23,15 @@ class MongoDBCollection(Collection):
 
     @property
     def mongo_collection(self) -> MongoCollection:
-        if not self.name:
+        # collection_name = self.alias or self.name
+        collection_name = self.alias
+        if not collection_name:
             raise ValueError("Collection name not set")
-        collection_name = self.alias or self.name
         return self.parent.native_db[collection_name]
 
+    def _check_if_initialized(self) -> bool:
+        return self.alias in self.parent.native_db.list_collection_names()
+
     def insert(self, objs: Union[OBJECT, List[OBJECT]], **kwargs):
         if not isinstance(objs, list):
             objs = [objs]
@@ -38,13 +41,15 @@ class MongoDBCollection(Collection):
             del obj["_id"]
         self._post_insert_hook(objs)
 
-    def query(self, query: Query, limit: Optional[int] = None, **kwargs) -> QueryResult:
+    def query(self, query: Query, limit: Optional[int] = None, offset: Optional[int] = None, **kwargs) -> QueryResult:
         mongo_filter = self._build_mongo_filter(query.where_clause)
         limit = limit or query.limit
+        cursor = self.mongo_collection.find(mongo_filter)
         if limit and limit >= 0:
-            cursor = self.mongo_collection.find(mongo_filter).limit(limit)
-        else:
-            cursor = self.mongo_collection.find(mongo_filter)
+            cursor = cursor.limit(limit)
+        offset = offset or query.offset
+        if offset and offset >= 0:
+            cursor = cursor.skip(offset)
 
         def _as_row(row: dict):
             row = copy(row)
@@ -63,46 +68,87 @@ class MongoDBCollection(Collection):
                 mongo_filter[field] = value
         return mongo_filter
 
+    from typing import Any, Dict, List, Union
+
     def query_facets(
-        self, where: Dict = None, facet_columns: List[str] = None, facet_limit=DEFAULT_FACET_LIMIT, **kwargs
-    ) -> Dict[str, List[Tuple[Any, int]]]:
+        self,
+        where: Dict = None,
+        facet_columns: List[Union[str, Tuple[str, ...]]] = None,
+        facet_limit=DEFAULT_FACET_LIMIT,
+        **kwargs,
+    ) -> Dict[Union[str, Tuple[str, ...]], List[Tuple[Any, int]]]:
         results = {}
-        cd = self.class_definition()
         if not facet_columns:
             facet_columns = list(self.class_definition().attributes.keys())
 
         for col in facet_columns:
             logger.debug(f"Faceting on {col}")
+
+            # Handle tuple columns
+            if isinstance(col, tuple):
+                group_id = {k.replace(".", "_"): f"${k}" for k in col}
+                all_fields = col
+            else:
+                group_id = f"${col}"
+                all_fields = [col]
+
+            # Initial pipeline without unwinding
+            facet_pipeline = [
+                {"$match": where} if where else {"$match": {}},
+                {"$group": {"_id": group_id, "count": {"$sum": 1}}},
+                {"$sort": {"count": -1}},
+                {"$limit": facet_limit},
+            ]
+
+            logger.info(f"Initial facet pipeline: {facet_pipeline}")
+            initial_results = list(self.mongo_collection.aggregate(facet_pipeline))
+
+            # Check if we need to unwind based on the results
+            needs_unwinding = False
             if isinstance(col, tuple):
-                sd = SlotDefinition(name="PLACEHOLDER")
+                needs_unwinding = any(
+                    isinstance(result["_id"], dict) and any(isinstance(v, list) for v in result["_id"].values())
+                    for result in initial_results
+                )
+            else:
+                needs_unwinding = any(isinstance(result["_id"], list) for result in initial_results)
+
+            if needs_unwinding:
+                logger.info(f"Detected array values for {col}, unwinding...")
+                facet_pipeline = [{"$match": where} if where else {"$match": {}}]
+
+                # Unwind each field if needed
+                for field in all_fields:
+                    field_parts = field.split(".")
+                    for i in range(len(field_parts)):
+                        facet_pipeline.append({"$unwind": f"${'.'.join(field_parts[:i + 1])}"})
+
+                facet_pipeline.extend(
+                    [
+                        {"$group": {"_id": group_id, "count": {"$sum": 1}}},
+                        {"$sort": {"count": -1}},
+                        {"$limit": facet_limit},
+                    ]
+                )
+
+                logger.info(f"Updated facet pipeline with unwinding: {facet_pipeline}")
+                facet_results = list(self.mongo_collection.aggregate(facet_pipeline))
             else:
-                if col in cd.attributes:
-                    sd = cd.attributes[col]
-                else:
-                    logger.info(f"No schema metadata for {col}")
-                    sd = SlotDefinition(name=col)
-            group = {"$group": {"_id": f"${col}", "count": {"$sum": 1}}}
+                facet_results = initial_results
+
+            logger.info(f"Facet results: {facet_results}")
+
+            # Process results
             if isinstance(col, tuple):
-                q = {k.replace(".", ""): f"${k}" for k in col}
-                group["$group"]["_id"] = q
-            if sd and sd.multivalued:
-                facet_pipeline = [
-                    {"$match": where} if where else {"$match": {}},
-                    {"$unwind": f"${col}"},
-                    group,
-                    {"$sort": {"count": -1}},
-                    {"$limit": facet_limit},
+                results[col] = [
+                    (tuple(result["_id"].values()), result["count"])
+                    for result in facet_results
+                    if result["_id"] is not None and all(v is not None for v in result["_id"].values())
                 ]
             else:
-                facet_pipeline = [
-                    {"$match": where} if where else {"$match": {}},
-                    group,
-                    {"$sort": {"count": -1}},
-                    {"$limit": facet_limit},
+                results[col] = [
+                    (result["_id"], result["count"]) for result in facet_results if result["_id"] is not None
                 ]
-            logger.info(f"Facet pipeline: {facet_pipeline}")
-            facet_results = list(self.mongo_collection.aggregate(facet_pipeline))
-            results[col] = [(result["_id"], result["count"]) for result in facet_results]
 
         return results
 

linkml_store/api/stores/mongodb/mongodb_database.py

@@ -3,9 +3,6 @@
 import logging
 from typing import Optional
 
-from linkml_runtime import SchemaView
-from linkml_runtime.linkml_model import ClassDefinition, SlotDefinition
-from linkml_runtime.utils.schema_builder import SchemaBuilder
 from pymongo import MongoClient
 from pymongo.database import Database as NativeDatabase
 
@@ -63,10 +60,9 @@ class MongoDBDatabase(Database):
             self._native_client.close()
 
     def drop(self, **kwargs):
-        self.native_client.drop_database(self.metadata.alias)
+        self.native_client.drop_database(self.native_db.name)
 
     def query(self, query: Query, **kwargs) -> QueryResult:
-        # TODO: DRY
         if query.from_table:
             collection = self.get_collection(query.from_table)
             return collection.query(query, **kwargs)
@@ -81,34 +77,3 @@ class MongoDBDatabase(Database):
             if collection_name not in self._collections:
                 collection = MongoDBCollection(name=collection_name, parent=self)
                 self._collections[collection_name] = collection
-
-    def induce_schema_view(self) -> SchemaView:
-        logger.info(f"Inducing schema view for {self.handle}")
-        sb = SchemaBuilder()
-        schema = sb.schema
-
-        for collection_name in self.native_db.list_collection_names():
-            sb.add_class(collection_name)
-            mongo_collection = self.native_db[collection_name]
-            sample_doc = mongo_collection.find_one()
-            if sample_doc:
-                for field, value in sample_doc.items():
-                    if field == "_id":
-                        continue
-                    sd = SlotDefinition(field)
-                    if isinstance(value, list):
-                        sd.multivalued = True
-                    if isinstance(value, dict):
-                        sd.inlined = True
-                    sb.schema.classes[collection_name].attributes[sd.name] = sd
-
-        sb.add_defaults()
-        for cls_name in schema.classes:
-            if cls_name in self.metadata.collections:
-                collection_metadata = self.metadata.collections[cls_name]
-                if collection_metadata.attributes:
-                    del schema.classes[cls_name]
-                    cls = ClassDefinition(name=collection_metadata.type, attributes=collection_metadata.attributes)
-                    schema.classes[cls.name] = cls
-
-        return SchemaView(schema)

linkml_store/api/stores/solr/solr_collection.py

@@ -18,7 +18,7 @@ class SolrCollection(Collection):
     @property
     def _collection_base(self) -> str:
         if self.parent.use_cores:
-            base_url = f"{self.parent.base_url}/{self.name}"
+            base_url = f"{self.parent.base_url}/{self.alias}"
         else:
             base_url = self.parent.base_url
         return base_url
@@ -37,7 +37,7 @@ class SolrCollection(Collection):
         if not qfs:
             raise ValueError("No searchable slots configured for Solr collection")
         solr_query = self._build_solr_query(where, search_term=query, extra={"defType": index_name, "qf": qfs})
-        logger.info(f"Querying Solr collection {self.name} with query: {solr_query}")
+        logger.info(f"Querying Solr collection {self.alias} with query: {solr_query}")
 
         response = requests.get(f"{self._collection_base}/select", params=solr_query)
         response.raise_for_status()
@@ -50,7 +50,7 @@ class SolrCollection(Collection):
 
     def query(self, query: Query, **kwargs) -> QueryResult:
         solr_query = self._build_solr_query(query)
-        logger.info(f"Querying Solr collection {self.name} with query: {solr_query}")
+        logger.info(f"Querying Solr collection {self.alias} with query: {solr_query}")
 
         response = requests.get(f"{self._collection_base}/select", params=solr_query)
         response.raise_for_status()
@@ -69,7 +69,7 @@ class SolrCollection(Collection):
         solr_query["facet.field"] = facet_columns
         solr_query["facet.limit"] = facet_limit
 
-        logger.info(f"Querying Solr collection {self.name} for facets with query: {solr_query}")
+        logger.info(f"Querying Solr collection {self.alias} for facets with query: {solr_query}")
 
         response = requests.get(f"{self._collection_base}/select", params=solr_query)
         response.raise_for_status()