esgvoc 0.3.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

esgvoc/cli/get.py

@@ -1,63 +1,70 @@
+import logging
+import re
+from typing import Any, List, Optional
 
-from typing import Any
-from esgvoc.api.projects import find_terms_in_collection, find_terms_in_project, get_all_collections_in_project, get_all_projects, get_all_terms_in_collection
-from esgvoc.api.universe import find_terms_in_data_descriptor, find_terms_in_universe, get_all_data_descriptors_in_universe, get_all_terms_in_data_descriptor
-from pydantic import BaseModel
-from requests import logging
-from rich.table import Table
 import typer
-import re
-from rich.json import JSON
+from pydantic import BaseModel
 from rich.console import Console
+from rich.json import JSON
+from rich.table import Table
+
+from esgvoc.api.projects import (get_all_collections_in_project,
+                                 get_all_projects, get_all_terms_in_collection,
+                                 get_term_in_collection, get_term_in_project)
+from esgvoc.api.universe import (find_terms_in_data_descriptor,
+                                 find_terms_in_universe,
+                                 get_all_data_descriptors_in_universe,
+                                 get_all_terms_in_data_descriptor,
+                                 get_term_in_data_descriptor,
+                                 get_term_in_universe)
 
 app = typer.Typer()
 console = Console()
 
 _LOGGER = logging.getLogger(__name__)
 
+
 def validate_key_format(key: str):
     """
     Validate if the key matches the XXXX:YYYY:ZZZZ format.
     """
-    if not re.match(r"^[a-zA-Z0-9\/_]*:[a-zA-Z0-9\/_]*:[a-zA-Z0-9\/_.]*$", key):
+    if not re.match(r"^[a-zA-Z0-9\/_-]*:[a-zA-Z0-9\/_-]*:[a-zA-Z0-9\/_.-]*$", key):
         raise typer.BadParameter(f"Invalid key format: {key}. Must be XXXX:YYYY:ZZZZ.")
     return key.split(":")
 
 
-def handle_universe(data_descriptor_id:str|None,term_id:str|None, options=None):
-    _LOGGER.debug(f"Handling universe with data_descriptor_id={data_descriptor_id}, term_id={term_id}") 
-
+def handle_universe(data_descriptor_id: str | None, term_id: str | None, options=None):
+    _LOGGER.debug(f"Handling universe with data_descriptor_id={data_descriptor_id}, term_id={term_id}")
     if data_descriptor_id and term_id:
-        return find_terms_in_data_descriptor(data_descriptor_id,term_id,options)
+        return get_term_in_data_descriptor(data_descriptor_id, term_id, options)
         # BaseModel|dict[str: BaseModel]|None:
 
     elif term_id:
-        return find_terms_in_universe(term_id,options)
+        return get_term_in_universe(term_id, options)
         # dict[str, BaseModel] | dict[str, dict[str, BaseModel]] | None:
 
-
     elif data_descriptor_id:
-        return get_all_terms_in_data_descriptor(data_descriptor_id)
+        return get_all_terms_in_data_descriptor(data_descriptor_id, options)
         # dict[str, BaseModel]|None:
 
     else:
         return get_all_data_descriptors_in_universe()
         # dict[str, dict]:
 
-def handle_project(project_id:str,collection_id:str|None,term_id:str|None,options=None):
+
+def handle_project(project_id: str, collection_id: str | None, term_id: str | None, options=None):
     _LOGGER.debug(f"Handling project {project_id} with Y={collection_id}, Z={term_id}, options = {options}")
-    
+
     if project_id and collection_id and term_id:
-        return find_terms_in_collection(project_id,collection_id,term_id)
+        return get_term_in_collection(project_id, collection_id, term_id, options)
         # BaseModel|dict[str: BaseModel]|None:
 
     elif term_id:
-        return find_terms_in_project(project_id, term_id,options)
+        return get_term_in_project(project_id, term_id, options)
         # dict[str, BaseModel] | dict[str, dict[str, BaseModel]] | None:
 
-
     elif collection_id:
-        return get_all_terms_in_collection(project_id, collection_id)
+        return get_all_terms_in_collection(project_id, collection_id, options)
         # dict[str, BaseModel]|None:
 
     else:
@@ -69,12 +76,11 @@ def handle_project(project_id:str,collection_id:str|None,term_id:str|None,option
         # dict[str, dict]:
 
 
-def handle_unknown(x:str|None,y:str|None,z:str|None):
+def handle_unknown(x: str | None, y: str | None, z: str | None):
     print(f"Something wrong in X,Y or Z : X={x}, Y={y}, Z={z}")
 
 
-def display(data:Any):
-
+def display(data: Any):
     if isinstance(data, BaseModel):
         # Pydantic Model
         console.print(JSON.from_data(data.model_dump()))
@@ -93,8 +99,12 @@ def display(data:Any):
         # Fallback to simple print
         console.print(data)
 
+
 @app.command()
-def get(keys: list[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZZZ format")):
+def get(
+    keys: List[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZZZ format"),
+    select: Optional[List[str]] = typer.Option(None, "--select", help="keys selected for the result"),
+):
     """
     Retrieve a specific value from the database system.\n
     This command allows you to fetch a value by specifying the universe/project, data_descriptor/collection,
@@ -110,7 +120,7 @@ def get(keys: list[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZ
         <term>\t\tThe term id within the specified collection.\n
     \n
     Example:
-        To retrieve the value from the "cmip6plus" project, under the "institution_id" column, the term with the identifier "ipsl", you would use: \n 
+        To retrieve the value from the "cmip6plus" project, under the "institution_id" column, the term with the identifier "ipsl", you would use: \n
             `get cmip6plus:institution_id:ipsl`\n
         The default project is the universe CV : the argument would be like `universe:institution:ipsl` or `:institution:ipsl` \n
         - to get list of available term from universe institution `:institution:` \n
@@ -121,23 +131,21 @@ def get(keys: list[str] = typer.Argument(..., help="List of keys in XXXX:YYYY:ZZ
         - Use a colon (`:`) to separate the parts of the argument.  \n
         - if more than one argument is given i.e get X:Y:Z A:B:C the 2 results are appended. \n
     \n
-    """ 
+    """
     known_projects = get_all_projects()
 
     # Validate and process each key
     for key in keys:
         validated_key = validate_key_format(key)
         _LOGGER.debug(f"Processed key: {validated_key}")
-        where,what,who = validated_key
-        what = what if what!="" else None
-        who = who if who!="" else None
-        if where == "" or where=="universe": 
-            res = handle_universe(what,who)
+        where, what, who = validated_key
+        what = what if what != "" else None
+        who = who if who != "" else None
+        if where == "" or where == "universe":
+            res = handle_universe(what, who, select)
         elif where in known_projects:
-            res = handle_project(where,what,who,None)
+            res = handle_project(where, what, who, select)
         else:
-            res = handle_unknown(where,what,who)
-        
-        display(res)
-
+            res = handle_unknown(where, what, who)
 
+        display(res)

esgvoc/cli/main.py

@@ -1,9 +1,13 @@
 import typer
+
+from esgvoc.cli.config import app as config_app
+from esgvoc.cli.drs import app as drs_app
+from esgvoc.cli.find import app as find_app
 from esgvoc.cli.get import app as get_app
+from esgvoc.cli.install import app as install_app
 from esgvoc.cli.status import app as status_app
 from esgvoc.cli.valid import app as valid_app
-from esgvoc.cli.install import app as install_app
-from esgvoc.cli.drs import app as drs_app   
+
 app = typer.Typer()
 
 # Register the subcommands
@@ -12,10 +16,13 @@ app.add_typer(status_app)
 app.add_typer(valid_app)
 app.add_typer(install_app)
 app.add_typer(drs_app)
+app.add_typer(config_app, name="config")
+app.add_typer(find_app)
+
 
 def main():
     app()
-    
+
 
 if __name__ == "__main__":
     main()

esgvoc/cli/status.py

@@ -1,38 +1,47 @@
-from esgvoc.core import service
-from rich.table import Table
 import typer
 from rich.console import Console
+from rich.table import Table
+
+from esgvoc.core import service
 
 app = typer.Typer()
 console = Console()
 
 
 def display(table):
-    console = Console(record=True,width=200)
+    console = Console(record=True, width=200)
     console.print(table)
 
 
-
 @app.command()
 def status():
     """
-    Command to display status 
-    i.e summary of version of usable ressources (between remote/cached)  
-    
+    Command to display status
+    i.e summary of version of usable ressources (between remote/cached)
+
     """
-    assert(service.current_state is not None)
+    assert service.current_state is not None
     service.current_state.get_state_summary()
-    #display(service.state_service.table())
-
+    # display(service.state_service.table())
 
     table = Table(show_header=False, show_lines=True)
 
-    table.add_row("","Remote github repo","Local repository","Cache Database", style = "bright_green")
-    table.add_row("Universe path",service.current_state.universe.github_repo,service.current_state.universe.local_path,service.current_state.universe.db_path, style = "white")
-    table.add_row("Version",service.current_state.universe.github_version,service.current_state.universe.local_version,service.current_state.universe.db_version, style="bright_blue")
-    for proj_name,proj in service.current_state.projects.items():
-        table.add_row(f"{proj_name} path",proj.github_repo,proj.local_path,proj.db_path, style="white")
-        table.add_row("Version",proj.github_version,proj.local_version,proj.db_version,style ="bright_blue")
+    table.add_row("", "Remote github repo", "Local repository", "Cache Database", style="bright_green")
+    table.add_row(
+        "Universe path",
+        service.current_state.universe.github_repo,
+        service.current_state.universe.local_path,
+        service.current_state.universe.db_path,
+        style="white",
+    )
+    table.add_row(
+        "Version",
+        service.current_state.universe.github_version,
+        service.current_state.universe.local_version,
+        service.current_state.universe.db_version,
+        style="bright_blue",
+    )
+    for proj_name, proj in service.current_state.projects.items():
+        table.add_row(f"{proj_name} path", proj.github_repo, proj.local_path, proj.db_path, style="white")
+        table.add_row("Version", proj.github_version, proj.local_version, proj.db_version, style="bright_blue")
     display(table)
-
-    

esgvoc/cli/valid.py

@@ -1,26 +1,21 @@
 
+import re
 from typing import List
-from esgvoc.api.projects import (
-    valid_term, 
-    valid_term_in_collection, 
-    valid_term_in_project, 
-    valid_term_in_all_projects
-)
-from requests import logging
-from rich.table import Table
+
 import typer
-import re
 from rich.console import Console
+from rich.table import Table
+
+from esgvoc.api.projects import valid_term, valid_term_in_all_projects, valid_term_in_collection, valid_term_in_project
 
 app = typer.Typer()
 console = Console()
 
-_LOGGER = logging.getLogger(__name__)
 
 @app.command()
 def valid(
     strings_targets: List[str] = typer.Argument(
-        ..., 
+        ...,
         help=(
             "Pairs of strings to validate against a key in the form '<StringToValidate> <Project:Collection:Term>'.\n"
             "Multiple pairs can be provided. The key '<Project:Collection:Term>' consists of three parts:\n"
@@ -51,7 +46,7 @@ def valid(
             \t\t- A string to validate.\n
             \t\t- A key in the form '<Project:Collection:Term>'.\n
     Usage :\n
-        \tValid one:\n 
+        \tValid one:\n
         \tesgvocab valid IPSL cmip6plus:institution_id:ipsl\n
         \tesgvocab valid IPSL cmip6plus:institution_id:\n
         \tesgvocab valid IPSL cmip6plus::\n
@@ -67,7 +62,7 @@ def valid(
         \tesgvocab valid IPSL :: IPS :: \n
         \t\tresult will be [True, False]\n
         \n
-        \tesgvocab valid --verbose IPS :: IPSL ::\n 
+        \tesgvocab valid --verbose IPS :: IPSL ::\n
         \tresult will be \n
         \t\t┏━━━━━━━━┳━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n
         \t\t┃ String ┃ Key ┃ Result     ┃ Errors                      ┃\n
@@ -83,7 +78,7 @@ def valid(
 
     # Combine string and target into pairs
     pairs = [strings_targets[i] + " " + strings_targets[i + 1] for i in range(0, len(strings_targets), 2)]
-    
+
     # Validate each string against each target
     for validation in pairs:
         match = re.match(r"(.+)\s+([^:]*):([^:]*):([^:]*)", validation)
@@ -109,7 +104,7 @@ def valid(
         except Exception as e:
             validation_result=False
             exception_message = repr(e)
-        
+
         # Handle validation result
 
         if validation_result:

esgvoc/core/constants.py

@@ -10,4 +10,4 @@ PATTERN_JSON_KEY = 'regex'
 TERM_TYPE_JSON_KEY = 'type'
 DRS_SPECS_JSON_KEY = 'drs_name'
 SQLITE_FIRST_PK = 1
-DATA_DESCRIPTOR_JSON_KEY = "@base"
+DATA_DESCRIPTOR_JSON_KEY = "@base"

esgvoc/core/db/__init__.py

@@ -1,5 +1,3 @@
-from esgvoc.core.db.connection import read_json_file
-from esgvoc.core.db.connection import DBConnection
+from esgvoc.core.db.connection import DBConnection, read_json_file
 
-
-__all__ = ["DBConnection", "read_json_file"]
+__all__ = ["DBConnection", "read_json_file"]

esgvoc/core/db/connection.py

@@ -1,11 +1,13 @@
-from pathlib import Path
 import json
+from pathlib import Path
+
 from sqlalchemy import Engine
 from sqlmodel import Session, create_engine
 
 
 class DBConnection:
     SQLITE_URL_PREFIX = 'sqlite://'
+
     def __init__(self, db_file_path: Path, echo: bool = False) -> None:
         self.engine = create_engine(f'{DBConnection.SQLITE_URL_PREFIX}/{db_file_path}', echo=echo)
         self.name = db_file_path.stem
@@ -20,7 +22,7 @@ class DBConnection:
     def create_session(self) -> Session:
         return Session(self.engine)
 
-    def get_name(self) -> str|None:
+    def get_name(self) -> str | None:
         return self.name
 
     def get_file_path(self) -> Path:
@@ -28,4 +30,4 @@ class DBConnection:
 
 
 def read_json_file(json_file_path: Path) -> dict:
-    return json.loads(json_file_path.read_text())
+    return json.loads(json_file_path.read_text())

esgvoc/core/db/models/project.py

@@ -2,23 +2,26 @@ import logging
 from pathlib import Path
 
 import sqlalchemy as sa
+from sqlalchemy import text
 from sqlalchemy.dialects.sqlite import JSON
 from sqlmodel import Column, Field, Relationship, SQLModel
 
 import esgvoc.core.db.connection as db
 from esgvoc.core.db.models.mixins import IdMixin, PkMixin, TermKind
-_LOGGER = logging.getLogger("project_db_creation")
+from esgvoc.core.exceptions import EsgvocDbError
+
+_LOGGER = logging.getLogger(__name__)
 
 
 class Project(SQLModel, PkMixin, IdMixin, table=True):
     __tablename__ = "projects"
     specs: dict = Field(sa_column=sa.Column(JSON))
     git_hash: str
-    collections: list["Collection"] = Relationship(back_populates="project")
+    collections: list["PCollection"] = Relationship(back_populates="project")
 
 
-class Collection(SQLModel, PkMixin, IdMixin, table=True):
-    __tablename__ = "collections"
+class PCollection(SQLModel, PkMixin, IdMixin, table=True):
+    __tablename__ = "pcollections"
     data_descriptor_id: str = Field(index=True)
     context: dict = Field(sa_column=sa.Column(JSON))
     project_pk: int | None = Field(default=None, foreign_key="projects.pk")
@@ -27,34 +30,73 @@ class Collection(SQLModel, PkMixin, IdMixin, table=True):
     term_kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
 
 
+# Well, the following instructions are not data duplication. It is more building an index.
+# Read: https://sqlite.org/fts5.html
+class PCollectionFTS5(SQLModel, PkMixin, IdMixin, table=True):
+    __tablename__ = "pcollections_fts5"
+    data_descriptor_id: str
+    context: dict = Field(sa_column=sa.Column(JSON))
+    project_pk: int | None = Field(default=None, foreign_key="projects.pk")
+    term_kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
+
+
 class PTerm(SQLModel, PkMixin, IdMixin, table=True):
     __tablename__ = "pterms"
     specs: dict = Field(sa_column=sa.Column(JSON))
     kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
-    collection_pk: int | None = Field(default=None, foreign_key="collections.pk")
-    collection: Collection = Relationship(back_populates="terms")
-    __table_args__ = (sa.Index(
-             "drs_name_index", specs.sa_column["drs_name"]
+    collection_pk: int | None = Field(default=None, foreign_key="pcollections.pk")
+    collection: PCollection = Relationship(back_populates="terms")
+    __table_args__ = (sa.Index("drs_name_index", specs.sa_column["drs_name"]), )  # type: ignore
+
+
+# Well, the following instructions are not data duplication. It is more building an index.
+# Read: https://sqlite.org/fts5.html
+class PTermFTS5(SQLModel, PkMixin, IdMixin, table=True):
+    __tablename__ = "pterms_fts5"
+    specs: dict = Field(sa_column=sa.Column(JSON))
+    kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
+    collection_pk: int | None = Field(default=None, foreign_key="pcollections.pk")
 
-         ),)
 
 def project_create_db(db_file_path: Path):
     try:
         connection = db.DBConnection(db_file_path)
     except Exception as e:
-        msg = f'Unable to create SQlite file at {db_file_path}. Abort.'
+        msg = f'unable to create SQlite file at {db_file_path}'
         _LOGGER.fatal(msg)
-        raise RuntimeError(msg) from e
+        raise EsgvocDbError(msg) from e
     try:
+        # Do not include pterms_fts5 table: it is build from a raw SQL query.
         tables_to_be_created = [SQLModel.metadata.tables['projects'],
-                                SQLModel.metadata.tables['collections'],
+                                SQLModel.metadata.tables['pcollections'],
                                 SQLModel.metadata.tables['pterms']]
         SQLModel.metadata.create_all(connection.get_engine(), tables=tables_to_be_created)
     except Exception as e:
-        msg = f'Unable to create tables in SQLite database at {db_file_path}. Abort.'
+        msg = f'unable to create tables in SQLite database at {db_file_path}'
+        _LOGGER.fatal(msg)
+        raise EsgvocDbError(msg) from e
+    try:
+        with connection.create_session() as session:
+            sql_query = "CREATE VIRTUAL TABLE IF NOT EXISTS pterms_fts5 USING " + \
+                        "fts5(pk, id, specs, kind, collection_pk, content=pterms, content_rowid=pk, prefix=3);"
+            session.exec(text(sql_query))  # type: ignore
+            session.commit()
+    except Exception as e:
+        msg = f'unable to create table pterms_fts5 for {db_file_path}'
+        _LOGGER.fatal(msg)
+        raise EsgvocDbError(msg) from e
+    try:
+        with connection.create_session() as session:
+            sql_query = 'CREATE VIRTUAL TABLE IF NOT EXISTS pcollections_fts5 USING ' + \
+                        'fts5(pk, id, data_descriptor_id, context, project_pk, ' + \
+                        'term_kind, content=pcollections, content_rowid=pk, prefix=3);'
+            session.exec(text(sql_query))  # type: ignore
+            session.commit()
+    except Exception as e:
+        msg = f'unable to create table pcollections_fts5 for {db_file_path}'
         _LOGGER.fatal(msg)
-        raise RuntimeError(msg) from e
+        raise EsgvocDbError(msg) from e
 
 
 if __name__ == "__main__":
-    pass
+    pass

esgvoc/core/db/models/universe.py

@@ -2,13 +2,15 @@ import logging
 from pathlib import Path
 
 import sqlalchemy as sa
+from sqlalchemy import text
 from sqlalchemy.dialects.sqlite import JSON
 from sqlmodel import Column, Field, Relationship, SQLModel
 
 import esgvoc.core.db.connection as db
 from esgvoc.core.db.models.mixins import IdMixin, PkMixin, TermKind
+from esgvoc.core.exceptions import EsgvocDbError
 
-_LOGGER = logging.getLogger("universe_db_creation")
+_LOGGER = logging.getLogger(__name__)
 
 
 class Universe(SQLModel, PkMixin, table=True):
@@ -18,7 +20,7 @@ class Universe(SQLModel, PkMixin, table=True):
 
 
 class UDataDescriptor(SQLModel, PkMixin, IdMixin, table=True):
-    __tablename__ = "data_descriptors"
+    __tablename__ = "udata_descriptors"
     context: dict = Field(sa_column=sa.Column(JSON))
     universe_pk: int | None = Field(default=None, foreign_key="universes.pk")
     universe: Universe = Relationship(back_populates="data_descriptors")
@@ -26,33 +28,70 @@ class UDataDescriptor(SQLModel, PkMixin, IdMixin, table=True):
     term_kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
 
 
+# Well, the following instructions are not data duplication. It is more building an index.
+# Read: https://sqlite.org/fts5.html
+class UDataDescriptorFTS5(SQLModel, PkMixin, IdMixin, table=True):
+    __tablename__ = "udata_descriptors_fts5"
+    context: dict = Field(sa_column=sa.Column(JSON))
+    universe_pk: int | None = Field(default=None, foreign_key="universes.pk")
+    term_kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
+
+
 class UTerm(SQLModel, PkMixin, IdMixin, table=True):
     __tablename__ = "uterms"
     specs: dict = Field(sa_column=sa.Column(JSON))
     kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
-    data_descriptor_pk: int | None = Field(
-        default=None, foreign_key="data_descriptors.pk"
-    )
+    data_descriptor_pk: int | None = Field(default=None, foreign_key="udata_descriptors.pk")
     data_descriptor: UDataDescriptor = Relationship(back_populates="terms")
 
 
+# Well, the following instructions are not data duplication. It is more building an index.
+# Read: https://sqlite.org/fts5.html
+class UTermFTS5(SQLModel, PkMixin, IdMixin, table=True):
+    __tablename__ = "uterms_fts5"
+    specs: dict = Field(sa_column=sa.Column(JSON))
+    kind: TermKind = Field(sa_column=Column(sa.Enum(TermKind)))
+    data_descriptor_pk: int | None = Field(default=None, foreign_key="udata_descriptors.pk")
+
+
 def universe_create_db(db_file_path: Path) -> None:
     try:
         connection = db.DBConnection(db_file_path)
     except Exception as e:
-        msg = f'Unable to create SQLite file at {db_file_path}. Abort.'
+        msg = f'unable to create SQLite file at {db_file_path}'
         _LOGGER.fatal(msg)
-        raise RuntimeError(msg) from e
+        raise EsgvocDbError(msg) from e
     try:
         # Avoid creating project tables.
         tables_to_be_created = [SQLModel.metadata.tables['uterms'],
-                                SQLModel.metadata.tables['data_descriptors'],
+                                SQLModel.metadata.tables['udata_descriptors'],
                                 SQLModel.metadata.tables['universes']]
         SQLModel.metadata.create_all(connection.get_engine(), tables=tables_to_be_created)
     except Exception as e:
-        msg = f'Unable to create tables in SQLite database at {db_file_path}. Abort.'
+        msg = f'unable to create tables in SQLite database at {db_file_path}'
+        _LOGGER.fatal(msg)
+        raise EsgvocDbError(msg) from e
+    try:
+        with connection.create_session() as session:
+            sql_query = 'CREATE VIRTUAL TABLE IF NOT EXISTS uterms_fts5 USING ' + \
+                        'fts5(pk, id, specs, kind, data_descriptor_pk, content=uterms, content_rowid=pk, prefix=3);'
+            session.exec(text(sql_query))  # type: ignore
+            session.commit()
+    except Exception as e:
+        msg = f'unable to create table uterms_fts5 for {db_file_path}'
+        _LOGGER.fatal(msg)
+        raise EsgvocDbError(msg) from e
+    try:
+        with connection.create_session() as session:
+            sql_query = 'CREATE VIRTUAL TABLE IF NOT EXISTS udata_descriptors_fts5 USING ' + \
+                        'fts5(pk, id, universe_pk, context, ' + \
+                        'term_kind, content=udata_descriptors, content_rowid=pk, prefix=3);'
+            session.exec(text(sql_query))  # type: ignore
+            session.commit()
+    except Exception as e:
+        msg = f'unable to create table udata_descriptors_fts5 for {db_file_path}'
         _LOGGER.fatal(msg)
-        raise RuntimeError(msg) from e
+        raise EsgvocDbError(msg) from e
 
 
 if __name__ == "__main__":