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