vtlengine 1.0.1__tar.gz → 1.0.2__tar.gz

{vtlengine-1.0.1 → vtlengine-1.0.2}/PKG-INFO

@@ -1,12 +1,14 @@
 Metadata-Version: 2.1
 Name: vtlengine
-Version: 1.0.1
+Version: 1.0.2
 Summary: Run and Validate VTL Scripts
+Home-page: https://github.com/Meaningful-Data/vtlengine
 License: AGPL-3.0
+Keywords: vtl,sdmx,vtlengine,Validation and Transformation Language
 Author: MeaningfulData
 Author-email: info@meaningfuldata.eu
 Requires-Python: >=3.10,<4.0
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Information Technology
 Classifier: Intended Audience :: Science/Research
@@ -16,20 +18,26 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
 Requires-Dist: antlr4-python3-runtime (==4.9.2)
 Requires-Dist: bottleneck (>=1.3.4,<2.0.0)
 Requires-Dist: duckdb (>=1.1.1,<2.0.0)
 Requires-Dist: networkx (>=2.8.8,<3.0.0)
-Requires-Dist: numba (>=0.60.0,<0.61.0)
 Requires-Dist: numexpr (>=2.9.0,<3.0.0)
 Requires-Dist: pandas (>=2.1.4,<3.0.0)
-Requires-Dist: pyarrow (>=17.0.0,<18.0.0)
 Requires-Dist: s3fs (>=2024.9.0,<2025.0.0)
 Requires-Dist: sqlglot (>=22.2.0,<23.0.0)
+Project-URL: Repository, https://github.com/Meaningful-Data/vtlengine
 Description-Content-Type: text/markdown
 
 # VTL Engine
 
+|         |                                                                                                                                                                                |
+|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Testing | [![Testing](https://github.com/Meaningful-Data/vtlengine/actions/workflows/testing.yml/badge.svg)](https://github.com/Meaningful-Data/vtlengine/actions/workflows/testing.yml) |
+| Package | [![PyPI Latest Release](https://img.shields.io/pypi/v/vtlengine.svg)](https://pypi.org/project/vtlengine/)                                                                     |
+| License | [![License - AGPL 3.0](https://img.shields.io/pypi/l/vtlengine.svg)](https://github.com/Meaningful-Data/vtlengine/blob/main/LICENSE.md)                                        |
+
 ## Introduction
 
 The VTL Engine is a Python library for validating and running VTL scripts.
@@ -67,7 +75,8 @@ Any action with VTL requires the following elements as input:
 * **VTL Script**: Is the VTL to be executed, which includes the transformation scheme, as well as de
   User Defined Operators, Hierarchical Rulesets and Datapoint Rulesets. It is provided as a string
   or as a Path object to a vtl file.
-* **Data structures** : Provides the structure of the input artifacts of the VTL script, according to
+* **Data structures** : Provides the structure of the input artifacts of the VTL script, according
+  to
   the VTL Information model. Given that the current version doesn't prescribe a standard format for
   providing the information, the VTL Engine is implementing a JSON format that can be found here.
   Data Structures can be provided as Dictionaries or as Paths to JSON files. It is possible to have

{vtlengine-1.0.1 → vtlengine-1.0.2}/README.md

@@ -1,5 +1,11 @@
 # VTL Engine
 
+|         |                                                                                                                                                                                |
+|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| Testing | [![Testing](https://github.com/Meaningful-Data/vtlengine/actions/workflows/testing.yml/badge.svg)](https://github.com/Meaningful-Data/vtlengine/actions/workflows/testing.yml) |
+| Package | [![PyPI Latest Release](https://img.shields.io/pypi/v/vtlengine.svg)](https://pypi.org/project/vtlengine/)                                                                     |
+| License | [![License - AGPL 3.0](https://img.shields.io/pypi/l/vtlengine.svg)](https://github.com/Meaningful-Data/vtlengine/blob/main/LICENSE.md)                                        |
+
 ## Introduction
 
 The VTL Engine is a Python library for validating and running VTL scripts.
@@ -37,7 +43,8 @@ Any action with VTL requires the following elements as input:
 * **VTL Script**: Is the VTL to be executed, which includes the transformation scheme, as well as de
   User Defined Operators, Hierarchical Rulesets and Datapoint Rulesets. It is provided as a string
   or as a Path object to a vtl file.
-* **Data structures** : Provides the structure of the input artifacts of the VTL script, according to
+* **Data structures** : Provides the structure of the input artifacts of the VTL script, according
+  to
   the VTL Information model. Given that the current version doesn't prescribe a standard format for
   providing the information, the VTL Engine is implementing a JSON format that can be found here.
   Data Structures can be provided as Dictionaries or as Paths to JSON files. It is possible to have

{vtlengine-1.0.1 → vtlengine-1.0.2}/pyproject.toml

@@ -1,32 +1,41 @@
 [tool.poetry]
 name = "vtlengine"
-version = "1.0.1"
+version = "1.0.2"
 description = "Run and Validate VTL Scripts"
 authors = ["MeaningfulData <info@meaningfuldata.eu>"]
 license = "AGPL-3.0"
 readme = "README.md"
+
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "Intended Audience :: Information Technology",
     "Intended Audience :: Science/Research",
+    "Typing :: Typed"
 ]
 
+keywords = ['vtl', 'sdmx', 'vtlengine', 'Validation and Transformation Language']
+repository = 'https://github.com/Meaningful-Data/vtlengine'
+
+[project.urls]
+BugTracker = 'https://github.com/Meaningful-Data/vtlengine/issues'
+Documentation = 'https://docs.vtlengine.meaningfuldata.eu'
+SourceCode = 'https://github.com/Meaningful-Data/vtlengine'
+
 [tool.poetry.dependencies]
 python = "^3.10"
 # PyPi dependencies
-duckdb="^1.1.1"
-numba="^0.60.0"
-s3fs="^2024.9.0"
-pyarrow = "^17.0.0"
+duckdb = "^1.1.1"
+#numba = "^0.60.0"
+s3fs = "^2024.9.0"
 
 # APT dependencies
-antlr4-python3-runtime="4.9.2"
-networkx="^2.8.8"
-numexpr="^2.9.0"
-pandas="^2.1.4"
-bottleneck="^1.3.4"
-sqlglot="^22.2.0"
+antlr4-python3-runtime = "4.9.2"
+networkx = "^2.8.8"
+numexpr = "^2.9.0"
+pandas = "^2.1.4"
+bottleneck = "^1.3.4"
+sqlglot = "^22.2.0"
 
 [tool.poetry.dev-dependencies]
 pytest = "^7.3"
@@ -39,6 +48,7 @@ black = "^24.8.0"
 mypy = "^1.11.2"
 pandas-stubs = "^2.2.3.241009"
 stubs = "^1.0.0"
+toml = "^0.10.2"
 
 [tool.black]
 line_length = 100

{vtlengine-1.0.1 → vtlengine-1.0.2}/src/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-1.0.1 → vtlengine-1.0.2}/src/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-1.0.1 → vtlengine-1.0.2}/src/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-1.0.1 → vtlengine-1.0.2}/src/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-1.0.1 → vtlengine-1.0.2}/src/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-1.0.1 → vtlengine-1.0.2}/src/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
 ;