pydpm_xl 0.1.39rc31__py3-none-any.whl → 0.2.0__py3-none-any.whl

py_dpm/grammar/dpm_xlParser.g4

@@ -1,263 +0,0 @@
-parser grammar dpm_xlParser;
-
-options { tokenVocab=dpm_xlLexer ;}
-
-// Added rule for expr management and EOF
-start:
-    statement ((EOL statements) | EOL?) EOF
-    ;
-
-statements:
-    (statement EOL)+
-    ;
-
-statement:
-    expressionWithoutAssignment                                                                      #exprWithoutAssignment
-    | temporaryAssignmentExpression                                                                  #assignmentExpr
-    ;
-
-persistentExpression:
-    persistentAssignmentExpression
-    | expressionWithoutAssignment
-    ;
-
-expressionWithoutAssignment:
-    expression                                                                  #exprWithoutPartialSelection
-    | WITH partialSelection
-    (SQUARE_BRACKET_LEFT WHERE expression SQUARE_BRACKET_RIGHT)?
-    COLON expression                                                            #exprWithSelection
-    ;
-
-partialSelection:
-    CURLY_BRACKET_LEFT cellRef CURLY_BRACKET_RIGHT                              #partialSelect
-    ;
-
-temporaryAssignmentExpression:
-    temporaryIdentifier ASSIGN persistentExpression
-    ;
-
-persistentAssignmentExpression:
-    varID PERSISTENT_ASSIGN expressionWithoutAssignment
-    ;
-
-expression:
-    LPAREN expression RPAREN                                                                            #parExpr
-    | functions                                                                                         #funcExpr
-    | expression SQUARE_BRACKET_LEFT clauseOperators SQUARE_BRACKET_RIGHT                               #clauseExpr
-    | op=(PLUS|MINUS) expression                                                                        #unaryExpr
-    | op=NOT LPAREN expression RPAREN                                                                   #notExpr
-    | left=expression op=(MULT|DIV) right=expression                                                    #numericExpr
-    | left=expression op=(PLUS|MINUS) right=expression                                                  #numericExpr
-    | left=expression op=CONCAT right=expression                                                        #concatExpr
-    | left=expression op=comparisonOperators right=expression                                           #compExpr
-    | left=expression op=IN setOperand                                                                  #inExpr
-    | left=expression op=AND right=expression                                                           #boolExpr
-    | left=expression op=(OR|XOR) right=expression                                                      #boolExpr
-    | IF conditionalExpr=expression THEN thenExpr=expression (ELSE elseExpr=expression)? ENDIF          #ifExpr
-    | itemReference                                                                                     #itemReferenceExpr
-    | propertyReference                                                                                 #propertyReferenceExpr
-    | keyNames                                                                                          #keyNamesExpr
-    | literal                                                                                           #literalExpr
-    | select                                                                                            #selectExpr
-    ;
-
-setOperand:
-    CURLY_BRACKET_LEFT setElements CURLY_BRACKET_RIGHT
-    ;
-
-setElements:
-    itemReference (COMMA itemReference)*
-    | literal (COMMA literal)*
-    ;
-
-functions:
-    aggregateOperators                                              #aggregateFunctions
-    | numericOperators                                              #numericFunctions
-    | comparisonFunctionOperators                                   #comparisonFunctions
-    | filterOperators                                               #filterFunctions
-    | conditionalOperators                                          #conditionalFunctions
-    | timeOperators                                                 #timeFunctions
-    | stringOperators                                               #stringFunctions
-;
-
-numericOperators:
-    op=(ABS|EXP|LN|SQRT) LPAREN expression RPAREN                                 #unaryNumericFunctions
-    | op=(POWER|LOG) LPAREN left=expression COMMA right=expression RPAREN         #binaryNumericFunctions
-    | op=(MAX|MIN) LPAREN expression (COMMA expression)+ RPAREN                   #complexNumericFunctions
-    ;
-
-comparisonFunctionOperators:
-    MATCH LPAREN expression COMMA literal RPAREN                    #matchExpr
-    | ISNULL LPAREN expression RPAREN                               #isnullExpr
-;
-
-filterOperators:
-    FILTER LPAREN expression COMMA expression RPAREN
-    ;
-
-timeOperators:
-    TIME_SHIFT LPAREN expression COMMA TIME_PERIOD COMMA INTEGER_LITERAL (COMMA propertyCode)? RPAREN #timeShiftFunction
-    ;
-
-conditionalOperators:
-    NVL LPAREN expression COMMA expression RPAREN           #nvlFunction
-    ;
-
-stringOperators:
-    LEN LPAREN expression RPAREN          #unaryStringFunction
-    ;
-
-aggregateOperators:
-    op=(MAX_AGGR
-        |MIN_AGGR
-        |SUM
-        |COUNT
-        |AVG
-        |MEDIAN) LPAREN expression (groupingClause)? RPAREN        #commonAggrOp
-    ;
-
-groupingClause:
-    GROUP_BY keyNames (COMMA keyNames)*
-;
-
-// Dimension management and members
-itemSignature: ITEM_SIGNATURE;
-itemReference: SQUARE_BRACKET_LEFT itemSignature SQUARE_BRACKET_RIGHT;
-
-// Cell Address and table management
-rowElem:
-    ROW
-    | ROW_RANGE
-    | ROW_ALL
-;
-colElem:
-    COL
-    | COL_RANGE
-    | COL_ALL
-;
-sheetElem:
-    SHEET
-    | SHEET_RANGE
-    | SHEET_ALL
-;
-rowHandler:
-    rowElem
-    | LPAREN ROW (COMMA ROW)* RPAREN;
-
-colHandler:
-    colElem
-    | LPAREN COL (COMMA COL)* RPAREN;
-
-sheetHandler:
-    sheetElem
-    | LPAREN SHEET (COMMA SHEET)* RPAREN
-;
-
-interval:
-    INTERVAL COLON BOOLEAN_LITERAL
-;
-
-default:
-    DEFAULT COLON literal
-    | DEFAULT COLON NULL_LITERAL
-;
-
-argument:
-    rowHandler                          #rowArg
-    | colHandler                        #colArg
-    | sheetHandler                      #sheetArg
-    | interval                          #intervalArg
-    | default                           #defaultArg
-;
-
-select:
-    CURLY_BRACKET_LEFT selectOperand CURLY_BRACKET_RIGHT
-    ;
-
-selectOperand:
-    cellRef
-    | varRef
-    | operationRef
-    | preconditionElem
-    ;
-
-varID:
-    CURLY_BRACKET_LEFT varRef CURLY_BRACKET_RIGHT
-    ;
-
-cellRef:
-    address=cellAddress
-    ;
-
-preconditionElem:
-    PRECONDITION_ELEMENT
-    ;
-
-varRef:
-    VAR_REFERENCE
-    ;
-
-operationRef:
-    OPERATION_REFERENCE
-    ;
-
-cellAddress:
-    tableReference (COMMA argument)*               #tableRef
-    | argument (COMMA argument)*                   #compRef;
-
-tableReference:
-    TABLE_REFERENCE
-    | TABLE_GROUP_REFERENCE
-    ;
-
-clauseOperators:
-    WHERE expression                                             #whereExpr
-    | GET keyNames                                               #getExpr
-    | RENAME renameClause (COMMA renameClause)*                  #renameExpr
-    | SUB propertyCode EQ (literal | select | itemReference)     #subExpr
-    ;
-
-// Always on grammar, not on tokens. Order is important (top ones should be the enclosing ones)
-
-renameClause:
-    keyNames TO keyNames
-    ;
-
-comparisonOperators:
-    EQ
-    |NE
-    |GT
-    |LT
-    |GE
-    |LE;
-
-literal:
-    INTEGER_LITERAL
-    | DECIMAL_LITERAL
-    | PERCENT_LITERAL
-    | STRING_LITERAL
-    | BOOLEAN_LITERAL
-    | DATE_LITERAL
-    | TIME_INTERVAL_LITERAL
-    | TIME_PERIOD_LITERAL
-    | EMPTY_LITERAL
-;
-
-keyNames:
-    ROW_COMPONENT
-    | COL_COMPONENT
-    | SHEET_COMPONENT
-    | PROPERTY_CODE
-;
-
-propertyReference:
-    SQUARE_BRACKET_LEFT propertyCode SQUARE_BRACKET_RIGHT;
-
-propertyCode:
-    PROPERTY_CODE
-    | CODE
-    ;
-
-temporaryIdentifier:
-    CODE
-    ;

py_dpm/semantics/DAG/DAGAnalyzer.py

@@ -1,158 +0,0 @@
-import numpy as np
-import networkx as nx
-
-from py_dpm.AST.ASTObjects import Start, PersistentAssignment, WithExpression, AST, OperationRef, TemporaryAssignment
-from py_dpm.AST.ASTTemplate import ASTTemplate
-from py_dpm.Exceptions import exceptions
-from py_dpm.Utils.tokens import INPUTS, OUTPUTS
-
-
-class DAGAnalyzer(ASTTemplate):
-    """
-    Class to generate the Direct Acyclic Graph from calculations scripts.
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.inputs: list = []
-        self.outputs: list = []
-        self.dependencies: dict = {}
-        self.calculation_number = 1
-
-        self.vertex: dict = {}
-        self.edges: dict = {}
-        self.number_of_vertex: int = 0
-        self.adjacency_matrix = None
-        self.sorting = None
-
-        self.graph = None
-
-    def create_DAG(self, ast: AST):
-        """
-        Method to generate the Direct  Acyclic Graph from ast
-        """
-        self.visit(ast)
-
-        self.load_vertex()
-        self.load_edges()
-        self.create_adjacency_matrix()
-
-        try:
-            self.nx_topological_sort()
-            if len(self.edges):
-                self.sort_ast(ast=ast)
-
-        except nx.NetworkXUnfeasible:
-            graph_cycles = nx.find_cycle(self.graph)
-            pos1, pos2 = graph_cycles[0]
-            op1 = self.vertex[pos1]
-            op2 = self.vertex[pos2]
-            raise exceptions.ScriptingError(code="6-4", op1=op1, op2=op2)
-
-    def load_vertex(self):
-        """
-
-        """
-
-        for key, calculation in self.dependencies.items():
-            outputs = calculation[OUTPUTS]
-            if len(outputs) > 0:
-                self.vertex[key] = outputs[0]
-        self.number_of_vertex = len(self.vertex)
-
-    def load_edges(self):
-        """
-
-        """
-        if len(self.vertex) > 0:
-            number_of_edges = 0
-            for key, calculation in self.dependencies.items():
-                outputs = calculation[OUTPUTS]
-                if len(outputs) > 0:
-                    output = outputs[0]
-                    for sub_key, sub_calculation in self.dependencies.items():
-                        inputs = sub_calculation[INPUTS]
-                        if inputs and output in inputs:
-                            self.edges[number_of_edges] = (key, sub_key)
-                            number_of_edges += 1
-
-    def create_adjacency_matrix(self):
-        """
-
-        """
-        self.adjacency_matrix = np.zeros((self.number_of_vertex, self.number_of_vertex), dtype=int)
-        for edge in list(self.edges.values()):
-            self.adjacency_matrix[edge[0] - 1][edge[1] - 1] = 1
-
-    def nx_topological_sort(self):
-        """
-
-        """
-        edges = list(self.edges.values())
-        self.graph = DAG = nx.DiGraph()
-        DAG.add_nodes_from(self.vertex)
-        DAG.add_edges_from(edges)
-        self.sorting = list(nx.topological_sort(DAG))
-
-    def sort_ast(self, ast):
-        """
-
-        """
-        lst = []
-        calculations = list(ast.children)
-        for x in self.sorting:
-            for i in range(len(calculations)):
-                if i == x - 1:
-                    lst.append(calculations[i])
-        self.check_overwriting(lst)
-        ast.children = lst
-
-    def check_overwriting(self, outputs):
-        """
-
-        """
-        non_repeated = []
-        outputs_lst = []
-        for output in outputs:
-            if isinstance(output, TemporaryAssignment):
-                temporary_identifier_value = output.left.value
-                outputs_lst.append(temporary_identifier_value)
-                if isinstance(output.right, PersistentAssignment):
-                    outputs_lst.append(output.right.left.variable)
-        for output_value in outputs_lst:
-            if output_value not in non_repeated:
-                non_repeated.append(output_value)
-            else:
-                raise exceptions.SemanticError("6-1", variable=output_value)
-
-    def get_calculation_structure(self):
-        """
-
-        """
-        inputs = list(set(self.inputs))
-        outputs = list(set(self.outputs))
-
-        return {INPUTS: inputs, OUTPUTS: outputs}
-
-    def visit_Start(self, node: Start):
-        for child in node.children:
-            self.visit(child)
-            self.dependencies[self.calculation_number] = self.get_calculation_structure()
-
-            self.calculation_number += 1
-
-            self.inputs = []
-            self.outputs = []
-
-    def visit_PersistentAssignment(self, node: PersistentAssignment):
-        self.visit(node.right)
-
-    def visit_TemporaryAssignment(self, node: TemporaryAssignment):
-        self.outputs.append(node.left.value)
-        self.visit(node.right)
-
-    def visit_OperationRef(self, node: OperationRef):
-        self.inputs.append(node.operation_code)
-
-    def visit_WithExpression(self, node: WithExpression):
-        self.visit(node.expression)

py_dpm/views/data_types.sql

@@ -1,12 +0,0 @@
-CREATE
-OR ALTER
-VIEW data_types AS
-SELECT vv.VariableID     as datapoint,
-       dt.Code           as data_type,
-       vv.StartReleaseID as start_release,
-       vv.EndReleaseID   as end_release
-from VariableVersion vv
-         inner join Property p on
-    p.PropertyID = vv.PropertyID
-         inner join DataType dt on
-    dt.DataTypeID = p.DataTypeID

py_dpm/views/datapoints.sql

@@ -1,65 +0,0 @@
-CREATE OR ALTER VIEW datapoints AS
-SELECT distinct tvc.CellCode AS cell_code,
-       tv.Code                                       AS table_code,
-       hvr.Code                                      AS row_code,
-       hvc.Code                                      AS column_code,
-       hvs.Code                                      AS sheet_code,
-       vv.VariableID                                 AS variable_id,
-       dt.Code                                       AS data_type,
-       tv.TableVID                                   AS table_vid,
-
-       p.PropertyID                                  AS property_id,
-       mv.StartReleaseID                             AS start_release,
-       mv.EndReleaseID                               AS end_release,
-       tvc.CellID                                    AS cell_id,
-       vv.ContextID                                  AS context_id,
-       vv.VariableVID                                AS variable_vid
-
-FROM dbo.TableVersionCell AS tvc
-
-         INNER JOIN dbo.TableVersion AS tv
-                    ON tvc.TableVID = tv.TableVID AND tvc.IsVoid = 0
-        INNER JOIN dbo.ModuleVersionComposition mvc on tv.TableVID = mvc.TableVID
-        inner join dbo.ModuleVersion mv on mvc.ModuleVID = mv.ModuleVID
-
-         LEFT OUTER JOIN dbo.VariableVersion AS vv
-                    ON tvc.VariableVID = vv.VariableVID
-
-         LEFT OUTER JOIN dbo.Property AS p ON vv.PropertyID = p.PropertyID
-
-         LEFT OUTER JOIN dbo.DataType AS dt ON p.DataTypeID = dt.DataTypeID
-
-         INNER JOIN dbo.Cell AS c ON tvc.CellID = c.CellID
-
-         LEFT OUTER JOIN
-
-     (SELECT hv.HeaderVID, hv.HeaderID, hv.Code, hv.EndReleaseID, tvh.TableVID
-
-      FROM HeaderVersion hv
-
-               INNER JOIN TableVersionHeader tvh
-                          ON tvh.HeaderVID = hv.HeaderVID) hvr
-     ON hvr.HeaderID = c.RowID AND hvr.EndReleaseID IS NULL AND
-        tv.TableVID = hvr.TableVID
-
-         LEFT OUTER JOIN
-
-     (SELECT hv.HeaderVID, hv.HeaderID, hv.Code, hv.EndReleaseID, tvh.TableVID
-
-      FROM HeaderVersion hv
-
-               INNER JOIN TableVersionHeader tvh
-                          ON tvh.HeaderVID = hv.HeaderVID) hvc
-     ON hvc.HeaderID = c.ColumnID AND hvc.EndReleaseID IS NULL AND
-        tv.TableVID = hvc.TableVID
-
-         LEFT OUTER JOIN
-
-     (SELECT hv.HeaderVID, hv.HeaderID, hv.Code, hv.EndReleaseID, tvh.TableVID
-
-      FROM HeaderVersion hv
-
-               INNER JOIN TableVersionHeader tvh
-                          ON tvh.HeaderVID = hv.HeaderVID) hvs
-     ON hvs.HeaderID = c.SheetID AND hvs.EndReleaseID IS NULL AND
-        tv.TableVID = hvs.TableVID

py_dpm/views/hierarchy_operand_reference.sql

@@ -1,11 +0,0 @@
-CREATE OR ALTER VIEW hierarchy_operand_reference_info AS
-select distinct o.code         as operation_code,
-                on2.NodeID     as operation_node_id,
-                orl.CellID     as cell_id,
-                or2.VariableID as variable_id
-FROM OperandReferenceLocation orl
-         inner join OperandReference or2 on orl.OperandReferenceID = or2.OperandReferenceID
-         inner join OperationNode on2 on on2.NodeID = or2.NodeID
-         inner join OperationVersion ov on ov.OperationVID = on2.OperationVID
-         inner join Operation o on o.OperationID = ov.OperationID
-WHERE o.[Source] = 'hierarchy';

py_dpm/views/hierarchy_preconditions.sql

@@ -1,13 +0,0 @@
-CREATE OR ALTER VIEW hierarchy_preconditions
-AS
-SELECT ov.Expression as expression,
-       o.Code        as operation_code,
-       VV.Code       as variable_code
-FROM Operation o
-         inner join OperationVersion ov on o.OperationID = ov.OperationID
-         inner join dbo.OperationNode N on ov.OperationVID = N.OperationVID
-         inner join dbo.OperandReference OR2 on N.NodeID = OR2.NodeID
-         inner join dbo.Variable V on OR2.VariableID = V.VariableID
-         inner join dbo.VariableVersion VV on V.VariableID = VV.VariableID
-where o.Code like 'p_%'
-  and Expression not like '%or%';

py_dpm/views/hierarchy_variables.sql

@@ -1,26 +0,0 @@
-CREATE OR ALTER VIEW hierarchy_variables AS
-SELECT scv.SubCategoryID as subcategory_id,
-       vv.VariableVID    as variable_vid,
-       tvc.CellCode      as cell_code,
-       mp.Code           as main_property_code,
-       cp.Code           as context_property_code,
-       i.Code            as item_code,
-       mv.StartReleaseID as start_release_id,
-       mv.EndReleaseID   as end_release_id
-FROM SubCategoryVersion scv
-         inner join SubCategoryItem sci
-                    on sci.SubCategoryVID = scv.SubCategoryVID
-         inner join ContextComposition cc on cc.ItemID = sci.ItemID
-         inner join VariableVersion vv on vv.ContextID = cc.ContextID
-         inner join TableVersionCell tvc on vv.VariableVID = tvc.VariableVID
-         inner join Property p on vv.PropertyID = p.PropertyID
-         inner join DataType dt on p.DataTypeID = dt.DataTypeID
-         left join ItemCategory mp on mp.ItemID = vv.PropertyID and mp.EndReleaseID is Null
-         left join ItemCategory cp on cp.ItemID = cc.PropertyID and cp.EndReleaseID is Null
-         left join ItemCategory i on i.ItemID = cc.ItemID and i.EndReleaseID is Null
-         inner join TableVersion tv on tv.TableVID = tvc.TableVID
-         inner join ModuleVersionComposition mvc on tv.TableVID = mvc.TableVID
-         inner join ModuleVersion mv on mvc.ModuleVID = mv.ModuleVID
-
-where dt.Code in ('m', 'i', 'r')
-  and tvc.CellCode is not Null

py_dpm/views/hierarchy_variables_context.sql

@@ -1,14 +0,0 @@
-CREATE or ALTER VIEW hierarchy_variables_context as
-SELECT distinct vv.VariableVID    as variable_vid,
-                cp.Code           as context_property_code,
-                i.Code            as item_code,
-                mv.StartReleaseID as start_release_id,
-                mv.EndReleaseID   as end_release_id
-FROM VariableVersion vv
-         inner join ContextComposition cc on cc.ContextID = vv.ContextID
-         inner join ItemCategory cp on cp.ItemID = cc.PropertyID and cp.EndReleaseID is Null
-         inner join ItemCategory i on i.ItemID = cc.ItemID and i.EndReleaseID is Null
-         inner join TableVersionCell tvc on vv.VariableVID = tvc.VariableVID
-         inner join TableVersion tv on tvc.TableVID = tv.TableVID
-         inner join ModuleVersionComposition mvc on tv.TableVID = mvc.TableVID
-         inner join ModuleVersion mv on mvc.ModuleVID = mv.ModuleVID;

py_dpm/views/key_components.sql

@@ -1,18 +0,0 @@
-CREATE OR ALTER VIEW key_components AS
-select tv.Code           as table_code,
-       ic.Code           as property_code,
-       dt.Code           as data_type,
-       tv.TableVID       as table_version_id,
-       ic.StartReleaseID as start_release_ic,
-       ic.EndReleaseID   as end_release_ic,
-       mv.StartReleaseID as start_release_mv,
-       mv.EndReleaseID   as end_release_mv
-from [dbo].TableVersion tv
-         inner join [dbo].KeyComposition kc on tv.KeyID = kc.KeyID
-         inner join [dbo].VariableVersion vv on vv.VariableVID = kc.VariableVID
-         inner join [dbo].Item i on vv.PropertyID = i.ItemID
-         inner join [dbo].ItemCategory ic on ic.ItemID = i.ItemID
-         inner join [dbo].Property p on vv.PropertyID = p.PropertyID
-         left join [dbo].DataType dt on p.DataTypeID = dt.DataTypeID
-         inner join [dbo].ModuleVersionComposition mvc on tv.TableVID = mvc.TableVID
-         inner join [dbo].ModuleVersion mv on mvc.ModuleVID = mv.ModuleVID;

py_dpm/views/module_from_table.sql

@@ -1,11 +0,0 @@
-CREATE OR ALTER VIEW module_from_table AS
-SELECT MV.Code      as module_code,
-       TV.Code     as table_code,
-       MV.FromReferenceDate as from_date,
-       MV.ToReferenceDate   as to_date
-from Module m
-         inner join ModuleVersion MV on m.ModuleID = MV.ModuleID
-         inner join ModuleVersionComposition MVC
-                    on MV.ModuleVID = MVC.ModuleVID
-         inner join TableVersion TV on MVC.TableVID = TV.TableVID
-where TV.Code is not null;

py_dpm/views/open_keys.sql

@@ -1,13 +0,0 @@
-CREATE
-OR ALTER
-VIEW open_keys AS
-select ic.Code           as property_code,
-       dt.Code           as data_type,
-       ic.StartReleaseID as start_release,
-       ic.EndReleaseID   as end_release
-from [dbo].KeyComposition kc
-         inner join [dbo].VariableVersion vv on vv.VariableVID = kc.VariableVID
-         inner join [dbo].Item i on vv.PropertyID = i.ItemID
-         inner join [dbo].ItemCategory ic on ic.ItemID = i.ItemID
-         inner join [dbo].Property p on vv.PropertyID = p.PropertyID
-         left join [dbo].DataType dt on p.DataTypeID = dt.DataTypeID;

py_dpm/views/operation_info.sql

@@ -1,27 +0,0 @@
-CREATE
-OR ALTER
-VIEW operation_info AS
-select opN.NodeID as operation_node_id,
-       opN.OperationVID as operation_version_id,
-       opN.ParentNodeID as parent_node_id,
-       O.OperatorID as operator_id,
-       O.Symbol as symbol,
-       opA.Name as argument,
-       opA.[Order] as operator_argument_order,
-       opN.IsLeaf as is_leaf,
-       opN.Scalar as scalar,
-       opR.OperandReferenceId as operand_reference_id,
-       opR.OperandReference as operand_reference,
-       opR.ItemID as item_id,
-       opR.PropertyID as property_id,
-       opR.VariableID as variable_id,
-       opR.x,
-       opR.y,
-       opR.z,
-       opN.UseIntervalArithmetics as use_interval_arithmetics,
-       opN.FallbackValue as fallback_value
-from [dbo].OperationNode opN
-         left join [dbo].OperandReference opR on opN.NodeID = opR.NodeID
-         left join [dbo].Operator O on O.OperatorID = opN.OperatorID
-         left join [dbo].OperatorArgument opA
-                   on opN.ArgumentID = opA.ArgumentID;

py_dpm/views/operation_list.sql

@@ -1,18 +0,0 @@
-CREATE OR ALTER VIEW operations AS
-SELECT o.Code            as operation_code,
-       ov.StartReleaseID as start_release,
-       ov.EndReleaseID   as end_release,
-       ov.Expression     as expression,
-       ov.OperationVID   as operation_version_id,
-       ov.PreconditionOperationVID as precondition_operation_version_id
-from Operation o
-         inner join OperationVersion ov on o.OperationId = ov.OperationId
-where o.Code in (SELECT DISTINCT o.Code
-                 from Operation o
-                          inner join OperationVersion ov
-                                     on o.OperationID = ov.OperationID
-                          left join dbo.OperationScope OS
-                                    on ov.OperationVID = OS.OperationVID
-                 where OS.IsActive = 1)
---          inner join Expression E on ov.OperationVID = E.OperationVID
--- where E.LanguageID = 2;