def is_not_in_condition(exp: Expression) -> bool: return __is_set_condition(exp, ConditionFunctions.NOT_IN) def is_not_in_condition_pattern( lhs: Pattern[Expression]) -> FunctionCallPattern: return __set_condition_pattern(lhs, ConditionFunctions.NOT_IN) def binary_condition(function_name: str, lhs: Expression, rhs: Expression) -> FunctionCall: return FunctionCall(None, function_name, (lhs, rhs)) binary_condition_patterns = { op: FunctionCallPattern(String(op), (AnyExpression(), AnyExpression())) for op in BINARY_OPERATORS } def condition_pattern( operators: Set[str], lhs_pattern: Pattern[Expression], rhs_pattern: Pattern[Expression], commutative: bool, ) -> Pattern[Expression]: """ Matches a binary condition given the two operands and the valid operators. It also supports commutative conditions. """ pattern: Pattern[Expression]
KEY_COL_MAPPING_PARAM, KEY_MAPPING_PARAM, TABLE_MAPPING_PARAM, mapping_pattern, ) from snuba.query.conditions import ConditionFunctions, condition_pattern from snuba.query.expressions import Column, Expression, FunctionCall, Literal from snuba.query.matchers import FunctionCall as FunctionCallPattern from snuba.query.matchers import Literal as LiteralPattern from snuba.query.matchers import String from snuba.request.request_settings import RequestSettings CONDITION_PATTERN = condition_pattern( {ConditionFunctions.EQ, ConditionFunctions.NEQ}, FunctionCallPattern( String("ifNull"), (mapping_pattern, LiteralPattern(String(""))), ), LiteralPattern(String("")), commutative=False, ) class EmptyTagConditionProcessor(QueryProcessor): """ If queries have conditions of the form `ifNull(tags[key], '') =/!= ''` we can simplify this using the `has` function. """ def process_query(self, query: Query, request_settings: RequestSettings) -> None: def process_condition(exp: Expression) -> Expression: result = CONDITION_PATTERN.match(exp)
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), ), ), ], ) def _check_expression( pattern: Pattern[Expression], expression: Expression, column_name: str ) -> bool: match = pattern.match(expression) return match is not None and match.optional_string("lhs") == column_name class ProjectIdEnforcer(ConditionChecker):
def is_not_in_condition(exp: Expression) -> bool: return __is_set_condition(exp, ConditionFunctions.NOT_IN) def is_not_in_condition_pattern(lhs: Pattern[Expression]) -> FunctionCallPattern: return __set_condition_pattern(lhs, ConditionFunctions.NOT_IN) def binary_condition( alias: Optional[str], function_name: str, lhs: Expression, rhs: Expression ) -> FunctionCall: return FunctionCall(alias, function_name, (lhs, rhs)) binary_condition_patterns = { op: FunctionCallPattern(None, String(op), (AnyExpression(), AnyExpression())) for op in BINARY_OPERATORS } def is_binary_condition(exp: Expression, operator: str) -> bool: if operator in binary_condition_patterns: return binary_condition_patterns[operator].match(exp) is not None return False def unary_condition( alias: Optional[str], function_name: str, operand: Expression ) -> FunctionCall: return FunctionCall(alias, function_name, (operand,))