vtlengine 1.0.3rc3__py3-none-any.whl → 1.1__py3-none-any.whl

vtlengine/Interpreter/__init__.py

@@ -1,16 +1,17 @@
 from copy import copy, deepcopy
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
 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,
@@ -68,10 +69,19 @@ from vtlengine.Operators.CastOperator import Cast
 from vtlengine.Operators.Comparison import Between, ExistIn
 from vtlengine.Operators.Conditional import Case, If
 from vtlengine.Operators.General import Eval
-from vtlengine.Operators.HROperators import HAAssignment, Hierarchy, get_measure_from_dataset
+from vtlengine.Operators.HROperators import (
+    HAAssignment,
+    Hierarchy,
+    get_measure_from_dataset,
+)
 from vtlengine.Operators.Numeric import Round, Trunc
 from vtlengine.Operators.String import Instr, Replace, Substr
-from vtlengine.Operators.Time import Current_Date, Date_Add, Fill_time_series, Time_Aggregation
+from vtlengine.Operators.Time import (
+    Current_Date,
+    Date_Add,
+    Fill_time_series,
+    Time_Aggregation,
+)
 from vtlengine.Operators.Validation import Check, Check_Datapoint, Check_Hierarchy
 from vtlengine.Utils import (
     AGGREGATION_MAPPING,
@@ -104,6 +114,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
@@ -153,7 +165,9 @@ class InterpreterAnalyzer(ASTTemplate):
         for ds_name in self.ds_analysis[INSERT][statement_num]:
             if ds_name in self.datapoints_paths:
                 self.datasets[ds_name].data = load_datapoints(
-                    self.datasets[ds_name].components, ds_name, self.datapoints_paths[ds_name]
+                    self.datasets[ds_name].components,
+                    ds_name,
+                    self.datapoints_paths[ds_name],
                 )
             elif ds_name in self.datasets and self.datasets[ds_name].data is None:
                 _fill_dataset_empty_data(self.datasets[ds_name])
@@ -177,10 +191,14 @@ 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, self.datasets[ds_name], self.output_path
+                self.time_period_representation,
+                self.datasets[ds_name],
+                self.output_path,
             )
             self.datasets[ds_name].data = None
 
@@ -201,8 +219,9 @@ class InterpreterAnalyzer(ASTTemplate):
             if isinstance(child, (AST.Assignment, AST.PersistentAssignment)):
                 vtlengine.Exceptions.dataset_output = child.left.value  # type: ignore[attr-defined]
                 self._load_datapoints_efficient(statement_num)
-            if (not isinstance(child, (AST.HRuleset, AST.DPRuleset, AST.Operator)) and
-                    not isinstance(child, (AST.Assignment, AST.PersistentAssignment))):
+            if not isinstance(
+                child, (AST.HRuleset, AST.DPRuleset, AST.Operator)
+            ) and not isinstance(child, (AST.Assignment, AST.PersistentAssignment)):
                 raise SemanticError("1-3-17")
             result = self.visit(child)
 
@@ -229,15 +248,14 @@ class InterpreterAnalyzer(ASTTemplate):
     # Definition Language
 
     def visit_Operator(self, node: AST.Operator) -> None:
-
         if self.udos is None:
             self.udos = {}
         elif node.op in self.udos:
             raise ValueError(f"User Defined Operator {node.op} already exists")
 
-        param_info = []
+        param_info: List[Dict[str, Union[str, Type[ScalarType], AST.AST]]] = []
         for param in node.parameters:
-            if param.name in param_info:
+            if param.name in [x["name"] for x in param_info]:
                 raise ValueError(f"Duplicated Parameter {param.name} in UDO {node.op}")
             # We use a string for model types, but the data type class for basic types
             # (Integer, Number, String, Boolean, ...)
@@ -262,7 +280,6 @@ class InterpreterAnalyzer(ASTTemplate):
         }
 
     def visit_DPRuleset(self, node: AST.DPRuleset) -> None:
-
         # Rule names are optional, if not provided, they are generated.
         # If provided, all must be provided
         rule_names = [rule.name for rule in node.rules if rule.name is not None]
@@ -323,7 +340,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]
@@ -357,8 +374,10 @@ class InterpreterAnalyzer(ASTTemplate):
     def visit_PersistentAssignment(self, node: AST.PersistentAssignment) -> Any:
         return self.visit_Assignment(node)
 
-    def visit_BinOp(self, node: AST.BinOp) -> Any:
+    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 (
             not self.is_from_condition
@@ -369,13 +388,23 @@ class InterpreterAnalyzer(ASTTemplate):
             is_from_if = self.is_from_if
             self.is_from_if = False
 
-        if (self.is_from_join and node.op in [MEMBERSHIP, AGGREGATE] and
-                hasattr(node.left, "value") and hasattr(node.right, "value")):
+        if (
+            self.is_from_join
+            and node.op in [MEMBERSHIP, AGGREGATE]
+            and hasattr(node.left, "value")
+            and hasattr(node.right, "value")
+        ):
             if self.udo_params is not None and node.right.value in self.udo_params[-1]:
                 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)
@@ -421,7 +450,10 @@ class InterpreterAnalyzer(ASTTemplate):
             if node.operand is not None and operand is not None:
                 op_comp: DataComponent = self.visit(node.operand)
                 comps_to_keep = {}
-                for comp_name, comp in self.regular_aggregation_dataset.components.items():
+                for (
+                    comp_name,
+                    comp,
+                ) in self.regular_aggregation_dataset.components.items():
                     if comp.role == Role.IDENTIFIER:
                         comps_to_keep[comp_name] = copy(comp)
                 comps_to_keep[op_comp.name] = Component(
@@ -554,6 +586,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",
@@ -565,7 +599,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",
@@ -744,8 +778,12 @@ class InterpreterAnalyzer(ASTTemplate):
                         is_partial_present = 0
                         found_comp = None
                         for comp_name in self.regular_aggregation_dataset.get_components_names():
-                            if ("#" in comp_name and comp_name.split("#")[1] == node.value or "#"
-                                    in node.value and node.value.split("#")[1] == comp_name):
+                            if (
+                                "#" in comp_name
+                                and comp_name.split("#")[1] == node.value
+                                or "#" in node.value
+                                and node.value.split("#")[1] == comp_name
+                            ):
                                 is_partial_present += 1
                                 found_comp = comp_name
                         if is_partial_present == 0:
@@ -756,7 +794,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",
@@ -783,7 +821,9 @@ class InterpreterAnalyzer(ASTTemplate):
             comp_name = self.ruleset_signature[node.value]
             if comp_name not in self.ruleset_dataset.components:
                 raise SemanticError(
-                    "1-1-1-10", comp_name=node.value, dataset_name=self.ruleset_dataset.name
+                    "1-1-1-10",
+                    comp_name=node.value,
+                    dataset_name=self.ruleset_dataset.name,
                 )
             data = None if self.rule_data is None else self.rule_data[comp_name]
             return DataComponent(
@@ -938,7 +978,6 @@ class InterpreterAnalyzer(ASTTemplate):
         return REGULAR_AGGREGATION_MAPPING[node.op].analyze(operands, dataset)
 
     def visit_If(self, node: AST.If) -> Dataset:
-
         self.is_from_condition = True
         condition = self.visit(node.condition)
         self.is_from_condition = False
@@ -948,7 +987,10 @@ class InterpreterAnalyzer(ASTTemplate):
             elseValue = self.visit(node.elseOp)
             if not isinstance(thenValue, Scalar) or not isinstance(elseValue, Scalar):
                 raise SemanticError(
-                    "1-1-9-3", op="If_op", then_name=thenValue.name, else_name=elseValue.name
+                    "1-1-9-3",
+                    op="If_op",
+                    then_name=thenValue.name,
+                    else_name=elseValue.name,
                 )
             if condition.value:
                 return self.visit(node.thenOp)
@@ -1024,7 +1066,9 @@ class InterpreterAnalyzer(ASTTemplate):
 
     def visit_Constant(self, node: AST.Constant) -> Any:
         return Scalar(
-            name=str(node.value), value=node.value, data_type=BASIC_TYPES[type(node.value)]
+            name=str(node.value),
+            value=node.value,
+            data_type=BASIC_TYPES[type(node.value)],
         )
 
     def visit_JoinOp(self, node: AST.JoinOp) -> None:
@@ -1130,7 +1174,9 @@ class InterpreterAnalyzer(ASTTemplate):
                 for comp_name in node.children[2:]:
                     if comp_name.__str__() not in dataset_element.components:
                         raise SemanticError(
-                            "1-1-1-10", comp_name=comp_name, dataset_name=dataset_element.name
+                            "1-1-1-10",
+                            comp_name=comp_name,
+                            dataset_name=dataset_element.name,
                         )
                 if dpr_info is not None and dpr_info["signature_type"] == "variable":
                     for i, comp_name in enumerate(node.children[2:]):
@@ -1164,7 +1210,9 @@ class InterpreterAnalyzer(ASTTemplate):
 
             # Datapoint Ruleset final evaluation
             return Check_Datapoint.analyze(
-                dataset_element=dataset_element, rule_info=rule_output_values, output=output
+                dataset_element=dataset_element,
+                rule_info=rule_output_values,
+                output=output,
             )
         elif node.op in (CHECK_HIERARCHY, HIERARCHY):
             if len(node.children) == 3:
@@ -1203,7 +1251,10 @@ class InterpreterAnalyzer(ASTTemplate):
                     and hr_info["signature"] != component
                 ):
                     raise SemanticError(
-                        "1-1-10-3", op=node.op, found=component, expected=hr_info["signature"]
+                        "1-1-10-3",
+                        op=node.op,
+                        found=component,
+                        expected=hr_info["signature"],
                     )
                 elif hr_info["node"].signature_type == "valuedomain" and component is None:
                     raise SemanticError("1-1-10-4", op=node.op)
@@ -1215,7 +1266,10 @@ class InterpreterAnalyzer(ASTTemplate):
                         and cond_components[i] != cond_comp
                     ):
                         raise SemanticError(
-                            "1-1-10-6", op=node.op, expected=cond_comp, found=cond_components[i]
+                            "1-1-10-6",
+                            op=node.op,
+                            expected=cond_comp,
+                            found=cond_components[i],
                         )
                     cond_info[cond_comp] = cond_components[i]
 
@@ -1235,6 +1289,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)
 
@@ -1270,7 +1328,9 @@ class InterpreterAnalyzer(ASTTemplate):
                 # Final evaluation
                 if node.op == CHECK_HIERARCHY:
                     result = Check_Hierarchy.analyze(
-                        dataset_element=dataset, rule_info=rule_output_values, output=output
+                        dataset_element=dataset,
+                        rule_info=rule_output_values,
+                        output=output,
                     )
                     del rule_output_values
                 else:
@@ -1396,10 +1456,12 @@ class InterpreterAnalyzer(ASTTemplate):
                     left_operand.data = pd.DataFrame({measure_name: []})
                 if right_operand.data is None:
                     right_operand.data = pd.DataFrame({measure_name: []})
-                left_null_indexes = set(left_operand.data[left_operand.data[
-                    measure_name].isnull()].index)
-                right_null_indexes = set(right_operand.data[right_operand.data[
-                    measure_name].isnull()].index)
+                left_null_indexes = set(
+                    left_operand.data[left_operand.data[measure_name].isnull()].index
+                )
+                right_null_indexes = set(
+                    right_operand.data[right_operand.data[measure_name].isnull()].index
+                )
                 # If no indexes are in common, then one datapoint is not null
                 invalid_indexes = list(left_null_indexes.intersection(right_null_indexes))
                 if len(invalid_indexes) > 0:
@@ -1415,7 +1477,6 @@ class InterpreterAnalyzer(ASTTemplate):
         return HR_UNARY_MAPPING[node.op].analyze(operand)
 
     def visit_Validation(self, node: AST.Validation) -> Dataset:
-
         validation_element = self.visit(node.validation)
         if not isinstance(validation_element, Dataset):
             raise ValueError(f"Expected dataset, got {type(validation_element).__name__}")
@@ -1532,12 +1593,26 @@ class InterpreterAnalyzer(ASTTemplate):
         components.update(
             {
                 name: Component(
-                    name=name, data_type=BASIC_TYPES[int], role=Role.MEASURE, nullable=True
+                    name=name,
+                    data_type=BASIC_TYPES[int],
+                    role=Role.MEASURE,
+                    nullable=True,
                 )
             }
         )
+
+        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)
 
@@ -1548,14 +1623,16 @@ 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):
+        if isinstance(left_operand, (Dataset, DataComponent)):
             if left_operand.data is None:
                 return left_operand, right_operand
             if isinstance(left_operand, Dataset):
@@ -1571,7 +1648,7 @@ class InterpreterAnalyzer(ASTTemplate):
             else:
                 left = left_operand.data
                 left_operand.data = left.reindex(merge_index, fill_value=None)
-        if isinstance(right_operand, Dataset | DataComponent):
+        if isinstance(right_operand, (Dataset, DataComponent)):
             if right_operand.data is None:
                 return left_operand, right_operand
             if isinstance(right_operand, Dataset):
@@ -1737,9 +1814,7 @@ class InterpreterAnalyzer(ASTTemplate):
                         signature_values[param["name"]] = self.visit(node.params[i])
                     elif param["type"] in ["Dataset", "Component"]:
                         if isinstance(node.params[i], AST.VarID):
-                            signature_values[param["name"]] = node.params[
-                                i
-                            ].value  # type: ignore[attr-defined]
+                            signature_values[param["name"]] = node.params[i].value  # type: ignore[attr-defined]
                         else:
                             param_element = self.visit(node.params[i])
                             if isinstance(param_element, Dataset):
@@ -1831,8 +1906,23 @@ 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, period_to=node.period_to, conf=node.conf
+            operand=operand,
+            period_from=node.period_from,
+            period_to=node.period_to,
+            conf=node.conf,
         )

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,23 +234,21 @@ 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 "", na_action="ignore"
+                    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 "", na_action="ignore"
+                    lambda x: str(TimePeriodHandler(str(x))) if x != "" else "",
+                    na_action="ignore",
                 )
             elif type_name in ["Integer", "Number"]:
                 type_ = "int64" if type_name == "Integer" else "float32"
                 # We use here a number to avoid errors on equality on empty strings
                 self.data[comp.name] = (
-                    self.data[comp.name]
-                    .replace("", -1234997)
-                    .astype(type_)  # type: ignore[call-overload]
+                    self.data[comp.name].replace("", -1234997).astype(type_)  # type: ignore[call-overload]
                 )
                 other.data[comp.name] = (
-                    other.data[comp.name]
-                    .replace("", -1234997)
-                    .astype(type_)  # type: ignore[call-overload]
+                    other.data[comp.name].replace("", -1234997).astype(type_)  # type: ignore[call-overload]
                 )
         try:
             assert_frame_equal(
@@ -334,7 +337,7 @@ class Dataset:
         return {
             "name": self.name,
             "components": {k: v.to_dict() for k, v in self.components.items()},
-            "data": self.data.to_dict(orient="records") if self.data is not None else None,
+            "data": (self.data.to_dict(orient="records") if self.data is not None else None),
         }
 
     def to_json(self) -> str:

vtlengine/Operators/Aggregation.py

@@ -29,8 +29,8 @@ from vtlengine.DataTypes import (
     unary_implicit_promotion,
 )
 from vtlengine.DataTypes.TimeHandling import (
-    DURATION_MAPPING,
-    DURATION_MAPPING_REVERSED,
+    PERIOD_IND_MAPPING,
+    PERIOD_IND_MAPPING_REVERSE,
     TimeIntervalHandler,
     TimePeriodHandler,
 )
@@ -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(
@@ -89,7 +89,10 @@ class Aggregation(Operator.Unary):
                     data[measure.name] = (
                         data[measure.name]
                         .astype(object)
-                        .map(lambda x: TimeIntervalHandler.from_iso_format(x), na_action="ignore")
+                        .map(
+                            lambda x: TimeIntervalHandler.from_iso_format(str(x)),
+                            na_action="ignore",
+                        )
                     )
                 else:
                     data[measure.name] = data[measure.name].map(
@@ -100,11 +103,13 @@ class Aggregation(Operator.Unary):
             elif measure.data_type == Duration:
                 if mode == "input":
                     data[measure.name] = data[measure.name].map(
-                        lambda x: DURATION_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: DURATION_MAPPING_REVERSED[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":
@@ -128,7 +133,10 @@ class Aggregation(Operator.Unary):
             for comp_name in grouping_columns:
                 if comp_name not in operand.components:
                     raise SemanticError(
-                        "1-1-1-10", op=cls.op, comp_name=comp_name, dataset_name=operand.name
+                        "1-1-1-10",
+                        op=cls.op,
+                        comp_name=comp_name,
+                        dataset_name=operand.name,
                     )
                 if operand.components[comp_name].role != Role.IDENTIFIER:
                     raise SemanticError(
@@ -202,7 +210,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, "
@@ -223,7 +231,7 @@ class Aggregation(Operator.Unary):
             )
 
         try:
-            return duckdb.query(query).to_df()
+            return duckdb.query(query).to_df().astype(object)
         except RuntimeError as e:
             if "Conversion" in e.args[0]:
                 raise SemanticError("2-3-8", op=cls.op, msg=e.args[0].split(":")[-1])