Skip to content

ftmq.search

Source code in ftmq/search/store/__init__.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@cache
def get_store(**kwargs: Any) -> BaseStore:
    settings = Settings()
    uri = kwargs.pop("uri", None)
    if uri is None:
        if settings.yaml_uri is not None:
            store = BaseStore.from_yaml_uri(settings.yaml_uri, **kwargs)
            return get_store(**store.model_dump())
        if settings.json_uri is not None:
            store = BaseStore.from_json_uri(settings.json_uri, **kwargs)
            return get_store(**store.model_dump())
        uri = settings.uri
    uri = ensure_uri(uri)
    parsed = urlparse(uri)
    if parsed.scheme == "sqlite":
        return SQliteStore(uri=uri, **kwargs)
    if parsed.scheme in ("tantivy", "memory"):
        try:
            from ftmq.search.store.tantivy import TantivyStore

            return TantivyStore(uri=uri, memory=parsed.scheme == "memory")
        except ImportError as e:
            raise ImportError(
                "Can not load TantivyStore. Install `tantivy` (`ftmq[search]`)"
            ) from e
    raise NotImplementedError(f"Store scheme: `{parsed.scheme}`")

FilterTerm dataclass

One search-index predicate: field holds any of values (none, if negated).

The terms of a query AND together.

Source code in ftmq/search/store/base.py 
20
21
22
23
24
25
26
27
28
29
@dataclass(frozen=True)
class FilterTerm:
    """One search-index predicate: `field` holds any of `values` (none, if `negated`).

    The terms of a query AND together.
    """

    field: str
    values: frozenset[str]
    negated: bool = False

get_filters(query)

Compile a query's filter tree into the flat term list a search index applies.

Only datasets, schema and countries are indexed, filters on other fields are dropped. A not / not_in comparator (or ~ around a single condition) becomes a negated term.

Parameters:

Name Type Description Default
query Query | None

The query to compile (None means no filters).

 required

Returns:

Type Description
list[FilterTerm]

The terms to AND together.

Raises:

Type Description
QueryError

For a shape ANDed terms can't express (a cross-field OR, a negated group, a comparator like ilike on an indexed field).
Source code in ftmq/search/store/base.py 
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
def get_filters(query: Query | None) -> list[FilterTerm]:
    """Compile a query's filter tree into the flat term list a search index applies.

    Only `datasets`, `schema` and `countries` are indexed, filters on other fields
    are dropped. A `not` / `not_in` comparator (or `~` around a single condition)
    becomes a negated term.

    Args:
        query: The query to compile (`None` means no filters).

    Returns:
        The terms to AND together.

    Raises:
        QueryError: For a shape ANDed terms can't express (a cross-field OR, a
            negated group, a comparator like `ilike` on an indexed field).
    """
    if query is None or query.q is None:
        return []
    return _collect(query.q)