vtlengine 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

vtlengine/AST/ASTConstructorModules/ExprComponents.py

@@ -1,21 +1,23 @@
 from antlr4.tree.Tree import TerminalNodeImpl
 
 from vtlengine.AST import (
+    ID,
     Aggregation,
-    If,
+    Analytic,
     BinOp,
-    UnaryOp,
-    ID,
-    ParamOp,
-    MulOp,
+    Case,
+    CaseObj,
     Constant,
+    EvalOp,
+    Identifier,
+    If,
+    MulOp,
     ParamConstant,
+    ParamOp,
     TimeAggregation,
-    Identifier,
-    EvalOp,
-    VarID,
-    Analytic,
     UDOCall,
+    UnaryOp,
+    VarID,
 )
 from vtlengine.AST.ASTConstructorModules.Terminals import Terminals
 from vtlengine.AST.Grammar.parser import Parser
@@ -34,20 +36,20 @@ class ExprComp(VtlVisitor):
     def visitExprComponent(self, ctx: Parser.ExprComponentContext):
         """
         exprComponent:
-            LPAREN exprComponent RPAREN                                                                             # parenthesisExprComp # noqa E501
-            | functionsComponents                                                                                   # functionsExpressionComp # noqa E501
-            | op=(PLUS|MINUS|NOT) right=exprComponent                                                               # unaryExprComp # noqa E501
-            | left=exprComponent op=(MUL|DIV) right=exprComponent                                                   # arithmeticExprComp # noqa E501
-            | left=exprComponent op=(PLUS|MINUS|CONCAT) right=exprComponent                                         # arithmeticExprOrConcatComp # noqa E501
-            | left=exprComponent comparisonOperand right=exprComponent                                              # comparisonExprComp # noqa E501
-            | left=exprComponent op=(IN|NOT_IN)(lists|valueDomainID)                                                # inNotInExprComp # noqa E501
-            | left=exprComponent op=AND right=exprComponent                                                         # booleanExprComp # noqa E501
-            | left=exprComponent op=(OR|XOR) right=exprComponent                                                    # booleanExprComp # noqa E501
-            | IF  conditionalExpr=exprComponent  THEN thenExpr=exprComponent ELSE elseExpr=exprComponent            # ifExprComp # noqa E501
-            | constant                                                                                              # constantExprComp # noqa E501
-            | componentID                                                                                           # compId # noqa E501
+            LPAREN exprComponent RPAREN                                                                             # parenthesisExprComp
+            | functionsComponents                                                                                   # functionsExpressionComp
+            | op=(PLUS|MINUS|NOT) right=exprComponent                                                               # unaryExprComp
+            | left=exprComponent op=(MUL|DIV) right=exprComponent                                                   # arithmeticExprComp
+            | left=exprComponent op=(PLUS|MINUS|CONCAT) right=exprComponent                                         # arithmeticExprOrConcatComp
+            | left=exprComponent comparisonOperand right=exprComponent                                              # comparisonExprComp
+            | left=exprComponent op=(IN|NOT_IN)(lists|valueDomainID)                                                # inNotInExprComp
+            | left=exprComponent op=AND right=exprComponent                                                         # booleanExprComp
+            | left=exprComponent op=(OR|XOR) right=exprComponent                                                    # booleanExprComp
+            | IF  conditionalExpr=exprComponent  THEN thenExpr=exprComponent ELSE elseExpr=exprComponent            # ifExprComp
+            | constant                                                                                              # constantExprComp
+            | componentID                                                                                           # compId
         ;
-        """
+        """ # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
@@ -87,6 +89,10 @@ class ExprComp(VtlVisitor):
         elif isinstance(ctx, Parser.IfExprCompContext):
             return self.visitIfExprComp(ctx)
 
+        # CASE WHEN conditionalExpr=expr THEN thenExpr=expr ELSE elseExpr=expr END # caseExpr
+        elif isinstance(ctx, Parser.CaseExprCompContext):
+            return self.visitCaseExprComp(ctx)
+
         # constant
         elif isinstance(ctx, Parser.ConstantExprCompContext):
             return Terminals().visitConstant(c)
@@ -169,6 +175,26 @@ class ExprComp(VtlVisitor):
 
         return if_node
 
+    def visitCaseExprComp(self, ctx: Parser.CaseExprCompContext):
+        ctx_list = list(ctx.getChildren())
+
+        if len(ctx_list) % 4 != 3:
+            raise ValueError("Syntax error.")
+
+        else_node = self.visitExprComponent(ctx_list[-1])
+        ctx_list = ctx_list[1:-2]
+        cases = []
+
+        for i in range(0, len(ctx_list), 4):
+            condition = self.visitExprComponent(ctx_list[i + 1])
+            thenOp = self.visitExprComponent(ctx_list[i + 3])
+            case_obj = CaseObj(condition, thenOp)
+            cases.append(case_obj)
+
+        case_node = Case(cases, else_node)
+
+        return case_node
+
     def visitOptionalExprComponent(self, ctx: Parser.OptionalExprComponentContext):
         """
         optionalExpr: expr
@@ -253,8 +279,8 @@ class ExprComp(VtlVisitor):
 
     def visitCallComponent(self, ctx: Parser.CallComponentContext):
         """
-        callFunction: operatorID LPAREN (parameterComponent (COMMA parameterComponent)*)? RPAREN    # callComponent  # noqa E501
-        """
+        callFunction: operatorID LPAREN (parameterComponent (COMMA parameterComponent)*)? RPAREN    # callComponent
+        """ # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
@@ -269,8 +295,8 @@ class ExprComp(VtlVisitor):
 
     def visitEvalAtomComponent(self, ctx: Parser.EvalAtomComponentContext):
         """
-        | EVAL LPAREN routineName LPAREN (componentID|scalarItem)? (COMMA (componentID|scalarItem))* RPAREN (LANGUAGE STRING_CONSTANT)? (RETURNS outputParameterTypeComponent)? RPAREN      # evalAtomComponent  # noqa E501
-        """
+        | EVAL LPAREN routineName LPAREN (componentID|scalarItem)? (COMMA (componentID|scalarItem))* RPAREN (LANGUAGE STRING_CONSTANT)? (RETURNS outputParameterTypeComponent)? RPAREN      # evalAtomComponent
+        """ # noqa E501
         ctx_list = list(ctx.getChildren())
 
         routine_name = Terminals().visitRoutineName(ctx_list[2])
@@ -320,8 +346,8 @@ class ExprComp(VtlVisitor):
 
     def visitCastExprComponent(self, ctx: Parser.CastExprComponentContext):
         """
-        | CAST LPAREN exprComponent COMMA (basicScalarType|valueDomainName) (COMMA STRING_CONSTANT)? RPAREN         # castExprComponent  # noqa E501
-        """
+        | CAST LPAREN exprComponent COMMA (basicScalarType|valueDomainName) (COMMA STRING_CONSTANT)? RPAREN         # castExprComponent
+        """ # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
@@ -541,7 +567,7 @@ class ExprComp(VtlVisitor):
 
     def visitTimeFunctionsComponents(self, ctx: Parser.TimeFunctionsComponentsContext):
         if isinstance(ctx, Parser.PeriodAtomComponentContext):
-            return self.visitPeriodAtomComponent(ctx)
+            return self.visitTimeUnaryAtomComponent(ctx)
         elif isinstance(ctx, Parser.FillTimeAtomComponentContext):
             return self.visitFillTimeAtomComponent(ctx)
         elif isinstance(ctx, Parser.FlowAtomComponentContext):
@@ -552,10 +578,25 @@ class ExprComp(VtlVisitor):
             return self.visitTimeAggAtomComponent(ctx)
         elif isinstance(ctx, Parser.CurrentDateAtomComponentContext):
             return self.visitCurrentDateAtomComponent(ctx)
+        elif isinstance(ctx, Parser.DateDiffAtomComponentContext):
+            return self.visitDateDiffAtomComponent(ctx)
+        elif isinstance(ctx, Parser.DateAddAtomComponentContext):
+            return self.visitDateAddAtomComponentContext(ctx)
+        elif (isinstance(ctx, (
+            Parser.YearAtomComponentContext,
+            Parser.MonthAtomComponentContext,
+            Parser.DayOfMonthAtomComponentContext,
+            Parser.DayOfYearAtomComponentContext,
+            Parser.DayToYearAtomComponentContext,
+            Parser.DayToMonthAtomComponentContext,
+            Parser.YearToDayAtomComponentContext,
+            Parser.MonthToDayAtomComponentContext
+        ))):
+            return self.visitTimeUnaryAtomComponent(ctx)
         else:
             raise NotImplementedError
 
-    def visitPeriodAtomComponent(self, ctx: Parser.PeriodAtomComponentContext):
+    def visitTimeUnaryAtomComponent(self, ctx: Parser.PeriodAtomComponentContext):
         """
         periodExpr: PERIOD_INDICATOR '(' expr? ')' ;
         """
@@ -607,9 +648,9 @@ class ExprComp(VtlVisitor):
 
     def visitTimeAggAtomComponent(self, ctx: Parser.TimeAggAtomComponentContext):
         """
-        TIME_AGG LPAREN periodIndTo=STRING_CONSTANT (COMMA periodIndFrom=(STRING_CONSTANT| OPTIONAL ))? # noqa E501
-        (COMMA op=optionalExprComponent)? (COMMA (FIRST|LAST))? RPAREN    # timeAggAtomComponent; # noqa E501
-        """
+        TIME_AGG LPAREN periodIndTo=STRING_CONSTANT (COMMA periodIndFrom=(STRING_CONSTANT| OPTIONAL ))?
+        (COMMA op=optionalExprComponent)? (COMMA (FIRST|LAST))? RPAREN    # timeAggAtomComponent;
+        """ # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
@@ -628,10 +669,7 @@ class ExprComp(VtlVisitor):
             and str_.getSymbol().type in [Parser.FIRST, Parser.LAST]
         ]
 
-        if len(conf) == 0:
-            conf = None
-        else:
-            conf = conf[0]
+        conf = None if len(conf) == 0 else conf[0]
 
         if ctx.op is not None:
             operand_node = self.visitOptionalExprComponent(ctx.op)
@@ -653,6 +691,34 @@ class ExprComp(VtlVisitor):
         c = list(ctx.getChildren())[0]
         return MulOp(op=c.getSymbol().text, children=[])
 
+    def visitDateDiffAtomComponent(self, ctx: Parser.TimeShiftAtomComponentContext):
+        """ """
+        ctx_list = list(ctx.getChildren())
+        c = ctx_list[0]
+
+        op = c.getSymbol().text
+        left_node = self.visitExprComponent(ctx_list[2])
+        right_node = self.visitExprComponent(ctx_list[4])
+
+        return BinOp(left=left_node, op=op, right=right_node)
+
+    def visitDateAddAtomComponentContext(self, ctx: Parser.DateAddAtomComponentContext):
+        """ """
+        ctx_list = list(ctx.getChildren())
+        c = ctx_list[0]
+
+        op = c.getSymbol().text
+        children_node = [self.visitExprComponent(ctx_list[2])]
+
+        param_constant_node = []
+
+        if len(ctx_list) > 4:
+            param_constant_node = [self.visitExprComponent(ctx_list[4])]
+            if len(ctx_list) > 6:
+                param_constant_node.append(self.visitExprComponent(ctx_list[6]))
+
+        return ParamOp(op=op, children=children_node, params=param_constant_node)
+
     """
                             -----------------------------------
                                     Conditional Functions
@@ -815,9 +881,7 @@ class ExprComp(VtlVisitor):
             elif isinstance(c, Parser.OrderByClauseContext):
                 order_by = Terminals().visitOrderByClause(c)
                 continue
-            elif isinstance(c, Parser.SignedIntegerContext) or isinstance(
-                c, Parser.ScalarItemContext
-            ):
+            elif isinstance(c, (Parser.SignedIntegerContext, Parser.ScalarItemContext)):
                 if params is None:
                     params = []
                 if isinstance(c, Parser.SignedIntegerContext):

vtlengine/AST/ASTConstructorModules/Terminals.py

@@ -1,13 +1,3 @@
-from vtlengine.DataTypes import (
-    Boolean,
-    Date,
-    Duration,
-    Integer,
-    Number,
-    String,
-    TimeInterval,
-    TimePeriod,
-)
 from antlr4.tree.Tree import TerminalNodeImpl
 
 from vtlengine.AST import (
@@ -24,6 +14,16 @@ from vtlengine.AST import (
 )
 from vtlengine.AST.Grammar.parser import Parser
 from vtlengine.AST.VtlVisitor import VtlVisitor
+from vtlengine.DataTypes import (
+    Boolean,
+    Date,
+    Duration,
+    Integer,
+    Number,
+    String,
+    TimeInterval,
+    TimePeriod,
+)
 from vtlengine.Model import Component, Dataset, Role, Scalar
 
 
@@ -377,21 +377,21 @@ class Terminals(VtlVisitor):
 
     def visitDpRuleset(self, ctx: Parser.DpRulesetContext):
         """
-        DATAPOINT                                                                               # dataPoint  # noqa E501
-            | DATAPOINT_ON_VD  (GLPAREN  valueDomainName (MUL valueDomainName)*  GRPAREN )?         # dataPointVd  # noqa E501
-            | DATAPOINT_ON_VAR  (GLPAREN  varID (MUL varID)*  GRPAREN )?                            # dataPointVar  # noqa E501
+        DATAPOINT                                                                               # dataPoint
+            | DATAPOINT_ON_VD  (GLPAREN  valueDomainName (MUL valueDomainName)*  GRPAREN )?         # dataPointVd
+            | DATAPOINT_ON_VAR  (GLPAREN  varID (MUL varID)*  GRPAREN )?                            # dataPointVar
         ;
-        """
+        """ # noqa E501
         # AST_ASTCONSTRUCTOR.54
         raise NotImplementedError
 
     def visitHrRuleset(self, ctx: Parser.HrRulesetContext):
         """
-        hrRuleset: HIERARCHICAL                                                                                                            # hrRulesetType  # noqa E501
-            | HIERARCHICAL_ON_VD ( GLPAREN  vdName=IDENTIFIER (LPAREN valueDomainName (MUL valueDomainName)* RPAREN)?  GRPAREN )?   # hrRulesetVdType  # noqa E501
-            | HIERARCHICAL_ON_VAR ( GLPAREN  varName=varID (LPAREN  varID (MUL varID)* RPAREN)?  GRPAREN )?                         # hrRulesetVarType  # noqa E501
+        hrRuleset: HIERARCHICAL                                                                                                            # hrRulesetType
+            | HIERARCHICAL_ON_VD ( GLPAREN  vdName=IDENTIFIER (LPAREN valueDomainName (MUL valueDomainName)* RPAREN)?  GRPAREN )?   # hrRulesetVdType
+            | HIERARCHICAL_ON_VAR ( GLPAREN  varName=varID (LPAREN  varID (MUL varID)* RPAREN)?  GRPAREN )?                         # hrRulesetVarType
         ;
-        """
+        """ # noqa E501
         # AST_ASTCONSTRUCTOR.55
         raise NotImplementedError
 
@@ -407,15 +407,9 @@ class Terminals(VtlVisitor):
             for constraint in ctx_list
             if isinstance(constraint, Parser.ScalarTypeContext)
         ]
-        if len(data_type) > 0:
-            data_type = data_type[0]
-        else:
-            data_type = String()
+        data_type = data_type[0] if len(data_type) > 0 else String()
 
-        if role_node == Role.IDENTIFIER:
-            nullable = False
-        else:
-            nullable = True
+        nullable = role_node != Role.IDENTIFIER
 
         return Component(name="Component", data_type=data_type, role=role_node, nullable=nullable)
 
@@ -503,7 +497,7 @@ class Terminals(VtlVisitor):
     def visitScalarWithCast(self, ctx: Parser.ScalarWithCastContext):
         """
         |  CAST LPAREN constant COMMA (basicScalarType) (COMMA STRING_CONSTANT)? RPAREN    #scalarWithCast  # noqa E501
-        """
+        """ # noqa E501
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
@@ -513,10 +507,7 @@ class Terminals(VtlVisitor):
         const_node = self.visitConstant(ctx_list[2])
         basic_scalar_type = [self.visitBasicScalarType(ctx_list[4])]
 
-        if len(ctx_list) > 6:
-            param_node = [ParamConstant("PARAM_CAST", ctx_list[6])]
-        else:
-            param_node = []
+        param_node = [ParamConstant("PARAM_CAST", ctx_list[6])] if len(ctx_list) > 6 else []
 
         if len(basic_scalar_type) == 1:
             children_nodes = [const_node, basic_scalar_type[0]]
@@ -681,14 +672,12 @@ class Terminals(VtlVisitor):
         first = num_rows_1  # unbounded (default value)
         second = num_rows_2  # current data point (default value)
 
-        if mode_2 == "preceding":
-            if (
-                mode_1 == "preceding" and num_rows_1 == -1 and num_rows_2 == -1
-            ):  # preceding and preceding (error)
-                raise Exception(
-                    f"Cannot have 2 preceding clauses with unbounded in analytic clause, "
-                    f"line {ctx_list[3].start.line}"
-                )
+        if (mode_2 == "preceding" and mode_1 == "preceding" and num_rows_1 == -1
+                and num_rows_2 == -1):  # preceding and preceding (error)
+            raise Exception(
+                f"Cannot have 2 preceding clauses with unbounded in analytic clause, "
+                f"line {ctx_list[3].start.line}"
+            )
 
         if (
             mode_1 == "following" and num_rows_1 == -1 and num_rows_2 == -1

vtlengine/AST/ASTTemplate.py

@@ -10,7 +10,6 @@ Template to start a new visitor for the AST.
 from typing import Any
 
 import vtlengine.AST as AST
-
 from vtlengine.AST.ASTVisitor import NodeVisitor
 
 
@@ -314,6 +313,22 @@ class ASTTemplate(NodeVisitor):
         self.visit(node.thenOp)
         self.visit(node.elseOp)
 
+    def visit_Case(self, node: AST.Case) -> Any:
+        """
+        Case: (conditions, thenOp, elseOp)
+
+        Basic usage:
+
+            for condition in node.conditions:
+                self.visit(condition)
+            self.visit(node.thenOp)
+            self.visit(node.elseOp)
+        """
+        for case in node.cases:
+            self.visit(case.condition)
+            self.visit(case.thenOp)
+        self.visit(node.elseOp)
+
     def visit_Validation(self, node: AST.Validation) -> Any:
         """
         Validation: (op, validation, params, inbalance, invalid)

vtlengine/AST/DAG/__init__.py

@@ -15,24 +15,24 @@ import networkx as nx
 
 from vtlengine.AST import (
     AST,
-    BinOp,
-    VarID,
     Aggregation,
     Analytic,
-    JoinOp,
-    ParamOp,
-    Operator,
-    Identifier,
+    Assignment,
+    BinOp,
     DefIdentifier,
-    Start,
+    DPRuleset,
     HRuleset,
-    RegularAggregation,
+    Identifier,
+    JoinOp,
+    Operator,
+    ParamOp,
     PersistentAssignment,
-    Assignment,
-    DPRuleset,
+    RegularAggregation,
+    Start,
+    VarID,
 )
 from vtlengine.AST.ASTTemplate import ASTTemplate
-from vtlengine.AST.DAG._words import INSERT, DELETE, OUTPUTS, PERSISTENT, INPUTS, GLOBAL
+from vtlengine.AST.DAG._words import DELETE, GLOBAL, INPUTS, INSERT, OUTPUTS, PERSISTENT
 from vtlengine.AST.Grammar.tokens import AS, MEMBERSHIP, TO
 from vtlengine.Exceptions import SemanticError
 
@@ -313,10 +313,7 @@ class DAGAnalyzer(ASTTemplate):
             self.visit(node.left)
             self.isDataset = False
             self.visit(node.right)
-        elif node.op == AS:
-            self.visit(node.left)
-            self.alias.append(node.right.value)
-        elif node.op == TO:
+        elif node.op == AS or node.op == TO:
             self.visit(node.left)
             self.alias.append(node.right.value)
         else:

vtlengine/AST/Grammar/Vtl.g4

@@ -21,30 +21,33 @@ expr:
     | op=(PLUS|MINUS|NOT) right=expr                                        # unaryExpr
     | left=expr op=(MUL|DIV) right=expr                                     # arithmeticExpr
     | left=expr op=(PLUS|MINUS|CONCAT) right=expr                           # arithmeticExprOrConcat
-    | left=expr op=comparisonOperand right=expr                            # comparisonExpr
+    | left=expr op=comparisonOperand  right=expr                            # comparisonExpr
     | left=expr op=(IN|NOT_IN)(lists|valueDomainID)                         # inNotInExpr
     | left=expr op=AND right=expr                                           # booleanExpr
     | left=expr op=(OR|XOR) right=expr							            # booleanExpr
     | IF  conditionalExpr=expr  THEN thenExpr=expr ELSE elseExpr=expr       # ifExpr
+    | CASE (WHEN expr THEN expr)+ ELSE expr                                 # caseExpr
     | constant														        # constantExpr
     | varID															        # varIdExpr
 
+
 ;
 
 
 exprComponent:
-    LPAREN exprComponent RPAREN                                                                             # parenthesisExprComp
-    | functionsComponents                                                                                   # functionsExpressionComp
-    | op=(PLUS|MINUS|NOT) right=exprComponent                                                               # unaryExprComp
-    | left=exprComponent op=(MUL|DIV) right=exprComponent                                                   # arithmeticExprComp
-    | left=exprComponent op=(PLUS|MINUS|CONCAT) right=exprComponent                                         # arithmeticExprOrConcatComp
-    | left=exprComponent comparisonOperand right=exprComponent                                              # comparisonExprComp
-    | left=exprComponent op=(IN|NOT_IN)(lists|valueDomainID)                                                # inNotInExprComp
-    | left=exprComponent op=AND right=exprComponent                                                         # booleanExprComp
-    | left=exprComponent op=(OR|XOR) right=exprComponent                                                    # booleanExprComp
-    | IF  conditionalExpr=exprComponent  THEN thenExpr=exprComponent ELSE elseExpr=exprComponent            # ifExprComp
-    | constant                                                                                              # constantExprComp
-    | componentID                                                                                           # compId
+    LPAREN exprComponent RPAREN                                                                                 # parenthesisExprComp
+    | functionsComponents                                                                                       # functionsExpressionComp
+    | op=(PLUS|MINUS|NOT) right=exprComponent                                                                   # unaryExprComp
+    | left=exprComponent op=(MUL|DIV) right=exprComponent                                                       # arithmeticExprComp
+    | left=exprComponent op=(PLUS|MINUS|CONCAT) right=exprComponent                                             # arithmeticExprOrConcatComp
+    | left=exprComponent comparisonOperand right=exprComponent                                                  # comparisonExprComp
+    | left=exprComponent op=(IN|NOT_IN)(lists|valueDomainID)                                                    # inNotInExprComp
+    | left=exprComponent op=AND right=exprComponent                                                             # booleanExprComp
+    | left=exprComponent op=(OR|XOR) right=exprComponent                                                        # booleanExprComp
+    | IF  conditionalExpr=exprComponent  THEN thenExpr=exprComponent ELSE elseExpr=exprComponent                # ifExprComp
+    | CASE (WHEN exprComponent THEN exprComponent)+ ELSE exprComponent                                          # caseExprComp
+    | constant                                                                                                  # constantExprComp
+    | componentID                                                                                               # compId
 ;
 
 functionsComponents:
@@ -84,6 +87,7 @@ datasetClause:
     | calcClause
     | keepOrDropClause
     | pivotOrUnpivotClause
+ /*   | customPivotClause */
     | subspaceClause
 ;
 
@@ -112,6 +116,10 @@ pivotOrUnpivotClause:
     op=(PIVOT|UNPIVOT) id_=componentID COMMA mea=componentID
 ;
 
+customPivotClause:
+    CUSTOMPIVOT id_=componentID COMMA mea=componentID IN constant (COMMA constant)*
+;
+
 subspaceClause:
     SUBSPACE subspaceClauseItem (COMMA subspaceClauseItem)*
 ;
@@ -138,7 +146,7 @@ defOperators:
 /*---------------------------------------------------FUNCTIONS-------------------------------------------------*/
 genericOperators:
     operatorID LPAREN (parameter (COMMA parameter)*)? RPAREN                                                                                                                    # callDataset
-    | EVAL LPAREN routineName LPAREN (varID|scalarItem)? (COMMA (varID|scalarItem))* RPAREN (LANGUAGE STRING_CONSTANT)? (RETURNS evalDatasetType)? RPAREN                       # evalAtom
+    | EVAL LPAREN routineName LPAREN (varID|scalarItem)? (COMMA (varID|scalarItem))* RPAREN (LANGUAGE STRING_CONSTANT)? (RETURNS evalDatasetType)? RPAREN                               # evalAtom
     | CAST LPAREN expr COMMA (basicScalarType|valueDomainName) (COMMA STRING_CONSTANT)? RPAREN                                                                                  # castExprDataset
 ;
 
@@ -149,6 +157,7 @@ genericOperatorsComponent:
 
 ;
 
+
 parameterComponent:
     exprComponent
     | OPTIONAL
@@ -176,13 +185,13 @@ stringOperatorsComponent:
 numericOperators:
     op=(CEIL | FLOOR | ABS | EXP | LN | SQRT) LPAREN expr RPAREN						        # unaryNumeric
     | op=(ROUND | TRUNC) LPAREN expr (COMMA optionalExpr)? RPAREN							    # unaryWithOptionalNumeric
-    | op=(MOD | POWER|LOG) LPAREN left=expr COMMA right=expr RPAREN							    # binaryNumeric
+    | op=(MOD | POWER | LOG | RANDOM) LPAREN left=expr COMMA right=expr RPAREN					# binaryNumeric
 ;
 
 numericOperatorsComponent:
-    op=(CEIL | FLOOR | ABS | EXP | LN | SQRT) LPAREN exprComponent RPAREN						# unaryNumericComponent
-    | op=(ROUND | TRUNC) LPAREN exprComponent (COMMA optionalExprComponent)? RPAREN			    # unaryWithOptionalNumericComponent
-    | op=(MOD | POWER | LOG) LPAREN left=exprComponent COMMA right=exprComponent RPAREN		    # binaryNumericComponent
+    op=(CEIL | FLOOR | ABS | EXP | LN | SQRT) LPAREN exprComponent RPAREN						    # unaryNumericComponent
+    | op=(ROUND | TRUNC) LPAREN exprComponent (COMMA optionalExprComponent)? RPAREN			        # unaryWithOptionalNumericComponent
+    | op=(MOD | POWER | LOG | RANDOM) LPAREN left=exprComponent COMMA right=exprComponent RPAREN    # binaryNumericComponent
 ;
 
 comparisonOperators:
@@ -205,6 +214,16 @@ timeOperators:
     | TIMESHIFT LPAREN expr COMMA signedInteger RPAREN                                                                                  # timeShiftAtom
     | TIME_AGG LPAREN periodIndTo=STRING_CONSTANT (COMMA periodIndFrom=(STRING_CONSTANT| OPTIONAL ))? (COMMA op=optionalExpr)? (COMMA (FIRST|LAST))? RPAREN     # timeAggAtom
     | CURRENT_DATE LPAREN RPAREN                                                                                                        # currentDateAtom
+    | DATEDIFF LPAREN dateFrom=expr COMMA dateTo=expr RPAREN                    # dateDiffAtom
+    | DATEADD LPAREN op=expr COMMA shiftNumber=expr COMMA periodInd=expr RPAREN # dateAddAtom
+    | YEAR_OP LPAREN expr RPAREN                                                # yearAtom
+    | MONTH_OP LPAREN expr RPAREN                                               # monthAtom
+    | DAYOFMONTH LPAREN expr RPAREN                                             # dayOfMonthAtom
+    | DAYOFYEAR LPAREN expr RPAREN                                              # datOfYearAtom
+    | DAYTOYEAR LPAREN expr RPAREN                                              # dayToYearAtom
+    | DAYTOMONTH LPAREN expr RPAREN                                             # dayToMonthAtom
+    | YEARTODAY LPAREN expr RPAREN                                              # yearTodayAtom
+    | MONTHTODAY LPAREN expr RPAREN                                             # monthTodayAtom
 ;
 
 timeOperatorsComponent:
@@ -213,7 +232,17 @@ timeOperatorsComponent:
     | op=(FLOW_TO_STOCK | STOCK_TO_FLOW) LPAREN exprComponent RPAREN	                                                                                    # flowAtomComponent
     | TIMESHIFT LPAREN exprComponent COMMA signedInteger RPAREN                                                                                 # timeShiftAtomComponent
     | TIME_AGG LPAREN periodIndTo=STRING_CONSTANT (COMMA periodIndFrom=(STRING_CONSTANT| OPTIONAL ))? (COMMA op=optionalExprComponent)? (COMMA (FIRST|LAST))? RPAREN    # timeAggAtomComponent
-    | CURRENT_DATE LPAREN RPAREN                                                                                                                # currentDateAtomComponent
+    | CURRENT_DATE LPAREN RPAREN                                                                                                               # currentDateAtomComponent
+    | DATEDIFF LPAREN dateFrom=exprComponent COMMA dateTo=exprComponent RPAREN                    # dateDiffAtomComponent
+    | DATEADD LPAREN op=exprComponent COMMA shiftNumber=exprComponent COMMA periodInd=exprComponent RPAREN # dateAddAtomComponent
+    | YEAR_OP LPAREN exprComponent RPAREN                                                # yearAtomComponent
+    | MONTH_OP LPAREN exprComponent RPAREN                                               # monthAtomComponent
+    | DAYOFMONTH LPAREN exprComponent RPAREN                                             # dayOfMonthAtomComponent
+    | DAYOFYEAR LPAREN exprComponent RPAREN                                              # datOfYearAtomComponent
+    | DAYTOYEAR LPAREN exprComponent RPAREN                                              # dayToYearAtomComponent
+    | DAYTOMONTH LPAREN exprComponent RPAREN                                             # dayToMonthAtomComponent
+    | YEARTODAY LPAREN exprComponent RPAREN                                              # yearTodayAtomComponent
+    | MONTHTODAY LPAREN exprComponent RPAREN                                             # monthTodayAtomComponent
 ;
 
 setOperators:
@@ -284,7 +313,7 @@ aggrOperatorsGrouping:
         | FIRST_VALUE
         | LAST_VALUE)
         LPAREN expr OVER LPAREN (partition=partitionByClause? orderBy=orderByClause? windowing=windowingClause?)RPAREN RPAREN       #anSimpleFunction
-    | op=(LAG |LEAD)  LPAREN expr (COMMA offet=signedInteger(COMMA defaultValue=scalarItem)?)?  OVER  LPAREN (partition=partitionByClause? orderBy=orderByClause)   RPAREN RPAREN    # lagOrLeadAn
+    | op=(LAG |LEAD)  LPAREN expr (COMMA offset=signedInteger(COMMA defaultValue=scalarItem)?)?  OVER  LPAREN (partition=partitionByClause? orderBy=orderByClause)   RPAREN RPAREN    # lagOrLeadAn
     | op=RATIO_TO_REPORT LPAREN expr OVER  LPAREN (partition=partitionByClause) RPAREN RPAREN                                                                           # ratioToReportAn
 ;
 

vtlengine/AST/Grammar/VtlTokens.g4

@@ -28,11 +28,22 @@ lexer grammar VtlTokens;
   MEMBERSHIP		: '#';
   EVAL              : 'eval';
   IF                : 'if';
+  CASE              : 'case';
   THEN              : 'then';
   ELSE              : 'else';
   USING             : 'using';
   WITH              : 'with';
   CURRENT_DATE      : 'current_date';
+  DATEDIFF          : 'datediff';
+  DATEADD           : 'dateadd';
+  YEAR_OP           : 'year';
+  MONTH_OP          : 'month';
+  DAYOFMONTH        : 'dayofmonth';
+  DAYOFYEAR         : 'dayofyear';
+  DAYTOYEAR         : 'daytoyear';
+  DAYTOMONTH        : 'daytomonth';
+  YEARTODAY         : 'yeartoday';
+  MONTHTODAY        : 'monthtoday';
   ON                : 'on';
   DROP              : 'drop';
   KEEP              : 'keep';
@@ -54,6 +65,7 @@ lexer grammar VtlTokens;
   DIFF              : 'diff';
   SYMDIFF           : 'symdiff';
   INTERSECT         : 'intersect';
+  RANDOM            : 'random';
   KEYS              : 'keys';
   INTYEAR           : 'intyear';
   INTMONTH          : 'intmonth';
@@ -394,4 +406,4 @@ FREQUENCY
   | 'M'
   | 'W'
   | 'D'
-  ;*/
+  ;*/