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

vtlengine/Interpreter/__init__.py

@@ -8,9 +8,10 @@ import pandas as pd
 import vtlengine.AST as AST
 import vtlengine.Exceptions
 import vtlengine.Operators as Operators
+from vtlengine.AST import VarID
 from vtlengine.AST.ASTTemplate import ASTTemplate
 from vtlengine.AST.DAG import HRDAGAnalyzer
-from vtlengine.AST.DAG._words import DELETE, GLOBAL, INSERT
+from vtlengine.AST.DAG._words import DELETE, GLOBAL, INSERT, PERSISTENT
 from vtlengine.AST.Grammar.tokens import (
     AGGREGATE,
     ALL,
@@ -96,6 +97,7 @@ from vtlengine.Utils import (
     THEN_ELSE,
     UNARY_MAPPING,
 )
+from vtlengine.Utils.__Virtual_Assets import VirtualCounter
 
 
 # noinspection PyTypeChecker
@@ -103,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
@@ -113,6 +116,8 @@ class InterpreterAnalyzer(ASTTemplate):
     output_path: Optional[Union[str, Path]] = None
     # Time Period Representation
     time_period_representation: Optional[TimePeriodRepresentation] = None
+    # Return only persistent
+    return_only_persistent: bool = True
     # Flags to change behavior
     nested_condition: Union[str, bool] = False
     is_from_assignment: bool = False
@@ -188,7 +193,9 @@ class InterpreterAnalyzer(ASTTemplate):
                 # We do not save global input datasets, only results of transformations
                 self.datasets[ds_name].data = None
                 continue
-
+            if self.return_only_persistent and ds_name not in self.ds_analysis[PERSISTENT]:
+                self.datasets[ds_name].data = None
+                continue
             # Saving only datasets, no scalars
             save_datapoints(
                 self.time_period_representation,
@@ -197,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          *
@@ -210,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]
@@ -227,6 +244,9 @@ class InterpreterAnalyzer(ASTTemplate):
             self.else_condition_dataset = None
             self.nested_condition = False
 
+            # Reset VirtualCounter
+            VirtualCounter.reset()
+
             if result is None:
                 continue
 
@@ -235,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
@@ -335,7 +368,7 @@ class InterpreterAnalyzer(ASTTemplate):
             for i, rule in enumerate(node.rules):
                 rule.name = (i + 1).__str__()
 
-        cond_comp = []
+        cond_comp: List[Any] = []
         if isinstance(node.element, list):
             cond_comp = [x.value for x in node.element[:-1]]
             node.element = node.element[-1]
@@ -369,6 +402,9 @@ class InterpreterAnalyzer(ASTTemplate):
     def visit_PersistentAssignment(self, node: AST.PersistentAssignment) -> Any:
         return self.visit_Assignment(node)
 
+    def visit_ParFunction(self, node: AST.ParFunction) -> Any:
+        return self.visit(node.operand)
+
     def visit_BinOp(self, node: AST.BinOp) -> Any:
         is_from_if = False
         if (
@@ -390,7 +426,13 @@ class InterpreterAnalyzer(ASTTemplate):
                 comp_name = f"{node.left.value}#{self.udo_params[-1][node.right.value]}"
             else:
                 comp_name = f"{node.left.value}#{node.right.value}"
-            ast_var_id = AST.VarID(value=comp_name)
+            ast_var_id = AST.VarID(
+                value=comp_name,
+                line_start=node.right.line_start,
+                line_stop=node.right.line_stop,
+                column_start=node.right.column_start,
+                column_stop=node.right.column_stop,
+            )
             return self.visit(ast_var_id)
         left_operand = self.visit(node.left)
         right_operand = self.visit(node.right)
@@ -515,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:
@@ -572,6 +617,8 @@ class InterpreterAnalyzer(ASTTemplate):
                 for comp_name in node.partition_by:
                     if comp_name in self.udo_params[-1]:
                         partitioning.append(self.udo_params[-1][comp_name])
+                    elif comp_name in operand.get_identifiers_names():
+                        partitioning.append(comp_name)
                     else:
                         raise SemanticError(
                             "2-3-9",
@@ -583,7 +630,7 @@ class InterpreterAnalyzer(ASTTemplate):
                 for o in node.order_by:
                     if o.component in self.udo_params[-1]:
                         o.component = self.udo_params[-1][o.component]
-                    else:
+                    elif o.component not in operand.get_identifiers_names():
                         raise SemanticError(
                             "2-3-9",
                             comp_type="Component",
@@ -749,10 +796,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
@@ -778,7 +825,7 @@ class InterpreterAnalyzer(ASTTemplate):
                             )
                         elif is_partial_present == 2:
                             raise SemanticError("1-1-13-9", comp_name=node.value)
-                        node.value = found_comp
+                        node.value = found_comp  # type:ignore[assignment]
                     if node.value not in self.regular_aggregation_dataset.components:
                         raise SemanticError(
                             "1-1-1-10",
@@ -817,8 +864,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:
@@ -1273,6 +1323,10 @@ class InterpreterAnalyzer(ASTTemplate):
                         signature_type=hr_info["node"].signature_type,
                         element=hr_info["node"].element,
                         rules=aux,
+                        line_start=node.line_start,
+                        line_stop=node.line_stop,
+                        column_start=node.column_start,
+                        column_stop=node.column_stop,
                     )
                     HRDAGAnalyzer().visit(hierarchy_ast)
 
@@ -1580,8 +1634,19 @@ class InterpreterAnalyzer(ASTTemplate):
                 )
             }
         )
+
+        if self.condition_stack and len(self.condition_stack) > 0:
+            last_condition_dataset = (
+                self.then_condition_dataset[-1]
+                if self.condition_stack[-1] == THEN_ELSE["then"]
+                else (self.else_condition_dataset[-1])
+            )
+            measure_name = last_condition_dataset.get_measures_names()[0]
+            then_data = then_data[then_data[name].isin(last_condition_dataset.data[measure_name])]
+            else_data = else_data[else_data[name].isin(last_condition_dataset.data[measure_name])]
         then_dataset = Dataset(name=name, components=components, data=then_data)
         else_dataset = Dataset(name=name, components=components, data=else_data)
+
         self.then_condition_dataset.append(then_dataset)
         self.else_condition_dataset.append(else_dataset)
 
@@ -1592,11 +1657,13 @@ class InterpreterAnalyzer(ASTTemplate):
             or self.condition_stack is None
         ):
             return left_operand, right_operand
+
         merge_dataset = (
             self.then_condition_dataset.pop()
             if self.condition_stack.pop() == THEN_ELSE["then"]
             else (self.else_condition_dataset.pop())
         )
+
         merge_index = merge_dataset.data[merge_dataset.get_measures_names()[0]].to_list()
         ids = merge_dataset.get_identifiers_names()
         if isinstance(left_operand, (Dataset, DataComponent)):
@@ -1873,8 +1940,20 @@ class InterpreterAnalyzer(ASTTemplate):
         return result
 
     def visit_TimeAggregation(self, node: AST.TimeAggregation) -> None:
-        operand = self.visit(node.operand)
-
+        if node.operand is not None:
+            operand = self.visit(node.operand)
+        else:
+            if self.aggregation_dataset is None:
+                raise SemanticError("1-1-19-11")
+            component_name = Time_Aggregation._get_time_id(self.aggregation_dataset)
+            ast_operand = VarID(
+                value=component_name,
+                line_start=node.line_start,
+                line_stop=node.line_stop,
+                column_start=node.column_start,
+                column_stop=node.column_stop,
+            )
+            operand = self.visit(ast_operand)
         return Time_Aggregation.analyze(
             operand=operand,
             period_from=node.period_from,

vtlengine/Model/__init__.py

@@ -1,3 +1,4 @@
+import inspect
 import json
 from collections import Counter
 from dataclasses import dataclass
@@ -128,10 +129,14 @@ class Component:
         )
 
     def to_dict(self) -> Dict[str, Any]:
+        data_type = self.data_type
+        if not inspect.isclass(self.data_type):
+            data_type = self.data_type.__class__  # type: ignore[assignment]
         return {
             "name": self.name,
-            "data_type": DataTypes.SCALAR_TYPES_CLASS_REVERSE[self.data_type],
-            "role": self.role.value,
+            "data_type": DataTypes.SCALAR_TYPES_CLASS_REVERSE[data_type],
+            # Need to check here for NoneType as UDO argument has it
+            "role": self.role.value if self.role is not None else None,  # type: ignore[redundant-expr]
             "nullable": self.nullable,
         }
 
@@ -229,11 +234,11 @@ class Dataset:
                 self.data[comp.name] = self.data[comp.name].astype(str)
                 other.data[comp.name] = other.data[comp.name].astype(str)
                 self.data[comp.name] = self.data[comp.name].map(
-                    lambda x: str(TimePeriodHandler(x)) if x != "" else "",
+                    lambda x: str(TimePeriodHandler(str(x))) if x != "" else "",
                     na_action="ignore",
                 )
                 other.data[comp.name] = other.data[comp.name].map(
-                    lambda x: str(TimePeriodHandler(x)) if x != "" else "",
+                    lambda x: str(TimePeriodHandler(str(x))) if x != "" else "",
                     na_action="ignore",
                 )
             elif type_name in ["Integer", "Number"]:

vtlengine/Operators/Aggregation.py

@@ -78,7 +78,7 @@ class Aggregation(Operator.Unary):
                     data[measure.name] = (
                         data[measure.name]
                         .astype(object)
-                        .map(lambda x: TimePeriodHandler(x), na_action="ignore")
+                        .map(lambda x: TimePeriodHandler(str(x)), na_action="ignore")
                     )
                 else:
                     data[measure.name] = data[measure.name].map(
@@ -90,7 +90,7 @@ class Aggregation(Operator.Unary):
                         data[measure.name]
                         .astype(object)
                         .map(
-                            lambda x: TimeIntervalHandler.from_iso_format(x),
+                            lambda x: TimeIntervalHandler.from_iso_format(str(x)),
                             na_action="ignore",
                         )
                     )
@@ -103,11 +103,13 @@ 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], na_action="ignore"
+                        lambda x: PERIOD_IND_MAPPING[x],  # type: ignore[index]
+                        na_action="ignore",
                     )
                 else:
                     data[measure.name] = data[measure.name].map(
-                        lambda x: PERIOD_IND_MAPPING_REVERSE[x], na_action="ignore"
+                        lambda x: PERIOD_IND_MAPPING_REVERSE[x],  # type: ignore[index]
+                        na_action="ignore",
                     )
             elif measure.data_type == Boolean:
                 if mode == "result":
@@ -168,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
@@ -208,7 +215,7 @@ class Aggregation(Operator.Unary):
                 e = f'"{e}"'
                 if cls.type_to_check is not None and cls.op != COUNT:
                     functions += (
-                        f"{cls.py_op}(CAST({e} AS REAL)) AS {e}, "  # Count can only be one here
+                        f"{cls.py_op}(CAST({e} AS DOUBLE)) AS {e}, "  # Count can only be one here
                     )
                 elif cls.op == COUNT:
                     functions += f"{cls.py_op}({e}) AS int_var, "

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(
@@ -189,21 +190,26 @@ class Analytic(Operator.Unary):
         if window is not None:
             mode = "ROWS" if window.type_ == "data" else "RANGE"
             start_mode = (
-                window.start_mode
-                if window.start_mode != "current" and window.start != "CURRENT ROW"
+                window.start_mode.upper()
+                if (isinstance(window.start, int) and window.start != 0)
+                or (isinstance(window.start, str) and window.start == "unbounded")
                 else ""
             )
             stop_mode = (
-                window.stop_mode
-                if window.stop_mode != "current" and window.stop != "CURRENT ROW"
+                window.stop_mode.upper()
+                if (isinstance(window.stop, int) and window.stop != 0)
+                or (isinstance(window.stop, str) and window.stop == "unbounded")
                 else ""
             )
-            if isinstance(window.start, int) and window.start == -1:
-                window.start = "UNBOUNDED"
-
-            if stop_mode == "" and window.stop == 0:
-                window.stop = "CURRENT ROW"
-            window_str = f"{mode} BETWEEN {window.start} {start_mode} AND {window.stop} {stop_mode}"
+            start = (
+                "UNBOUNDED"
+                if window.start == "unbounded" or window.start == -1
+                else str(window.start)
+            )
+            stop = (
+                "CURRENT ROW" if window.stop == "current" or window.stop == 0 else str(window.stop)
+            )
+            window_str = f"{mode} BETWEEN {start} {start_mode} AND {stop} {stop_mode}"
 
         # Partitioning
         partition = "PARTITION BY " + ", ".join(partitioning) if len(partitioning) > 0 else ""
@@ -224,7 +230,7 @@ class Analytic(Operator.Unary):
             if cls.op == RANK:
                 measure_query = f"{cls.sql_op}()"
             elif cls.op == RATIO_TO_REPORT:
-                measure_query = f"CAST({measure} AS REAL) / SUM(CAST({measure} AS REAL))"
+                measure_query = f"CAST({measure} AS DOUBLE) / SUM(CAST({measure} AS DOUBLE))"
             elif cls.op in [LAG, LEAD]:
                 measure_query = f"{cls.sql_op}({measure}, {','.join(map(str, params or []))})"
             else:

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)
         )