vtlengine 1.1rc2__py3-none-any.whl → 1.2.0__py3-none-any.whl

vtlengine/Operators/Conditional.py

@@ -19,6 +19,7 @@ from vtlengine.DataTypes import (
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import DataComponent, Dataset, Role, Scalar
 from vtlengine.Operators import Binary, Operator
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 
 class If(Operator):
@@ -75,8 +76,8 @@ class If(Operator):
     ) -> Dataset:
         ids = condition.get_identifiers_names()
         condition_measure = condition.get_measures_names()[0]
-        true_data = condition.data[condition.data[condition_measure] == True]
-        false_data = condition.data[condition.data[condition_measure] != True].fillna(False)
+        true_data = condition.data[condition.data[condition_measure].dropna() == True]
+        false_data = condition.data[condition.data[condition_measure] != True]
 
         if isinstance(true_branch, Dataset):
             if len(true_data) > 0 and true_branch.data is not None:
@@ -84,7 +85,7 @@ class If(Operator):
                     true_data,
                     true_branch.data,
                     on=ids,
-                    how="right",
+                    how="left",
                     suffixes=("_condition", ""),
                 )
             else:
@@ -99,7 +100,7 @@ class If(Operator):
                     false_data,
                     false_branch.data,
                     on=ids,
-                    how="right",
+                    how="left",
                     suffixes=("_condition", ""),
                 )
             else:
@@ -113,12 +114,12 @@ class If(Operator):
             pd.concat([true_data, false_data], ignore_index=True)
             .drop_duplicates()
             .sort_values(by=ids)
-        )
+        ).reset_index(drop=True)
         if isinstance(result, Dataset):
             drop_columns = [
                 column for column in result.data.columns if column not in result.components
             ]
-            result.data = result.data.dropna(subset=drop_columns).drop(columns=drop_columns)
+            result.data = result.data.drop(columns=drop_columns)
         if isinstance(true_branch, Scalar) and isinstance(false_branch, Scalar):
             result.get_measures()[0].data_type = true_branch.data_type
             result.get_measures()[0].name = COMP_NAME_MAPPING[true_branch.data_type]
@@ -135,6 +136,7 @@ class If(Operator):
         nullable = False
         left = true_branch
         right = false_branch
+        dataset_name = VirtualCounter._new_ds_name()
         if true_branch.__class__ != false_branch.__class__:
             if (isinstance(true_branch, DataComponent) and isinstance(false_branch, Dataset)) or (
                 isinstance(true_branch, Dataset) and isinstance(false_branch, DataComponent)
@@ -147,6 +149,7 @@ class If(Operator):
                 right = true_branch
 
         # Datacomponent
+        comp_name = VirtualCounter._new_dc_name()
         if isinstance(condition, DataComponent):
             if not condition.data_type == Boolean:
                 raise SemanticError(
@@ -164,7 +167,7 @@ class If(Operator):
             if isinstance(right, DataComponent):
                 nullable |= right.nullable
             return DataComponent(
-                name="result",
+                name=comp_name,
                 data=None,
                 data_type=binary_implicit_promotion(left.data_type, right.data_type),
                 role=Role.MEASURE,
@@ -184,7 +187,7 @@ class If(Operator):
             left.data_type = right.data_type = binary_implicit_promotion(
                 left.data_type, right.data_type
             )
-            return Dataset(name="result", components=copy(condition.components), data=None)
+            return Dataset(name=dataset_name, components=copy(condition.components), data=None)
         if left.get_identifiers() != condition.get_identifiers():
             raise SemanticError("1-1-9-10", op=cls.op, clause=left.name)
         if isinstance(right, Scalar):
@@ -218,7 +221,7 @@ class If(Operator):
             if left.get_identifiers() != condition.get_identifiers():
                 raise SemanticError("1-1-9-6", op=cls.op)
         result_components = {comp_name: copy(comp) for comp_name, comp in left.components.items()}
-        return Dataset(name="result", components=result_components, data=None)
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
 
 class Nvl(Binary):
@@ -238,7 +241,7 @@ class Nvl(Binary):
         result = cls.validate(left, right)
 
         if isinstance(left, Scalar) and isinstance(result, Scalar):
-            if pd.isnull(left):  # type: ignore[call-overload]
+            if left.data_type is Null:
                 result.value = right.value
             else:
                 result.value = left.value
@@ -254,6 +257,8 @@ class Nvl(Binary):
 
     @classmethod
     def validate(cls, left: Any, right: Any) -> Union[Scalar, DataComponent, Dataset]:
+        dataset_name = VirtualCounter._new_ds_name()
+        comp_name = VirtualCounter._new_dc_name()
         result_components = {}
         if isinstance(left, Scalar):
             if not isinstance(right, Scalar):
@@ -271,7 +276,7 @@ class Nvl(Binary):
                 )
             cls.type_validation(left.data_type, right.data_type)
             return DataComponent(
-                name="result",
+                name=comp_name,
                 data=pd.Series(dtype=object),
                 data_type=left.data_type,
                 role=Role.MEASURE,
@@ -298,7 +303,7 @@ class Nvl(Binary):
             }
             for comp in result_components.values():
                 comp.nullable = False
-        return Dataset(name="result", components=result_components, data=None)
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
 
 class Case(Operator):
@@ -308,8 +313,23 @@ class Case(Operator):
     ) -> Union[Scalar, DataComponent, Dataset]:
         result = cls.validate(conditions, thenOps, elseOp)
         for condition in conditions:
-            if isinstance(condition, (DataComponent, Dataset)) and condition.data is not None:
+            if isinstance(condition, Dataset) and condition.data is not None:
                 condition.data.fillna(False, inplace=True)
+                condition_measure = condition.get_measures_names()[0]
+                if condition.data[condition_measure].dtype != bool:
+                    condition.data[condition_measure] = condition.data[condition_measure].astype(
+                        bool
+                    )
+            elif (
+                isinstance(
+                    condition,
+                    DataComponent,
+                )
+                and condition.data is not None
+            ):
+                condition.data.fillna(False, inplace=True)
+                if condition.data.dtype != bool:
+                    condition.data = condition.data.astype(bool)
             elif isinstance(condition, Scalar) and condition.value is None:
                 condition.value = False
 
@@ -324,9 +344,9 @@ class Case(Operator):
 
             for i, condition in enumerate(conditions):
                 value = thenOps[i].value if isinstance(thenOps[i], Scalar) else thenOps[i].data
-                result.data = np.where(  # type: ignore[call-overload]
+                result.data = np.where(
                     condition.data.notna(),
-                    np.where(condition.data, value, result.data),  # type: ignore[call-overload]
+                    np.where(condition.data, value, result.data),
                     result.data,
                 )
 
@@ -366,7 +386,7 @@ class Case(Operator):
                 ]
             )
 
-            result.data.loc[condition_mask_else, columns] = (
+            result.data.loc[condition_mask_else, columns] = (  # type: ignore[index, unused-ignore]
                 elseOp.value
                 if isinstance(elseOp, Scalar)
                 else elseOp.data.loc[condition_mask_else, columns]
@@ -378,6 +398,8 @@ class Case(Operator):
     def validate(
         cls, conditions: List[Any], thenOps: List[Any], elseOp: Any
     ) -> Union[Scalar, DataComponent, Dataset]:
+        dataset_name = VirtualCounter._new_ds_name()
+        comp_name = VirtualCounter._new_dc_name()
         if len(set(map(type, conditions))) > 1:
             raise SemanticError("2-1-9-1", op=cls.op)
 
@@ -421,7 +443,7 @@ class Case(Operator):
                 data_type = binary_implicit_promotion(data_type, op.data_type)
 
             return DataComponent(
-                name="result",
+                name=comp_name,
                 data=None,
                 data_type=data_type,
                 role=Role.MEASURE,
@@ -444,4 +466,4 @@ class Case(Operator):
             if isinstance(op, Dataset) and op.get_components_names() != comp_names:
                 raise SemanticError("2-1-9-7", op=cls.op)
 
-        return Dataset(name="result", components=components, data=None)
+        return Dataset(name=dataset_name, components=components, data=None)

vtlengine/Operators/General.py

@@ -7,6 +7,7 @@ from vtlengine.DataTypes import COMP_NAME_MAPPING
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import Component, DataComponent, Dataset, ExternalRoutine, Role
 from vtlengine.Operators import Binary, Unary
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 
 class Membership(Binary):
@@ -21,6 +22,7 @@ class Membership(Binary):
 
     @classmethod
     def validate(cls, left_operand: Any, right_operand: Any) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         if right_operand not in left_operand.components:
             raise SemanticError(
                 "1-1-1-10",
@@ -46,7 +48,7 @@ class Membership(Binary):
             for name, comp in left_operand.components.items()
             if comp.role == Role.IDENTIFIER or comp.name == right_operand
         }
-        result_dataset = Dataset(name="result", components=result_components, data=None)
+        result_dataset = Dataset(name=dataset_name, components=result_components, data=None)
         return result_dataset
 
     @classmethod

vtlengine/Operators/HROperators.py

@@ -9,6 +9,7 @@ import vtlengine.Operators as Operators
 from vtlengine.AST.Grammar.tokens import HIERARCHY
 from vtlengine.DataTypes import Boolean, Number
 from vtlengine.Model import Component, DataComponent, Dataset, Role
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 
 def get_measure_from_dataset(dataset: Dataset, code_item: str) -> DataComponent:
@@ -221,10 +222,11 @@ class Hierarchy(Operators.Operator):
     def validate(
         cls, dataset: Dataset, computed_dict: Dict[str, DataFrame], output: str
     ) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         result_components = {
             comp_name: copy(comp) for comp_name, comp in dataset.components.items()
         }
-        return Dataset(name=dataset.name, components=result_components, data=None)
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
     @classmethod
     def evaluate(

vtlengine/Operators/Join.py

@@ -13,6 +13,7 @@ from vtlengine.DataTypes import binary_implicit_promotion
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import Component, Dataset, Role
 from vtlengine.Operators import Operator, _id_type_promotion_join_keys
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 
 class Join(Operator):
@@ -196,12 +197,13 @@ class Join(Operator):
 
     @classmethod
     def validate(cls, operands: List[Dataset], using: Optional[List[str]]) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         if len(operands) < 1 or sum([isinstance(op, Dataset) for op in operands]) < 1:
             raise Exception("Join operator requires at least 1 dataset")
         if not all(isinstance(op, Dataset) for op in operands):
             raise SemanticError("1-1-13-10")
         if len(operands) == 1 and isinstance(operands[0], Dataset):
-            return Dataset(name="result", components=operands[0].components, data=None)
+            return Dataset(name=dataset_name, components=operands[0].components, data=None)
         for op in operands:
             if len(op.get_identifiers()) == 0:
                 raise SemanticError("1-3-27", op=cls.op)
@@ -215,7 +217,7 @@ class Join(Operator):
         if len(set(components.keys())) != len(components):
             raise SemanticError("1-1-13-9", comp_name="")
 
-        return Dataset(name="result", components=components, data=None)
+        return Dataset(name=dataset_name, components=components, data=None)
 
     @classmethod
     def identifiers_validation(cls, operands: List[Dataset], using: Optional[List[str]]) -> None:

vtlengine/Operators/Time.py

@@ -40,6 +40,7 @@ from vtlengine.DataTypes.TimeHandling import (
 )
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import Component, DataComponent, Dataset, Role, Scalar
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 
 class Time(Operators.Operator):
@@ -57,14 +58,17 @@ class Time(Operators.Operator):
     op = FLOW_TO_STOCK
 
     @classmethod
-    def _get_time_id(cls, operand: Dataset) -> Optional[str]:
+    def _get_time_id(cls, operand: Dataset) -> str:
         reference_id = None
+        identifiers = operand.get_identifiers()
+        if len(identifiers) == 0:
+            raise SemanticError("1-1-19-8", op=cls.op, comp_type="time dataset")
         for id in operand.get_identifiers():
             if id.data_type in cls.TIME_DATA_TYPES:
                 if reference_id is not None:
                     raise SemanticError("1-1-19-8", op=cls.op, comp_type="time dataset")
                 reference_id = id.name
-        return reference_id
+        return str(reference_id)
 
     @classmethod
     def sort_by_time(cls, operand: Dataset) -> Optional[pd.DataFrame]:
@@ -121,12 +125,13 @@ class Time(Operators.Operator):
 class Unary(Time):
     @classmethod
     def validate(cls, operand: Any) -> Any:
+        dataset_name = VirtualCounter._new_ds_name()
         if not isinstance(operand, Dataset):
             raise SemanticError("1-1-19-8", op=cls.op, comp_type="time dataset")
         if cls._get_time_id(operand) is None:
             raise SemanticError("1-1-19-8", op=cls.op, comp_type="time dataset")
         operand.data = cls.sort_by_time(operand)
-        return Dataset(name="result", components=operand.components.copy(), data=None)
+        return Dataset(name=dataset_name, components=operand.components.copy(), data=None)
 
     @classmethod
     def evaluate(cls, operand: Any) -> Any:
@@ -180,9 +185,10 @@ class Period_indicator(Unary):
 
     @classmethod
     def validate(cls, operand: Any) -> Any:
+        dataset_name = VirtualCounter._new_ds_name()
         if isinstance(operand, Dataset):
             time_id = cls._get_time_id(operand)
-            if time_id is None or operand.components[time_id].data_type != TimePeriod:
+            if operand.components[time_id].data_type != TimePeriod:
                 raise SemanticError("1-1-19-8", op=cls.op, comp_type="time period dataset")
             result_components = {
                 comp.name: comp
@@ -195,7 +201,7 @@ class Period_indicator(Unary):
                 role=Role.MEASURE,
                 nullable=True,
             )
-            return Dataset(name="result", components=result_components, data=None)
+            return Dataset(name=dataset_name, components=result_components, data=None)
         # DataComponent and Scalar validation
         if operand.data_type != TimePeriod:
             raise SemanticError("1-1-19-8", op=cls.op, comp_type="time period component")
@@ -223,7 +229,7 @@ class Period_indicator(Unary):
             if (operand.data is not None)
             else pd.Series()
         )
-        period_series: Any = result.data[cls.time_id].map(cls._get_period)  # type: ignore[index]
+        period_series: Any = result.data[cls.time_id].map(cls._get_period)
         result.data["duration_var"] = period_series
         return result
 
@@ -286,6 +292,7 @@ class Fill_time_series(Binary):
 
     @classmethod
     def validate(cls, operand: Dataset, fill_type: str) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         if not isinstance(operand, Dataset):
             raise SemanticError("1-1-19-8", op=cls.op, comp_type="time dataset")
         cls.time_id = cls._get_time_id(operand)
@@ -295,7 +302,7 @@ class Fill_time_series(Binary):
             raise SemanticError("1-1-19-8", op=cls.op, comp_type="time dataset")
         if fill_type not in ["all", "single"]:
             fill_type = "all"
-        return Dataset(name="result", components=operand.components.copy(), data=None)
+        return Dataset(name=dataset_name, components=operand.components.copy(), data=None)
 
     @classmethod
     def max_min_from_period(cls, data: pd.DataFrame, mode: str = "all") -> Dict[str, Any]:
@@ -378,7 +385,7 @@ class Fill_time_series(Binary):
                         )
 
         filled_data = pd.concat(filled_data, ignore_index=True)
-        combined_data = pd.concat([filled_data, data], ignore_index=True)  # type: ignore[list-item]
+        combined_data = pd.concat([filled_data, data], ignore_index=True)
         if len(cls.periods) == 1 and cls.periods[0] == "A":
             combined_data[cls.time_id] = combined_data[cls.time_id].astype(int)
         else:
@@ -456,7 +463,7 @@ class Fill_time_series(Binary):
 
         filled_data = pd.concat(filled_data, ignore_index=True)
         filled_data[cls.time_id] = filled_data[cls.time_id].dt.strftime(date_format)
-        combined_data = pd.concat([filled_data, data], ignore_index=True)  # type: ignore[list-item]
+        combined_data = pd.concat([filled_data, data], ignore_index=True)
         combined_data[cls.time_id] = combined_data[cls.time_id].astype(str)
         return combined_data.sort_values(by=cls.other_ids + [cls.time_id])
 
@@ -544,9 +551,7 @@ class Time_Shift(Binary):
         shift_value = int(shift_value.value)
         cls.time_id = cls._get_time_id(result)
 
-        data_type: Any = (
-            result.components[cls.time_id].data_type if isinstance(cls.time_id, str) else None
-        )
+        data_type: Any = result.components[cls.time_id].data_type
 
         if data_type == Date:
             freq = cls.find_min_frequency(
@@ -573,9 +578,10 @@ class Time_Shift(Binary):
 
     @classmethod
     def validate(cls, operand: Dataset, shift_value: str) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         if cls._get_time_id(operand) is None:
             raise SemanticError("1-1-19-8", op=cls.op, comp_type="time dataset")
-        return Dataset(name="result", components=operand.components.copy(), data=None)
+        return Dataset(name=dataset_name, components=operand.components.copy(), data=None)
 
     @classmethod
     def shift_dates(cls, dates: Any, shift_value: int, frequency: str) -> Any:
@@ -906,6 +912,7 @@ class Date_Add(Parametrized):
     def validate(
         cls, operand: Union[Scalar, DataComponent, Dataset], param_list: List[Scalar]
     ) -> Union[Scalar, DataComponent, Dataset]:
+        dataset_name = VirtualCounter._new_ds_name()
         expected_types = [Integer, String]
         for i, param in enumerate(param_list):
             error = (
@@ -937,7 +944,7 @@ class Date_Add(Parametrized):
 
         if all(comp.data_type not in [Date, TimePeriod] for comp in operand.components.values()):
             raise SemanticError("2-1-19-14", op=cls.op, name=operand.name)
-        return Dataset(name="result", components=operand.components.copy(), data=None)
+        return Dataset(name=dataset_name, components=operand.components.copy(), data=None)
 
     @classmethod
     def evaluate(
@@ -966,7 +973,7 @@ class Date_Add(Parametrized):
             for measure in operand.get_measures():
                 if measure.data_type in [Date, TimePeriod]:
                     result.data[measure.name] = result.data[measure.name].map(
-                        lambda x: cls.py_op(x, shift, period, measure.data_type == TimePeriod),
+                        lambda x: cls.py_op(str(x), shift, period, measure.data_type == TimePeriod),
                         na_action="ignore",
                     )
                     measure.data_type = Date

vtlengine/Operators/Validation.py

@@ -14,6 +14,7 @@ from vtlengine.DataTypes import (
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import Component, Dataset, Role
 from vtlengine.Operators import Operator
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 
 # noinspection PyTypeChecker
@@ -29,6 +30,7 @@ class Check(Operator):
         error_level: Optional[int],
         invalid: bool,
     ) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         if len(validation_element.get_measures()) != 1:
             raise SemanticError("1-1-10-1", op=cls.op, op_type="validation", me_type="Boolean")
         measure = validation_element.get_measures()[0]
@@ -71,7 +73,7 @@ class Check(Operator):
             name="errorlevel", data_type=Integer, role=Role.MEASURE, nullable=True
         )
 
-        return Dataset(name="result", components=result_components, data=None)
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
     @classmethod
     def evaluate(
@@ -126,6 +128,7 @@ class Validation(Operator):
 
     @classmethod
     def validate(cls, dataset_element: Dataset, rule_info: Dict[str, Any], output: str) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         result_components = {comp.name: comp for comp in dataset_element.get_identifiers()}
         result_components["ruleid"] = Component(
             name="ruleid", data_type=String, role=Role.IDENTIFIER, nullable=False
@@ -154,7 +157,7 @@ class Validation(Operator):
             name="errorlevel", data_type=Number, role=Role.MEASURE, nullable=True
         )
 
-        return Dataset(name="result", components=result_components, data=None)
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
     @classmethod
     def evaluate(cls, dataset_element: Dataset, rule_info: Dict[str, Any], output: str) -> Dataset:

vtlengine/Operators/__init__.py

@@ -37,6 +37,7 @@ from vtlengine.DataTypes.TimeHandling import (
 )
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import Component, DataComponent, Dataset, Role, Scalar, ScalarSet
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 ALL_MODEL_DATA_TYPES = Union[Dataset, Scalar, DataComponent]
 
@@ -289,6 +290,7 @@ class Binary(Operator):
 
     @classmethod
     def dataset_validation(cls, left_operand: Dataset, right_operand: Dataset) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         left_identifiers = left_operand.get_identifiers_names()
         right_identifiers = right_operand.get_identifiers_names()
 
@@ -336,12 +338,13 @@ class Binary(Operator):
                 right_comp = right_operand.components[comp.name]
                 comp.nullable = left_comp.nullable or right_comp.nullable
 
-        result_dataset = Dataset(name="result", components=result_components, data=None)
+        result_dataset = Dataset(name=dataset_name, components=result_components, data=None)
         cls.apply_return_type_dataset(result_dataset, left_operand, right_operand)
         return result_dataset
 
     @classmethod
     def dataset_scalar_validation(cls, dataset: Dataset, scalar: Scalar) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         if len(dataset.get_measures()) == 0:
             raise SemanticError("1-1-1-8", op=cls.op, name=dataset.name)
 
@@ -350,7 +353,7 @@ class Binary(Operator):
             for comp_name, comp in dataset.components.items()
             if comp.role in [Role.IDENTIFIER, Role.MEASURE]
         }
-        result_dataset = Dataset(name="result", components=result_components, data=None)
+        result_dataset = Dataset(name=dataset_name, components=result_components, data=None)
         cls.apply_return_type_dataset(result_dataset, dataset, scalar)
         return result_dataset
 
@@ -379,10 +382,10 @@ class Binary(Operator):
         :param right_operand: The right component
         :return: The result data type of the validation
         """
-
+        comp_name = VirtualCounter._new_dc_name()
         result_data_type = cls.type_validation(left_operand.data_type, right_operand.data_type)
         result = DataComponent(
-            name="result",
+            name=comp_name,
             data_type=result_data_type,
             data=None,
             role=left_operand.role,
@@ -405,6 +408,7 @@ class Binary(Operator):
 
     @classmethod
     def dataset_set_validation(cls, dataset: Dataset, scalar_set: ScalarSet) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         if len(dataset.get_measures()) == 0:
             raise SemanticError("1-1-1-8", op=cls.op, name=dataset.name)
         for measure in dataset.get_measures():
@@ -415,7 +419,7 @@ class Binary(Operator):
             if comp.role in [Role.IDENTIFIER, Role.MEASURE]
         }
 
-        result_dataset = Dataset(name="result", components=result_components, data=None)
+        result_dataset = Dataset(name=dataset_name, components=result_components, data=None)
         cls.apply_return_type_dataset(result_dataset, dataset, scalar_set)
         return result_dataset
 
@@ -423,9 +427,10 @@ class Binary(Operator):
     def component_set_validation(
         cls, component: DataComponent, scalar_set: ScalarSet
     ) -> DataComponent:
+        comp_name = VirtualCounter._new_dc_name()
         cls.type_validation(component.data_type, scalar_set.data_type)
         result = DataComponent(
-            name="result",
+            name=comp_name,
             data_type=cls.type_validation(component.data_type, scalar_set.data_type),
             data=None,
             role=Role.MEASURE,
@@ -757,6 +762,7 @@ class Unary(Operator):
 
     @classmethod
     def dataset_validation(cls, operand: Dataset) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         cls.validate_dataset_type(operand)
         if len(operand.get_measures()) == 0:
             raise SemanticError("1-1-1-8", op=cls.op, name=operand.name)
@@ -766,7 +772,7 @@ class Unary(Operator):
             if comp.role in [Role.IDENTIFIER, Role.MEASURE]
         }
 
-        result_dataset = Dataset(name="result", components=result_components, data=None)
+        result_dataset = Dataset(name=dataset_name, components=result_components, data=None)
         cls.apply_return_type_dataset(result_dataset, operand)
         return result_dataset
 
@@ -778,9 +784,10 @@ class Unary(Operator):
 
     @classmethod
     def component_validation(cls, operand: DataComponent) -> DataComponent:
+        comp_name = VirtualCounter._new_dc_name()
         result_type = cls.type_validation(operand.data_type)
         result = DataComponent(
-            name="result",
+            name=comp_name,
             data_type=result_type,
             data=None,
             role=operand.role,

vtlengine/Utils/__Virtual_Assets.py

@@ -0,0 +1,34 @@
+from copy import copy
+
+
+class VirtualCounter:
+    _instance = None
+    dataset_count: int = 0
+    component_count: int = 0
+
+    def __init__(self) -> None:
+        self.dataset_count = 0
+        self.component_count = 0
+
+    def __new__(cls):  # type: ignore[no-untyped-def]
+        if cls._instance is None:
+            cls._instance = super(VirtualCounter, cls).__new__(cls)
+            cls._instance.reset()
+        return cls._instance
+
+    @classmethod
+    def reset(cls) -> None:
+        cls.dataset_count = 0
+        cls.component_count = 0
+
+    @classmethod
+    def _new_ds_name(cls) -> str:
+        cls.dataset_count += 1
+        name = f"@VDS_{copy(cls.dataset_count)}"
+        return name
+
+    @classmethod
+    def _new_dc_name(cls) -> str:
+        cls.component_count += 1
+        name = f"@VDC_{copy(cls.component_count)}"
+        return name

vtlengine/Utils/__init__.py

@@ -1,5 +1,7 @@
 from typing import Any, Dict
 
+from pysdmx.model.dataflow import Role
+
 from vtlengine.AST.Grammar.tokens import (
     ABS,
     AGGREGATE,
@@ -428,3 +430,50 @@ HA_UNARY_MAPPING = {
     PLUS: HRUnPlus,
     MINUS: HRUnMinus,
 }
+VTL_DTYPES_MAPPING = {
+    "String": "String",
+    "Alpha": "String",
+    "AlphaNumeric": "String",
+    "Numeric": "String",
+    "BigInteger": "Integer",
+    "Integer": "Integer",
+    "Long": "Integer",
+    "Short": "Integer",
+    "Decimal": "Number",
+    "Float": "Number",
+    "Double": "Number",
+    "Boolean": "Boolean",
+    "URI": "String",
+    "Count": "Integer",
+    "InclusiveValueRange": "Number",
+    "ExclusiveValueRange": "Number",
+    "Incremental": "Number",
+    "ObservationalTimePeriod": "Time_Period",
+    "StandardTimePeriod": "Time_Period",
+    "BasicTimePeriod": "Date",
+    "GregorianTimePeriod": "Date",
+    "GregorianYear": "Date",
+    "GregorianYearMonth": "Date",
+    "GregorianMonth": "Date",
+    "GregorianDay": "Date",
+    "ReportingTimePeriod": "Time_Period",
+    "ReportingYear": "Time_Period",
+    "ReportingSemester": "Time_Period",
+    "ReportingTrimester": "Time_Period",
+    "ReportingQuarter": "Time_Period",
+    "ReportingMonth": "Time_Period",
+    "ReportingWeek": "Time_Period",
+    "ReportingDay": "Time_Period",
+    "DateTime": "Date",
+    "TimeRange": "Time",
+    "Month": "String",
+    "MonthDay": "String",
+    "Day": "String",
+    "Time": "String",
+    "Duration": "Duration",
+}
+VTL_ROLE_MAPPING = {
+    Role.DIMENSION: "Identifier",
+    Role.MEASURE: "Measure",
+    Role.ATTRIBUTE: "Attribute",
+}