query tokens refactoring

Author: alexvolha

uncoder-core/app/translator/core/const.py

@@ -1,7 +1,10 @@
 from typing import Union
 
-from app.translator.core.models.field import Alias, Field, FieldValue, Keyword
-from app.translator.core.models.function_value import FunctionValue
-from app.translator.core.models.identifier import Identifier
+from app.translator.core.models.query_tokens.field import Alias, Field
+from app.translator.core.models.query_tokens.field_field import FieldField
+from app.translator.core.models.query_tokens.field_value import FieldValue
+from app.translator.core.models.query_tokens.function_value import FunctionValue
+from app.translator.core.models.query_tokens.identifier import Identifier
+from app.translator.core.models.query_tokens.keyword import Keyword
 
-QUERY_TOKEN_TYPE = Union[FieldValue, FunctionValue, Keyword, Identifier, Field, Alias]
+QUERY_TOKEN_TYPE = Union[FieldField, FieldValue, FunctionValue, Keyword, Identifier, Field, Alias]

uncoder-core/app/translator/core/mixins/logic.py

@@ -1,19 +1,21 @@
-from typing import Union
-
+from app.translator.core.const import QUERY_TOKEN_TYPE
 from app.translator.core.custom_types.tokens import GroupType, LogicalOperatorType
-from app.translator.core.models.field import FieldValue, Keyword
-from app.translator.core.models.identifier import Identifier
+from app.translator.core.models.query_tokens.field_field import FieldField
+from app.translator.core.models.query_tokens.field_value import FieldValue
+from app.translator.core.models.query_tokens.function_value import FunctionValue
+from app.translator.core.models.query_tokens.identifier import Identifier
+from app.translator.core.models.query_tokens.keyword import Keyword
 
 
 class ANDLogicOperatorMixin:
     @staticmethod
-    def get_missed_and_token_indices(tokens: list[Union[FieldValue, Keyword, Identifier]]) -> list[int]:
+    def get_missed_and_token_indices(tokens: list[QUERY_TOKEN_TYPE]) -> list[int]:
         missed_and_indices = []
         for index in range(len(tokens) - 1):
             token = tokens[index]
             next_token = tokens[index + 1]
             if (
-                isinstance(token, (FieldValue, Keyword))
+                isinstance(token, (FieldField, FieldValue, FunctionValue, Keyword))
                 or isinstance(token, Identifier)
                 and token.token_type == GroupType.R_PAREN
             ) and not (
@@ -23,9 +25,7 @@ def get_missed_and_token_indices(tokens: list[Union[FieldValue, Keyword, Identif
                 missed_and_indices.append(index + 1)
         return list(reversed(missed_and_indices))
 
-    def add_and_token_if_missed(
-        self, tokens: list[Union[FieldValue, Keyword, Identifier]]
-    ) -> list[Union[FieldValue, Keyword, Identifier]]:
+    def add_and_token_if_missed(self, tokens: list[QUERY_TOKEN_TYPE]) -> list[QUERY_TOKEN_TYPE]:
         indices = self.get_missed_and_token_indices(tokens=tokens)
         for index in indices:
             tokens.insert(index, Identifier(token_type=LogicalOperatorType.AND))

uncoder-core/app/translator/core/mixins/operator.py

@@ -19,7 +19,7 @@
 from typing import Optional, Union
 
 from app.translator.core.custom_types.tokens import OperatorType
-from app.translator.core.models.identifier import Identifier
+from app.translator.core.models.query_tokens.identifier import Identifier
 
 
 class WildCardMixin:

uncoder-core/app/translator/core/models/field.py

@@ -6,8 +6,8 @@
 from app.translator.core.const import QUERY_TOKEN_TYPE
 from app.translator.core.custom_types.meta_info import SeverityType
 from app.translator.core.mapping import DEFAULT_MAPPING_NAME
-from app.translator.core.models.field import Field
 from app.translator.core.models.functions.base import ParsedFunctions
+from app.translator.core.models.query_tokens.field import Field
 
 
 class MetaInfoContainer:

uncoder-core/app/translator/core/models/function_value.py

@@ -0,0 +1,39 @@
+from typing import Optional
+
+from app.translator.core.mapping import DEFAULT_MAPPING_NAME, SourceMapping
+
+
+class Alias:
+    def __init__(self, name: str):
+        self.name = name
+
+
+class Field:
+    def __init__(self, source_name: str):
+        self.source_name = source_name
+        self.__generic_names_map = {}
+
+    def get_generic_field_name(self, source_id: str) -> Optional[str]:
+        return self.__generic_names_map.get(source_id)
+
+    def add_generic_names_map(self, generic_names_map: dict) -> None:
+        self.__generic_names_map = generic_names_map
+
+    def set_generic_names_map(self, source_mappings: list[SourceMapping], default_mapping: SourceMapping) -> None:
+        generic_names_map = {
+            source_mapping.source_id: source_mapping.fields_mapping.get_generic_field_name(self.source_name)
+            or self.source_name
+            for source_mapping in source_mappings
+        }
+        if DEFAULT_MAPPING_NAME not in generic_names_map:
+            fields_mapping = default_mapping.fields_mapping
+            generic_names_map[DEFAULT_MAPPING_NAME] = (
+                fields_mapping.get_generic_field_name(self.source_name) or self.source_name
+            )
+
+        self.__generic_names_map = generic_names_map
+
+
+class PredefinedField:
+    def __init__(self, name: str):
+        self.name = name

uncoder-core/app/translator/core/models/query_container.py

@@ -0,0 +1,18 @@
+from app.translator.core.models.query_tokens.field import Alias, Field
+from app.translator.core.models.query_tokens.identifier import Identifier
+
+
+class FieldField:
+    def __init__(
+        self,
+        source_name_left: str,
+        operator: Identifier,
+        source_name_right: str,
+        is_alias_left: bool = False,
+        is_alias_right: bool = False,
+    ):
+        self.field_left = Field(source_name=source_name_left) if not is_alias_left else None
+        self.alias_left = Alias(name=source_name_left) if is_alias_left else None
+        self.operator = operator
+        self.field_right = Field(source_name=source_name_right) if not is_alias_right else None
+        self.alias_right = Alias(name=source_name_right) if is_alias_right else None

uncoder-core/app/translator/core/models/query_tokens/__init__.py

@@ -0,0 +1,35 @@
+from typing import Union
+
+from app.translator.core.custom_types.tokens import STR_SEARCH_OPERATORS
+from app.translator.core.models.query_tokens.field import Alias, Field, PredefinedField
+from app.translator.core.models.query_tokens.identifier import Identifier
+from app.translator.core.models.query_tokens.value import Value
+from app.translator.core.str_value_manager import StrValue
+
+
+class FieldValue(Value):
+    def __init__(
+        self,
+        source_name: str,
+        operator: Identifier,
+        value: Union[bool, int, str, StrValue, list, tuple],
+        is_alias: bool = False,
+        is_predefined_field: bool = False,
+    ):
+        super().__init__(value, cast_to_int=operator.token_type not in STR_SEARCH_OPERATORS)
+        # mapped by platform fields mapping
+        self.field = Field(source_name=source_name) if not (is_alias or is_predefined_field) else None
+        # not mapped
+        self.alias = Alias(name=source_name) if is_alias else None
+        # mapped by platform predefined fields mapping
+        self.predefined_field = PredefinedField(name=source_name) if is_predefined_field else None
+        self.operator = operator
+
+    def __repr__(self):
+        if self.alias:
+            return f"{self.alias.name} {self.operator.token_type} {self.values}"
+
+        if self.predefined_field:
+            return f"{self.predefined_field.name} {self.operator.token_type} {self.values}"
+
+        return f"{self.field.source_name} {self.operator.token_type} {self.values}"