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)