def proxy_field(cls, field: str) -> str:
field, suffix = parse_field(field)
if field in cls.FIELDS_PROXY:
field = cls.FIELDS_PROXY[field]
if cls.FIELDS_USE_UUID and not suffix and field in cls.FIELDS_USE_UUID:
suffix = "uuid"
return "{}__{}".format(field, suffix) if suffix else field
def parse(cls, tokenized_query: Dict[str, Iterable]) -> Dict[str, Iterable]:
parsed_query = {}
for key, expressions in tokenized_query.items():
field, _ = parse_field(key)
parsed_query[key] = [
cls.PARSERS_BY_FIELD[field](exp) for exp in expressions
]
return parsed_query
def build(cls, parsed_query: Dict[str, Iterable]) -> Dict[str, Iterable]:
built_query = {}
for key, operations in parsed_query.items():
field, _ = parse_field(key)
built_query[key] = [
QueryCondSpec(
cond=cls.CONDITIONS_BY_FIELD[field](
op=op_spec.op, negation=op_spec.negation),
params=op_spec.params,
) for op_spec in operations
]
return built_query
def tokenize(cls, query_spec: str) -> Dict[str, Iterable]:
tokenized_query = tokenize_query(query_spec)
results = {}
for key in tokenized_query.keys():
field, _ = parse_field(key)
if field and (field not in cls.PARSERS_BY_FIELD
or field not in cls.CONDITIONS_BY_FIELD):
raise PQLException(
"key `{}` is not supported by query manager `{}`.".format(
key, cls.NAME))
cls.trans_field(key, tokenized_query, results)
return results
def trans_field(
cls,
key: str,
tokenized_query: Dict[str, Iterable],
update_tokenized_query: Dict[str, Iterable],
) -> None:
field, suffix = parse_field(key)
if field in cls.FIELDS_TRANS:
field_trans = cls.FIELDS_TRANS[field]["field"]
update_tokenized_query["{}_value".format(
field_trans)] = tokenized_query[key]
update_tokenized_query["{}_name".format(field_trans)] = [suffix]
if cls.FIELDS_TRANS[field].get("type"):
update_tokenized_query["{}_type".format(
field_trans)] = cls.FIELDS_TRANS[field]["type"]
else:
update_tokenized_query[key] = tokenized_query[key]
def proxy_field(cls, field: str) -> str:
field, suffix = parse_field(field)
if field in cls.FIELDS_PROXY:
field = cls.FIELDS_PROXY[field]
return "{}__{}".format(field, suffix) if suffix else field
def test_parse_field(self):
with self.assertRaises(PQLException):
parse_field("")
with self.assertRaises(PQLException):
parse_field(".")
with self.assertRaises(PQLException):
parse_field("sdf.sdf.sf")
with self.assertRaises(PQLException):
parse_field("foo.")
assert parse_field("foo") == ("foo", None)
assert parse_field("foo_bar") == ("foo_bar", None)
assert parse_field("foo.bar") == ("foo", "bar")
assert parse_field("metric.foo_bar") == ("metric", "foo_bar")
def parse_field(cls, field: str) -> Tuple[str, Optional[str]]:
return parse_field(field=field)
