Function compile_condition

tables/conditions.py:451–503

Compile a condition and extract usable index conditions. Looks for variable-constant comparisons in the `condition` string involving the indexed columns whose variable names appear in `indexedcols`. The part of `condition` having usable indexes is returned as a compiled condition i

(
    condition: str, typemap: dict[str, type], indexedcols: frozenset[str]
)

def compile_condition(
    condition: str, typemap: dict[str, type], indexedcols: frozenset[str]
) -> CompiledCondition:
    """Compile a condition and extract usable index conditions.

    Looks for variable-constant comparisons in the `condition` string
    involving the indexed columns whose variable names appear in
    `indexedcols`.  The part of `condition` having usable indexes is
    returned as a compiled condition in a `CompiledCondition` container.

    Expressions such as '0 < c1 <= 1' do not work as expected.  The
    Numexpr types of *all* variables must be given in the `typemap`
    mapping.  The ``function`` of the resulting `CompiledCondition`
    instance is a Numexpr function object, and the ``parameters`` list
    indicates the order of its parameters.

    """
    # Get the expression tree and extract index conditions.
    expr = ne.necompiler.stringToExpression(condition, typemap, {})
    if expr.astKind != "bool":
        raise TypeError(
            "condition ``%s`` does not have a boolean type" % condition
        )
    idxexprs = _get_idx_expr(expr, indexedcols)
    # Post-process the answer
    if isinstance(idxexprs, list):
        # Simple expression
        strexpr = ["e0"]
    else:
        # Complex expression
        idxexprs, strexpr = idxexprs
    # Get rid of the unnecessary list wrapper for strexpr
    strexpr = strexpr[0]

    # Get the variable names used in the condition.
    # At the same time, build its signature.
    varnames = _get_variable_names(expr)
    signature = [(var, typemap[var]) for var in varnames]
    try:
        # See the comments in `numexpr.evaluate()` for the
        # reasons of inserting copy operators for unaligned,
        # *unidimensional* arrays.
        func = ne.necompiler.NumExpr(expr, signature)
    except NotImplementedError as nie:
        # Try to make this Numexpr error less cryptic.
        raise _unsupported_operation_error(nie)

    _, ex_uses_vml = ne.necompiler.getExprNames(condition, {})
    kwargs = {"ex_uses_vml": ex_uses_vml}

    params = varnames
    # This is more comfortable to handle about than a tuple.
    return CompiledCondition(func, params, idxexprs, strexpr, **kwargs)


def call_on_recarr(