def build_match(
col: str, ops: Sequence[str], param_type: Any, alias: Optional[str] = None
) -> Or[Expression]:
# The IN condition has to be checked separately since each parameter
# has to be checked individually.
alias_match = AnyOptionalString() if alias is None else String(alias)
column_match = Param("column", ColumnPattern(alias_match, String(col)))
return Or(
[
FunctionCallPattern(
Or([String(op) for op in ops]),
(column_match, Param("rhs", LiteralPattern(AnyPattern(param_type)))),
),
FunctionCallPattern(
String(ConditionFunctions.IN),
(
column_match,
Param(
"rhs",
FunctionCallPattern(
Or([String("array"), String("tuple")]),
all_parameters=LiteralPattern(AnyPattern(param_type)),
),
),
),
),
]
)
def test_not_in_condition() -> None:
not_in_condition = binary_condition(
ConditionFunctions.NOT_IN,
Column(None, None, "tags_key"),
literals_tuple(None, [Literal(None, "t1"), Literal(None, "t2")]),
)
assert is_not_in_condition(not_in_condition)
match = is_not_in_condition_pattern(ColumnPattern(None, String("tags_key"))).match(
not_in_condition
)
assert match is not None
assert match.expression("tuple") == literals_tuple(
None, [Literal(None, "t1"), Literal(None, "t2")]
)
assert match.expression("lhs") == Column(None, None, "tags_key")
def test_binary_match() -> None:
c1 = binary_condition(
ConditionFunctions.EQ, Column(None, "table1", "column1"), Literal(None, "test"),
)
lhs = ColumnPattern(String("table1"), String("column1"))
rhs = LiteralPattern(String("test"))
assert (
condition_pattern({ConditionFunctions.EQ}, lhs, rhs, True).match(c1) is not None
)
assert (
condition_pattern({ConditionFunctions.EQ}, lhs, rhs, False).match(c1)
is not None
)
assert (
condition_pattern({ConditionFunctions.EQ}, rhs, lhs, True).match(c1) is not None
)
assert condition_pattern({ConditionFunctions.EQ}, rhs, lhs, False).match(c1) is None
def build_match(
col: str,
ops: Sequence[str],
param_type: Any,
alias: Optional[str] = None,
key: Optional[str] = None,
) -> Or[Expression]:
# The IN condition has to be checked separately since each parameter
# has to be checked individually.
alias_match = AnyOptionalString() if alias is None else String(alias)
pattern: Union[ColumnPattern, SubscriptableReferencePattern]
if key is not None:
pattern = SubscriptableReferencePattern(table_name=alias_match,
column_name=String(col),
key=String(key))
else:
pattern = ColumnPattern(table_name=alias_match,
column_name=String(col))
column_match = Param("column", pattern)
return Or([
FunctionCallPattern(
Or([String(op) for op in ops]),
(column_match, Param("rhs", LiteralPattern(
AnyPattern(param_type)))),
),
FunctionCallPattern(
String(ConditionFunctions.IN),
(
column_match,
Param(
"rhs",
FunctionCallPattern(
Or([String("array"), String("tuple")]),
all_parameters=LiteralPattern(AnyPattern(param_type)),
),
),
),
),
])
condition_pattern,
get_first_level_and_conditions,
)
from snuba.query.matchers import Any
from snuba.query.matchers import Column as ColumnPattern
from snuba.query.matchers import FunctionCall as FunctionCallPattern
from snuba.query.matchers import Literal as LiteralPattern
from snuba.query.matchers import Or, Param, Pattern, String
from snuba.request.request_settings import RequestSettings
from snuba.state import get_config
logger = logging.getLogger(__name__)
EQ_CONDITION_PATTERN = condition_pattern(
{ConditionFunctions.EQ},
ColumnPattern(None, Param("lhs", Any(str))),
LiteralPattern(Any(int)),
commutative=True,
)
FULL_CONDITION_PATTERN = Or([
EQ_CONDITION_PATTERN,
FunctionCallPattern(
String(ConditionFunctions.IN),
(
ColumnPattern(None, Param("lhs", Any(str))),
FunctionCallPattern(Or([String("tuple"),
String("array")]), None),
),
),
], )