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), ), ), ], )