vtlengine 1.1.1__py3-none-any.whl → 1.2.1rc1__py3-none-any.whl

vtlengine/Exceptions/messages.py

@@ -9,6 +9,8 @@ All exceptions exposed by the Vtl engine.
 
 centralised_messages = {
     # Input Validation errors
+    "0-1-1-1": "invalid script format type: {format_}. Input must be a string, "
+    "TransformationScheme or Path object",
     "0-1-2-1": "Invalid json structure because additional properties have been supplied "
     "on file {filename}.",
     "0-1-2-2": "Errors found on file {filename}: {errors}",
@@ -22,6 +24,7 @@ centralised_messages = {
     "0-1-3-4": "Dataset {short_urn} not found in mapping dictionary.",
     "0-1-3-5": "Dataset {dataset_name} not found in the input datasets.",
     "0-1-3-6": "Input name {missing} not found in the input datasets.",
+    "0-1-3-7": "Invalid input datasets type: {type_}. Expected a sequence of PandasDataset.",
     # JSON Schema validations
     "0-3-1-1": "Dataset {dataset} is not valid according to JSON schema",
     # Infer Data Structure errors
@@ -241,8 +244,8 @@ centralised_messages = {
     "2-3-1": "{comp_type} {comp_name} not found.",
     "2-3-2": "{op_type} cannot be used with {node_op} operators.",
     "2-3-4": "{op} operator must have a {comp}",
-    "2-3-5": "Expected {param_type}, got {type_name} on UDO {op}, parameter {param_name}",
-    "2-3-6": "Dataset {dataset_name} not found, please check input datastructures",
+    "2-3-5": "Expected {param_type}, got {type_name} on UDO {op}, parameter {param_name}.",
+    "2-3-6": "Dataset or scalar {dataset_name} not found, please check input datastructures.",
     "2-3-9": "{comp_type} {comp_name} not found in {param}.",
     "2-3-10": "No {comp_type} have been defined.",
     "2-3-11": "{pos} operand must be a dataset.",

vtlengine/Interpreter/__init__.py

@@ -97,6 +97,7 @@ from vtlengine.Utils import (
     THEN_ELSE,
     UNARY_MAPPING,
 )
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 
 # noinspection PyTypeChecker
@@ -104,6 +105,7 @@ from vtlengine.Utils import (
 class InterpreterAnalyzer(ASTTemplate):
     # Model elements
     datasets: Dict[str, Dataset]
+    scalars: Optional[Dict[str, Scalar]] = None
     value_domains: Optional[Dict[str, ValueDomain]] = None
     external_routines: Optional[Dict[str, ExternalRoutine]] = None
     # Analysis mode
@@ -202,6 +204,15 @@ class InterpreterAnalyzer(ASTTemplate):
             )
             self.datasets[ds_name].data = None
 
+    def _save_scalars_efficient(self, scalars: Dict[str, Scalar]) -> None:
+        output_path = Path(self.output_path)  # type: ignore[arg-type]
+        output_path.mkdir(parents=True, exist_ok=True)
+
+        for name, scalar in scalars.items():
+            file_path = output_path / f"{name}.csv"
+            df = pd.DataFrame([[scalar.value]] if scalar.value is not None else [[]])
+            df.to_csv(file_path, header=False, index=False)
+
     # **********************************
     # *                                *
     # *          AST Visitors          *
@@ -215,6 +226,7 @@ class InterpreterAnalyzer(ASTTemplate):
         else:
             Operators.only_semantic = False
         results = {}
+        scalars_to_save = set()
         for child in node.children:
             if isinstance(child, (AST.Assignment, AST.PersistentAssignment)):
                 vtlengine.Exceptions.dataset_output = child.left.value  # type: ignore[attr-defined]
@@ -232,6 +244,9 @@ class InterpreterAnalyzer(ASTTemplate):
             self.else_condition_dataset = None
             self.nested_condition = False
 
+            # Reset VirtualCounter
+            VirtualCounter.reset()
+
             if result is None:
                 continue
 
@@ -240,9 +255,22 @@ class InterpreterAnalyzer(ASTTemplate):
             # Save results
             self.datasets[result.name] = copy(result)
             results[result.name] = result
+            if isinstance(result, Scalar):
+                scalars_to_save.add(result.name)
+                if self.scalars is None:
+                    self.scalars = {}
+                self.scalars[result.name] = copy(result)
             self._save_datapoints_efficient(statement_num)
             statement_num += 1
 
+        if self.output_path is not None and scalars_to_save:
+            scalars_filtered = {
+                name: self.scalars[name]  # type: ignore[index]
+                for name in scalars_to_save
+                if (not self.return_only_persistent or name in self.ds_analysis.get(PERSISTENT, []))  # type: ignore[union-attr]
+            }
+            self._save_scalars_efficient(scalars_filtered)
+
         return results
 
     # Definition Language
@@ -529,7 +557,10 @@ class InterpreterAnalyzer(ASTTemplate):
             # Setting here group by as we have already selected the identifiers we need
             grouping_op = "group by"
 
-        return AGGREGATION_MAPPING[node.op].analyze(operand, grouping_op, groupings, having)
+        result = AGGREGATION_MAPPING[node.op].analyze(operand, grouping_op, groupings, having)
+        if not self.is_from_regular_aggregation:
+            result.name = VirtualCounter._new_ds_name()
+        return result
 
     def _format_having_expression_udo(self, having: str) -> str:
         if self.udo_params is None:
@@ -560,16 +591,25 @@ class InterpreterAnalyzer(ASTTemplate):
             else:
                 operand_comp = self.visit(node.operand)
                 component_name = operand_comp.name
+                id_names = self.regular_aggregation_dataset.get_identifiers_names()
                 measure_names = self.regular_aggregation_dataset.get_measures_names()
+                attribute_names = self.regular_aggregation_dataset.get_attributes_names()
                 dataset_components = self.regular_aggregation_dataset.components.copy()
-                for name in measure_names:
-                    if name != operand_comp.name:
-                        dataset_components.pop(name)
+                for name in measure_names + attribute_names:
+                    dataset_components.pop(name)
+
+                dataset_components[operand_comp.name] = Component(
+                    name=operand_comp.name,
+                    data_type=operand_comp.data_type,
+                    role=operand_comp.role,
+                    nullable=operand_comp.nullable,
+                )
 
                 if self.only_semantic or self.regular_aggregation_dataset.data is None:
                     data = None
                 else:
-                    data = self.regular_aggregation_dataset.data[dataset_components.keys()]
+                    data = self.regular_aggregation_dataset.data[id_names].copy()
+                    data[operand_comp.name] = operand_comp.data
 
                 operand = Dataset(
                     name=self.regular_aggregation_dataset.name,
@@ -765,10 +805,10 @@ class InterpreterAnalyzer(ASTTemplate):
             if self.is_from_join and node.value in self.datasets:
                 return self.datasets[node.value]
             if self.regular_aggregation_dataset is not None:
-                if node.value in self.datasets and isinstance(self.datasets[node.value], Scalar):
+                if self.scalars is not None and node.value in self.scalars:
                     if node.value in self.regular_aggregation_dataset.components:
                         raise SemanticError("1-1-6-11", comp_name=node.value)
-                    return self.datasets[node.value]
+                    return self.scalars[node.value]
                 if self.regular_aggregation_dataset.data is not None:
                     if (
                         self.is_from_join
@@ -833,8 +873,11 @@ class InterpreterAnalyzer(ASTTemplate):
                 role=self.ruleset_dataset.components[comp_name].role,
                 nullable=self.ruleset_dataset.components[comp_name].nullable,
             )
+        if self.scalars and node.value in self.scalars:
+            return self.scalars[node.value]
         if node.value not in self.datasets:
             raise SemanticError("2-3-6", dataset_name=node.value)
+
         return self.datasets[node.value]
 
     def visit_Collection(self, node: AST.Collection) -> Any:

vtlengine/Operators/Aggregation.py

@@ -103,12 +103,12 @@ class Aggregation(Operator.Unary):
             elif measure.data_type == Duration:
                 if mode == "input":
                     data[measure.name] = data[measure.name].map(
-                        lambda x: PERIOD_IND_MAPPING[x],  # type: ignore[index]
+                        lambda x: PERIOD_IND_MAPPING[x],
                         na_action="ignore",
                     )
                 else:
                     data[measure.name] = data[measure.name].map(
-                        lambda x: PERIOD_IND_MAPPING_REVERSE[x],  # type: ignore[index]
+                        lambda x: PERIOD_IND_MAPPING_REVERSE[x],
                         na_action="ignore",
                     )
             elif measure.data_type == Boolean:
@@ -170,9 +170,14 @@ class Aggregation(Operator.Unary):
             for measure_name in operand.get_measures_names():
                 result_components.pop(measure_name)
             new_comp = Component(
-                name="int_var", role=Role.MEASURE, data_type=Integer, nullable=True
+                name="int_var",
+                role=Role.MEASURE,
+                data_type=Integer,
+                nullable=True,
             )
             result_components["int_var"] = new_comp
+
+        # VDS is handled in visit_Aggregation
         return Dataset(name="result", components=result_components, data=None)
 
     @classmethod

vtlengine/Operators/Analytic.py

@@ -37,6 +37,7 @@ from vtlengine.DataTypes import (
 )
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import Component, Dataset, Role
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 return_integer_operators = [MAX, MIN, SUM]
 
@@ -157,8 +158,8 @@ class Analytic(Operator.Unary):
                     role=Role.MEASURE,
                     nullable=nullable,
                 )
-
-        return Dataset(name="result", components=result_components, data=None)
+        dataset_name = VirtualCounter._new_ds_name()
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
     @classmethod
     def analyticfunc(

vtlengine/Operators/CastOperator.py

@@ -22,6 +22,7 @@ from vtlengine.DataTypes import (
 from vtlengine.DataTypes.TimeHandling import str_period_to_date
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import Component, DataComponent, Dataset, Role, Scalar
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 duration_mapping = {"A": 6, "S": 5, "Q": 4, "M": 3, "W": 2, "D": 1}
 
@@ -331,7 +332,8 @@ class Cast(Operator.Unary):
             role=Role.MEASURE,
             nullable=measure.nullable,
         )
-        return Dataset(name="result", components=result_components, data=None)
+        dataset_name = VirtualCounter._new_ds_name()
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
     @classmethod
     def component_validation(  # type: ignore[override]
@@ -346,7 +348,8 @@ class Cast(Operator.Unary):
 
         from_type = operand.data_type
         cls.check_cast(from_type, to_type, mask)
-        return DataComponent(name=operand.name, data=None, data_type=to_type, role=operand.role)
+        comp_name = VirtualCounter._new_dc_name()
+        return DataComponent(name=comp_name, data=None, data_type=to_type, role=operand.role)
 
     @classmethod
     def scalar_validation(  # type: ignore[override]

vtlengine/Operators/Clause.py

@@ -15,6 +15,7 @@ from vtlengine.DataTypes import (
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import Component, DataComponent, Dataset, Role, Scalar
 from vtlengine.Operators import Operator
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 
 class Calc(Operator):
@@ -23,7 +24,8 @@ class Calc(Operator):
     @classmethod
     def validate(cls, operands: List[Union[DataComponent, Scalar]], dataset: Dataset) -> Dataset:
         result_components = {name: copy(comp) for name, comp in dataset.components.items()}
-        result_dataset = Dataset(name=dataset.name, components=result_components, data=None)
+        dataset_name = VirtualCounter._new_ds_name()
+        result_dataset = Dataset(name=dataset_name, components=result_components, data=None)
 
         for operand in operands:
             if operand.name in result_dataset.components:
@@ -70,7 +72,8 @@ class Aggregate(Operator):
 
     @classmethod
     def validate(cls, operands: List[Union[DataComponent, Scalar]], dataset: Dataset) -> Dataset:
-        result_dataset = Dataset(name=dataset.name, components=dataset.components, data=None)
+        dataset_name = VirtualCounter._new_ds_name()
+        result_dataset = Dataset(name=dataset_name, components=dataset.components, data=None)
 
         for operand in operands:
             if operand.name in dataset.get_identifiers_names() or (
@@ -122,7 +125,8 @@ class Filter(Operator):
     def validate(cls, condition: DataComponent, dataset: Dataset) -> Dataset:
         if condition.data_type != Boolean:
             raise ValueError(f"Filter condition must be of type {Boolean}")
-        return Dataset(name=dataset.name, components=dataset.components, data=None)
+        dataset_name = VirtualCounter._new_ds_name()
+        return Dataset(name=dataset_name, components=dataset.components, data=None)
 
     @classmethod
     def evaluate(cls, condition: DataComponent, dataset: Dataset) -> Dataset:
@@ -139,19 +143,20 @@ class Keep(Operator):
 
     @classmethod
     def validate(cls, operands: List[str], dataset: Dataset) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         for operand in operands:
             if operand not in dataset.get_components_names():
                 raise SemanticError(
-                    "1-1-1-10", op=cls.op, comp_name=operand, dataset_name=dataset.name
+                    "1-1-1-10", op=cls.op, comp_name=operand, dataset_name=dataset_name
                 )
             if dataset.get_component(operand).role == Role.IDENTIFIER:
-                raise SemanticError("1-1-6-2", op=cls.op, name=operand, dataset=dataset.name)
+                raise SemanticError("1-1-6-2", op=cls.op, name=operand, dataset=dataset_name)
         result_components = {
             name: comp
             for name, comp in dataset.components.items()
             if comp.name in operands or comp.role == Role.IDENTIFIER
         }
-        return Dataset(name=dataset.name, components=result_components, data=None)
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
     @classmethod
     def evaluate(cls, operands: List[str], dataset: Dataset) -> Dataset:
@@ -170,17 +175,18 @@ class Drop(Operator):
 
     @classmethod
     def validate(cls, operands: List[str], dataset: Dataset) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         for operand in operands:
             if operand not in dataset.components:
-                raise SemanticError("1-1-1-10", comp_name=operand, dataset_name=dataset.name)
+                raise SemanticError("1-1-1-10", comp_name=operand, dataset_name=dataset_name)
             if dataset.get_component(operand).role == Role.IDENTIFIER:
-                raise SemanticError("1-1-6-2", op=cls.op, name=operand, dataset=dataset.name)
+                raise SemanticError("1-1-6-2", op=cls.op, name=operand, dataset=dataset_name)
         if len(dataset.components) == len(operands):
             raise SemanticError("1-1-6-12", op=cls.op)
         result_components = {
             name: comp for name, comp in dataset.components.items() if comp.name not in operands
         }
-        return Dataset(name=dataset.name, components=result_components, data=None)
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
     @classmethod
     def evaluate(cls, operands: List[str], dataset: Dataset) -> Dataset:
@@ -195,6 +201,7 @@ class Rename(Operator):
 
     @classmethod
     def validate(cls, operands: List[RenameNode], dataset: Dataset) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         from_names = [operand.old_name for operand in operands]
         if len(from_names) != len(set(from_names)):
             duplicates = set([name for name in from_names if from_names.count(name) > 1])
@@ -211,14 +218,14 @@ class Rename(Operator):
                     "1-1-1-10",
                     op=cls.op,
                     comp_name=operand.old_name,
-                    dataset_name=dataset.name,
+                    dataset_name=dataset_name,
                 )
             if operand.new_name in dataset.components:
                 raise SemanticError(
                     "1-1-6-8",
                     op=cls.op,
                     comp_name=operand.new_name,
-                    dataset_name=dataset.name,
+                    dataset_name=dataset_name,
                 )
 
         result_components = {comp.name: comp for comp in dataset.components.values()}
@@ -230,8 +237,7 @@ class Rename(Operator):
                 nullable=result_components[operand.old_name].nullable,
             )
             del result_components[operand.old_name]
-
-        return Dataset(name=dataset.name, components=result_components, data=None)
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
     @classmethod
     def evaluate(cls, operands: List[RenameNode], dataset: Dataset) -> Dataset:
@@ -256,6 +262,7 @@ class Pivot(Operator):
 class Unpivot(Operator):
     @classmethod
     def validate(cls, operands: List[str], dataset: Dataset) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         if len(operands) != 2:
             raise ValueError("Unpivot clause requires two operands")
         identifier, measure = operands
@@ -263,10 +270,10 @@ class Unpivot(Operator):
         if len(dataset.get_identifiers()) < 1:
             raise SemanticError("1-3-27", op=cls.op)
         if identifier in dataset.components:
-            raise SemanticError("1-1-6-2", op=cls.op, name=identifier, dataset=dataset.name)
+            raise SemanticError("1-1-6-2", op=cls.op, name=identifier, dataset=dataset_name)
 
         result_components = {comp.name: comp for comp in dataset.get_identifiers()}
-        result_dataset = Dataset(name=dataset.name, components=result_components, data=None)
+        result_dataset = Dataset(name=dataset_name, components=result_components, data=None)
         # noinspection PyTypeChecker
         result_dataset.add_component(
             Component(name=identifier, data_type=String, role=Role.IDENTIFIER, nullable=False)
@@ -306,6 +313,7 @@ class Sub(Operator):
 
     @classmethod
     def validate(cls, operands: List[DataComponent], dataset: Dataset) -> Dataset:
+        dataset_name = VirtualCounter._new_ds_name()
         if len(dataset.get_identifiers()) < 1:
             raise SemanticError("1-3-27", op=cls.op)
         for operand in operands:
@@ -314,14 +322,14 @@ class Sub(Operator):
                     "1-1-1-10",
                     op=cls.op,
                     comp_name=operand.name,
-                    dataset_name=dataset.name,
+                    dataset_name=dataset_name,
                 )
             if operand.role != Role.IDENTIFIER:
                 raise SemanticError(
                     "1-1-6-10",
                     op=cls.op,
                     operand=operand.name,
-                    dataset_name=dataset.name,
+                    dataset_name=dataset_name,
                 )
             if isinstance(operand, Scalar):
                 raise SemanticError("1-1-6-5", op=cls.op, name=operand.name)
@@ -331,7 +339,7 @@ class Sub(Operator):
             for name, comp in dataset.components.items()
             if comp.name not in [operand.name for operand in operands]
         }
-        return Dataset(name=dataset.name, components=result_components, data=None)
+        return Dataset(name=dataset_name, components=result_components, data=None)
 
     @classmethod
     def evaluate(cls, operands: List[DataComponent], dataset: Dataset) -> Dataset:

vtlengine/Operators/Comparison.py

@@ -25,6 +25,7 @@ from vtlengine.AST.Grammar.tokens import (
 from vtlengine.DataTypes import COMP_NAME_MAPPING, Boolean, Null, Number, String
 from vtlengine.Exceptions import SemanticError
 from vtlengine.Model import Component, DataComponent, Dataset, Role, Scalar, ScalarSet
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 
 class Unary(Operator.Unary):
@@ -403,6 +404,7 @@ class ExistIn(Operator.Operator):
     def validate(
         cls, dataset_1: Dataset, dataset_2: Dataset, retain_element: Optional[Boolean]
     ) -> Any:
+        dataset_name = VirtualCounter._new_ds_name()
         left_identifiers = dataset_1.get_identifiers_names()
         right_identifiers = dataset_2.get_identifiers_names()
 
@@ -412,7 +414,7 @@ class ExistIn(Operator.Operator):
             raise ValueError("Datasets must have common identifiers")
 
         result_components = {comp.name: copy(comp) for comp in dataset_1.get_identifiers()}
-        result_dataset = Dataset(name="result", components=result_components, data=None)
+        result_dataset = Dataset(name=dataset_name, components=result_components, data=None)
         result_dataset.add_component(
             Component(name="bool_var", data_type=Boolean, role=Role.MEASURE, nullable=False)
         )

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(
@@ -154,17 +157,21 @@ class If(Operator):
                     op=cls.op,
                     type=SCALAR_TYPES_CLASS_REVERSE[condition.data_type],
                 )
-            if not isinstance(left, Scalar) or not isinstance(right, Scalar):
-                nullable = condition.nullable
-            else:
-                if left.data_type == Null or right.data_type == Null:
-                    nullable = True
-            if isinstance(left, DataComponent):
-                nullable |= left.nullable
-            if isinstance(right, DataComponent):
-                nullable |= right.nullable
+
+            if (
+                isinstance(left, Scalar)
+                and isinstance(right, Scalar)
+                and (left.data_type == Null or right.data_type == Null)
+            ):
+                nullable = True
+            if isinstance(left, DataComponent) and isinstance(right, DataComponent):
+                nullable = left.nullable or right.nullable
+            elif isinstance(left, DataComponent):
+                nullable = left.nullable or right.data_type == Null
+            elif isinstance(right, DataComponent):
+                nullable = left.data_type == Null or 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 +191,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 +225,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):
@@ -254,6 +261,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 +280,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 +307,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):
@@ -393,6 +402,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)
 
@@ -426,17 +437,15 @@ class Case(Operator):
                     raise SemanticError("2-1-9-4", op=cls.op, name=condition.name)
 
             nullable = any(
-                (thenOp.nullable if isinstance(thenOp, DataComponent) else thenOp.data_type == Null)
-                for thenOp in ops
+                (op.nullable if isinstance(op, DataComponent) else op.data_type == Null)
+                for op in ops
             )
-            nullable |= any(condition.nullable for condition in conditions)
-
             data_type = ops[0].data_type
             for op in ops[1:]:
                 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,
@@ -459,4 +468,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(