Recursive filter algorithms on hierarchical data models described for the use by the attribute value derivation

A system, a method, and a computer program product for filtering data stored in a hierarchical data model for use by an attribute value derivation are provided. At least one filtering mechanism to filter at least one instruction containing at least one target attribute value corresponding to at least one source attribute value combination stored in a hierarchical data model is provided. The instruction is filtered using the filtering mechanism. A user interface for displaying the hierarchical data model containing the filtered instruction is generated.

TECHNICAL FIELD

This disclosure relates generally to data processing and, in particular, to providing various filtering mechanisms of data stored in a hierarchical data model for use by an attribute value derivation.

BACKGROUND

In today's world, data is vital to operations of many businesses, whether large or small. On regular basis, businesses rely, use, process and/or store vast amounts of data that can be related to businesses' finances, operations, logistics, customers, and many other aspects of their operations. Proper storage of data and fast access to such data are important to smooth operations of the businesses.

Typically, data is stored using hierarchical data models. A hierarchical data model can be a data model that organizes data into a tree-like structure. The data can be stored as records that are connected using links. In some cases, a record can include a collection of fields containing only one value, where the fields can be defined by an entity type. Typically, the hierarchical data model can include parent records and child records (or nodes), where each child record can have only one parent and each parent can have one or more child records. To retrieve data from a hierarchical database, it is necessary to traverse the entire tree beginning with the root node. This process can be compute intensive and time consuming. Thus, there is a need to provide an ability to obtain and display data in accordance with user preferences that does not create a significant computing burden.

SUMMARY

In some implementations, the current subject matter relates to a computer-implemented method for filtering data stored in a hierarchical data model for use by an attribute value derivation are provided. The method can include providing at least one filtering mechanism to filter at least one instruction containing at least one target attribute value corresponding to at least one source attribute value combination stored in a hierarchical data model, filtering, using the at least one filtering mechanism, the at least one instruction, and generating a user interface for displaying the hierarchical data model containing the at least one filtered instruction. At least one of the providing, the filtering, and the generating can be performed using at least one processor of at least one computing system.

In some implementations, the current subject matter can include one or more of the following optional features. The filtering mechanism can include at least one of the following: a filtering mechanism for displaying at least one directly maintained target attribute value, a filtering mechanism based on at least one source attributes, and a filtering mechanism for expanding a tree of source attributes up to a selected source attribute. The filtering mechanisms can be applied using a predetermined sequence.

In some implementations, the filtering mechanism can be based on at least one of the following algorithms. A first algorithm (which can be an AND-filter described above) for generating a path can retrieve at least one node in the hierarchical data model using a predicate function corresponding to the node. The path can contain a plurality of nodes and end in the at least one node, where each node in the plurality of nodes in the generated path has valid predicate functions. A second algorithm (which can be an OR-filter described above) for generating a path can also retrieve at least one node in the hierarchical data model using a predicate function corresponding to the node. Here, the path can also contain a plurality of nodes and end in the at least one node, but at least one node in the plurality of nodes in the generated path has a valid predicate function. A third algorithm (which can be a level filter described above) for retrieving at least one node in the hierarchical data model can be based on a level of the hierarchical data model containing the node. Any combination of these algorithms can be used to retrieve a node in the hierarchical data model.

In some implementations, the first algorithm can uses at least one of the following: predicate functions of nodes in the generated path containing the plurality of nodes and ending with the at least one node (which corresponds to AND-filter complete paths filtering mechanism), and predicate functions of all nodes on each level of the hierarchical data model, each level containing a node in the generated path (which corresponds to AND-filter all levels filtering mechanism). Using the first algorithm, a node is filtered out when a predicate function of that node has a false value.

In some implementations, the second algorithm can return at least one of the following: a partial path to the at least one node, the partial path containing a node having a predicate function with a true value (which corresponds to an OR-filter partial paths filtering mechanism), and a complete path to the at least one node, the complete path containing each node having a predicate function with a true value (which corresponds to an OR filter complete paths filtering mechanism).

In some implementations, a path generated using the third algorithm can contain nodes located on a plurality of levels in the hierarchical data model. Each level, preceding and inclusive of the level containing the at least one node, can contain nodes having predicate functions with a true value.

The generated user interface can display at least one of the following: the filtered source attribute, the source attribute value corresponding to the filtered source attribute, the source attribute description corresponding to the filtered one source attribute, and a filtered target attribute corresponding to the filtered source attribute.

DETAILED DESCRIPTION

To address these and potentially other deficiencies of currently available solutions, one or more implementations of the current subject matter provide methods, systems, articles or manufacture, and the like that can, among other possible advantages, provide for a user interface for providing various filtering mechanisms of data stored in a hierarchical data model for use by an attribute value derivation.

In some implementations, the current subject matter relates to hierarchical data models and ability to maintain attribute values of data stored using a hierarchical data model using an attribute value derivation tool. A hierarchical data model can be a data model in which the data is represented in a tree structure. The elements of the hierarchical data model can be represented by nodes.FIG. 1illustrates an exemplary hierarchical data model100, according to some implementations of the current subject matter. The data model100can include a plurality of levels102-108(i.e., level0102, level1104, level2106, and level3108). The data model100can allow storage of data at different levels, where the data can be stored in a plurality of nodes. For example, level0can include a root or parent node102a; level1can include child nodes/parent nodes104aand104b; level2can include child nodes/parent nodes106b,106dand child nodes/leaf nodes106aand106c; level3can include child nodes/leaf nodes108a,108b, and108c. A root node102typically does not have any parent nodes. A child node can include a parent node and can also include child nodes of its own. A leaf node does not have any child nodes. A child node typically inherits data attributes associated with data that is stored in its parent, grandparent, etc. nodes as well as the root node of the model. Hence, the child node/leaf node108acan inherit attributes associated with the child node/parent node106b, child node/parent node104a, and the root node/parent node102a.

The nodes in the data model100can be connected by branches that can represent parent-child relationship of the nodes. Each parent node can have many child nodes, but each child node has only one parent node. In some implementations, in the data mode, the level can be defined by a hierarchy of nodes and a number of the nodes from the root node down to the leaf nodes. Thus, the level102of the root node102acan be defined as a ‘0’ level; the level104of the child nodes104a-bof the root node102acan be defined as a level ‘1’; the level106of the child nodes106a-dof the parent node level104can be defined as a level2; and the level108of the child nodes108a-cof the parent node level106can be defined as a level3.

In some implementations, a path can be defined as a sequence of nodes starting at the root node where the successor of a node is a child of the predecessor node. A path can be called a complete path if it ends at a leaf node and it can be called a partial path if it ends at a non-leaf node. For example, a path from root node102ato the child node108ais a complete path. A path from the root node102ato the child node106dis a partial path.

In some implementations, the data model100can be searched and/or filtered to obtain a specific data set stored in one or more nodes in the data model. A filter can be a function that processes data of a given data structure and returns a new data structure containing a subset of the given data based on a certain filter logic using predicates of the elements of the data structure. The filter function can process data of a hierarchical data model and can return a new hierarchical data model that can include all or a subset of the given data and consider predicate functions on the nodes as well as the level of the nodes in the hierarchical data model. A predicate function (or: predicate) can be a Boolean-valued function p: X→{true, false}, called the predicate on X. In some implementations, the predicate function p can be applied to the node of the hierarchical data model and return a Boolean value.

The attribute value derivation tool can be a generic and reusable tool for rule-based mapping and derivation of data. It can be based on rules for mapping and deriving values for target attributes based on values of source attributes and based on an inheritance logic, which uses default values. The attribute value derivation can provide a user interface to maintain values for the target attributes in a hierarchical set of rules, also called instructions. The values for the target attributes can be defined in a hierarchical set of instructions based on source attribute value combinations of the source attribute hierarchy. The tree structure can include any number of rules.

In some implementations, the current subject matter can provide a user interface that can allow a user to perform various maintenance functions and/or data manipulations of data stored in the hierarchical data model. These functions can effectuate changes of attribute values in the hierarchy of source attribute value combinations. Further, the user interface can provide an overview of the attribute values and the source attribute value combinations of the source attribute hierarchy. The user interface can also allow filtering the rules by given selection criteria, filtering the rules by directly maintained values, and/or expanding the tree of source attributes to a given level. For any of these functions, different recursive filter algorithms can be used.

FIG. 2illustrates an exemplary source attribute hierarchy200, according to some implementations of the current subject matter. The hierarchy200can include a default level202, a source attribute A level204, a source attribute B level206, and a source attribute C level208. The hierarchy can include any number of levels. At each level, there can exist a number of rules or instructions, where child level instructions inherit parent level instructions. As shown inFIG. 2, the default level202can include an instruction1202a; level204can include instruction2204aand instruction3204b; level206can include instruction3206a, instruction4206b, instruction5206c, and instruction7206d; level208can include instruction8208a, instruction9208b, and instruction10208c. As shown in this figure, instruction8208acan inherit instruction5, instruction2and instruction1. In some implementations, source attributes can be defined in a hierarchy where each level consists of a source attribute to group source attribute value combinations based on a specific value or a grouping such as a selection of source attribute values to individually generate groups of source attribute value combinations.

In some implementations, values for target attributes can be defined in a hierarchical set of instructions, which can be also referred to as an attribute value derivation instruction set (“AVD instruction set”). The definitions of the target attributes can be based on source attribute value combinations of the source attribute hierarchy. Each value of a target attribute of the instruction can be defined by a specific or an explicit value, a reference to a source attribute, or, alternatively can be determined based on a function.

This value can be directly maintained. If it is not directly maintained, then this value can be inherited by the corresponding value of the instruction of the upper level of the source attribute hierarchy. As shown inFIG. 2, the AVD instruction set can include an instruction202aincluding overall default values, which can be independent of the values of the source attributes. The AVD instruction set can further include a hierarchical data model where the source attributes (including the groupings) can define a level of the tree (202-208) and the instruction(s) with the source attribute value combinations can define the nodes of the tree (202a-208c). The root node202acan also be called the default instruction.

FIG. 3illustrates an exemplary user interface300containing an attribute value derivation instruction set and corresponding to the tree structure200shown inFIG. 2, according to some implementations of the current subject matter. The user interface300illustrates a tree structure where the source attributes (and/or groupings) can define a level of the tree200and the source attribute value combinations and the assigned instruction can define the nodes of the tree200. The assigned instructions can also define target attribute values (by a directly maintained value (highlighted in bold) or by an inherited value). For example, a directly maintained value can be a target attribute value1(“Trg. Attrib. Value1”) corresponding to the default instruction202a. The directly maintained value can also be target attribute value2(“Trg. Attrib. Value2”), target attribute value3(“Trg. Attrib. Value3”), and target attribute value4(“Trg. Attrib. Value4”). Target attribute value2can be defined by instruction4206a(as shown inFIG. 2) and can be based on the source attribute B206that defines a source attribute value of “ABC1”. Target attribute value3can be defined by instruction5206b(as shown inFIG. 2) and can be based on the source attribute B206that defines a source attribute value of “ABC2”. Target attribute value4can be defined by instruction10208c(as shown inFIG. 2) and can be based on the source attribute C208that defines a source attribute value of “K”. Other target attribute values can be inherited attribute values. For example, a target attribute value defined by instruction2204acan be based on the source attribute A having a source attribute value of “X1”. This target attribute value can be inherited from the corresponding upper level instruction, i.e., instruction1, so that the target attribute value1(“Trg. Attrib. Value1”) can be used as target attribute value for instruction2. Examples of other inherited attribute values are shown inFIG. 3.

In some implementations, the current subject matter can provide recursive filter mechanisms for hierarchical data models and uses these filter mechanisms by the attribute value derivation. The filter mechanisms can process data stored in a hierarchical data model and return a subset of data based on predicates on the elements contained the hierarchical data model and/or the level of elements in the hierarchical data model. A predicate function (or: predicate) can be a Boolean-valued function p: X->{true, false}, called the predicate on X. In this context, the predicate function p can be applied to a node of the hierarchical data model and return a Boolean value. This value can be considered in the filter logic. As stated above, the attribute value derivation can use rules to map and derive values for target attributes dependent on values of source attributes and can provide a user interface to maintain these values in a hierarchical set of rules defined for the source attribute value combinations. The user interface can also provide different filter mechanisms. One of these mechanisms can include a filter of the source attribute values, where the rules are filtered using selection criteria, which can be defined for any source attribute(s) of the source attribute hierarchy and which can be applied to the values of the source attributes. Another mechanism can include a filter for directly maintained target attribute values. Here, if this filter is set, then all rules can be displayed, which include at least one directly maintained value. In addition, all corresponding upper level rules can also be shown. A further filter mechanism can include a filter of the source attribute hierarchy level. This filter can define a level so that all rules from the root level down to the given level can be displayed. The following is a discussion of filters that can be used in connection with the attribute value derivation.

In some implementations, different filtering mechanisms or filters can be used to filter data contained in a hierarchical data model. These filters can consider the predicates as well as level(s) of nodes. The current subject matter can be implemented at least one of the following filters: AND-filter (including complete paths and all levels filters) and an OR-filter (including partial paths, complete paths, and a level-filter). The filters can be applied in various combinations, which include at least one of the following: AND-filter and level-filter, OR-filter and level-filter, AND-filter and OR-filter, and AND-filter, OR-filter and level-filter. The filters use recursive retrieval logic for the nodes contained in the hierarchical data model. The recursive logic can retrieve all nodes of the hierarchical data model starting at the root node down to all leaf nodes.

FIG. 4illustrates an exemplary hierarchical data model400that can use recursive logic to retrieve data stored in its nodes, according to some implementations of the current subject matter. The data model400can include a level0402node (i.e., a root node N1), a level1404nodes (i.e., parent/child nodes N2, N3), a level2406nodes (i.e., leaf/child nodes N4, N6, and parent/child nodes N5, N7), and level3408nodes (i.e., leaf/child nodes N8, N9, N10).

This retrieval mechanism can be applied to any hierarchical data model of any level and can be implemented by starting with the root node of the data model as the current node in the following way:Return current node;Determine all child nodes of the current node;If there are no child nodes, then exit;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node;Return all retrieved nodes.

Referring toFIG. 4, the above retrieval mechanism can be implemented as follows (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix A1):Start with root node N1as current node;Return node N1;Determine the child nodes of N1, i.e., N2and N3;Apply the recursive retrieval logic to the nodes N2and N3:Return node N2;Determine the child nodes of N2, i.e., N4and N5;Apply the recursive retrieval logic to the nodes N4and N5Return N4;Since the node N4does not have any child nodes, exit;Return N5, . . . , and its child nodes N8and N9;Return N3, . . . , and its child nodes N6, N7and N10.

In some implementations, the AND-filter can be a recursive algorithm for retrieving and filtering nodes of a hierarchical data model subject to predicate functions of the nodes. The result of the predicate functions can include a node that is returned if it belongs to a complete path where all predicate functions (if given) of the nodes of this path return the value ‘true’. The path is valid when all node predicates are valid. This logic can be modified in the way that the predicate functions of all levels are considered even if the complete path ends at a level which is not the maximum level of the hierarchy. As stated above, the AND-filter can include two variations: an AND-filter complete paths and AND-filter all levels.

Referring toFIG. 5a, the AND-filter complete paths filtering mechanism can consider predicate functions of nodes of complete paths of the hierarchical data model. This filter mechanism can filter nodes using the following sequence: a node is filtered out if there is a predicate function given for this node and if the predicate function of the node returns the value ‘false’; if a node is filtered out, then all child nodes of this node are also filtered out; and if all child nodes of a node are filtered out, then this node is also filtered out.

The AND-filter complete paths filtering mechanism can return all nodes that belong to at least one complete path for which all nodes either do not have a predicate function set or this predicate function is ‘true’. Here, there is no difference if there is no predicate function set for a node or if the predicate function is given for this node and this predicate function returns the value ‘true’.

This filtering mechanism can be applied to any hierarchical data model at any level and can be implemented by starting with the root node of the data model as the current node in the following way:If AND-predicate of current node=‘false’, then exit;determine all child nodes of the current node;if there are no child nodes, then return current node and exit;For all child nodes of the current node: retrieve all nodes by applying this logic recursively for every child node of the current node;If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes.

Referring toFIG. 5a, the above filtering mechanism can be implemented as follows (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix B1):start with root node N1as current node;determine the child nodes of N1, i.e., N2and N3;apply the recursive retrieval logic to the nodes N2and N3:return node N2;determine the child nodes of N2, i.e., N4and N5;apply the recursive retrieval logic of N4:N4does not have child nodes: return N4;apply the recursive retrieval logic of N5:determine child nodes of N5: N8and N9;since the AND-predicate of N8is ‘false’ (i.e., P8(N8)=false), exit;since the AND-predicate of N9is ‘false’ (i.e., P9(N9)=false), exit;since there are no valid child nodes of N5returned (i.e., P8(N8)=false and P9(N9)=false), N5is also not returned (shown inFIG. 5aas being crossed-out);return N2and N4.
Thus, as a result of this filtering mechanism, the node N3is processed and the nodes N3and N6are returned.

The nodes N7, N8and N9are filtered out because the predicate function is ‘false’ (i.e., P7(N7)=false; P8(N8)=false; and P9(N9)=false, which are shown as crossed out inFIG. 5a). Since node N7is filtered out, all its child nodes, i.e., node N10, are filtered out (although its predicate function is ‘true’). Since all child nodes of node N5, i.e., nodes N8and N9, are filtered out, the node N5is also filtered out (although its predicate function is ‘true’).

FIG. 5billustrates an example of an AND-filter all levels filtering mechanism. The AND-filter complete paths filtering mechanism logic discussed above can be modified to also consider the predicate functions of all levels in the data model for those paths which do not end at the maximum level of the node hierarchy. For this modified logic, the predicate function can be the same for each hierarchy level. Then, the AND-filter all levels filtering mechanism can be defined using the same filtering logic as the AND-filter complete paths filtering mechanism with the following additional rule: if a node is not at the lowest level of the hierarchy and if there is a predicate function set for at least one level below the level of the given node, then this node is filtered out. Thus, it is assumed that the given node has child nodes down to the lowest level but the predicate function(s) of these child nodes return the value ‘false’. Hence, this filtering mechanism is different from the AND-filter complete path filtering mechanism because there is a difference if there is no predicate function set for a node or if the predicate function is given for this node and this predicate function returns the value ‘true’.

The AND-filter all levels filtering mechanism can operate as follows (by starting with the root node as the current node):If AND-predicate of current node=‘false’, then exit;Determine all child nodes of the current node;If there are no child nodes, then check if there is a predicate function set for at least one of the lower levels of the current node;If this is the case, then exit;Otherwise, return current node;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node;If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes.

Referring toFIG. 5b, the above filtering mechanism can be implemented as follows (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix B2):nodes N7and N9are filtered out (shown as crossed-out inFIG. 5b) because the predicate function is ‘false’ (i.e., PL2(N7)=false and PL3(N9)=false);since the nodes N4and N6(at level2506) are not at the lowest level and there is a predicate function set for a lower level, i.e., for level3508, the nodes N4and N6are filtered out (shown as crossed-out inFIG. 5b);since node N7is filtered out, all its child nodes, i.e., node N10(although its predicate function is ‘true’), are filtered out;since all child nodes of node N3, i.e., nodes N6and N7, are filtered out, the node N3is also filtered out (although its predicate function is not set).

FIGS. 6a-billustrates exemplary OR-filter filtering mechanisms in a hierarchical data model600, according to some implementations of the current subject matter. The data model600(similar to data models400and500shown inFIGS. 4 and 5a-b)) includes a level0602node (i.e., a root node N1), a level1604nodes (i.e., parent/child nodes N2, N3), a level2606nodes (i.e., leaf/child nodes N4, N6, and parent/child nodes N5, N7), and level3608nodes (i.e., leaf/child nodes N8, N9, N10).FIG. 6ashows an OR-filter partial paths filtering mechanism example andFIG. 6bshows an OR-filter complete paths filtering mechanism example.

In some implementations, the OR-filter filtering mechanism can retrieve and filter nodes of a hierarchical data model subject to the predicate functions of the nodes. The result of the predicate functions can return a node if it belongs to a path where at least one predicate function of the nodes of this path returns the value ‘true’. Thus, using this filtering mechanism, at least one of the node predicates of a path may need to be valid to make all nodes of the path valid.

The OR-filter partial paths filtering mechanism can return only those nodes that belong to at least one of those paths which end at a node that does not have a predicate function set or this predicate function is ‘true’. The OR-filter complete paths filtering mechanism can return a complete path if at least one of the nodes of this path has a predicate function with the value ‘true’. A predicate function of the OR-filter is referred to as the OR-predicate function.

Referring toFIG. 6a, using the OR-filter partial paths filtering mechanism, a node is not filtered out if there is no predicate function given for the node or if the predicate function of the node returns the value ‘true’. If a node is not filtered out, then all its parent nodes up to the root node are also not filtered out (even if their predicate function is ‘false’). A node is filtered out if there is a predicate function for the node and this predicate function returns the value ‘false’ and if there is no child node for which a predicate function returns the value ‘true’. In this case, there is no difference if there is no predicate function set for a node or if the predicate function is given for this node and this predicate function returns the value ‘true’.

The OR-filter partial paths filtering mechanism can start at the root node as the current node and proceed as follows:Determine all child nodes of the current node;If there are no child nodes, then exit;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node;If there are nodes returned from these child nodes (=valid nodes), then return these nodes and the current node;Otherwise, return current node if the OR-predicate of the current node is ‘true’.

As shown inFIG. 6a, the OR-filter partial paths filtering mechanism can operate as follows (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix C1):nodes N1, N2, N3, N4, N7and N8(not cross-out inFIG. 6a) are not filtered out because these nodes do not have a predicate function set or the predicate function is ‘true’;because node N8is not filtered out, all its parent nodes are also not filtered out, i.e., the nodes N5(although its predicate function is ‘false’), N2and N1are not filtered out.

The OR-filter complete paths filtering mechanism can return all complete paths up to leaf nodes if there is at least one positive OR-predicate. In this case, a node is not filtered out if there is no predicate function given for the node or if the predicate function of the node returns the value ‘true’. If a node is not filtered out, then all its parent nodes up to the root node as well as all its child nodes are also not filtered out (even if there is a predicate function set for this parent node and this predicate function is ‘false’). A node is filtered out if there is a predicate function given for the node and this predicate function returns the value ‘false’ and if there is neither a parent node nor a child node for which a predicate function returns the value ‘true’. Thus, this filtering mechanism can return all nodes that belong to at least one of those paths which end at a leaf node and for which there is at least one node which do not have a predicate function set or this predicate function is ‘true’. In this case, this filtering mechanism can operate similarly if there is no predicate function set for a node or if the predicate function is given for this node and this predicate function returns the value ‘true’.

In some implementations, the OR-filter complete paths filtering mechanism can start at the root node as the current node and proceed as follows:Determine all child nodes of the current node;If there are no child nodes and if the OR-predicate of the given node is ‘true’ or there is a parent node which has an OR-predicate with value ‘true’ (‘Collect all child nodes’-flag), then return given node and exit;If the OR-predicate of the given node is ‘true’ or if the given ‘Collect all child nodes’-flag is set, then set (local) ‘Collect all child nodes’-flag;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node and with the (local) ‘Collect all child nodes’-flag;If there are nodes returned from these child nodes (=valid nodes), then return these nodes and the current node;Otherwise, return current node if the OR-predicate of the current node is ‘true’.

As shown inFIG. 6b, the OR-filter complete paths filtering mechanism can operate as follows (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix C2):nodes N2, N6and N8are not filtered out because these nodes do not have a predicate function set or the predicate function is ‘true’;all parent nodes and all child nodes of these nodes, i.e., the nodes N1, N3, N4, N5and N9, are also not filtered out (although the predicate functions of these nodes are ‘false’);nodes N7and N10are filtered out because these nodes do not have parent nodes or child nodes for which the predicate function is set or this predicate function is ‘true’.

FIG. 7illustrates an exemplary level-filter filtering mechanisms in a hierarchical data model700, according to some implementations of the current subject matter. The data model700(similar to data models400,500,600shown inFIGS. 4-6b, respectively)) includes a level0702node (i.e., a root node N1), a level1704nodes (i.e., parent/child nodes N2, N3), a level2706nodes (i.e., leaf/child nodes N4, N6, and parent/child nodes N5, N7), and level3708nodes (i.e., leaf/child nodes N8, N9, N10). The level filter filtering mechanism can be a recursive algorithm to retrieve and filter the nodes of a hierarchical data model subject to a given hierarchy level. This filter algorithm can filter the nodes by their hierarchy level. It can be defined using the following logic. All nodes that belong to a level between the root node level (i.e., level ‘0’) down to the given level can be returned. In some implementations, the level filtering mechanism can include similar logic as the OR-filter filtering mechanism where all nodes of a given level can have a predicate function with a value ‘true’ and child nodes of these nodes can have a predicate function with value ‘false’.

In a hierarchical data model, this filtering mechanism can be implemented by starting at a given level and with the root node as the current node.Return current node;If the given level=‘0’, then exit;Reduce level by ‘1’ (=current level);Determine all child nodes of the current node;If there are no child nodes, then exit;If current level=‘0’, then return child nodes and exit;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively with the current level for every child node of the current node;Return all retrieved nodes.

As a result of the above filtering, nodes N1, N2, . . . , N7can be returned because they belong to levels between the root node level ‘0’ down to the given level ‘2’. Nodes N8, N9, and N10can be filtered out (shown as crossed-out inFIG. 7) because they belong to a lower level (i.e., level ‘3’).

In some implementations, one or more of the above filtering mechanisms can be combined. Some examples of the combined filtering mechanisms can include an AND-filter and level-filter filtering mechanism (as shown inFIGS. 8a-b), an OR-filter and level-filter filtering mechanism (shown inFIGS. 8c-d), an AND-filter and OR-filter filtering mechanism (shown inFIG. 8e), and an AND-filter, OR-filter and level-filter filtering mechanism (shown inFIG. 8f). The following provides a brief overview of each of these combined filtering mechanisms.

Referring toFIGS. 8a-b, a combined AND-filter and level-filter filtering mechanism is illustrated. In some implementations, the AND-filter can be applied first, followed by the level-filter as applied on the result of the AND-filter.FIG. 8aillustrates an exemplary combination of AND-filter complete paths with a level-filter filtering mechanism.FIG. 8billustrates an exemplary combination of AND-filter all levels with a level-filter filtering mechanism.

The combination of the AND-filter complete paths with the level-filter can be performed as follows, starting at the root node as the current node:If AND-predicate of current node=‘false’, then exit;If given level=‘0’ and if there is no AND-predicate function set, then return current node and exit;Reduce level by ‘1’ (=current level);Determine all child nodes of the current node;If there are no child nodes, then exit;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node with the current level;If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes if given level is greater ‘0’.

As shown inFIG. 8a, the combined AND-filter complete paths with the level-filter can operate as follows (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix E1):start with root node N1as current node;return node N1;reduce level by ‘1’: current level=‘1’;determine child nodes of N1, i.e., N2and N3;apply the recursive retrieval logic to nodes N2and N3with current level=‘1’:return node N2;reduce level by ‘1’: current level=‘0’;determine child nodes of N2, i.e., N4and N5;and so on, returning nodes N4, N3and N6.As a result of this filtering mechanism, nodes N7, N8and N9can be filtered out (shown as crossed-out inFIG. 8a), because predicate function is ‘false’. Since node N7is filtered out, all its child nodes, i.e., node N10, can be filtered out (although its predicate function is ‘true’). Since all child nodes of node N5, i.e., nodes N8and N9, are filtered out, node N5can also be filtered out (although its predicate function is ‘true’).

As stated above,FIG. 8billustrates an exemplary combination of the AND-filter all levels filtering mechanism with a level-filter filtering mechanism. This combined filtering mechanism can be implemented by starting with the root node as the current node.If AND-predicate of current node=‘false’, then exit;Reduce level by ‘1’ (=current level);Determine all child nodes of the current node;If there are no child nodes, then check if there is a predicate function set for at least one of the lower levels of the current node;If this is the case, then exit;Otherwise, return current node;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node with the current level;If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes if given level is greater ‘0’.

As shown inFIG. 8b, the combined AND-filter all levels with the level-filter can operate as follows (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix E2):nodes N7and N9are filtered out (shown as crossed-out inFIG. 8b) because the predicate function is ‘false’;since nodes N4and N6(at level2) are not at the lowest level and there is a predicate function set for a lower level, i.e., for level3, the nodes N4and N6are filtered out;since node N7is filtered out, all its child nodes, i.e., node N10(although its predicate function is ‘true’), are filtered out;since all child nodes of node N3, i.e., nodes N6and N7, are filtered out, the nodeN3is also filtered out (although its predicate function is not set).

Referring toFIGS. 8c-d, a combined OR-filter and level-filter filtering mechanism is illustrated. In some implementations, the OR-filter can be applied first and then the level-filter can be applied on the result of the OR-filter.FIG. 8cillustrates an exemplary combination of OR-filter partial paths with a level-filter filtering mechanism.FIG. 8dillustrates an exemplary combination of OR-filter complete paths with a level-filter filtering mechanism.

Referring toFIG. 8c, a combination of OR-filter partial paths and level-filter can be implemented by starting with the root node as the current node:Return current node;If AND-predicate of current node=‘false’, then exit;Reduce level by ‘1’ (=current level);Determine all child nodes of the current node;If there are no child nodes, then exit;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node with the current level;If there are nodes returned from these child nodes (=valid nodes), then return these nodes and the current node;Otherwise, return current node if the OR-predicate of the current node is ‘true’.

As shown inFIG. 8c, the combined OR-filter partial paths with the level-filter can operate as follows (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix E3):nodes N1, N2, N3, N4, N7and N8are not filtered out (not shown as cross-out inFIG. 8c) because these nodes do not have a predicate function set or the predicate function is ‘true’;because the node N8is not filtered out, all its parent nodes are also not filtered out, i.e., nodes N5(although its predicate function is ‘false’), N2and N1are not filtered out.

Referring toFIG. 8d, an OR-filter complete paths filtering mechanism can be combined with the level-filter filtering mechanism. This combined filtering mechanism can be operate as follows, starting at the root node as the current node:If given level=‘0’ and if there is no OR-predicate function set, then return current node and exit;Reduce level by ‘1’ (=current level);Determine all child nodes of the current node;If there are no child nodes and if the OR-predicate of the given node is ‘true’ or there is a parent node which has an OR-predicate with value ‘true’ (‘Collect all child nodes’-flag), then return given node and exit;If the OR-predicate of the given node is ‘true’ or if the given ‘Collect all child nodes’-flag is set, then set (local) ‘Collect all child nodes’-flag;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node and with the (local) ‘Collect all child nodes’-flag;If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes if given level is greater ‘0’;Otherwise, return current node if the OR-predicate of the current node is ‘true’.

As shown inFIG. 8d, the combined OR-filter complete paths with the level-filter can operate as follows (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix E4):nodes N2, N6and N8are not filtered out (not shown as crossed-out inFIG. 8d) because these nodes do not have a predicate function set or the predicate function is ‘true’;all parent nodes and all child nodes of these nodes, i.e., the nodes N1, N3, N4, N5and N9, are also not filtered out (although the predicate functions of these nodes are ‘false’);nodes N7and N10are filtered out (shown as cross-out inFIG. 8d) because these nodes do not have parent nodes or child nodes for which the predicate function is set or this predicate function is ‘true’.

FIG. 8eillustrates an exemplary combination of an AND-filter all levels filtering mechanism with an OR-filter partial paths filtering mechanism. This combined filter can operate as follows, starting at the root node as the current node:If AND-predicate of current instruction=‘false’, set “Children-filtered-out”-flag, return this flag and exit. Determine all child nodes of the current node;If there are no child nodes, then check if there is a predicate function set for at least one of the lower levels of the current node;If so, then:If the level of the current instruction=maximum number of levels, then return current instruction if there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given instruction is ‘true’;Otherwise:If there is a predicate function set for at least one of the lower levels of the current node, then set “Children-filtered-out”-flag;Otherwise: If there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given instruction is ‘true’, then return current instruction;Otherwise: If there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given instruction is ‘true’, then return current instruction;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node with the current level. Check if all child nodes are filtered out (by the AND-predicates). If so, then set “Children-filtered-out”-flag;If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes;If there is no OR-predicate function set (at any hierarchy level), then: If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes;Otherwise: If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes. Otherwise: If there is no OR_predicate function set (at any hierarchy level) or if the OR-Predicate function of the given instruction is ‘true’, then do not return current instruction, otherwise return current instruction;Return all retrieved valid nodes and return “Children-filtered-out”-flag.

As shown inFIG. 8e, the combined AND-filter all levels with the OR-filter partial paths can operate as follows. InFIG. 8e, predicate functions of the AND-Filter are shown by PLevel(Node) and predicate functions of the OR-Filter are indicated by the following: no shading indicates that OR-predicate function of this node is set to ‘false’ or not set and shading indicates that OR-predicate function of this node is set to ‘true’. The operation is as follows (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix E5):nodes N7and N9are filtered out because the predicate function is ‘false’;since nodes N4and N6(at level2) are not at the lowest level and there is a predicate function set for a lower level, i.e., for level3, the nodes N4and N6are filtered out (although the OR-predicate function and the AND-predicate function of node4is ‘true’ and although the AND-predicate function of node6is ‘true’);since node N7is filtered out, all its child nodes, i.e., node N10(although its predicate function is ‘true’), are filtered out;since all child nodes of node N3, i.e., nodes N6and N7, are filtered out, node N3is also filtered out (although its OR-predicate function is ‘true’);node N5is not filtered out because its AND-predicate function is ‘true’ and its OR-predicate function is ‘true’;nodes N1and N2are not filtered out because the node N5is not filtered out.

FIG. 8fillustrates an exemplary combination of an AND-filter all levels filtering mechanism, an OR-filter partial paths filtering mechanism and a level-filter filtering mechanism that operates by applying the AND-filter, the OR-filter and the level-filter in this sequence. This combined filter can operate as follows, starting at the root node as the current node:If AND-predicate of current node=‘false’, set “Children-filtered-out”-flag, return this flag and exit;If the given level is ‘0’ and if there is no AND-predicate function set and if there is no OR-predicate function set, then return current node and exit;Reduce level by ‘1’ (=current level);Determine all child nodes of the current node;If there are no child nodes, then check if there is a predicate function set for at least one of the lower levels of the current node;If so, then:If the level of the current node=maximum number of levels, then return current node if there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given node is ‘true’;Otherwise:If there is a predicate function set for at least one of the lower levels of the current node, then set “Children-filtered-out”-flag;Otherwise: If there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given node is ‘true’, then return current node;Otherwise: If there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given node is ‘true’, then return current node;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node with the current level. Check if all child nodes are filtered out (by the AND-predicates). If so, then set “Children-filtered-out”-flag;If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes;If there is no OR-predicate function set (at any hierarchy level), then: If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes if given level is greater ‘0’;Otherwise: If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes if given level is greater ‘0’. Otherwise: If there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given node is ‘true’, then do not return current node, otherwise return current node;Return all retrieved valid nodes and return “Children-filtered-out”-flag.

As shown inFIG. 8f, the combined AND-filter all levels filtering mechanism, OR-filter partial paths filtering mechanism and a level-filter filtering mechanism can operate as follows. Assuming that the given filter level is ‘1’ (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix E6):nodes N1and N2are not filtered out because they belong to levels up to the given level ‘1’ and they are not filtered out by the AND-filter or the OR-filter;node N3is filtered out because all child nodes of node N3, i.e., nodes N6and N7, are filtered out (although node N3belongs to level ‘1’);node N5is filtered out because they belong to a lower level (although is not filtered out by the AND-filter and by the OR-filter);nodes N4, N6, N7, N8, N9and N10are filtered out because they belong to a lower level and because they are filtered out by the AND-filter or by the OR-filter.

As stated above with regard toFIGS. 1-3, the attribute value derivation can provide rule based mapping and derivation of data, where the rules allow mapping and deriving values for target attributes based on values of source attributes including an inheritance logic using default values. The AVD provides a user interface to maintain values in a hierarchical set of rules, i.e., instructions, defined for source attribute value combinations. The user interface can allow filtering of rules using a given selection criteria, filtering by directly maintained values, and expanding the tree of source attributes to a particular level. These functionalities can be accomplished using various recursive filter algorithms.

In some implementations, attribute value derivation can be implemented as a business object which can include methods to initialize the business object, to load the data, to change the instruction data, to derive the target attribute values, to filter the instruction data, etc. The business object can be independent of the user interface to maintain the AVD instruction set and/or to derive the target attribute values. The user interface can use public methods of the business object to, for example, change the instruction data. The business object can run on a computer system and the user interface can communicate with the business object by calling the methods. The user interface can run on the same computer system or runs on a different computer system and calls the public methods remotely. Business objects can include methods for filtering instructions by different filtering criteria. These methods can implement the filtering functions using recursive filter algorithms discussed above. The user interface can allow actions and/or other functions to be set and apply these filters and call corresponding methods of business objects which can return results of the filtered instructions.

In some implementations, the user interface can provide at least one of following filter functions: source attribute filter, filter for directly maintained value, and expanding the source attribute tree function. The source attribute filter can include selection criteria which can be defined for every source attribute. Applying this filter, all instructions are shown where the source attribute values fit to the given source attribute selection criteria. Using filter for directly maintained values, all instructions are shown which have at least one directly maintained value. Further, all corresponding upper level instructions up to the default instruction can be shown. Using the expanding the source attribute tree instructions, the source attribute tree can be expanded to any level of the source attribute hierarchy, then, only those instructions are shown which belong to a level down to the given level and the default instruction is always shown. In some implementations, these filters can be applied in combination.

In some implementations, the filters of the attribute value derivation can include at least one of the following: a source attribute filter, a filter for directly maintained values, an expanding the source attribute tree function, and a default instruction. The source attribute filter can correspond to the AND-filter where selection criteria of the source attributes can be the predicate functions of the level of the corresponding source attribute. The filter for directly maintained values can correspond to the OR-filter where the predicate function of all instructions of all levels can be defined by the flag if the data of the node (i.e., the instruction) has at least one directly maintained value for the given target attributes. The expanding the source attribute tree function can correspond to the level filter where the default instruction (as the root node) has level ‘0’. The default instruction of the AVD instruction set, i.e., the root node of the hierarchy, can be always returned.

FIG. 9illustrates an exemplary user interface of AVD instruction set900that includes filters, according to some implementations of the current subject matter. The filters that are included in the AVD instructions set900(shown at the bottom half of the instruction set900) can include a filter to show only the directly maintained values (i.e., a filter to show only instructions with manually defined values), a filter for source attributes (i.e., “Source Attribute A: Selection Criteria for Source Attribute A”, “Source Attribute B: Selection Criteria for Source Attribute B”, and “Source Attribute C: Selection Criteria for Source Attribute C”) and an expand function to expand the tree up to a selected source attribute. Results of these filters are shown in the bottom half ofFIG. 9.

Application of the filter to show only instructions with directly maintained values can result in target attribute values corresponding to Instruction1, Instruction4, Instruction5, and Instruction10that indicate (i.e., those that are shown in bold inFIG. 9, i.e., “Trg. Attrib. Value1”, “Trg. Attrib. Value2”, “Trg. Attrib. Value3”, and “Trg. Attrib. Value4”, respectively) and their corresponding upper level instructions. Application of the filter for source attributes results in instructions and values corresponding only to the source attributes A, B, and C. The resulting set can be expanded up to a specific selected source attribute, e.g., Source Attribute C.

In some implementation, a filter mechanism of the attribute value derivation can include a combination of AND-filter all levels filtering mechanism, OR-filter partial paths filtering mechanism and level-filter filtering mechanism. The filter mechanism of the AVD instruction set can operate as follows, starting at the default instruction (i.e., root node) as the current node (an exemplary pseudo-code illustrating this logic is attached hereto as Appendix F1):If the AND-predicate of current instruction=‘false’, set “Children-filtered-out”-flag, return this flag and exit;If the given level is ‘0’ and if there is no AND-predicate function set and if there is no OR-predicate function set, then return current instruction and exit;Reduce level by ‘1’ (=current level);Determine all child nodes of the current node;If there are no child nodes, then check if there is a predicate function set for at least one of all nodes;If so, then:If the level of the current instruction=‘0’, then return this instruction (default instruction);If the level of the current instruction=maximum number of levels, then return current instruction if there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given instruction is ‘true’;Otherwise:If there is a predicate function set for at least one of the lower levels of the current node, then set “Children-filtered-out”-flag;Otherwise: If there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given instruction is ‘true’, then return current instruction;Otherwise: If there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given instruction is ‘true’, then return current instruction;For all child nodes of the current node: Retrieve all nodes by applying this logic recursively for every child node of the current node with the current level. Check if all child nodes are filtered out (by the AND-predicates). If so, then set “Children-filtered-out”-flag;If there is no OR-predicate function set (at any hierarchy level), then: If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes if given level is greater ‘0’;Otherwise: If there are nodes returned from these child nodes (=valid nodes), then return current node and return valid child nodes if given level is greater ‘0’. Otherwise: If there is no OR-predicate function set (at any hierarchy level) or if the OR-Predicate function of the given instruction is ‘true’, then do not return current instruction, otherwise return current instruction;Return all retrieved valid nodes and return “Children-filtered-out”-flag.

FIGS. 10a-dillustrate exemplary implementations of the above filtering mechanism logic to the AVD instruction set900shown inFIG. 9, according to some implementations of the current subject matter. The logic can be applied in a hierarchical data model1000, according to some implementations of the current subject matter. As shown inFIGS. 10a-10c, the data model1000can include a default instruction1002(i.e., a default instruction1), source attribute A instructions1004(i.e., instructions2and3), source attribute B instructions1006(i.e., instructions4and6, and instructions5and7), and source attribute C instructions1008(i.e., instructions8,9, and10). As shown inFIG. 10a, the predicate functions of instructions4-8and10are set to ‘true’ and prediction function of instruction9is set to false.FIG. 10aillustrates application of source attribute filter and a filter for directly maintained values andFIG. 10billustrates a resulting user interface1010.

FIG. 10cillustrates an expanding function of the source attribute tree in addition to the filters shown inFIG. 10bandFIG. 10dillustrates a resulting user interface1020.

Referring toFIGS. 10a-b, the top part of the user interface1010shows filters that are being applied, i.e., a first filter to show only instruction with manually defined values and a second filter for source attributes (i.e., “Source Attribute B starts with ‘ABC’” and “Source Attribute C equals K”). Thus, the first filter results in “Trg. Attrib. Value1”, “Trg. Attrib. Value2”, “Trg. Attrib. Value3”, and “Trg. Attrib. Value4” corresponding to instructions1,4,5, and10, respectively and their corresponding upper level instructions2,3, and7(as shown inFIG. 9). However, once the second filter is applied, directly maintained target attribute values1,3, and4corresponding to instructions1,5, and10and their corresponding upper level instructions2,3, and7are shown. This is because the second filter includes a first part that limits the data set to Source Attribute B that starts with ABC and a second part that limits the data set to Source Attribute C that equals K. As shown inFIG. 10b, these are “Source Attribute B: Src. Attrib. Value=‘ABC2’ corresponding to instruction5and “Source Attribute C: Src. Attrib. Value=‘K’ corresponding to instruction10.

Referring toFIGS. 10c-d, the filtering mechanism user interface1020can include an additional filter of expanding up to Source Attribute B. As shown inFIG. 10d, the resulting data set is smaller than the data set shown in the user interface1010ofFIG. 10b. As a result of this filter, only source attributes A and B are shown and source attribute C and its corresponding instructions are filtered out. Hence, “Source Attribute C: Src. Attrib. Value=‘K’ corresponding to instruction10is removed from the resulting data set.

FIGS. 11a-cillustrate exemplary applications of the AVD instructions set filtering mechanism, according to some implementations of the current subject matter. In these examples, the source attribute hierarchy of the AVD instruction set can include three source attributes ‘Product Group’, ‘Product Category’, and ‘Product Subcategory’. The target attribute can be ‘Material Group’.FIG. 11aillustrates an entire unfiltered instruction set and filters that can be used in this filtering mechanism, i.e., filter to show only instructions with manually defined values, filter for source attributes (i.e., “Product Group: selection Criteria for Product Group”, “Product Category: Selection Criteria for Product Category”, and “Product Subcategory: Selection Criteria for Product Subcategory”), and a filter to expand up to a selected source attribute.

In the hierarchy, the source attribute of the default instructions can correspond to materials group target attribute “A1”; source attribute product group “X1” can correspond to the materials group target attribute “A1”; product category “ABC1” source attribute can correspond to target attribute “A2” and product category “ABC2” source attribute can correspond to target attribute “A3”; and so on, as shown in the user interface1110illustrated inFIG. 11a. Target attributes that are shown in bold inFIG. 11aare directly maintained (i.e., A1corresponding to default source attribute; A2corresponding to product category “ABC1” source attribute; A3corresponding to product category “ABC2” source attribute; and A4corresponding to product subcategory “K” under product group “X2” and product category “ABC3”).

FIG. 11billustrates a user interface1120that shows application of the filter to show only instructions with manually defined values and filter for source attributes (i.e., “product category starts with ‘ABC’” and “product subcategory equals ‘K’”). As shown inFIG. 11b, product categories and product subcategories that do not include directly maintained values are filtered out (i.e., “Product Category ‘ABC1’” under “Product Group ‘X1’”; both product subcategories under “Product Category ‘ABC2’”; and “Product Category ‘ABC1’” under “Product Group ‘X2’”).

FIG. 11cillustrates a user interface1130that shows application of a further filter of expanding up to Product Category in addition to the filters shown inFIG. 11b. As shown inFIG. 11c, “Product Subcategory ‘K’” under “Product Category ‘ABC3’” is filtered out.

FIG. 12illustrates an exemplary user interface1200for applying various filtering mechanisms, according to some implementations of the currently subject matter. The top part of the user interface1200shows the filter of the manually maintained values and the filter for the source attributes. The bottom part of the user interface1200shows the instructions and the result of the filter logic. In this part of the user interface, expanding to a source attribute level function is shown (e.g. “Expand up to Category ID (Grouping)”).

In some implementations, the current subject matter can be configured to be implemented in a system1300, as shown inFIG. 13. The system1300can include a processor1310, a memory1320, a storage device1330, and an input/output device1340. Each of the components1310,1320,1330and1340can be interconnected using a system bus1350. The processor1310can be configured to process instructions for execution within the system1300. In some implementations, the processor1310can be a single-threaded processor. In alternate implementations, the processor1310can be a multi-threaded processor. The processor1310can be further configured to process instructions stored in the memory1320or on the storage device1330, including receiving or sending information through the input/output device1340. The memory1320can store information within the system1300. In some implementations, the memory1320can be a computer-readable medium. In alternate implementations, the memory1320can be a volatile memory unit. In yet some implementations, the memory1320can be a non-volatile memory unit. The storage device1330can be capable of providing mass storage for the system1300. In some implementations, the storage device1330can be a computer-readable medium. In alternate implementations, the storage device1330can be a floppy disk device, a hard disk device, an optical disk device, a tape device, non-volatile solid state memory, or any other type of storage device. The input/output device1340can be configured to provide input/output operations for the system1300. In some implementations, the input/output device1340can include a keyboard and/or pointing device. In alternate implementations, the input/output device1340can include a display unit for displaying graphical user interfaces.

FIG. 14illustrates an exemplary method1400for providing various filtering mechanisms of data stored in a hierarchical data model for use by an attribute value derivation, according to some implementations of the current subject matter. At1402, at least one filtering mechanism can be provided to filter at least one instruction containing at least one target attribute value corresponding to at least one source attribute value combination stored in a hierarchical data model. At1404, the instructions can be filtered using the at least one filtering mechanism. At1406, a user interface can be generated and can display the hierarchical data model containing the filtered instructions.

In some implementations, the current subject matter can include one or more of the following optional features. The filtering mechanism can include at least one of the following: a filtering mechanism for displaying at least one directly maintained target attribute value, a filtering mechanism based on at least one source attributes, and a filtering mechanism for expanding a tree of source attributes up to a selected source attribute. The filtering mechanisms can be applied using a predetermined sequence.

In some implementations, the filtering mechanism can be based on at least one of the following algorithms. A first algorithm (which can be an AND-filter described above) for generating a path can retrieve at least one node in the hierarchical data model using a predicate function corresponding to the node. The path can contain a plurality of nodes and end in the at least one node, where each node in the plurality of nodes in the generated path has valid predicate functions. A second algorithm (which can be an OR-filter described above) for generating a path can also retrieve at least one node in the hierarchical data model using a predicate function corresponding to the node. Here, the path can also contain a plurality of nodes and end in the at least one node, but at least one node in the plurality of nodes in the generated path has a valid predicate function. A third algorithm (which can be a level filter described above) for retrieving at least one node in the hierarchical data model can be based on a level of the hierarchical data model containing the node. Any combination of these algorithms can be used to retrieve a node in the hierarchical data model.

In some implementations, the first algorithm can uses at least one of the following: predicate functions of nodes in the generated path containing the plurality of nodes and ending with the at least one node (which corresponds to AND-filter complete paths filtering mechanism), and predicate functions of all nodes on each level of the hierarchical data model, each level containing a node in the generated path (which corresponds to AND-filter all levels filtering mechanism). Using the first algorithm, a node is filtered out when a predicate function of that node has a false value.

In some implementations, the second algorithm can return at least one of the following: a partial path to the at least one node, the partial path containing a node having a predicate function with a true value (which corresponds to an OR-filter partial paths filtering mechanism), and a complete path to the at least one node, the complete path containing each node having a predicate function with a true value (which corresponds to an OR filter complete paths filtering mechanism).

In some implementations, a path generated using the third algorithm can contain nodes located on a plurality of levels in the hierarchical data model. Each level, preceding and inclusive of the level containing the at least one node, can contain nodes having predicate functions with a true value.

The generated user interface can display at least one of the following: the filtered source attribute, the source attribute value corresponding to the filtered source attribute, the source attribute description corresponding to the filtered one source attribute, and a filtered target attribute corresponding to the filtered source attribute.

As used herein, the term “user” can refer to any entity including a person or a computer.