Skip to content

type_bridge.expressions.boolean

boolean

Boolean expressions for logical combinations.

BooleanExpr 

BooleanExpr(operation, operands)

Bases: Expression

Boolean expression for combining other expressions with AND, OR, NOT.

Represents logical combinations of query constraints.

Create a boolean expression.

Parameters:

Name Type Description Default
operation Literal['and', 'or', 'not']

Boolean operation type

 required
operands list[Expression]

List of expressions to combine

 required
Source code in type_bridge/expressions/boolean.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
def __init__(
    self,
    operation: Literal["and", "or", "not"],
    operands: list[Expression],
):
    """Create a boolean expression.

    Args:
        operation: Boolean operation type
        operands: List of expressions to combine
    """
    self.operation = operation
    self.operands = operands

    # Validate operand count
    if operation == "not" and len(operands) != 1:
        raise ValueError("NOT operation requires exactly 1 operand")
    if operation in ("and", "or") and len(operands) < 2:
        raise ValueError(f"{operation.upper()} operation requires at least 2 operands")

get_attribute_types 

get_attribute_types()

Get all attribute types referenced by this boolean expression.

Recursively collects attribute types from all operands.

Returns:

Type Description
set[type[Attribute]]

Set of attribute types used in this expression and its operands
Source code in type_bridge/expressions/boolean.py 
40
41
42
43
44
45
46
47
48
49
50
51
def get_attribute_types(self) -> set[type[Attribute]]:
    """Get all attribute types referenced by this boolean expression.

    Recursively collects attribute types from all operands.

    Returns:
        Set of attribute types used in this expression and its operands
    """
    result = set()
    for operand in self.operands:
        result.update(operand.get_attribute_types())
    return result

to_ast 

to_ast(var)

Generate AST patterns for this boolean expression.

Source code in type_bridge/expressions/boolean.py 
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
def to_ast(self, var: str) -> list[Pattern]:
    """Generate AST patterns for this boolean expression."""
    from type_bridge.query.ast import NotPattern, OrPattern

    if self.operation == "and":
        # Flatten all patterns from operands
        all_patterns = []
        for op in self.operands:
            all_patterns.extend(op.to_ast(var))
        return all_patterns

    if self.operation == "or":
        # Operands define alternatives
        # Each operand produces a list of patterns (a conjunction block)
        alternatives = [op.to_ast(var) for op in self.operands]
        return [OrPattern(alternatives=alternatives)]

    if self.operation == "not":
        # Negate the conjunction of the operand's patterns
        # Typically NOT applies to a block
        operand_patterns = self.operands[0].to_ast(var)
        return [NotPattern(patterns=operand_patterns)]

    raise ValueError(f"Unknown boolean operation: {self.operation}")

and_ 

and_(other)

Combine with another expression using AND, flattening if possible.

If this is already an AND expression, adds the new operand to create a flat structure instead of a nested binary tree.

Parameters:

Name Type Description Default
other Expression

Another expression to AND with this one

 required

Returns:

Type Description
BooleanExpr

BooleanExpr with flattened operands
Source code in type_bridge/expressions/boolean.py 
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
def and_(self, other: Expression) -> BooleanExpr:
    """Combine with another expression using AND, flattening if possible.

    If this is already an AND expression, adds the new operand to create
    a flat structure instead of a nested binary tree.

    Args:
        other: Another expression to AND with this one

    Returns:
        BooleanExpr with flattened operands
    """
    if self.operation == "and":
        # Flatten: (a AND b).and_(c) -> (a AND b AND c)
        return BooleanExpr("and", [*self.operands, other])
    # Different operation, must wrap
    return BooleanExpr("and", [self, other])

or_ 

or_(other)

Combine with another expression using OR, flattening if possible.

If this is already an OR expression, adds the new operand to create a flat structure instead of a nested binary tree. This is critical for avoiding TypeDB query planner stack overflow with many values.

Parameters:

Name Type Description Default
other Expression

Another expression to OR with this one

 required

Returns:

Type Description
BooleanExpr

BooleanExpr with flattened operands
Source code in type_bridge/expressions/boolean.py 
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
def or_(self, other: Expression) -> BooleanExpr:
    """Combine with another expression using OR, flattening if possible.

    If this is already an OR expression, adds the new operand to create
    a flat structure instead of a nested binary tree. This is critical
    for avoiding TypeDB query planner stack overflow with many values.

    Args:
        other: Another expression to OR with this one

    Returns:
        BooleanExpr with flattened operands
    """
    if self.operation == "or":
        # Flatten: (a OR b).or_(c) -> (a OR b OR c)
        return BooleanExpr("or", [*self.operands, other])
    # Different operation, must wrap
    return BooleanExpr("or", [self, other])