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

vtlengine/API/_InternalApi.py

@@ -8,7 +8,9 @@ from s3fs import S3FileSystem  # type: ignore[import-untyped]
 
 from vtlengine.AST import PersistentAssignment, Start
 from vtlengine.DataTypes import SCALAR_TYPES
-from vtlengine.Model import ValueDomain, Dataset, Scalar, Component, Role, ExternalRoutine
+from vtlengine.Exceptions import check_key
+from vtlengine.Model import (ValueDomain, Dataset, Scalar, Component, Role,
+                             ExternalRoutine, Role_keys)
 from vtlengine.files.parser import _validate_pandas, _fill_dataset_empty_data
 
 base_path = Path(__file__).parent
@@ -30,15 +32,17 @@ def _load_dataset_from_structure(structures: Dict[str, Any]) -> Dict[str, Any]:
     if "datasets" in structures:
         for dataset_json in structures["datasets"]:
             dataset_name = dataset_json["name"]
-            components = {
-                component["name"]: Component(
+            components = {}
+
+            for component in dataset_json["DataStructure"]:
+                check_key("data_type", SCALAR_TYPES.keys(), component["type"])
+                check_key("role", Role_keys, component["role"])
+                components[component["name"]] = Component(
                     name=component["name"],
                     data_type=SCALAR_TYPES[component["type"]],
                     role=Role(component["role"]),
                     nullable=component["nullable"],
                 )
-                for component in dataset_json["DataStructure"]
-            }
 
             datasets[dataset_name] = Dataset(name=dataset_name, components=components, data=None)
     if "scalars" in structures:

vtlengine/API/__init__.py

@@ -78,7 +78,7 @@ def create_ast(text: str) -> Start:
     stream = _lexer(text)
     cst = _parser(stream)
     visitor = ASTVisitor()
-    ast = visitor.visit(cst)
+    ast = visitor.visitStart(cst)
     DAGAnalyzer.createDAG(ast)
     return ast
 

vtlengine/AST/ASTConstructorModules/Expr.py

@@ -1,5 +1,6 @@
 import re
 from copy import copy
+from typing import Any
 
 from antlr4.tree.Tree import TerminalNodeImpl
 
@@ -25,6 +26,8 @@ from vtlengine.AST import (
     Analytic,
     Windowing,
     VarID,
+    Case,
+    CaseObj,
 )
 from vtlengine.AST.ASTConstructorModules.ExprComponents import ExprComp
 from vtlengine.AST.ASTConstructorModules.Terminals import Terminals
@@ -59,6 +62,7 @@ class Expr(VtlVisitor):
                | left=expr op=AND right=expr                                           # booleanExpr # noqa E501
                | left=expr op=(OR|XOR) right=expr							            # booleanExpr # noqa E501
                | IF  conditionalExpr=expr  THEN thenExpr=expr ELSE elseExpr=expr       # ifExpr # noqa E501
+               | CASE WHEN expr THEN expr ELSE expr END                             # caseExpr # noqa E501
                | constant														        # constantExpr # noqa E501
                | varID															        # varIdExpr # noqa E501
         ;
@@ -115,6 +119,26 @@ class Expr(VtlVisitor):
 
             return if_node
 
+        # CASE WHEN expr THEN expr ELSE expr END                             # caseExpr
+        elif isinstance(c, TerminalNodeImpl) and (c.getSymbol().type == Parser.CASE):
+
+            if len(ctx_list) % 4 != 3:
+                raise ValueError("Syntax error.")
+
+            else_node = self.visitExpr(ctx_list[-1])
+            ctx_list = ctx_list[1:-2]
+            cases = []
+
+            for i in range(0, len(ctx_list), 4):
+                condition = self.visitExpr(ctx_list[i + 1])
+                thenOp = self.visitExpr(ctx_list[i + 3])
+                case_obj = CaseObj(condition, thenOp)
+                cases.append(case_obj)
+
+            case_node = Case(cases, else_node)
+
+            return case_node
+
         # constant
         elif isinstance(ctx, Parser.ConstantExprContext):
             return Terminals().visitConstant(c)
@@ -755,7 +779,8 @@ class Expr(VtlVisitor):
 
     def visitTimeFunctions(self, ctx: Parser.TimeFunctionsContext):
         if isinstance(ctx, Parser.PeriodAtomContext):
-            return self.visitPeriodAtom(ctx)
+            # return self.visitPeriodAtom(ctx)
+            return self.visitTimeUnaryAtom(ctx)
         elif isinstance(ctx, Parser.FillTimeAtomContext):
             return self.visitFillTimeAtom(ctx)
         elif isinstance(ctx, Parser.FlowAtomContext):
@@ -766,13 +791,30 @@ class Expr(VtlVisitor):
             return self.visitTimeAggAtom(ctx)
         elif isinstance(ctx, Parser.CurrentDateAtomContext):
             return self.visitCurrentDateAtom(ctx)
+        elif isinstance(ctx, Parser.DateDiffAtomContext):
+            return self.visitTimeDiffAtom(ctx)
+        elif isinstance(ctx, Parser.DateAddAtomContext):
+            return self.visitTimeAddAtom(ctx)
+        elif isinstance(ctx, Parser.YearAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.MonthAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.DayOfMonthAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.DayOfYearAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.DayToYearAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.DayToMonthAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.YearTodayAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.MonthTodayAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
         else:
             raise NotImplementedError
 
-    def visitPeriodAtom(self, ctx: Parser.PeriodAtomContext):
-        """
-        periodExpr: PERIOD_INDICATOR '(' expr? ')' ;
-        """
+    def visitTimeUnaryAtom(self, ctx: Any):
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
@@ -789,6 +831,26 @@ class Expr(VtlVisitor):
 
         return UnaryOp(op=op, operand=operand_node[0])
 
+    # def visitPeriodAtom(self, ctx: Parser.PeriodAtomContext):
+    #     """
+    #     periodExpr: PERIOD_INDICATOR '(' expr? ')' ;
+    #     """
+    #     ctx_list = list(ctx.getChildren())
+    #     c = ctx_list[0]
+    #
+    #     op = c.getSymbol().text
+    #     operand_node = [
+    #         self.visitExpr(operand)
+    #         for operand in ctx_list
+    #         if isinstance(operand, Parser.ExprContext)
+    #     ]
+    #
+    #     if len(operand_node) == 0:
+    #         # AST_ASTCONSTRUCTOR.15
+    #         raise NotImplementedError
+    #
+    #     return UnaryOp(op=op, operand=operand_node[0])
+
     def visitTimeShiftAtom(self, ctx: Parser.TimeShiftAtomContext):
         """
         timeShiftExpr: TIMESHIFT '(' expr ',' INTEGER_CONSTANT ')' ;
@@ -872,6 +934,35 @@ class Expr(VtlVisitor):
         c = list(ctx.getChildren())[0]
         return MulOp(op=c.getSymbol().text, children=[])
 
+    def visitTimeDiffAtom(self, ctx: Parser.TimeShiftAtomContext):
+        """ """
+        ctx_list = list(ctx.getChildren())
+        c = ctx_list[0]
+
+        op = c.getSymbol().text
+        left_node = self.visitExpr(ctx_list[2])
+        right_node = self.visitExpr(ctx_list[4])
+
+        return BinOp(left=left_node, op=op, right=right_node)
+
+    def visitTimeAddAtom(self, ctx: Parser.TimeShiftAtomContext):
+        """ """
+
+        ctx_list = list(ctx.getChildren())
+        c = ctx_list[0]
+
+        op = c.getSymbol().text
+        children_node = [self.visitExpr(ctx_list[2])]
+
+        param_constant_node = []
+
+        if len(ctx_list) > 4:
+            param_constant_node = [self.visitExpr(ctx_list[4])]
+            if len(ctx_list) > 6:
+                param_constant_node.append(self.visitExpr(ctx_list[6]))
+
+        return ParamOp(op=op, children=children_node, params=param_constant_node)
+
     """
                             -----------------------------------
                                     Conditional Functions

vtlengine/AST/ASTConstructorModules/ExprComponents.py

@@ -16,6 +16,8 @@ from vtlengine.AST import (
     VarID,
     Analytic,
     UDOCall,
+    Case,
+    CaseObj,
 )
 from vtlengine.AST.ASTConstructorModules.Terminals import Terminals
 from vtlengine.AST.Grammar.parser import Parser
@@ -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
@@ -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,30 @@ class ExprComp(VtlVisitor):
             return self.visitTimeAggAtomComponent(ctx)
         elif isinstance(ctx, Parser.CurrentDateAtomComponentContext):
             return self.visitCurrentDateAtomComponent(ctx)
+        elif isinstance(ctx, Parser.DateDiffAtomComponentContext):
+            return self.visitDateAddAtomComponentContext(ctx)
+        elif isinstance(ctx, Parser.DateAddAtomComponentContext):
+            return self.visitDateAddAtomComponentContext(ctx)
+        elif isinstance(ctx, Parser.YearAtomComponentContext):
+            return self.visitTimeUnaryAtomComponent(ctx)
+        elif isinstance(ctx, Parser.MonthAtomComponentContext):
+            return self.visitTimeUnaryAtomComponent(ctx)
+        elif isinstance(ctx, Parser.DayOfMonthAtomComponentContext):
+            return self.visitTimeUnaryAtomComponent(ctx)
+        elif isinstance(ctx, Parser.DayOfYearAtomComponentContext):
+            return self.visitTimeUnaryAtomComponent(ctx)
+        elif isinstance(ctx, Parser.DayToYearAtomComponentContext):
+            return self.visitTimeUnaryAtomComponent(ctx)
+        elif isinstance(ctx, Parser.DayToMonthAtomComponentContext):
+            return self.visitTimeUnaryAtomComponent(ctx)
+        elif isinstance(ctx, Parser.YearToDayAtomComponentContext):
+            return self.visitTimeUnaryAtomComponent(ctx)
+        elif isinstance(ctx, 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? ')' ;
         """
@@ -653,6 +699,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 = Constant("INTEGER_CONSTANT", int(ctx_list[4].getSymbol().text))
+
+        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

vtlengine/AST/ASTTemplate.py

@@ -314,6 +314,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/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'
-  ;*/
+  ;*/