Pre-proportional validation techniques for data managed by data processing systems.

Abstract

Some embodiments provide techniques for performing valid data assignment in a data processing system where data can be dynamically updated by user devices and / or computer processes. These techniques use validation rules associated with a data entity to identify one or more valid values ​​to assign to an attribute of an instance of the data entity. These techniques identify the valid values ​​by generating a query for one or more valid values ​​using one or more conditions for the attribute in the validation rule, and executing the generated query to obtain one or more valid values ​​for a first attribute. The attribute is then assigned one or more of the identified valid values.

Description

[Technical Field]

[0001] Related Applications This application claims the benefit of priority under 35 U.S.C. §119(e) to U.S. Provisional Patent Application No. 63 / 404,758, entitled "TECHNIQUES FOR PRE-ASSIGNMENT VALIDATION OF DATA MANAGED BY A DATA PROCESSING SYSTEM," filed September 8, 2022, which is incorporated herein by reference in its entirety.

[0002] Aspects of the present disclosure relate to techniques for performing valid data assignments in a data processing system where data may be updated (e.g., by users and / or processes), which reduce the risk of invalid numeric assignments to variables in the data processing system. [Background technology]

[0003] Modern data processing systems manage vast amounts of data (e.g., millions, billions, or trillions of data records). Organizations (e.g., multinational banks, global technology companies, e-commerce companies, etc.) may have vast amounts of data (e.g., hundreds to thousands of terabytes) used in their operations. For example, this data may include transaction records, documents, tables, files, and / or other types of data.

[0004] A data processing system may execute software applications to support various functions. Software applications may be used to provide functionality that supports the business of an organization. For example, a bank may develop software applications that support various aspects of its business, such as programs that generate credit reports, bank account histories, transaction reports, and / or other data. Software applications may also be used to extract various insights from data. Summary of the Invention [Means for solving the problem]

[0005] Some embodiments provide a method for performing efficient data allocation in a data processing system configured to process data updated by user devices and / or computer processes. The method includes performing the following using at least one computer hardware processor: receiving, by the data processing system, a request to assign a value to a first attribute in a first data entity instance of a first data entity, the first data entity including a plurality of attributes including a first attribute and a second attribute, the first data entity associated with at least one validation rule, the at least one validation rule including a first validation rule associated with the first attribute, the first validation rule specifying a first condition for the first attribute that is dependent on the second attribute; identifying, using the first validation rule, one or more valid values ​​for the first attribute, the identifying including generating a query for the one or more valid values ​​using the first condition for the first attribute and executing the generated query to obtain the one or more valid values ​​for the first attribute; and assigning, assigning, to the first attribute in the first data entity instance according to input indicating a selection of at least one of the one or more valid values ​​for the first attribute, the assigning including assigning the selected at least one valid value to the first attribute.

[0006] In some embodiments, generating a query for one or more valid values ​​for the first attribute using a first condition on the first attribute that is dependent on the second attribute includes identifying a current value assigned to the second attribute of the first data entity instance and generating a query using the current value of the second attribute in the first data entity instance. In some embodiments, the current value assigned to the second attribute in the first data entity instance is an instance of a second data entity, and generating a query based on the current value assigned to the second attribute of the first data entity includes accessing at least one attribute from the second data entity and generating a query based on the at least one attribute value from the instance of the second data entity.

[0007] In some embodiments, the at least one validation rule includes a plurality of validation rules associated with respective attributes of the first data entity, and the method further includes identifying a first validation rule among the plurality of validation rules based on an association of the first validation rule with the first attribute. In some embodiments, the first validation rule includes a second condition for the first attribute, and generating the query for the one or more valid values ​​includes generating a first portion of the query based on the first condition for the first attribute and generating a second portion of the query based on the second condition for the first attribute.

[0008] In some embodiments, generating a query for one or more valid values ​​using the first condition includes converting the first condition for the first attribute into a query search condition and incorporating the query search condition into the query. In some embodiments, assigning a value to the first attribute in the first data entity instance includes assigning an instance of a second data entity to the first attribute in the first data entity instance. In some embodiments, generating a query for one or more valid values ​​using the first condition for the first attribute includes generating a query on an instance of the second data entity. In some embodiments, executing the generated query to obtain one or more valid values ​​for the first attribute includes executing the generated query on a subset of data consisting of instances of the second data entity.

[0009] In some embodiments, the first attribute indicates an owner, an access security level, a data source, or a data format associated with the first data entity instance. In some embodiments, the first data entity instance stores information about a software application or a dataset as attribute values ​​in the first data entity instance. In some embodiments, the first attribute indicates a data source or a data format that will be used by the software application when attempting to invoke a function of the software application. In some embodiments, the one or more valid values ​​are suitable for invoking the function of the software application. In some embodiments, the first attribute indicates an access security level associated with the dataset that will be used when attempting to provide access to the dataset. In some embodiments, the one or more valid values ​​are one or more access security levels that provide access to the dataset.

[0010] In some embodiments, the method further includes sending to the client device an indication of valid values ​​for one or more of the first attributes for display within a graphical user interface (GUI), and receiving from the client device through the GUI an input indicating a selection of at least one of the one or more valid values ​​for the first attribute. In some embodiments, identifying the one or more valid values ​​for the first attribute includes identifying one or more instances of the second data entity as the one or more valid values ​​for the first attribute.

[0011] In some embodiments, the first validation rule includes a second condition for the first attribute, and identifying one or more valid values ​​using the first validation rule further includes generating a query by generating a first query search term using the first condition for the first attribute and generating a second query search term using the second condition for the first attribute. In some embodiments, the method further includes identifying one or more invalid values ​​for the first attribute using the first validation rule and preventing submission of the one or more invalid values.

[0012] In some embodiments, the first data entity instance has no value assigned to the second attribute, and identifying one or more valid values ​​for the first attribute includes identifying an entered unassigned value for the second attribute and generating a query for the one or more valid values ​​using the unassigned value for the second attribute.

[0013] Some embodiments provide a system for performing valid data assignment in a data processing system configured to process data updated by a user device and / or a computer process, the data processing system storing data using data entities and instances thereof, the system including at least one computer hardware processor and at least one non-transitory computer-readable storage medium storing an assignment validation module, the assignment validation module including a rule selection component, a query generation component, and a query execution component, the at least one computer hardware processor executing the assignment validation module to: receive, by the assignment validation module, a request to assign a value to a first attribute of a first data entity instance of a first data entity, the first data entity including a plurality of attributes including a first attribute and a second attribute, the first data entity associated with at least one validation rule that attribute values ​​in the instance of the first data entity must conform to in order to be valid, and The data entity rule is programmed to: receive, using a rule selection component and the first validation rule, one or more valid values ​​for the first attribute, the first validation rule being associated with the first attribute, the first validation rule specifying a first condition for the first attribute that is dependent on the second attribute; identify, using a rule selection component and the first validation rule, one or more valid values ​​for the first attribute, the identifying including: generating, using a query generation component, a query for the one or more valid values ​​using the first condition for the first attribute; and executing, using a query execution component, the generated query to obtain the one or more valid values ​​for the first attribute; and assign, according to input indicating a selection of at least one of the one or more valid values ​​for the first attribute, the assigning including assigning the selected at least one valid value to the first attribute.

[0014] Some embodiments provide at least one non-transitory computer-readable storage medium storing instructions that, when executed by at least one computer hardware processor, cause the at least one computer hardware processor to perform a method for performing effective data allocation in a data processing system configured to process data updated by user devices and / or computer processes, wherein the data processing system stores data using data entities and instances thereof. The method includes receiving, by a data processing system, a request to assign a value to a first attribute of a first data entity instance of a first data entity, the first data entity including a plurality of attributes including a first attribute and a second attribute, the first data entity associated with at least one validation rule that must be met for an attribute value in the instance of the first data entity to be valid, the at least one validation rule including a first validation rule associated with the first attribute, the first validation rule specifying a first condition for the first attribute that depends on the second attribute; identifying one or more valid values ​​for the first attribute using the first validation rule, the identifying including generating a query for the one or more valid values ​​using the first condition for the first attribute and executing the generated query to obtain the one or more valid values ​​for the first attribute; and assigning a value to the first attribute in the first data entity instance according to input indicating a selection of at least one of the one or more valid values ​​for the first attribute, the assigning including assigning the selected at least one valid value to the first attribute.

[0015] Some embodiments provide a method for performing valid data assignment in a data processing system configured to process data updated by a user device and / or a computer process, the data processing system storing data using data entities and instances thereof. The method includes using at least one computer hardware processor to: receive, through a graphical user interface (GUI) by the data processing system, an input indicating a request to assign a value to a first attribute in a first data entity instance of a first data entity, the first data entity including a plurality of attributes including a first attribute and a second attribute, the first data entity associated with at least one validation rule that must be met for attribute values ​​in the instance of the first data entity to be valid, the at least one validation rule including a first validation rule associated with the first attribute, and The method includes receiving a validation rule specifying a first condition for a first attribute that is dependent on a second attribute; transmitting a request to a data processing system, the request causing the data processing system to identify one or more valid values ​​for the first attribute using the first validation rule; receiving from the data processing system the one or more valid values ​​for the first attribute; displaying an indication of the one or more valid values ​​for the first attribute in a GUI; receiving through the GUI an input indicating a selected value of the one or more valid values ​​to assign to the first attribute; and transmitting to the data processing system an indication of the selected value to assign to the first attribute.

[0016] In some embodiments, the request causes the data processing system to identify one or more valid values ​​for the first attribute by generating a query for the one or more valid values ​​using a first condition on the first attribute and executing the generated query to obtain the one or more valid values ​​for the first attribute. In some embodiments, executing the generated query to obtain the one or more valid values ​​for the first attribute includes executing the generated query on a subset of data consisting of instances of the second data entity.

[0017] In some embodiments, the first attribute indicates an owner, an access security level, a data source, or a data format associated with the first data entity instance. In some embodiments, the first data entity instance stores information about a software application or a dataset as attribute values ​​within the first data entity instance. In some embodiments, the first attribute indicates a data source or a data format that is to be used by the software application when attempting to invoke a function of the software application. In some embodiments, the one or more valid values ​​are suitable for invoking the function of the software application. In some embodiments, the first attribute indicates an access security level associated with the dataset that is to be used when attempting to provide access to the dataset. In some embodiments, the one or more valid values ​​are one or more access security levels that provide access to the dataset.

[0018] In some embodiments, receiving one or more valid values ​​for the first attribute includes receiving one or more results of executing a query for one or more valid values ​​generated using the first condition for the first attribute. In some embodiments, the second attribute of the first data entity instance is assigned to an instance of a second data entity, and receiving one or more valid values ​​for the first attribute includes receiving one or more values ​​determined based on the instance of the second data entity. In some embodiments, receiving one or more valid values ​​for the first attribute includes receiving one or more instances of the second data entity, and at least one of the one or more instances of the second data entity can be assigned to the first attribute.

[0019] Some embodiments provide a system for performing valid data assignment in a data processing system configured to process data updated by a user device and / or a computer process, the data processing system storing data using data entities and instances thereof, the system comprising at least one computer hardware processor, and when executed by the at least one computer hardware processor, the system is configured to receive, via a graphical user interface (GUI) by the data processing system, an input indicating a request to assign a value to a first attribute of a first data entity instance of a first data entity, the first data entity including a plurality of attributes including a first attribute and a second attribute, the first data entity associated with at least one validation rule that must be met for an attribute value in the instance of the first data entity to be valid, the at least one validation rule being a validation rule associated with the first attribute. receiving a request to a data processing system, the request causing the data processing system to identify one or more valid values ​​for the first attribute using the first validation rule; receiving from the data processing system the one or more valid values ​​for the first attribute; displaying an indication of the one or more valid values ​​for the first attribute within a GUI; receiving through the GUI an input indicating a selected value from the one or more valid values ​​for assignment to the first attribute; and at least one non-transitory computer-readable storage medium storing instructions causing the data processing system to:

[0020] In some embodiments, the request causes the data processing system to identify one or more valid values ​​for the first attribute by generating a query for the one or more valid values ​​using a first condition for the first attribute and executing the generated query to obtain the one or more valid values ​​for the first attribute.

[0021] In some embodiments, receiving one or more valid values ​​for the first attribute includes receiving one or more results of executing a query for one or more valid values ​​generated using the first condition on the first attribute. In some embodiments, the second attribute of the first data entity is assigned to instances of a second data entity, and receiving one or more valid values ​​for the first attribute includes receiving one or more values ​​determined based on the instances of the second data entity. In some embodiments, receiving one or more valid values ​​for the first attribute includes receiving one or more instances of the second data entity, and at least one of the one or more instances of the second data entity can be assigned to the first attribute.

[0022] Some embodiments provide at least one non-transitory computer-readable storage medium storing instructions that, when executed by at least one computer hardware processor, cause the at least one computer hardware processor to perform a method for performing effective data allocation in a data processing system configured to process data updated by user devices and / or computer processes, the data processing system storing data using data entities and instances thereof. The method includes receiving, through a graphical user interface (GUI) by a data processing system, input indicating a request to assign a value to a first attribute in a first data entity instance of a first data entity, the first data entity including a plurality of attributes including a first attribute and a second attribute, the first data entity associated with at least one validation rule that must be met for the instance of the first data entity to be valid, the at least one validation rule including a first validation rule associated with the first attribute, the first validation rule specifying a first condition on the first attribute that is dependent on the second attribute; sending the request to the data processing system, the request causing the data processing system to identify one or more valid values ​​for the first attribute using the first validation rule; receiving from the data processing system the one or more valid values ​​for the first attribute; displaying within the GUI an indication of the one or more valid values ​​for the first attribute; receiving through the GUI an input indicating a selected value of the one or more valid values ​​to assign to the first attribute; and sending to the data processing system an indication of the selected value to assign to the first attribute.

[0023] The above is a non-limiting summary.

[0024] Various aspects and embodiments are described with reference to the following drawings, which should be understood as not necessarily drawn to scale, and elements shown in more than one drawing are designated by the same or similar reference numerals throughout all the drawings in which they appear. [Brief explanation of the drawings]

[0025] [Figure 1A] 1 is a block diagram of a data processing system configured to manage data using data entities and their instances in accordance with some embodiments of the technology described herein. [Figure 1B] 1B illustrates relationships between validation rules, data entities, and data entity instances of the data processing system of FIG. 1A in accordance with some embodiments of the techniques described herein. [Figure 1C] 1B illustrates a graphical user interface (GUI) for assignment of attribute values ​​among data entity instances of the data processing system of FIG. 1A in accordance with some embodiments of the techniques described herein. [Figure 2A] 1 is a block diagram of a data processing system in accordance with some embodiments of the techniques described herein. [Figure 2B] 2B illustrates a GUI for assigning values ​​to attributes in data entity instances in the data processing system of FIG. 2A in accordance with some embodiments of the techniques described herein. [Figure 2C] 2C illustrates the graphical user interface of FIG. 2B after valid values ​​for attributes have been selected, in accordance with some embodiments of the techniques described herein. [Figure 2D] 2B illustrates interactions between components of an assignment validation module of the data processing system of FIG. 2A in accordance with some embodiments of the techniques described herein. [Figure 3A] FIG. 1 is a diagram of validation rules according to some embodiments of the technology described herein. [Figure 3B]FIG. 3B is a diagram of an example of validation rules shown in FIG. 3A, according to some embodiments of the technology described herein. [Figure 3C] 1 is an exemplary GUI for specifying one or more validation rules according to some embodiments of the technology described herein. [Figure 4A] FIG. 2 is a block diagram of an example data entity in accordance with some embodiments of the techniques described herein. [Figure 4B] 4B is a schematic diagram of an example instance of the data entity of FIG. 4A in accordance with some embodiments of the techniques described herein. [Figure 4C] 4B is a validation rule set associated with the data entity of FIG. 4A according to some embodiments of the technology described herein. [Figure 4D] 4C is an example data flow for a process of identifying valid values ​​for attributes in the data entity instance of FIG. 4B according to some embodiments of the techniques described herein. [Figure 5A] 1 is a schematic diagram of an exemplary relationship of a data entity to other data entities, according to some embodiments of the techniques described herein. [Figure 5B] 5B is a schematic diagram of an example instance of the data entity of FIG. 5A in accordance with some embodiments of the techniques described herein. [Figure 5C] 5B illustrates a validation rule set associated with the data entity of FIG. 5A in accordance with some embodiments of the techniques described herein. [Figure 5D] 5C is a data flow diagram of a process for identifying valid values ​​for attributes in the data entity instance of FIG. 5B according to some embodiments of the techniques described herein. [Figure 6A] 1 is a schematic diagram of an exemplary relationship between one data entity and other data entities, according to some embodiments of the techniques described herein. [Figure 6B] 6B is a schematic diagram of an example instance of the data entity of FIG. 6A in accordance with some embodiments of the techniques described herein. [Figure 6C] 6B illustrates a validation rule set associated with the data entity of FIG. 6A in accordance with some embodiments of the techniques described herein. [Figure 6D] 6C is an example data flow for a process of identifying valid values ​​for attributes in the data entity instance of FIG. 6B according to some embodiments of the techniques described herein. [Figure 7] 1 is a block diagram illustrating components of a data processing system in accordance with some embodiments of the technology described herein. [Figure 8] FIG. 2 is a schematic diagram of data entities that may be defined by data processing according to some embodiments of the techniques described herein. [Figure 9] 1 is a flowchart of an example process for performing efficient data allocation, in accordance with some embodiments of the techniques described herein. [Figure 10] 10 is a flowchart of an exemplary process of a client device for assigning values ​​to attributes in a data entity instance, in accordance with some embodiments of the techniques described herein. [Figure 11] 10 is an exemplary GUI for creating a new validation rule according to some embodiments of the technology described herein. [Figure 12A] 10 is an exemplary GUI for defining a new validation rule according to some embodiments of the technology described herein. [Figure 12B] 12B illustrates the breakdown of conditions for attributes in the GUI of FIG. 12A according to some embodiments of the techniques described herein. [Figure 12C] 12B illustrates the breakdown of conditions for other attributes in the GUI of FIG. 12A in accordance with some embodiments of the techniques described herein. [Figure 12D] 12B illustrates details of the validation rules user interface execution operations in the GUI of FIG. 12A according to some embodiments of the technology described herein. [Figure 12E]12B illustrates details of the validation rule import execution operation in the GUI of FIG. 12A in accordance with some embodiments of the technology described herein. [Figure 12F] 12B illustrates a breakdown of the severity of a violation of a validation rule in the GUI of FIG. 12A, according to some embodiments of the technology described herein. [Figure 13] 12A-12F is an exemplary GUI displaying information about the validation rules created in FIGS. 12A-12F, according to some embodiments of the technology described herein. [Figure 14A] 1 is an exemplary GUI for displaying information about validation rules according to some embodiments of the technology described herein. [Figure 14B] 1 is an exemplary GUI for displaying information about a data entity instance, according to some embodiments of the technology described herein. [Figure 14C] 14C is an exemplary GUI displaying valid values ​​identified for attributes in the data entity instance of FIG. 14B according to some embodiments of the techniques described herein. [Figure 14D] 14C is a GUI of FIG. 14C displaying valid and invalid values ​​for attributes in the data entity instance of FIG. 14B according to some embodiments of the techniques described herein. [Figure 14E] 14C is the GUI of FIG. 14B after valid values ​​have been selected for assignment to the business owner attribute, according to some embodiments of the technology described herein. [Figure 14F] 14C is the GUI of FIG. 14B displaying the data entity instance after valid values ​​have been assigned to the business owner attribute in accordance with some embodiments of the technology described herein. [Figure 14G] 14C is the GUI of FIG. 14B after an invalid value has been selected for assignment to the business owner attribute, in accordance with some embodiments of the technology described herein. [Figure 14H]14C is the GUI of FIG. 14B after an invalid value has been submitted for assignment to the business owner attribute, in accordance with some embodiments of the technology described herein. [Figure 15] FIG. 1 is a block diagram of an illustrative computer system that may be used in implementing some embodiments of the techniques described herein. DETAILED DESCRIPTION OF THE INVENTION

[0026] The present inventors have developed techniques for performing efficient data allocation in data processing systems in which data may be dynamically updated by users and / or computer-implemented processes (e.g., processes performed by one or more software applications).

[0027] A data processing system may manage data for an organization, such as a multinational corporation (e.g., a logistics company, a financial institution, a utility company, an automotive company, an e-commerce company, etc.) or other organization. The organization may manage vast amounts of data (e.g., hundreds or thousands of terabytes of data) through the data processing system. Data may be updated by users and / or processes within the data processing system. Data updates may occur when users and / or computer processes change one or more data values ​​(e.g., via one or more application programming interface (API) calls). Data updates may include creating new values, modifying existing values, and / or deleting values. As an example, data updates may include changing the values ​​of variables and / or attributes.

[0028] Data updates can be extensive and frequent, in that many data values ​​may be updated and updates may occur frequently. As an illustrative example, a data processing system may manage data for a multinational bank. Data may be updated many times daily as part of its operations (e.g., account management, lending, borrowing, investing, and / or operations), requiring frequent data updates. As another example, a data processing system may manage data for an e-commerce company. Data may be updated frequently as part of the e-commerce company's operations (e.g., online trading, order fulfillment, and / or other operations).

[0029] Depending on the type of data managed by a data processing system, it may be important to restrict the values ​​that the data can take on. For example, some variables in the data may be restricted to taking on only a particular set of values ​​(e.g., one of a finite set of options, a value within a range of allowed continuum, etc.). Restricting the values ​​that certain variables can take on is important in various applications, such as when such values ​​affect aspects of the operation of the data processing system. For example, variables may include security permissions for accessing data, identification of sources from which data may be accessed, a hierarchy indication within a data structure, and an indication of users authorized to manipulate the data. The values ​​of such variables affect how the data processing system operates. For example, these variables affect who is authorized to view certain information within the data processing system, how data is stored within the data processing system's memory, and who is authorized to modify data within the data processing system.

[0030] One problem that arises in this regard is that, due to the large number of updates made by users and / or processes, there is a high probability that invalid (e.g., unauthorized, improperly formatted, and / or otherwise incorrect) data values ​​will be assigned to the data processing system. For example, as a result of improper assignment of a variable value, a user may assign an invalid owner to an asset (e.g., a software application, a data set, or other asset), which may allow someone to gain improper access to the asset. The improper assignment may lead to unauthorized access to the data. As another example, improper assignment of a variable may cause a user to assign an invalid security level to an asset, which may result in a security anomaly in the data processing system. The improper assignment may result in an incorrect (e.g., insufficiently restrictive, overly restrictive, or otherwise incorrect) security protocol being assigned to the asset.

[0031] Additionally, organizations may have data governance policies or other technical requirements to which data managed by a data processing system must conform. An invalid value in a data processing system can cause non-compliance with a data governance policy. For example, a data governance policy may specify that a particular software application is only permitted to use data from a specific set of data sources. A user or process may assign an invalid value in a data processing system, allowing the software application to access data from a data source that is not included in the set of permitted data sources, thereby violating the data governance policy. Invoking the software application and / or one of its functions may further result in an error as a result of improper data access. As another example, a data governance policy may require that the value of a particular variable conform to a specific format. Assigning a value to a variable that does not conform to the specific format would result in non-compliance with the data governance policy. Furthermore, a software application and / or its function that uses the variable value may experience an error due to the assignment of a variable value that does not conform to the specific format.

[0032] A conventional approach to addressing the above-mentioned problem is to allow data values ​​to be updated and then check the updated data values ​​to identify any incorrect values ​​that have been assigned. Any identified incorrect values ​​can be rejected, corrected, and / or flagged for correction. For example, there may be logic that specifies what values ​​are and are not allowed for a particular variable. After a value is assigned to a variable (e.g., by a user and / or computer process, e.g., via an API call), this logic may be used to determine whether the assigned value is valid. However, this approach is inefficient because it requires the user or process to repeatedly submit multiple data assignments, each of which is checked for validity by the data processing system, before finally settling on a value identified as valid according to the logic. In some cases, there may be tens, hundreds, or even thousands of invalid values ​​among the set of possible selection values ​​from which the user or process must choose. Furthermore, for each data assignment, the data processing system sends all possible values ​​to the client device (e.g., for presentation in a GUI) and / or to the computer process from which a selection is made. Since many of the values ​​may be invalid, the data processing system sends more information than necessary, which results in increased data latency during communication. Therefore, this conventional approach is not a practical way to address the above-mentioned problem, especially in data processing systems where data allocation is frequent.

[0033] One type of data processing system in which the above-described problems arise is a data processing system that manages data using data entities and their instances. The data processing system may organize data in an object-oriented paradigm using data entities. Similar to how object-oriented programming involves classes and their instances, the data processing system may be comprised of definitions of data entities and manage data using instances of the data entities. A data entity may exhibit one or more attributes to which values ​​may be assigned within an instance of the data entity. The data processing system may store data within one or more instances of the data entity. In some embodiments, a data entity instance may store information about the data (“metadata”). The information about the data may be stored in the data entity instance as attribute values. The data entity instances may be stored by the data processing system in any suitable format and / or using any suitable data structure, as aspects of the technology described herein are not limited in this respect.

[0034] As an illustration, a data processing system may define a "Business Term" data entity that includes the attributes "Name," "Definition," "Region," and "Steward." One instance of the Business Term data entity may be used to store data about a set of credit scores for an organization's customers who reside in North America. This instance may store the value of "Credit Score" for the "Name" attribute, a text description of the credit score as the value of the "Definition" attribute, "North America" ​​as the value of the "Region" attribute, and the name of the person responsible for managing the credit scores as the value of the "Steward" attribute.

[0035] A data processing system that manages data using data entities and their instances may coordinate the assignment of data values ​​to data entity attributes using validation rules associated with the data entities. A validation rule may specify one or more conditions for a particular attribute of a data entity. A value assigned to a particular attribute of an instance of that data entity may be valid if it satisfies the conditions specified by the validation rule. A condition for an attribute of a data entity may further depend on one or more other attributes of other data entities. Therefore, the validity of a value assigned to an attribute of an instance of a data entity may depend on the values ​​of other attributes of other data entity instances.

[0036] FIG. 1A is a block diagram of an exemplary data processing system 100 for managing data, in accordance with some embodiments of the techniques described herein. Data processing system 100 manages data, at least in part, through the use of data entities and their instances. Data processing system 100 includes validation rules 102, data entities 104, and data entity instances 106. Data entities 104 may each define one or more attributes for which values ​​are stored by the data entity instances. In the example of FIG. 1A, data entity instances 106 include: (1) instance 106A of data entity 104A; (2) instances 106B and 106C of data entity 104B; (3) instances 106D, 106E, and 106F of data entity 104C; and (4) instances 106G and 106H of data entity 104D. Each of the data entity instances 106A, 106B, 106C, 106D, 106E, 106F, 106G, and 106H may store values ​​for one or more attributes that are specified by the respective data entity from which the data entity instance is created.

[0037] Attributes of a data entity may reference other data entities. As indicated by the arrows between data entities 104 in FIG. 1A , data entity 104A includes an attribute that references data entity 104B and an attribute that references data entity 104C. Furthermore, data entity 104C includes an attribute that references data entity 104D. When an attribute of a first data entity references a second data entity, an instance of the second data entity may be assigned as an attribute value within the first data entity instance. When an instance of the second data entity is assigned as an attribute value within the first data entity instance, the first data entity instance may store a reference to the second data entity instance as an attribute value. For example, the first data entity instance may store a pointer, identifier, URL, memory address, file location, and / or any other suitable type of reference to the second data entity instance as an attribute value.

[0038] Validation rules 102 define the validity of an instance of a data entity. Validation rules 102 include validation rule sets 102A, 102B, 102C, and 102D. Each of validation rule sets 102A, 102B, 102C, and 102D is associated with a respective data entity. In the example of FIG. 1A , validation rule 102A is associated with data entity 104A, validation rule 102B is associated with data entity 104B, validation rule 102C is associated with data entity 104C, and validation rule 102D is associated with data entity 104D. To be valid, an instance of a data entity may need to conform to the validation rules associated with the data entity. Each of validation rules 102A, 102B, 102C, and 102D may have one or more validation rules. For example, data entity 104A may include multiple attributes, and each attribute may be associated with a respective one of multiple validation rule portions of validation rules 102A. It should therefore be understood that each data entity may be associated with multiple validation rules.

[0039] To illustrate how validation rules define the validity of instances of data entities, Figure 1B shows the relationships between validation rules 102A, data entities 104A, 104B, and 104C, and data entity instances 106A and 106B, in accordance with some embodiments of the technology described herein. In this example, a "Price" instance 106A of a "Data Element" data entity 104A references a "Purchase" instance 106B of a "Dataset" data entity 104B. The "Price" instance 106A stores information about purchase price data stored in a purchase dataset (a dataset containing information about purchases made by customers). Among the information stored in the "Price" instance 106A is the value of the "BusinessTerm" attribute 104A-4, which is a reference to a particular instance of a Business Term data entity 104C that describes the purchase price.

[0040] 1B, Data Element data entity 104A includes the following attributes: Name 104A-1, Dataset 104A-2, ColumnOrder 104A-3, and BusinessTerm 104A-4. Dataset attribute 104A-2 references Dataset data entity 104B, and BusinessTerm attribute 104A-4 references Business Term data entity 104C. Dataset data entity 104B includes the following attributes: Name 104B-1, Division Name 104B-2, and Type 104B-3. Business Term data entity 104C includes the following attributes: Name 104C-1, Description 104C-2, MinimumOrder 104C-3, and DivisionName 104C-4. Validation rules 102A associated with Data Element data entity 104A include rule 102A-1, which requires that the following conditions be met for an instance of Data Element data entity 104A to be valid: (1) in the referenced instance of Business Term data entity 104C, the value of ColumnOrder attribute 104A-3 must be greater than the value of MinimumOrder attribute 104C-3, and (2) the value of DivisionName attribute 104B-2 of the referenced instance of Dataset data entity 104B must match the value of DivisionName attribute 104C-4 in the referenced instance of Business Term data entity 104C.

[0041] A data entity instance may store values ​​assigned to its attributes (e.g., as attribute-value pairs). In the example of FIG. 1B, the PRice instance 106A of the Data Element data entity 104A stores (1) the value “Price” assigned to its Name attribute 104A-1, (2) a reference to an instance 106B of the Dataset data entity 104B called “Purchase” assigned to its Dataset attribute 104A-2, and (3) a value of “5” assigned to its ColumnOrder attribute 104A-3. In the example of FIG. 1B, the Price instance 106A requires the value 110 to be assigned to its BusinessTerm attribute 104A-4. Attribute values ​​may be assigned via user input and / or a computer process (e.g., a function call).

[0042] 1C illustrates an exemplary graphical user interface 107 for assigning a value 110 of a Price instance 106A of a Data Element data entity 104A, in accordance with some embodiments of the techniques described herein. The graphical user interface 107 illustrates a view 107A of the Price instance 106A displaying the attribute-value pairs of the Price instance 106A. The graphical user interface 107 provides a list 107A-1 of values ​​that can be assigned to the BusinessTerm attribute 104A-4 of the data entity instance 106A. In the example of FIG. 1C, these values ​​include references to the following instances of the BusinessTerm data entity 104C: a Credit Score instance 106D, a Balance instance 106E, and a Purchase Price instance 106F. However, list of values ​​107A-1 includes both valid values ​​(i.e., those that conform to rule 102A-1) and invalid values ​​(i.e., those that do not satisfy rule 102A-1) for BusinessTerm attribute 104A-4. User 108 does not know which values ​​from list 107A-1 satisfy rule 102A-1 in validation rule 102A associated with Data Element data entity 104A because the user does not know the attribute values ​​in all instances in the list or the attribute values ​​of Purchase instance 106B referenced by Price instance 106A. Knowledge of these attribute values ​​is necessary to identify whether each of the values ​​in list 107A-1 is valid. Furthermore, list 107A-1 may contain hundreds or thousands of values ​​from which user 108 must identify valid choices. Therefore, it is not practical for user 108 to comb through each of the instances in list 107A-1 to identify which of the instances are valid.

[0043] Additionally, for a given instance, the user may need to access a hierarchy of multiple instances that affect the validity of that instance based on rule 102A-1. Traversing each of the instances further requires the user's device to perform multiple operations to access, access, and display the attribute values ​​of each instance that affect the validity of each instance. Even if user 108 accessed each instance in list 107A-1, determining the validity of an instance would be difficult, if not impossible, for user 108 given the complexity of the validation rules that govern the validity of the instance.

[0044] To address the infeasibility of the aforementioned conventional approaches for performing valid data assignments, the inventors have developed a new technique for restricting data assignments to only valid values ​​by (1) identifying a set of valid values ​​that can be assigned to an attribute, and (2) providing the set of valid values ​​to a user and / or software, which then uses this list to identify the value to which the attribute should be set. Thus, when a data assignment is requested (e.g., by a user or process), the technique developed by the inventors and described herein identifies the conditions that a variable value must satisfy to be valid (e.g., as defined by appropriate validation rules) and identifies values ​​that are valid for assignment based on the conditions. In some embodiments, the technique identifies values ​​that are valid to assign to attributes of a data entity instance. Thus, the new technique makes performing valid data assignments more efficient, which mitigates (e.g., reduces or eliminates) the risk of invalid values ​​being assigned to variables in a data processing system.

[0045] The inventors recognize that identifying valid values ​​that can be assigned to an attribute is not straightforward because, in many cases, a variable value must satisfy complex requirements to be considered valid. For example, the requirements (e.g., implemented by validation rules or any other suitable type of logic used to define validity) may depend on other variables stored by the data processing system. As one example, to be valid, a variable value may need to be within a range defined by one or more other variables stored in the data processing system. As another example, to be valid, a variable value may need to match the values ​​of other variables. As yet another example, a variable value may be a reference to one or more other objects, and the condition may depend on data values ​​within these objects.

[0046] As described herein, with respect to a data processing system that manages data using data entities and their instances, a variable may be a data entity instance attribute to which a value is to be assigned. One or more validation rules associated with that attribute define a set of valid values, any of which may be assigned to that attribute. However, a rule may not simply provide a list of valid values. Instead, it may do so through a set of conditions that may include other information, such as the values ​​of one or more other variables managed by the system. As such, a validation rule may depend on one or more attribute values ​​of one or more other data entity instances. Therefore, validation rules are not only complex (because they depend on the values ​​of multiple variables), but also depend on values ​​that may themselves be changing. As a result, accurately identifying one or more valid values ​​for a particular data entity instance attribute may need to take into account the current values ​​of many other variables (e.g., the values ​​of attributes referenced by validation rules associated with a particular data entity instance attribute). Because such values ​​may also change, the set of valid values ​​for a particular data entity instance attribute may likewise change.

[0047] The technique developed by the inventors for identifying valid values ​​to assign to an attribute takes into account dependencies on other variables by accessing the current values ​​of other variables and using them to identify which values ​​are valid to assign to the variable. For example, the technique may access attribute values ​​from other data entity instances that determine the validity of an attribute in a data entity instance and use these attribute values ​​to identify valid values ​​that can be assigned to the attribute.

[0048] Thus, in some embodiments, valid values ​​are identified by (1) programmatically generating a query using validation rules that govern the validity of a variable, and (2) executing the query to obtain valid values ​​that can be assigned to the variable. For example, this technique may include programmatically generating a query using rules that govern the validity of attribute values, and executing the query (e.g., against data managed by a data processing system) to obtain values ​​that would be advantageous to assign as attribute values.

[0049] Thus, in some embodiments, a technique developed by the inventors and described herein identifies valid values ​​for an attribute in an instance of a data entity using validation rules associated with the data entity. The technique may use the validation rules to identify valid values ​​for the attribute by (1) generating a query for valid values ​​using the condition portion of the validation rule and (2) executing the generated query to obtain valid values. The technique may limit the assignment of values ​​for the attribute to the identified valid values. For example, the technique may present only the valid values ​​to a user (e.g., in a graphical user interface (GUI)) or to a software application for selection of a value to assign to the attribute. In another example, the technique may reject a value submitted for assignment to the attribute that is not one of the valid values. The technique may assign a value for the attribute in an instance of a data entity based on input (e.g., from a user or a process) indicating a selection of one or more of the identified valid values. The technique, therefore, reduces the assignment of invalid attribute values ​​in a data processing system.

[0050] Some embodiments provide for a system for performing effective data assignment in a data processing system configured to process data updated by a user (e.g., through a GUI) and / or by a process (e.g., a software application). The data processing system stores data using data entities and their instances. The data processing system receives a request to assign a value to an attribute (e.g., Owner attribute 400A-3 of FIG. 4B) of a first data entity instance (e.g., North America Credit Scores instance 420 of FIG. 4B) of a first data entity (e.g., Biz Term data entity 400A of FIG. 4A). A first data entity (e.g., Biz Term data entity 400A) includes multiple attributes (e.g., attributes 400A-1, 400A-2, 400A-3, and 400A-4 in FIG. 4A ), including a first attribute (e.g., Owner attribute 400A-3) and a second attribute (e.g., Institution attribute 400A-4 in FIG. 4A ). The first data entity is associated with one or more validation rules (e.g., validation rule 404 in FIG. 4C ) that must be met for attribute values ​​in an instance of the first data entity to be valid. The validation rules include a first validation rule (e.g., rule 404A in FIG. 4C ) associated with the first attribute (e.g., Owner attribute 400A-3) that includes a first condition on the first attribute that depends on the second attribute (e.g., Institution attribute 400A-4). The system may be configured to identify one or more valid values ​​for a first attribute using a first validation rule (e.g., rule 404A) by (1) generating a query (e.g., query 408 of FIG. 4D) for one or more valid values ​​using a first condition on the first attribute, and (2) executing the generated query (e.g., against a database that stores the data entity instances) to obtain valid values ​​for the first attribute (e.g., query result 410 of FIG. 4D).The system may be configured to assign a value to a first attribute of a first data entity instance according to input (e.g., received through a GUI) indicating a selection of at least one valid value for the first attribute, and to assign the selected at least one valid value to the first attribute.

[0051] In some embodiments, the system may be configured to generate a query (e.g., query 408 of FIG. 4D ) for valid values ​​for a first attribute (e.g., Owner attribute 400A-3 of FIG. 4B ) using a first condition on the first attribute by (1) identifying a current value of a second attribute (e.g., Institution attribute 400A-4) in a first data entity instance (e.g., North America Credit Scores instance 420), and (2) generating the query (e.g., query 408 of FIG. 4D ) using the current value of the second attribute of the first data entity instance.

[0052] In some embodiments, the current value of the second attribute of the first data entity instance is assigned to an instance (e.g., MegaBank instance 422 of FIG. 4B) of a second data entity (e.g., Institution data entity 400C of FIG. 4A). The system may be configured to generate a query based on the current value of the second attribute of the first data entity instance by (1) accessing the first attribute value (e.g., the value of Region attribute 400C-2) from the instance of the second data entity (e.g., MegaBank instance 422), and (2) generating a query (e.g., query 408 of FIG. 4D) based on the first attribute value from the instance of the second data entity.

[0053] In some embodiments, the at least one validation rule includes multiple validation rules (e.g., rules 404A, 404B in FIG. 4C ) associated with respective attributes (e.g., Owner attribute 400A-3 and Institution attribute 400A-4) of the first data entity (e.g., Biz Term data entity 400A). The system may be configured to identify a first validation rule among the multiple validation rules based on an association between the first validation rule (e.g., rule 404A) and the first attribute (e.g., Owner attribute 400A-3).

[0054] In some embodiments, the first validation rule includes a second condition for the first attribute. The system may be configured to generate a query for one or more valid values ​​(e.g., query 408 of FIG. 4D ) by (1) generating a first portion of the query (e.g., first set of SQL statements) based on the first condition for the first attribute, and (2) generating a second portion of the query (e.g., second set of SQL statements) based on the second condition for the first attribute. In some embodiments, the system may be configured to generate a query for valid values ​​using the first condition by (1) converting the first condition for the first attribute into a query search term, and (2) incorporating the query search term into the query.

[0055] In some embodiments, the system may be configured to assign an instance of a second data entity (e.g., Business Owner data entity 400B of FIG. 4A) as a value to a first attribute (e.g., Owner attribute 400A-3) of a first data entity instance. In some embodiments, the system may be configured to generate a query for valid values ​​(e.g., query 408 of FIG. 4D) by generating a query on the instance of the second data entity. In some embodiments, the system may be configured to execute the generated query on a subset of data consisting of the instance of the second data entity.

[0056] In some embodiments, the first attribute indicates an owner, an access security level, a data source, or a data format associated with the first data entity instance.

[0057] In some embodiments, the first data entity instance stores information about a software application or dataset as attribute values ​​within the first data entity instance. For example, the first attribute may indicate a data source or data format that will be used by the software application when attempting to invoke a function of the software application. The valid value may be suitable for invoking the function of the software application. As another example, the first attribute may indicate an access security level associated with the dataset that will be used when attempting to provide access to the dataset. The valid value may be one or more access security levels that provide access to the dataset.

[0058] In some embodiments, the system may be configured to send to a client device an indication of valid values ​​for the first attribute for display in a graphical user interface (GUI). The system may be configured to receive from the client device, through the GUI, an input indicating a selection of at least one of the one or more valid values ​​for the first attribute. In some embodiments, the system may be configured to identify valid values ​​for the first attribute by identifying one or more instances of the second data entity as one or more valid values ​​for the first attribute.

[0059] In some embodiments, the first validation rule includes a second condition for the first attribute. The system may be configured to use the first validation rule to identify valid values ​​by (1) generating a first query search term using the first condition for the first attribute and (2) generating a second query search term using the second condition for the first attribute. In some embodiments, the system may be configured to use the first validation rule to identify one or more invalid values ​​for the first attribute and prevent transmission (e.g., to a client device) of the invalid values.

[0060] In some embodiments, if the first data entity instance does not have a value assigned to the second attribute, the system may be configured to identify valid values ​​for the first attribute by (1) identifying the unassigned values ​​entered for the second attribute and (2) generating a query for one or more valid values ​​using the unassigned values ​​for the second attribute.

[0061] In some embodiments, a client device may be configured to receive input through a GUI indicating a request to assign a value to a first attribute of a first data entity instance of a first data entity. The client device may be configured to forward the request to a data processing system, which uses a first validation rule to identify one or more valid values ​​for the first attribute. The client device may be configured to receive the valid values ​​for the first attribute from the system. The client device may be configured to display an indication of the one or more valid values ​​for the first attribute in the GUI. The client device may be configured to receive input through the GUI indicating a selected value of the valid values ​​to assign to the first attribute. The client device may be configured to send an indication of the selected value to assign to the first attribute to the data processing system.

[0062] The techniques described herein may be implemented in any of a variety of ways, as the techniques are not limited to any particular implementation method. Example implementation details are provided herein for illustrative purposes only. Furthermore, the techniques disclosed herein may be used individually or in any suitable combination, as the techniques described herein are not limited to the use of any particular technique or combination of techniques.

[0063] 2A is a block diagram of a data processing system 200 in accordance with some embodiments of the techniques described herein. Data processing system 200 includes validation rules 202, data entities 204, and data entity instances 206. Data processing system 200 includes an interface 207 by which a client device of a user 208 can interact with data processing system 200. Data processing system 200 further includes an assignment validation module 210, which provides valid attribute values ​​for assignments via interface 207 (e.g., for presentation to user 208 in a GUI).

[0064] Data processing system 200 may be configured to manage data using data entities 204. Each of data entities 204 may define one or more attributes for which values ​​may be assigned to each instance of data. For example, data entities 204 may include an organization data entity that defines attributes. In this example, an instance of the organization data entity may store information about a respective organization (e.g., a corporation, company, enterprise, etc.) as values ​​assigned to its attributes. In another example, data entities 204 may include a business term data entity that defines attributes. In this example, an instance of the business term data entity may store information about a type of business data (e.g., a customer credit score, an account balance, a salary, etc.). Data processing system 200 may be configured to create any number of instances of data entities.

[0065] Data processing system 200 may be configured to store data using data entity instances 206. Each data entity instance 206 may be created from a respective data entity that defines the data entity instance. Each of the attributes of a data entity instance may be assigned one or more values ​​(e.g., by a user and / or a process). Data processing system 200 may be configured to receive a request (e.g., from a client device and / or process) to assign a value to an attribute. Data processing system 200 may be configured to assign a value to an attribute (e.g., by performing process 1000 described herein with respect to FIG. 10 ).

[0066] Data processing system 200 may be configured to assign values ​​to attributes of a data entity instance. In some embodiments, data processing system 200 may be configured to assign values ​​to attributes based on user input received through a GUI provided by data processing system 200 on a client device. For example, a user may provide input indicating a selection of a value to assign to an attribute in a data entity instance. In some embodiments, data processing system 200 may be configured to assign values ​​to attributes based on input from a process. For example, data processing system 200 may receive input from a software application indicating a value to assign to an attribute in a data entity instance. In some embodiments, data processing system 200 may be configured to assign values ​​to attributes as part of execution of an internal process of data processing system 200. For example, data processing system 200 may automatically assign a default value to an attribute of a data entity instance.

[0067] The data processing system 200 may be configured to use validation rules 202 to enforce valid data assignments within a data entity instance 206. Each validation rule 202 includes one or more conditions for an attribute of the data entity associated with the validation rule. For an instance of a data entity to be valid, a value assigned to that attribute of the instance must satisfy the conditions of the validation rule. The data processing system 200 may include any number of validation rules 202. The data processing system 200 may be configured to use the validation rules 202 to ensure valid values ​​are assigned to attributes of a data entity instance.

[0068] The data processing system 200 may be configured to associate validation rules with data entities. The data processing system 200 may be configured to associate validation rules with data entities by storing a reference to the associated data entity in the validation rule. For example, the data processing system 200 may store an identifier (e.g., a name, ID number, or other identifier) ​​of the associated data entity in the validation rule. In another example, the data processing system 200 may store a pointer to the associated data entity in the validation rule. In some embodiments, the data processing system 200 may be configured to store an indication of the attribute of the associated data entity with which the validation rule is associated in the validation rule. The value of the attribute in a data entity instance may need to satisfy the validation rule associated with the attribute in order for the value to be valid. In some embodiments, the data processing system 200 may be configured to associate validation rules with data entities by storing a reference to the validation rule in the data entity. For example, data processing system 200 may store an identifier (e.g., a name, an ID number, or other identifier) ​​of the validation rule in the data entity. In another example, data processing system 200 may store a pointer to the validation rule in the data entity.

[0069] Data processing system 200 may be configured to store validation rules 202, data entities 204, and data entity instances 206 in one or more data stores. The data stores may be stored in a data persistence layer of data processing system 200, as described herein with respect to FIG. 7. The data stores may consist of storage hardware (e.g., hard disk drives, solid state drives, disks, and / or other types of storage hardware). The data stores may be co-located or geographically distributed (e.g., in a distributed database system). In some embodiments, the data stores may be cloud-based data storage. For example, the data stores may be stored in one or more data centers accessible over the internet.

[0070] Interface 207 allows user 208 to interact with data processing system 200. Interface 207 may include one or more graphical user interfaces (GUIs) 207A.

[0071] In some embodiments, GUI 207A may include a GUI for creating and editing validation rules. The GUI may be configured to allow creation of a new validation rule and specification of information about the validation rule (e.g., name, associated data entities, associated attributes of the associated data entities, conditions, and / or other information). For example, the GUI may include one or more fields into which information about the validation rule can be entered.

[0072] In some embodiments, GUI 207A may include a GUI that enables assignment of attribute values ​​within a data entity instance. The GUI may be configured to display information about the data entity instance, such as the name, current attribute values, the data entity that defines the data entity instance, and / or other information about the data entity instance. The GUI may be configured to allow a user to assign values ​​to attributes within the data entity instance. In some embodiments, the GUI may be configured to allow a user to assign values ​​to an attribute by (1) submitting one or more valid values ​​for the attribute and (2) receiving a selection of a valid value to assign to the attribute. In some embodiments, the GUI may be configured to allow a user to view invalid values ​​for an attribute in response to selecting an option (e.g., a checkbox indicating that invalid values ​​should be displayed). In some embodiments, the GUI may be configured to provide a graphical indication of the value selected to assign to the attribute. For example, when the selected value is determined to be invalid, the GUI may display a graphical element (e.g., an icon) indicating that the selected value is invalid. In another example, the GUI may display a graphical element indicating that a value was not assigned to the attribute because it is invalid. In other examples, the GUI may be configured to display a graphical element that indicates that the value selected for assignment is valid and / or that the value was successfully assigned to the attribute. In some embodiments, the GUI may be configured to display an indication of one or more validation rules applicable to the data entity instance. For example, the GUI may provide a link to the validation rule that the user can select to view information about the validation rule.

[0073] In some embodiments, GUI 207A may include a GUI that allows a user to view information about a data entity. The GUI may be configured to display information about the data entity (e.g., name, description, attributes, associated validation rules, and / or other information). The GUI may be configured to allow a user to edit information about the data entity. For example, the GUI may allow a user to set attributes of the data entity. The GUI may be configured to allow a user to navigate to one or more validations associated with the data entity. For example, the GUI may allow a user to follow links to validation rules associated with the data entity.

[0074] In some embodiments, interface 207 may include one or more interfaces through which a process (e.g., a software application) can interact with data processing system 200. For example, an interface may include one or more application program interfaces (APIs) 207B through which a software application can interact with data processing system 200. APIs 207B may enable a software application to create and / or edit validation rules, data entities, and / or data entity instances. APIs may also enable a software application to assign attribute values ​​within a data entity instance. In some embodiments, interface 207 may enable processes external to data processing system 200 to interact with data processing system 200. In some embodiments, interface 207 may enable internal processes to perform operations within data processing system 200.

[0075] Each of the users 208 shown in FIG. 2A may communicate with data processing system 200 using a client device. The client device may be any suitable computing device. For example, the client device may be a laptop, a desktop, a smartphone, a tablet, or any other suitable computing device. In some embodiments, the client device may communicate with data processing system 200 over a communications network. For example, the communications network may be the Internet.

[0076] In some embodiments, assignment validation module 210 may be configured to identify one or more valid values ​​for an attribute and present the valid values ​​to a user or process for selection. Assignment validation module 210 may then assign a value to the attribute based on a value selection from the received valid values. In some embodiments, assignment validation module 210 may be configured to filter out invalid values ​​from the provided value selections to prevent invalid values ​​from being selected for assignment to the attribute. In some embodiments, assignment validation module 210 may be configured to provide an indication of whether a value is valid or invalid for the attribute. For example, a GUI may be configured to display an indication of whether each value is valid or invalid in a list of values ​​for the attribute.

[0077] 2B illustrates a GUI 207A for assigning values ​​to attributes of a data entity instance 206A in the data processing system of FIG. 2A in accordance with some embodiments of the techniques described herein. Data entity instance 206A is an instance of data entity 204A having attributes 204A-1 and 204A-2. Data entity instance 206A is configured to store attribute value 206A-1 for attribute 204A-1 and attribute value 206A-2 for attribute 204A-2. The validity of attribute values ​​206A-1 and 206A-2 may be defined by validation rules 202A. Validation rules 202A include rules 202A-1 and 202A-2.

[0078] As shown in the exemplary embodiment of Figure 2B, GUI 207A includes a view 207A-1 of data entity instance 206A, which shows various attribute values ​​of data entity instance 206A, thereby allowing values ​​to be assigned to attributes. As shown in Figure 2B, assignment validation module 210 presents a list 207A-2 of valid values ​​to user 208A in GUI 207A.

[0079] In some embodiments, user 208A may provide input through GUI 207A indicating a selection of one of the valid values ​​to assign to attribute 204A-1 of data entity instance 206A. In this manner, assignment validation module 210 eliminates the possibility that user 208A may select an invalid value to assign to attribute 204A-1.

[0080] 2B, the list of values ​​207A-2 presented to the user in GUI 207A includes only valid values, but in some embodiments, list 207A-2 may include both valid and invalid values, along with an indication of whether each value is valid or invalid. Thus, the user may know which values ​​are valid and invalid for attribute 204A-1. This makes it easier for the user to select a valid value to assign to attribute 204A-1 and reduces the risk of assigning an invalid value.

[0081] 2C illustrates GUI 207A of FIG. 2B after a valid value for attribute 204A-1 has been selected, in accordance with some embodiments of the techniques described herein. As shown in the example of FIG. 2C, GUI 207A may provide a graphical indication that the assigned value is valid.

[0082] 2D is a diagram illustrating interactions between components 210A, 210B, 210C, and 210D of assignment validation module 210 of FIG. 2A in accordance with some embodiments of the techniques described herein. Assignment validation module 210 uses a set of validation rules 202A associated with a data entity to identify valid attribute values ​​212 for attributes of an instance of the data entity. In some embodiments, the flow of data between components of assignment validation module 210 shown in FIG. 2D may occur when data processing system 200 receives a request to assign values ​​to attributes of an instance of a data entity. In the example of FIG. 2D, the flow of data between components may occur in identifying valid values ​​212 for attribute 204A-1.

[0083] In some embodiments, rule selection component 210A may be configured to select one or more validation rules from a group of validation rules 202A. The validation rules 202A may be associated with a data entity 204A, as described herein with respect to FIG. 2B. Rule selection component 210A may be configured to select one or more of the group of validation rules 202A associated with an attribute of the data entity to which a value is assigned in an instance of the data entity. Rule selection component 210A may be configured to select a validation rule from the group of validation rules 202A associated with the attribute to which a value is to be assigned by (1) accessing the group of validation rules 202A associated with the data entity, (2) identifying a rule associated with the attribute to which a value is to be assigned, and (3) selecting the identified rule. In some embodiments, each of the group of validation rules 202A may indicate the attribute with which the validation rule is associated. The rule selection component 210 can be configured to use the attributes indicated by the set of validation rules 202A to identify validation rules associated with attributes to which data will be assigned in an instance of a data entity.

[0084] In some embodiments, rule translation component 210B can be configured to translate selected validation rules for use in generating one or more queries. In some embodiments, rule translation component 210B can be configured to translate the selected rules by (1) identifying each condition on an attribute among the selected validation rules and (2) translating each condition into a respective search condition. For example, rule translation component 210B can translate each rule into a logical expression that can be used as a search condition in a query.

[0085] In some embodiments, a condition on an attribute to which a value is assigned may depend on other attributes of the data entity. In such embodiments, rule conversion component 210B may be configured to convert the rule by (1) identifying values ​​for other attributes of the instance of the data entity and (2) using the identified values ​​to generate a converted rule. Rule conversion component 210B may be configured to identify current attribute values ​​of the instance on which a condition depends and convert the condition into a search condition using the current values. For example, rule conversion component 210B may replace an attribute identifier in a condition expression with the value of the attribute in the instance of the data entity. Examples of such conversions are described herein with respect to Figures 4D, 5D, and 6D.

[0086] In some embodiments, the attribute requires that instances of other data entities be assigned as values. In such embodiments, rule transformation component 210B may be configured to transform the conditions of a selected rule so that the transformed rule can be used to generate queries that run only on instances of other data entities (e.g., to reduce the amount of data that needs to be queried). Rule transformation component 210B may be configured to modify the data entity path specified in the rule by removing specifics of the data entity whose instances are queried. For example, in a condition for an instance of data entity "B" to be valid for assignment to an attribute, the rule may use a data entity path of "BCp" in the condition specification. Rule transformation component 210B may remove specifics of data entity "B" from the data entity path to obtain a data entity path to "Cp" in the transformed rule, because queries generated from the transformed rule will run only on instances of data entity "B." Because the query will run only on instances of data entity "B," the query does not require specifics of data entity "B" in the data entity path. Examples of such transformations are described herein with respect to Figures 4B, 5D, and 6D.

[0087] In some embodiments, a rule may specify a condition under which an instance of a data entity is valid to assign to an attribute, without specifying a specific attribute of the data entity. For example, a rule may specify a path "B" in specifying a condition under which an instance of data entity "B" is valid to assign to an attribute. In such an embodiment, rule translation component 210B may be configured to replace the specified data entity with a specific attribute of the data entity. In some embodiments, the specific attribute may be a default attribute selected when no attribute is specified in the condition. For example, rule translation component 210B may replace a simple path "B" with the ID attribute of the data entity (e.g., "B_ID").

[0088] The query generation component 210C may be configured to generate a query using the transformed rules. As described herein with respect to the rule transformation component 210B, a transformed rule may include one or more search conditions, which may be combined into one or more queries. In some embodiments, the query execution component 210D may be configured to combine all of the transformed rules into a single query. For example, the query execution component 210D may combine multiple search conditions by applying an AND operation to the search conditions. In some embodiments, the query execution component 210D may generate multiple queries. For example, the query execution component 210D may generate a query for each of the multiple transformed rules. Exemplary queries generated by the query generation component 210C are described herein with respect to FIGS. 4B, 5D, and 6D.

[0089] The query execution component 210D may be configured to execute one or more queries generated by the query generation component 210C. For example, the queries may be SQL queries. The query execution component 210D may be configured to execute the SQL queries on a data store (e.g., storing data entity instances 206) of the data processing system 200 to obtain query results. In some embodiments, the query execution component 210D may be configured to execute queries on a subset of the data entity instances 206 of the data processing system 200. For example, a query may be configured (e.g., by the query generation component 210C) to execute on a particular data entity instance (e.g., assigned as a value to an assigned attribute). In other examples, a query may be configured to execute on all of the data entity instances 206.

[0090] The assignment validation module 210 may be configured to provide the query results as valid attribute values ​​212. In some embodiments, the assignment validation module 210 may be configured to present the valid attribute values ​​212 to a user through a GUI. For example, the assignment validation module 210 may present the valid attribute values ​​212 in an attribute value assignment menu of the GUI from which a user can select one or more of the valid attribute values ​​212 to assign to the attribute. In some embodiments, the assignment validation module 210 may be configured to send the valid attribute values ​​212 to a process. For example, the assignment validation module 210 can send the valid attribute values ​​212 to a software application (e.g., through an API), which can use the valid attribute values ​​to programmatically assign valid values ​​to attributes.

[0091] FIG. 3A is a diagram of a validation rule 300 according to some embodiments of the technology described herein. As shown in FIG. 3A, the validation rule 300 includes various information. The validation rule 300 includes a name 300A that identifies the validation rule 300. For example, the name 300A can be an alphanumeric identifier that identifies the rule. The validation rule 300 includes an indication 300B of the data entity with which the validation rule 300 is associated. For example, the associated data entity indication 300B can be the name of the data entity or other identifier of the data entity. The validation rule 300 also includes an indication 300C of the attribute to which the rule 300 applies. For example, the attribute indication 300C can be the name of the attribute within the data entity indicated by 300B. The validation rule 300 includes a description 300D of the validation rule 300. For example, the description 300D can be a textual description. Validation rule 300 includes severity 300E, which specifies the type of alert that will be displayed to the user (e.g., in a GUI) when an assigned attribute value violates rule 300. Validation rule 300 includes import execution 300F, which specifies the type of action to take when an attribute value violates rule 300. For example, import execution 300F may block the assignment of the attribute value. Validation rule 300 includes user interface execution 300G, which specifies the user interface action that will enforce rule 300. For example, user interface execution 300G may indicate that rule 300 will be executed upon submission of an attribute value for assignment.

[0092] 3A, a validation rule 300 includes a condition 300H for the attribute with which the validation rule 300 is associated. The condition may be expressed by one or more logical expressions. The validation rule 300 includes a validation trigger 300I that specifies the condition necessary for the validation rule 300 to be used for validation. The condition may be expressed by one or more logical expressions.

[0093] 3B is a diagram of an example validation rule 310 shown in FIG. 3A, in accordance with some embodiments of the technology described herein. As shown in FIG. 3B, the name 310A of the validation rule 310 is "Biz Term Owner." The related data entity 310B is listed as "Biz Term," and the related attribute 310C is listed as "Owner." The validation rule 310 has a description 310D that reads, "This rule validates the Owner attribute." The validation rule 310 indicates a severity 310E of "Error," indicating that the data processing system 200 will reject the assignment of a value to the Owner attribute in an instance of a Biz Term data security if it violates the validation rule 310.

[0094] Validation rules 310 indicate an "On Submit" import execution 310F, which may indicate that data processing system 200 checks the validity of values ​​when data is imported into data processing system 200. Validation rules 310 further indicate an "On Submit" user interface execution 310G, which indicates that data processing system 200 checks the validity of a value selected for an attribute when a user submits an updated data entity instance (e.g., for assignment of the selected value to an attribute of the data entity instance).

[0095] Validation rules 310 include the following conditions 310H for the Owner attribute: (1) Owner.Region must equal "North America", (2) Owner.Name must start with the letter "A", and (3) Owner.group must be specified. An AND operation is applied to the conditions, indicating that all of them must be met for a value of the Owner attribute to be valid in an instance of a Biz Term data entity. In the example of FIG. 3B, the value assigned to the Owner attribute must be an instance of another data entity. The first condition indicates that the Region attribute of the assigned instance must equal "North America". The second condition indicates that the Name attribute of the assigned instance must start with the letter "A". The third condition indicates that the Group attribute of the assigned instance must have the value specified in the instance.

[0096] Condition 310H may be used by data processing system 200 to identify valid values ​​to assign to the Owner attribute and / or to check the validity of values ​​previously assigned to the Owner attribute. Validation rule 310 includes validation trigger 310I that indicates that validation should only be performed if the name of the instance of the Biz Term data entity being validated has the specified Name attribute value.

[0097] 3C illustrates an exemplary rule definition GUI 320 for defining a validation rule 330, according to some embodiments of the technology described herein. As shown in FIG. 3C, the rule definition GUI 320 includes a general information section 330A, a section 330B that specifies conditions for attributes, a section 330C that indicates one or more conditions for which the rule 330 should be executed, and a section 330D that specifies one or more conditions that the validation rule 330 should be used to validate.

[0098] As shown in FIG. 3C, general information section 330A includes the name of the rule, an indication of the data entity with which the rule is associated, a textual description of the rule, and an indication of the action to be taken if the selected attribute value violates the rule.

[0099] In some embodiments, the name of a rule may identify the validation rule 330 among other validation rules. In some embodiments, a validation rule 330 may include an identifier in addition to or instead of the rule's name. For example, a validation rule 330 may include an alphanumeric identifier.

[0100] 3C, in some embodiments, an indication of the data entity with which the rule is associated is stored in validation rule 330. This indication can be the name of the data entity with which validation rule 330 is associated. For example, validation rule 330 can store a string that consists of the name of the data entity. In some embodiments, validation rule 330 can include a reference (e.g., a pointer, URL, or other reference) to the data entity with which the rule is associated.

[0101] In some embodiments, the textual description of a validation rule 330 may be a string that includes a description of the validation rule 330. For example, the textual description of a rule 330 may provide a general description of the conditions for the attributes specified in the validation rule 330.

[0102] In some embodiments, actions that can be taken when a selected attribute value violates validation rule 330 include providing a visual indication to a user or process that the selected attribute value is invalid, preventing assignment of the invalid value, blocking a user interface action (e.g., submit for assignment), and / or other actions. In some embodiments, the action to be taken when a selected value for assignment is invalid may be indicated by a severity level. For example, a first severity level (e.g., "warning") may cause data processing system 100 to present an indication (e.g., via a GUI) that the selected value is invalid, and a second severity level (e.g., "error") may prevent data processing system 200 from assigning an invalid value to the attribute.

[0103] In some embodiments, the information in section 330B indicating the action for which validation rule 330 is performed may include an indication of the user interface action for which validation rule 330 is performed. For example, the user interface action may be selecting a save option, selecting an option to submit a value for assignment, proceeding with a workflow, and / or other user interface action. In some embodiments, the information 330B indicating the action for which validation rule 330 is performed may indicate an import action. For example, the import action may be submitting a value for assignment to an attribute. In other examples, information 330B may indicate an action to reject assignments of attribute values ​​that do not satisfy validation rule 330, while allowing other assignments (e.g., that are valid values).

[0104] In some embodiments, the condition specification 330B for an attribute may include one or more expressions of the condition. In some embodiments, each of the expressions may be a logical expression that indicates the respective condition for the attribute. In some embodiments, each of the expressions may be in a particular software coding language (e.g., C++, Python, or other coding language). In some embodiments, each of the expressions may be expressed through a GUI that allows for the definition of a logical expression that expresses the condition for the attribute. Data processing system 200 may be configured to convert input received through the GUI into instructions in the coding language. Exemplary conditions for attributes and their expressions are described herein.

[0105] The specification 330D of the conditions required for validation using the validation rules 330 may include one or more expressions of the conditions. In some embodiments, each of the expressions may be a logical expression indicating a respective condition required to validate a data entity instance using the validation rules 330. In some embodiments, each of the expressions may be specifically written in a software coding language (e.g., C++, Python, or other coding language). In some embodiments, each of the expressions may be expressed through a GUI that allows for the definition of logical expressions that can be used to express the conditions. The data processing system 200 may be configured to convert input received through the GUI into instructions in the coding language. Exemplary conditions that trigger validation are described herein.

[0106] Data processing system 200 may be configured to store validation rules 330 in any suitable manner. For example, data processing system 200 may store validation rules 330 as information in an instance of a validation rules data entity. In another example, data processing system 200 may store validation rules 330 as a file (e.g., a text file, a CSV file, an XML file, or any other suitable type of file).

[0107] 4A is a schematic diagram of a Biz Term data entity 400A in accordance with some embodiments of the technology described herein. As shown in FIG. 4A, the Biz Term data entity 400A includes the following attributes: Identifier attribute 400A-1, Definition attribute 400A-2, Owner attribute 400A-3, and Institution attribute 400A-4. Identifier attribute 400A-1 may be assigned an integer value in an instance of the Biz Term data entity 400A. Definition attribute 400A-2 may be assigned a string value in an instance of the Biz Term data entity 400A.

[0108] Owner attribute 400A-3 references Business Owner data entity 400B, indicating that in an instance of Biz Term data entity 400A, Owner attribute 400A-3 may be assigned an instance of Business Owner data entity 400B as a value. Business Owner data entity 400B includes the following attributes: Name 400B-1, Region 400B-2, and Group 400B-3. Institution attribute 400A-4 references Institution data entity 400C, indicating that in Biz Term data entity 400A, Institution attribute 400A-4 may be assigned an instance of Institution data entity 400C as a value. Institution data entity 400C includes the following attributes: Name 400C-1, Region 400C-2, and Type 400C-3.

[0109] 4B is a schematic diagram of an example North America Credit Scores instance 420 of the Biz Term data entity 400A of FIG. 4A, in accordance with some embodiments of the technology described herein. As shown in FIG. 4B, the North America Credit Scores instance 420 has a value of "123" for the Identifier attribute 400A-1 and a textual definition of the credit score as the value of the Definition attribute 400A-2. The MegaBank instance 422 of the Institution data entity 400C is assigned as a value to the Institution attribute 400A-4 of the North America Credit Scores instance 420.

[0110] MegaBank instance 422 has a value of "Mega Bank" for Name attribute 400C-1, a value of "North America" ​​for Region attribute 400C-2, and a value of "Corporation" for Type attribute 400C-3.

[0111] 4B, a value is assigned to Owner attribute 400A-3 of North America Credit Scores instance 420. For example, a user may submit a request to assign a value to Owner attribute 400A-3 through a GUI. In another example, a software application may submit a request to data processing system 200 to assign a value to Owner attribute 400A-3.

[0112] 4C illustrates a set of validation rules 404 associated with a Biz Term data entity 400A, in accordance with some embodiments of the technology described herein. As shown in FIG. 4C, the set of validation rules 404 includes a first rule 404A and a second rule 404B. Rule 404A includes the following conditions for Owner attribute 400A-3: (1) Owner.Name must begin with the letter "B," and (2) Owner.Region must equal Institution.Region. Rule 404A requires that (1) the Name attribute of the instance assigned to Owner attribute 400A-3 must begin with the letter "B," and (2) the Region attribute of the instance assigned to Owner attribute 400A-3 must equal the Region attribute of the instance assigned to Institution attribute 400A-4. Rule 404B of validation rules 404 has the following condition: Institution.Region is defined: Rule 404B requires that the region attribute of an instance assigned to organization attribute 400A-4 is "North America."

[0113] As shown in FIG. 4C , each of rules 404A and 404B is associated with a respective attribute. Rule 404A is associated with Owner attribute 400A-3, and rule 404B is associated with Institution attribute 400A-4. In some embodiments, each of rules 404A and 404B may be associated with an attribute by storing a reference to the attribute in the rule. For example, rule 404A may store a reference to Owner attribute 400A-3 of Biz Term data entity 400A, and rule 404B may store a reference to Institution attribute 400A-4 of Biz Term data entity 400A. While the example of FIG. 4C shows only Owner attribute 400A-3 and Institution attribute 400A-4 associated with each, in some embodiments, multiple rules may be associated with a particular attribute.

[0114] 4D is an example data flow for a process of identifying valid values ​​for an attribute in a Biz Term data entity North America Credit Scores instance 420 according to some embodiments of the technology described herein. The data flow in FIG. 4D may be generated by components 210A, 210B, 210C, 210D of assignment validation module 210 described herein with respect to FIG. 2D.

[0115] Rule selection component 210A selected rule 404A, which is associated with Owner attribute 400A-3 of Biz Term data entity 400A, because a value will be assigned to Owner attribute 400A-3 of North America Credit Scores instance 420, which has the value shown in Figure 4B. For example, rule selection component 210A may (1) determine, using information from rule 404A, that rule 404A is associated with Owner attribute 400A-3, and (2) select rule 404A based on the determination that rule 404A is associated with Owner attribute 400A-3.

[0116] Next, rule translation component 210B translates selected rule 404A to generate translated rule 406. Translated rule 406 includes two expressions 406A, 406B generated from the two conditions of rule 404A. Rule translation component 210B translates the condition (Owner.Name starts with "B") to the expression (Name[0]="B"), which requires that for instances of the Owner data entity, the first character of the Name attribute value must be "B". Rule translation component 210B translates the condition (Owner.Region equals Institution.Region) to the expression (Region="North America"). The rule translation component 210B identified the current value of the Region attribute 400C-2 in the MegaBank instance 422 assigned to the Institution attribute 400A-4, which is "North America," and generated an expression requiring that the Region attribute of the instance assigned to the Owner attribute 400A-3 be "North America." The rule translation component 210B may access the MegaBank instance 422 to identify the current value of the Region attribute 400C-2 in the MegaBank instance 422.

[0117] As shown in the exemplary embodiment of FIG. 4D, the transformed rule does not include the prefix “Owner” for the attribute of Business Owner data entity 400B. In the exemplary embodiment of FIG. 4D, rule transformation component 210B may be configured to remove the prefix that identifies the data entity whose instance will be assigned to Owner attribute 400A-3. Rule transformation component 210B may remove the prefix that identifies the data entity because queries generated from the transformed rule can be performed only on instances of the data entity. Therefore, the transformed rule does not need to explicitly state the data entity. In the example of FIG. 4D, Owner attribute 400A-3 will be assigned the instance of Business Owner data entity 400B as its value. Queries generated from the transformed rules 406 can be executed on instances of the Business Owner data entity, and therefore expressions can use names of attributes from the Business Owner data entity 400B without prefixes that identify the data entity.

[0118] The transformed rule 406 is then used by the query generation component 210C to generate a query 408. As shown in the example of Figure 4D, the query generation component 210C generates an SQL query that selects instances of the Business Owner data entity 400B that satisfy the search criteria indicated by the transformed rule expressions 406A, 406B. The query 408 includes a logical "AND" operation between the two search criteria, indicating that both search criteria must be satisfied for an instance to be returned by the query, resulting in a result that satisfies both conditions of the rule 404A.

[0119] The generated query 408 is then executed by the query execution component 210D to generate the query results 410. The query execution component 210D may be configured to execute the query against a data store using at least one processor. For example, the query execution component 210D may execute the query 408 against a data store that stores the data entity instances 206 of the data processing system 200. In the example of FIG. 4D , the query 408 indicates that results should be selected from instances of the Business Owner data entity 400B. The query execution component 210D may search for instances of the Business Owner data entity 400B that satisfy the search criteria indicated in the “WHERE” portion of the query 408.

[0120] Query result 410 consists of all instances of Business Owner data entity 400B that have a Name attribute 400B-1 value that begins with "B" and a Region attribute 400B-2 value of "North America." Assignment validation module 210 may be configured to identify query result 410 as a valid value for Owner attribute 400A-3 of North America Credit Scores instance 420. For example, assignment validation module 210 may present query result 410 to a user through a graphical user interface (e.g., to select a value to assign for Owner attribute 400A-3 in instance 420). In another example, assignment validation module 210 may send query result 410 to a software application (e.g., to select a value to assign to Owner attribute 400A-3 in instance 420).

[0121] 5A is a schematic diagram of an example relationship between a Data Element data entity 510 and other data entities, according to some embodiments of the technology described herein. As shown in FIG. 5A, the Data Element data entity 510 includes the following attributes: Name, Dataset, ColumnOrder, and BusinessTerm. The Dataset attribute references a Dataset data entity 514, indicating that an instance of the Data Element data entity 510 will have an instance of the Dataset data entity 514 assigned as a value for its Dataset attribute. The BusinessTerm attribute references a BusinessTerm data entity 512, indicating that an instance of the Data Element data entity 510 will have an instance of the Business Term data entity 512 assigned as a value for its BusinessTerm attribute. The Dataset data entity 514 includes the following attributes: Name, DivisionName, and Type.

[0122] The Business Term data entity 512 includes the following attributes: Name, Description, MinimumOrder, TechGroup, and DivisionName. The TechGroup attribute references the Tech Group data entity 516, meaning that an instance of the Business Term data entity 512 will have an instance of the Tech Group data entity 516 assigned as the value of its TechGroup attribute. The Tech Group data entity 516 includes the following attributes: Name and DivisionName.

[0123] 5B is a schematic diagram of an example Price instance 500 of a Data Element data entity 510, in accordance with some embodiments of the techniques described herein. As shown in FIG. 5B, the Price instance 500 has the following attribute values: (1) a Name attribute value of "Price," (2) a Dataset attribute value of a Purchase instance 502 of a Dataset data entity 514, and (3) a ColumnOrder attribute value of 7. These attribute values ​​may have been previously assigned within the Price instance 500. A value 500A needs to be assigned to the BusinessTerm attribute of the Price instance 500.

[0124] 5C illustrates a set of validation rules 504 associated with a Data Element data entity 510, in accordance with some embodiments of the technology described herein. As shown in FIG. 5C, rule 504A is associated with the BusinessTerm attribute of Data Element data entity 510. Rule 504A includes the following three conditions for the BusinessTerm attribute: (1) ColumnOrder>BusinessTerm.MinimumOrder, (2) BusinessTerm.TechGroup.Name="Enterprise", and (3) Dataset.DivisionName=BusinessTerm.DivisionName. The first condition indicates that the value of the ColumnOrder attribute in an instance of Data Element data entity 510 must be greater than the value of the MinimumOrder attribute of the instance of Business Term data entity 512 assigned as the value to the BusinessTerm attribute in the instance of Data Element data entity 510. The second condition states that "Enterprise" is the value of the Name attribute of an instance of the Tech Group data entity 516 that is assigned as a value to the TechGroup attribute in an instance of the Business Term data entity 512 that is assigned as a value to the BusinessTerm attribute in an instance of the Data Element data entity 510.The third condition indicates that the value of the DivisionName attribute in an instance of Dataset data entity 514 assigned as a value to the Dataset attribute in an instance of Data Element data entity 510 must be equal to the value of the DivisionName attribute in an instance of Business Term data entity 512 assigned as a value to the BusinessTerm attribute in an instance of Data Element data entity 510. Because all of the conditions in rule 504A are combined with a logical AND operation, all three conditions must be satisfied by an instance of Business Term data entity 512 to be valid for assignment to the BusinessTerm attribute of an instance of Data Element data entity 510.

[0125] 5D is a data flow of a process for identifying valid values ​​to assign to a BusinessTerm attribute in a Price instance 500 of a Data Element data entity 510, according to some embodiments of the techniques described herein. The data flow may be generated as part of assigning a value to a BusinessTerm attribute in a Price instance 500 by components of the assignment validation module 210 described herein with respect to FIG.

[0126] 5D, rule 504A of validation rules 504 is selected by rule selection component 210A. Rule selection component 210A may be configured to select rule 504A by identifying (e.g., based on information stored in rule 504A) that rule 504A is associated with a BusinessTerm attribute of Data Element data entity 510. Exemplary techniques for identifying rules associated with attributes are described herein.

[0127] Rule 504A is then converted by rule conversion component 210B into converted rule 520 shown in Figure 5D. Each of the conditions in rule 504A is converted into a respective representation in converted rule 520.

[0128] The first condition (ColumnOrder>BusinessTerm.MinimumOrder) is transformed into expression 520A. Rule transformation component 210B may be configured to identify the current value of the ColumnOrder attribute in the price instance 500 and replace “ColumnOrder” in the condition with the current value of 7. Rule transformation component 210B may be configured to remove the “BusinessTerm” prefix from the “BusinessTerm.MinimumOrder” data entity path in the first condition because queries generated using expression 520A will only be executed against instances of the Business Term data entity 512. Therefore, expression 520A may directly reference attributes of the Business Term data entity 512 without explicitly specifying the data entity.

[0129] The second term (BusinessTerm.TechGroup.Name="Enterprise") is transformed into expression 520B. Rule transformation component 210B may be configured to remove the prefix "BusinessTerm" from the data entity path of this term to obtain expression 520B.

[0130] The third condition (Dataset.DivisionName = BusinessTerm.DivisionName) is transformed into expression 520C. The rule transformation component 210B may be configured to identify that "Procurement" is the current value of the DivisionName attribute in the instance of the Dataset data entity 514 assigned as the value to the Dataset attribute of the Price instance 500. Therefore, the rule transformation component 210B replaced "Dataset.DivisionName" in the condition with the value of "Procurement" in expression 520C. The rule transformation component 210B may be configured to remove the prefix "BusinessTerm" from "BusinessTerm.DivisionName" in the condition to obtain expression 520C.

[0131] Transformation rules 520 are used by query generation component 210C to generate query 522. As shown in the example of Figure 5D, query 522 is a SELECT statement that identifies instances of Business Term data entity 512 in a data store (e.g., a data store that stores data entity instances in data processing system 200) that satisfy all of the search conditions indicated by transformed rules 520. Expressions 520A, 520B, and 520C are assembled into query 522 with a logical AND operator to search for instances that satisfy all of the conditions in rule 504A.

[0132] Query 522 is executed by query execution component 210D to generate query results 524. Query results 524 may consist of instances of Business Term data entity 512 that satisfy rule 504A. The instances may be presented to a user (e.g., through a GUI) and / or a process (e.g., through an API) for selection of one or more values ​​to assign to the BusinessTerm attribute of Price instance 500.

[0133] 6A is a schematic diagram of an exemplary relationship between a data entity "T" 610 and other data entities, in accordance with some embodiments of the techniques described herein. As shown in FIG. 6A, data entity "T" 610 includes attributes "T_ID," "x," "y," "B," and "D." Attribute "B" references data entity "B" 614, indicating that an instance of data entity "B" 614 can be assigned as a value to attribute "B" in data entity "T" 610. Attribute "D" references data entity "D," indicating that an instance of data entity "D" 612 can be assigned as a value to attribute "D" in an instance of data entity "T" 610.

[0134] Data entity B 614, referenced by attribute "B" of data entity "T" 610, includes attributes "B_ID", "j", "k", and "C". Attribute "C" references data entity "C" 616, indicating that an instance of data entity "C" 616 can be assigned as a value to attribute "C" in an instance of data entity "B" 614. Data entity "C" 616 includes attributes "C_ID", "p", "q", and "D". Attribute "D" references data entity "D" 612, indicating that an instance of data entity "D" 612 can be assigned as a value to attribute "D" in an instance of data entity "C" 616. Data entity "D" 612 includes attributes "D_ID" and "z".

[0135] 6B is a schematic diagram of an exemplary instance "T1" 600 of data entity "T" 610, in accordance with some embodiments of the techniques described herein. As shown in FIG. 6B, instance "T1" 600 has a value of 54512 assigned to attribute "T_ID," a value of 100 assigned to attribute "x," a value of 10000 assigned to attribute "y," and an instance "D1" 602 of data entity "D" 612 assigned to attribute "D." Attribute "B" of instance "T1" 600 currently does not have a value assigned to it.

[0136] 6C illustrates a set of validation rules 604 associated with data entity "T" 610, in accordance with some embodiments of the techniques described herein. As shown in FIG. 6C, rule 604A is associated with attribute "B" of data entity "T" 610. Rule 604A has three conditions on attribute "B": (1) x>Bj, (2) BCp="Enterprise", and (3) Dz=Bk. The first condition (x>Bj) indicates that the value of attribute "x" in an instance of data entity "T" 610 must be greater than the value of attribute "j" in an instance of data entity "B" 614 assigned as the value of attribute "B" in the instance of data entity "T" 610. The second condition (BCp="Enterprise") indicates that attribute "p" in an instance of data entity "C" 616 assigned to attribute "C" must be equal to "Enterprise". The third condition (Dz=Bk) indicates that the value of attribute "z" in an instance of data entity "D" 612 assigned to attribute "D" must equal the value of attribute "k" in an instance of data entity "B" 614 assigned to attribute "B". Because all of the conditions in rule 604A are combined with a logical AND operation, all three of the conditions must be met for an instance of data entity "B" 614 to be valid for assignment to attribute "B" in an instance of data entity "T" 610.

[0137] 6D is an example dataflow for a process of identifying valid values ​​to assign to attribute "B" in instance "T1" 600 of data entity "T" 610 according to some embodiments of the techniques described herein. This dataflow may be generated by components of assignment validation module 210 described herein with respect to FIG. 4A as part of assigning a value to attribute "B" of instance T1 600 of data entity T 610.

[0138] 6D, rule 604A of validation rules 604 is selected by rule selection component 210A. Rule selection component 210A may be configured to select rule 604A by identifying (e.g., based on information stored in rule 604A) that rule 604A is associated with attribute "B" of data entity T 610. Exemplary techniques for identifying a rule associated with an attribute are described herein.

[0139] Rule 604A is then converted by rule conversion component 210B into converted rule 620. Each of the conditions in rule 604A is converted into an expression.

[0140] The first condition (Tx>Bj) is transformed into an expression (100>j). Rule transformation component 210B may be configured to identify the current value of attribute "x" in instance "T1" 600 and replace "Tx" in the first condition with the current value 100. Rule transformation component 210B may be configured to remove the prefix "B." from "Bj" in the first condition because queries generated from the transformed rule 620 will only run on instances of B. Therefore, the expression may directly reference attributes of data entity "B" 614 without explicitly specifying the data entity.

[0141] The second condition (BCp="Enterprise") is transformed into an expression (Cp="Enterprise"), which requires that an instance assigned to attribute "C" has a value of "Enterprise" for its attribute "p". Rule transformation component 210B may be configured to remove the prefix "B." from the data entity path "BCp" in the condition.

[0142] The third condition (Dz=Bk) is transformed into the expression (300=k). Rule transformation component 210B may be configured to identify that the current value of attribute "z" in the instance of data entity D 612 assigned to attribute D is 300. Rule transformation component 210B therefore replaces Dz with the value 300. Rule transformation component 210B may be configured to remove the prefix "B." from "Bk".

[0143] The transformed rule 620 is used by the query generation component 210C to generate a query 622. As shown in the example of Figure 6D, the query 622 is a SELECT statement that identifies instances of data entity B 614 in a data store (e.g., the data store that stores the data entity instance 206 of the data processing system 200) that satisfy all of the search conditions indicated by the transformed rule 620. The expressions are assembled into the query 622 with a logical AND operator to search for instances that satisfy the conditions of the rule 604A.

[0144] Query 622 is executed by query execution component 210D to generate query results 624. Query results 624 may consist of instances of data entity B 614 that satisfy rule 604A. The instances may be presented to a user (e.g., through a GUI) and / or to a process (e.g., through an API) for selection of one or more values ​​to assign to attribute B of instance T1 600.

[0145] 7 is a block diagram illustrating components of a data processing system 200 in accordance with some embodiments of the techniques described herein. As shown in FIG. 7, the data processing system 200 includes an interface 207, an assignment validation module 210, and a data persistence layer 220.

[0146] The interface 207 includes a GUI 207A and an API 207B, as described herein with respect to Figures 2A-2D.

[0147] In some embodiments, GUI 207A may include a validation rule definition GUI, through which validation rules can be defined within data processing system 200. In some embodiments, the validation rule definition GUI may enable a user to define a validation rule. The GUI may enable a user to create a validation rule that includes information, as described herein with respect to FIG. 3C. For example, the validation rule definition GUI may enable a user to select a graphical element that represents a command to create a new validation rule. The user may then enter information that defines the new validation rule and associates the new validation rule with data entities and their attributes. In some embodiments, the validation rule definition GUI may enable a user to specify the conditions of the rule. For example, the GUI may enable a user to enter a logical expression that represents the condition.

[0148] In some embodiments, GUI 207A may include an attribute value assignment GUI, through which a user can assign a value to an attribute. The attribute value assignment GUI may be configured to present, within the GUI, an indication of valid values ​​that can be assigned to the attribute. The attribute value assignment GUI may be configured to receive, through the GUI, one or more selections of valid values ​​to assign to the attribute. In some embodiments, the attribute value assignment GUI may be configured to allow a user to view invalid values ​​in addition to valid values. For example, the attribute value assignment GUI may provide an option (e.g., a graphical switch, check box, or other GUI option) that allows a user to request invalid values ​​for an attribute in addition to valid values.

[0149] In some embodiments, the attribute value assignment GUI may be configured to indicate the validity of a value selected for assignment to an attribute. For example, the attribute value assignment GUI may display a graphical element (e.g., an exclamation point) near the selected attribute value indicating that the selected value is invalid. In other examples, the attribute value assignment GUI may display a graphical element near the selected attribute value indicating that the selected value is valid.

[0150] In some embodiments, the attribute value assignment GUI may be configured to trigger validation using one or more validation rules in response to detecting one or more user actions in the GUI. For example, user input to change a workflow stage, user input to submit an attribute value assignment, and / or user input to save a selected value for an attribute may be detected in the GUI. Validation of a data entity instance may be triggered in response to detecting the user actions.

[0151] In some embodiments, API 207B may include a validation rule definition API, through which validation rules may be programmatically created in data processing system 200. For example, validation rule definition API may provide an API through which a software application may send instructions that cause data processing system 200 to generate new validation rules.

[0152] In some embodiments, API 207B may include an attribute value assignment API, through which attribute values ​​may be programmatically assigned within data processing system 200. For example, attribute value assignment API may provide an API through which a software application may send instructions that cause data processing system 200 to assign values ​​to attributes.

[0153] 7, interface 207 sends data requests 702 to assignment validation module 210 and receives data 704 in response to data requests 702. Interface 207 may be configured to provide data through various interfaces (e.g., GUI, API, and / or other interfaces). Data requests 702 may include information used by assignment validation module 210 (e.g., validation rule definition information) and / or requests to obtain information from assignment validation module 210. In some embodiments, data 704 may include information about validation rules, data entities, and / or data entity instances. For example, data 704 may include valid values ​​for attributes. In other examples, data 704 may include an indication of whether a value is valid to assign to an attribute.

[0154] Assignment validation module 210 includes a rule selection component 210A, a rule transformation component 210B, a query generation component 210C, a query execution component 210D, and a rule definition component 210E. Rule selection component 210A, rule transformation component 210B, query generation component 210C, and query execution component 210D are described herein.

[0155] Rule definition component 210E may be configured to generate validation rules within data processing system 200. In some embodiments, rule definition component 210E may be configured to generate validation rules using information obtained from interface 207. Exemplary information that may be obtained by rule definition component 210E is described herein with respect to Figures 3A-3C. Rule definition component 210E may be configured to store (e.g., in data persistence layer 220) information about the validation rules and their data entities and their attributes.

[0156] 7, assignment validation module 210 may be configured to send a data request 706 to data persistence layer 220. In some embodiments, data request 706 may include sending information for new validation rules and / or information to update validation rules for storage in data persistence layer 220. In some embodiments, data request 706 may be a query for one or more data entity instances (e.g., identified valid values ​​for an attribute). In some embodiments, data request 706 may include a request for information about validation rules, data entities, and / or data entity instances (e.g., for provision in one or more of interfaces 207). In some embodiments, data request 706 may be a selection of a value to assign to an attribute.

[0157] The attribute validation module 210 is configured to receive data 708 from the data persistence layer. In some embodiments, the data 708 may include query results. For example, the data 708 may include one or more valid values ​​(e.g., valid instances) that can be assigned to an attribute. In some embodiments, the data 708 may include information about validation rules, data entities, and / or data entity instances. In some embodiments, the data 708 may include confirmations (e.g., indicating whether the assignment of an attribute value was successful).

[0158] 7 , data persistence layer 220 stores validation rules 202, data entities 204, and data entity instances 206 of data processing system 200. Data persistence layer 220 may include one or more data stores for storing data. In some embodiments, a data store may include a relational database system, whereby data may be stored in tables in the relational database system. However, a data store is not limited to being a relational database system, as a data store may be configured to store data in any suitable manner. For example, a data store may include an object-oriented database, a distributed database, a NoSQL database, an SQL database, and / or any other suitable database.

[0159] In some embodiments, data persistence layer 220 may include one or more storage devices that store data in any suitable type of one or more formats. For example, the storage devices may store data using one or more database tables, spreadsheet files, text files, and / or files in any other suitable format. The storage devices may be of any suitable type, including one or more servers, one or more database systems, one or more portable storage devices, one or more non-volatile storage devices, one or more volatile storage devices, and / or any other device configured to store data. In embodiments in which the database includes multiple storage devices, the storage devices may be co-located in one physical location (e.g., a building) or distributed across multiple locations (e.g., multiple buildings, different cities, states, or countries). The storage devices may be configured to communicate with each other using a communications network (e.g., the Internet).

[0160] FIG. 8 is a schematic diagram of a data entity 800A that may be defined within data processing system 200. As shown in FIG. 8, data entity 800A includes attributes 800A-1, 800A-2, 800A-3, and 800A-4. Attribute 800A-1 may be assigned an integer value within an instance of data entity 800A, and attribute 800A-2 may be assigned a string value within an instance of data entity 800A. Attribute 800A-3 may be assigned an instance of data entity 800B as a value for the instance of data entity 800A. As shown in FIG. 8, data entity 800B has its own set of attributes, including attributes 800B-1 and 800B-2. Attribute 800A-4 may be assigned an instance of data entity 800C as a value. As shown in FIG. 8, data entity 800C has its own set of attributes, including attributes 800C-1 and 800C-2.

[0161] Data processing system 200 may be configured to assign data entity instances as values ​​to attributes in various ways. In some embodiments, data processing system 200 may be configured to assign data entity instances as values ​​to attributes by storing references to the data entity instances as the attribute values. For example, data processing system 200 may store a URL, identifier, pointer, or other reference to the data entity instance that is assigned as the value.

[0162] Data processing system 200 may be configured to reference attributes of one data entity to other data entities in various ways. In some embodiments, data processing system 200 may be configured to store references (e.g., pointers, links, URLs, names, or other references) to other data entities. For example, data processing system 200 may store a link to data entity 800B as attribute 800A-3 of data entity 800A. In some embodiments, data processing system 200 may be configured to store the referenced data entity within the data entity that references the referenced data entity. For example, data processing system 200 may be configured to store data entity 800B within data entity 800A associated with attribute 800A-3.

[0163] 9 is a flowchart of an example process 900 for performing valid data assignment in accordance with some embodiments of the techniques described herein. In some embodiments, process 900 may be performed by data processing system 100. For example, data processing system 100 may perform process 900 using assignment validation module 210.

[0164] Process 900 begins at block 902, where the system receives a request to assign a value to an attribute in a data entity instance. In some embodiments, the system may be configured to receive the request through a GUI displayed on a user's client device. For example, the system may receive a request sent through a GUI that enables a user to assign a value to an attribute in a data entity instance. In some embodiments, the system may be configured to receive the request from a process (e.g., a software application). For example, the system may receive the request through an API request to assign a value to an attribute in a data entity instance.

[0165] Next, process 900 proceeds to block 904, where the system uses one or more validation rules to identify one or more valid values ​​for the attribute. Validation rules may be associated with a data entity from which the data entity instance is generated. Examples of data entities and their instances are described herein with respect to Figures 4B-4C, 5A-5B, and 6A-6B. Examples of validation rules are described herein with respect to Figures 3A-3C, 4D, 5C, and 6C.

[0166] In subblock 904A of block 904, the system generates at least one query for valid values ​​of the attribute using the conditions for the attribute of the validation rule. The system may be configured to generate the query for valid values ​​of the attribute by (1) transforming the application validation rule to obtain a transformed rule, and (2) generating a query using the transformed rule. In some embodiments, the transformed rule may include various components associated with each condition in the rule. For example, the transformed rule may include multiple logical expressions of the conditions in the rule. The system may be configured to generate portions of the query using each component of the transformed rule. For example, the system may generate an SQL query statement using each component of the transformed rule. Exemplary techniques for generating queries using validation rules are described herein with respect to FIGS. 4E, 5D, and 6D.

[0167] In sub-block 904B of block 904, the system executes the generated at least one query to obtain valid values ​​for the attribute. The system may be configured to execute the at least one query against a database that stores the data entity instances. For example, the system may execute the at least one query against a database (e.g., an SQL database) that stores the data entity instances. In some embodiments, the system may be configured to send the query to another system for execution. For example, a processor in the database may execute the query and send the results to the system executing process 900.

[0168] In some embodiments, the system may be configured to execute a query on a portion of the data store. For example, the system may execute the generated query on a subset of the data entity instances in the data store. The subset of data entity instances may be data entity instances that can be assigned to the attribute for which a value is to be assigned (e.g., as indicated by the data entity from which the data entity instance is generated). The system may be configured to execute the query on the portion of the data store by (1) identifying data entity instances that can be assigned as values ​​to the attribute, and (2) executing the query on the identified data entity instances to obtain valid values ​​for the attribute.

[0169] Process 900 then proceeds to block 906, where the system outputs the valid values ​​for the attribute. In some embodiments, the system may be configured to present the valid values ​​in a GUI through which a user may select one or more of the valid values ​​to assign to the attribute. For example, the system may present the valid values ​​as a list in an assignment GUI from which a user may select a value and submit it for assignment to the attribute. In some embodiments, the system is configured to send the valid values ​​to a process that can select one or more of the valid values ​​to assign to the attribute. For example, the system may send the valid values ​​to a software application (e.g., through an API) to programmatically select one or more of the valid values ​​to assign to the attribute.

[0170] Process 900 then proceeds to block 908, where the system assigns a value to the attribute in the data entity instance based on input indicating a selection of a value from the valid values. For example, the system may be configured to receive input through a GUI and / or an API. The system may be configured to save (e.g., in data persistence layer 220) the selected value as the value assigned to the attribute of the data entity instance. As indicated by the dotted line in block 908, the step of block 908 may be performed as part of process 900. For example, the system may not perform the step of block 908 because no value selection is received. In some embodiments, the system may be configured to perform the step of block 908 separately from the steps of blocks 902-906. For example, the system may assign the value at a later time along with other attribute value assignments.

[0171] 10 is a flowchart of an exemplary process 1000 of a client device for assigning values ​​to attributes in a data entity in accordance with some embodiments of the techniques described herein. Process 1000 may be performed by any suitable computing device in communication with a data processing system. For example, process 1000 may be performed by one of the devices of user 208 in communication with data processing system 200, as described herein with respect to FIGS. 2A-2C.

[0172] Process 1000 begins at block 1002, where a device receives, through a GUI, an input indicating a request to assign a value to an attribute in a data entity instance. In some embodiments, the GUI may be a data entity instance edit GUI, through which the value can be assigned to the attribute. For example, the device may receive, through the GUI, a selection of an option to assign a value to the attribute.

[0173] Next, process 1000 proceeds to block 1004, where the device sends a request to a data processing system to assign a value to an attribute in a data entity instance. For example, the device may send the request over a communications network (e.g., the Internet). In some embodiments, the request may include a network communication indicating the attribute and the data entity instance. For example, the request may specify an identifier of the data entity instance and the attribute in the data entity instance for which the value is to be assigned.

[0174] Process 1000 then proceeds to block 1006, where the device receives one or more valid values ​​for the attribute from a data processing system. For example, a request sent by the device causes the data processing system to obtain the valid values ​​by performing process 900 described herein with respect to FIG. 9. In some embodiments, the device may be configured to receive the valid values ​​over a communications network (e.g., the Internet). For example, the device may receive a network communication indicating the valid values. In some cases, the valid values ​​may be instances of other data entities. In some cases, the valid values ​​may be integers, strings, floating-point values, or other types of data. In some embodiments, the network communication may include only the valid values. In some embodiments, the network communication may include all values ​​assigned to the attribute, along with information indicating which values ​​are valid and / or invalid.

[0175] Next, process 1000 proceeds to block 1008, where the device presents valid values ​​for the attribute in a GUI. In some embodiments, the device may be configured to present the valid values ​​in an assignment GUI that lists the valid values. For example, the device may present the valid values ​​in a scrolling list of valid values ​​from which a user can select a value to assign to the attribute. In some embodiments, the GUI may allow a user to select an option that causes the GUI to display one or more invalid values ​​for the attribute in addition to the valid values. For example, in response to selecting this option in the GUI, the device may request the invalid values ​​of the attribute for display. As another example, the device may display the invalid values ​​obtained in block 1006 along with the valid values.

[0176] Next, process 1000 proceeds to block 1010, where the device receives input through the GUI indicating assigning a selected value of the valid values ​​to the attribute. For example, the device may receive the input in response to a user selecting a value in the GUI and selecting a submit option. As another example, the device may receive the input in response to a user action (e.g., a tap, a voice command, or other user action).

[0177] Next, process 1000 proceeds to block 1012, where the system transmits to the data processing system an indication of the selected value to assign to the attribute. For example, the device may transmit an identifier of the selected value to assign to the attribute. The transmission may cause the data processing system to assign the selected value to the attribute as described in block 908 of process 900 described herein with respect to FIG. 9.

[0178] 11 is a GUI 1100 for creating a new validation rule, according to some embodiments of the technology described herein. As shown in FIG. 11, GUI 1100 allows a user to provide input specifying the names 1102 of valid values, the data entities 1104 with which the validation rule is associated, and the attributes 1106 of the data entities with which the validation rule is associated. A user may navigate to GUI 1100 in a variety of ways. For example, a user may select graphical element 1108 to begin creating a new validation rule.

[0179] FIG. 12A is a GUI 1200 for defining a new validation rule, according to some embodiments of the technology described herein. As shown in FIG. 12A , GUI 1200 allows a user to provide input specifying information about the validation rule (e.g., the information described with respect to FIGS. 3A-3C ). GUI 1200 allows a user to provide input specifying the name 1202 of the validation rule, the attribute 1204 of the data entity with which the validation rule is associated, the severity 1206, a textual description 1208 of the validation rule, and a message 1210 to display for the validation rule. GUI 1200 allows a user to provide input specifying an execute import action 1212 for the validation rule and an execute user interface action 1214 for the validation rule.

[0180]

[00130] Figure 12B illustrates the specification of a condition for an attribute of GUI 1200 of Figure 12A, in accordance with some embodiments of the technology described herein. As shown in Figure 12B, GUI 1200 provides an interface through which a user can specify one or more expressions that define the conditions of a validation rule. In the example of Figure 12B, expression 1220 indicates the condition that the Business Owner attribute of the term data entity is equal to the value "Data Profilers."

[0181] Figure 12C illustrates additional representations 1222, 1224 of the GUI 1200 of Figure 12A in accordance with some embodiments of the techniques described herein. In addition to representation 1220, in the example of Figure 12C, representations 1222, 1224 are also specified for validation rules. Representation 1222 indicates that the DataElems attribute of the Term data entity has a specified value. Representation 1224 indicates that the Name attribute of the Calculated Data attribute begins with the letter "B." An AND operation 1226 is applied between representations 1220, 1222, and an OR operation 1228 is applied between the result of the AND operation and representation 1224.

[0182] FIG. 12D illustrates the specification of the execute validation rules user interface action 1214 in the GUI 1200 of FIG. 12A in accordance with some embodiments of the techniques described herein. As shown in FIG. 12D, the GUI 1200 allows selection from a set of user interface actions 1214A, including "None," "On Save," "On Submit," and "On Workflow Advance." Each of these indicates a particular user interface action that triggers execution of a validation rule. For example, a data processing system may determine whether a data entity instance satisfies a validation rule in response to an explicit user interface action. In some embodiments, the data processing system may restrict completion of a user interface action until the data entity instance satisfies the validation rule. "None" may indicate that no execution of any user interface action will occur.

[0183] Figure 12E illustrates the specification of the enforce validation rules import operation 1212 in the GUI 1200 of Figure 12A, according to some embodiments of the techniques described herein. As shown in Figure 12E, the GUI 1200 allows selection from a group of enforce import operations 1212A, including "None," "On Submit," and "Reject Record." "Reject Record" may indicate that a data entity instance is rejected if the data entity instance does not satisfy a validation rule. The "On Submit" operation may cause the data processing system to specify whether a validation rule is satisfied when the data import is submitted. "None" may indicate that validation rules are not enforced in the import operation.

[0184] Figure 12F illustrates the specification of severity 1206 for validation rule failure in GUI 1200 of Figure 12A, according to some embodiments of the techniques described herein. GUI 1200 allows selection from the following severity levels 1206A: "Error" and "Warning." "Error" prevents the data processing system from assigning an invalid value to the attribute and displays an error. "Warning" causes the data processing system to assign an invalid value, but displays a warning in the GUI informing users that the selected value is invalid.

[0185] FIG. 13 is a GUI 1300 that displays information about a validation rule created using the GUI 1100 of FIGS. 12A-12F, in accordance with some embodiments of the technology described herein. As shown in FIG. 13, the validation rule is called "Demo" and is associated with the attribute "Business Owner" of the "Term" data entity. The validation rule is enabled and has a severity of "Error." The validation rule will be executed when the import is submitted and / or when submit is selected in the user interface. The validation rule specifies the condition that a data entity instance is valid if the Name attribute of the Calculated Data attribute begins with the letter "B" or if the Business Owner attribute is equal to "Data Profilers," the DataElems attribute is specified with a value, and the character length of the definition attribute is greater than three.

[0186] FIG. 14A is a GUI 1400 displaying information about a validation rule, according to some embodiments of the technology described herein. As shown in FIG. 14A, the name of the validation rule is "CDE Test Rule Business Owner," which is associated with a Critical Data Element data entity. The validation rule is further associated with the Business Owner attribute of the Critical Data Element data entity. The validation rule has a severity of "Error." The validation rule further comprises a display message that reads, "The Business Owner's name must start with the letter A." The validation rule will be enforced on import by rejecting the record if the validation rule is not met (i.e., if the Business Owner attribute value is invalid). The validation rule will also be enforced when a submit action is performed in the user interface. The validation rule has a condition that the Business Owner attribute value must start with the letter "A." The validation rule further indicates that a data entity instance is validated using the validation rule only if the Name attribute of the data entity instance is specified and equals "arises from counterparty risk".

[0187] 14B is a GUI 1410 that displays information about a data entity instance, according to some embodiments of the technology described herein. As shown in FIG. 14B, the data entity instance includes a Business Owner attribute 1412 that has not yet been assigned a value. GUI 1410 may allow a user to assign a value to attribute 1412. The name of the data entity instance is "Arising from Counterparty Risk." Because the data entity instance is an instance of a Critical Data Element, the validation rules of FIG. 14A apply to the data entity instance.

[0188] Figure 14C is a GUI 1420 displaying the identified valid values ​​for attribute 1412 in the data entity instance of Figure 14B, in accordance with some embodiments of the techniques described herein. GUI 1420 displays a list 1422 of valid values. The valid values ​​may be obtained by a data processing system using an assignment validation module (by performing process 1000 described herein with respect to Figure 10). As shown in Figure 14C, all of the listed values ​​for the Business Owner attribute begin with the letter "A," as required by the validation rules of Figure 14A.

[0189] Figure 14D is GUI 1420 of Figure 14C displaying valid and invalid values ​​for an attribute in the data entity instance of Figure 14B, in accordance with some embodiments of the techniques described herein. GUI 1420 includes an option 1432 that, when selected, causes GUI 1420 to display a list 1434 of valid and invalid values ​​for Business Owner attribute 1412. As shown in Figure 14D, list 1434 includes valid values ​​(e.g., starting with the letter "A") and invalid values ​​(i.e., not starting with the letter "A").

[0190] Figure 14E is the GUI 1410 of Figure 14B after a valid value 1442 has been selected for assignment to the Business Owner attribute 1412, in accordance with some embodiments of the technology described herein. As shown in Figure 14E, the value "Abby A. Williams" has been selected for assignment to the Business Owner attribute 1412.

[0191] Figure 14F is the GUI 1410 of Figure 14B displaying the data entity instance after a valid value 1442 has been assigned to the Business Owner attribute in accordance with some embodiments of the technology described herein. As shown in Figure 14F, the GUI 1410 does not display any indication of an error or invalid value because a valid value has been successfully assigned to the Business Owner attribute 1412.

[0192] Figure 14G is the GUI 1410 of Figure 14B after an invalid value 1462 has been selected for assignment to the Business Owner attribute 1412, in accordance with some embodiments of the technology described herein. As shown in Figure 14G, a value of "Postal Code Steward" has been selected for assignment to the Business Owner attribute 1412. Because this value does not begin with the letter "A," it does not satisfy the validation rule of Figure 14A and is therefore invalid. GUI 1410 includes a graphical element 1464 that indicates that the selected value is invalid. When a user hovers the cursor over graphical element 1464, GUI 1410 further displays the display message set in the validation rule of Figure 14A, indicating that "The Business Owner's Name Must Start with A."

[0193] 14H is the GUI of FIG. 14B after an invalid value has been submitted for assignment to the Business Owner attribute, in accordance with some embodiments of the technology described herein. In the example of FIG. 14H, the data processing system may reject the assignment of "Postal Code Steward" to the Business Owner attribute 1412 because the FIG. 14A validation rule is set with a severity of "Error." Therefore, the value of "Postal Code Steward" was not assigned to the Business Owner attribute 1412. In some embodiments, the value may be saved without being assigned as a value to the attribute.

[0194] Exemplary Computer System 15 illustrates an example of a suitable computing system environment 1500 on which the technology described herein may be implemented. The computing system environment 1500 is only one example of a suitable computing environment and is not intended to suggest any limitation as to the scope of use or functionality of the technology described herein. Neither should the computing environment 1500 be interpreted as having any dependency or requirement relating to any one or combination of components illustrated in the exemplary operating environment 1500.

[0195] The technology described herein also operates with a variety of other general-purpose or special-purpose computing system environments or configurations. Examples of well-known computing systems, environments, and / or configurations that may be suitable for use with the technology described herein include, but are not limited to, personal computers, server computers, handheld or laptop devices, multiprocessor systems, microprocessor-based systems, set-top boxes, programmable consumer electronics devices, network PCs, minicomputers, mainframe computers, distributed computing environments that include any of the above systems or devices, and others.

[0196] A computing environment may execute computer-executable instructions such as program modules. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The technology described herein may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media, including memory storage devices.

[0197] With reference to FIG. 15, an exemplary system for implementing the techniques described herein includes a general-purpose computing device in the form of a computer 1510. Components of the computer 1510 may include, but are not limited to, a processing unit 1520, a system memory 1530, and a system bus 1521 that couples various system components including the system memory to the processing unit 1520. The system bus 1521 may be any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, and a local bus using various bus architectures. For example, but not limited to, such architectures include the Industry Standard Architecture (ISA) bus, MicroChannel Architecture (MCA) bus, Enhanced ISA (ELISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus, also known as Mezzanine bus.

[0198] The computer 1510 typically includes a variety of computer-readable media. Computer-readable media can be any available media that can be accessed by the computer 1510 and can include both volatile and nonvolatile media, removable and non-removable media. For example, and without limitation, computer-readable media can include computer storage media and communication media. Computer storage media includes volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules, or other data. Computer storage media includes, but is not limited to, RAM, ROM, EEPROM, flash memory, or other memory technology, CD-ROM, digital versatile disk (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage, or other magnetic storage devices, or any other medium that can be used to store the desired information and that can be accessed by the computer 1510. Communication media typically embodies computer-readable instructions, data structures, program modules, or other data in a modulated data signal such as a carrier wave or other transport mechanism and includes any information delivery media. The term "modular data signal" means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media includes wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, RF, infrared and other wireless media. Combinations of any of the above should also be included within the scope of computer-readable media.

[0199] The system memory 1530 includes computer storage media in the form of volatile and / or nonvolatile memory such as read-only memory (ROM) 1531 and random access memory (RAM) 1532. A basic input / output system 1533 (BIOS), containing the basic routines that help to transfer information between elements within the computer 1510, such as during start-up, is typically stored in ROM 1531. RAM 1532 typically contains data and / or program modules that are immediately accessible to and / or presently being operated on by the processing unit 1520. By way of example, and not limitation, FIG. 15 illustrates operating system 1534, application programs 1535, other program modules 1536, and program data 1537.

[0200] Computer 1510 may also include other removable / non-removable, volatile / non-volatile computer storage media. By way of example only, Figure 15 illustrates hard disk drive 1541, which reads from or writes to non-removable, non-volatile magnetic media, removable non-volatile memory 1552, such as flash drive 1551, which reads from or writes to flash memory, and optical disk drive 1555, which reads from or writes to a removable, non-volatile optical disk 1556, such as a CD-ROM or other optical media. Other removable / non-removable, volatile / non-volatile computer storage media that can be used in this exemplary operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid-state RAM, solid-state ROM, and the like. The hard disk drive 1541 is typically connected to the system bus 1521 through a non-removable memory interface such as interface 1540, and the magnetic disk drive 1551 and optical disk drive 1555 are typically connected to the system bus 1521 by a removable memory interface such as interface 1550.

[0201] The drives and their associated computer storage media, discussed above and illustrated in FIG. 15, provide storage of computer-readable instructions, data structures, program modules, and other data for computer 1510. In FIG. 15, for example, hard disk drive 1541 is illustrated as storing operating system 1544, application programs 1545, other program modules 1546, and program data 1547. Note that these components can either be the same as or different from operating system 1534, application programs 1545, other program modules 1536, and program data 1537. Operating system 1544, application programs 1545, other program modules 1546, and program data 1547 are numbered differently here to illustrate that, at a minimum, they are different copies. Actors may enter commands and information into computer 1510 through input devices such as a keyboard 1562 and pointing device 1561, commonly referred to as a mouse, trackball, or touchpad. Other input devices (not shown) may include a microphone, joystick, game pad, satellite television dish, scanner, or the like. These and other input devices are often connected to the processing unit 1520 through a user input interface 1560 that is coupled to the system bus, but may also be connected by other interface and bus structures, such as a parallel port, game port, or universal serial bus (USB). A monitor 1591 or other type of display device is also connected to the system bus 1521 via an interface, such as a video interface 1590. In addition to a monitor, computers may also include other peripheral output devices such as speakers 1597 and printer 1596, which may be connected through an output peripheral interface 1595.

[0202] The computer 1510 may operate in a networked environment using logical connections to one or more remote computers, such as remote computer 1580. The remote computer 1580 may be a personal computer, a server, a router, a network PC, a peer device, or other common network node, and typically includes many or all of the elements described above relative to the computer 1510, although only a memory storage device 1581 is illustrated in FIG. 15. The logical connections depicted in FIG. 15 include a local area network (LAN) 1581 and a wide area network (WAN) 1583, but may also include other networks. Such networking environments are commonplace in offices, enterprise-wide computer networks, intranets, and the Internet.

[0203] When used in a LAN networking environment, the computer 1510 is connected to the LAN 1581 through a network interface or adapter 1580. When used in a WAN networking environment, the computer 1510 typically includes a modem 1582 or other means for establishing communications over the WAN 1583, such as the Internet. The modem 1582, which may be internal or external, may be connected to the system bus 1521 via the actor input interface 1560 or other appropriate mechanism. In a networked environment, program modules depicted relative to the computer 1510, or portions thereof, may be stored in a remote memory storage device. For example, and not limitation, FIG. 15 illustrates remote application programs 1585 residing on memory device 1581. It is to be understood that the illustrated network connections are exemplary and other means of establishing a communications link between computers may be used.

[0204] Having described several aspects of at least one embodiment of the technology described herein, it is to be appreciated that various alterations, modifications, and improvements will readily occur to those skilled in the art.

[0205] Such changes, modifications, and improvements are intended to be part of this disclosure and are intended to be within the spirit and scope of this disclosure. Furthermore, while advantages of the technology described herein have been set forth, it should be understood that not all embodiments of the technology described herein include all of the described advantages. Some embodiments may not implement any of the features described herein as advantageous, and in some cases, one or more of the described features may be implemented to achieve another embodiment. Accordingly, the foregoing description and drawings are by way of example only.

[0206] The above-described embodiments of the technology described herein may be implemented in any of a variety of ways. For example, embodiments may be implemented using hardware, software, or a combination thereof. When implemented in software, the software code may execute on any suitable processor or collection of processors, whether on a single computer or distributed among multiple computers. Such a processor may be implemented as an integrated circuit, where one or more processors in the integrated circuit component may include commercially available integrated circuit components known in the art by names such as CPU chips, GPU chips, microprocessors, microcontrollers, or coprocessors. Alternatively, the processor may be implemented in custom circuitry, such as an ASIC, or a semiconductor circuit resulting from constructing a programmable logic device. As yet another alternative, the processor may be part of a larger circuit or semiconductor device, whether commercially available, semi-custom, or custom. As a specific example, some commercially available microprocessors have multiple cores, whereby one or a subset of these cores may constitute a processor. However, the processor may be implemented using any suitable format of circuitry.

[0207] Furthermore, a computer may be implemented in any of many forms, such as a rack-mounted computer, a desktop computer, a laptop computer, or a tablet computer, etc. In addition, a computer may be embedded within a device not generally considered a computer, but having suitable processing capabilities, including a personal digital assistant (PDA), a smartphone, or any other suitable portable or fixed electronic device.

[0208] A computer may also have one or more input and output devices. These devices can be used, among other things, to present a user interface. Examples of output devices that can be used to provide a user interface include a printer or display screen for visual presentation of output and a speaker or other sound-generating device for audible presentation of output. Examples of input devices that can be used for a user interface include a keyboard, a pointing device such as a mouse, a touchpad, or a digitizing tablet. As another example, a computer may receive input information through speech recognition or in other audible formats.

[0209] Such computers may be interconnected by one or more networks in any suitable form, including as a local area network or a wide area network, such as an enterprise network or the Internet. Such networks may be based on any suitable technology and operate according to any suitable protocol, and may include wireless networks, wired networks, or fiber optic networks.

[0210] Also, the various methods or processes outlined herein may be coded as software executable on one or more processors utilizing any one of a variety of operating systems or platforms. In addition, such software may be written using any of a number of suitable programming languages ​​and / or programming or scripting tools, and may be compiled as executable machine language code or intermediate code that runs on a framework or virtual machine.

[0211] In this regard, aspects of the technology described herein may be embodied as a computer-readable storage medium (or multiple computer-readable media) (e.g., computer memory, one or more floppy disks, compact disks (CDs), optical disks, digital video disks (DVDs), magnetic tape, flash memory, field programmable gate array circuitry or other semiconductor devices, or other tangible computer storage media) encoded with one or more programs that, when executed on one or more computers or other processors, perform methods that implement the various embodiments described above. As is evident from the above examples, a computer-readable storage medium may retain information for a sufficient period of time to provide computer-executable instructions in a non-transitory form. Such one or more computer-readable storage media may be transportable, whereby one or more programs stored thereon can be loaded into one or more different computers or other processors to implement various aspects of the technology described above. As used herein, the term “computer-readable storage medium” includes only non-transitory computer-readable media that can be considered an article of manufacture (i.e., an article of manufacture) or a machine. Alternatively, or additionally, aspects of the technology described herein may be embodied in a computer-readable medium other than a computer-readable storage medium, such as a propagated signal.

[0212] The terms "program" or "software" are used herein in a generic sense to refer to any type of computer code or set of computer-executable instructions that can be used to program a computer or other processor to implement various aspects of the technology described above. Additionally, in accordance with one aspect of this embodiment, one or more computer programs that, when executed, perform the methods of the technology described herein need not reside on a single computer or processor, but may be modularly distributed among a number of different computers or processors to implement various aspects of the technology described herein.

[0213] Computer-executable instructions may be in many forms, such as program modules, executed by one or more computers or other devices. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Typically, the functionality of the program modules may be combined or distributed as desired in various embodiments.

[0214] Additionally, data structures may be stored in any suitable form on a computer-readable medium. For simplicity of explanation, data structures may be shown as having fields that are related through their locations within the data structure. Such relationships may also be achieved by assigning storage for the fields with locations in the computer-readable medium that convey the relationship between the fields. However, any suitable mechanism for establishing relationships between information in fields of a data structure may be used, including through the use of pointers, tags, or other mechanisms for establishing relationships between data elements.

[0215] Various aspects of the technology described herein may be used alone, in combination, or in various arrangements not specifically set forth in the foregoing embodiments, and therefore are not limited in their application to the details and arrangements of components set forth in the foregoing description or illustrated in the drawings. For example, aspects described in one embodiment may be combined in any manner with aspects described in other embodiments.

[0216] Additionally, the techniques described herein may be implemented as methods, examples of which are provided herein, including those relating to Figures 3 and 7. The actions performed as part of any of the methods may be ordered in any suitable manner. Thus, embodiments may be constructed in which actions are performed in an order different from that illustrated, including performing some actions simultaneously even though they are shown as sequential actions in the exemplary embodiments.

[0217] Additionally, some actions are described as being performed by an "actor" or "user." An "actor" or "user" need not be a single individual; in some embodiments, actions performed by an "actor" or a "user" may be performed by a team of individuals and / or a collaboration between an individual and a computer-assisted tool or other mechanism.

[0218] The use of ordinal terms such as "first," "second," "third," etc. to modify claim elements in a claim does not, by itself, imply any priority, superordinate, or ordering of one claim element over other elements, nor any temporal order in which method actions are performed, but is merely used as a label to distinguish one claim element having a particular name from other elements having the same name (other than the use of ordinal terms).

[0219] Also, the phraseology and terminology used herein is for the purpose of description and should not be regarded as limiting. The use herein of "including," "comprising," "having," "containing," "involving," and variations thereof, is meant to encompass the items listed thereafter and equivalents thereof, as well as additional items.

Claims

1. A method for performing a valid data allocation in a data processing system configured to process data updated by a user device and / or a computer process, Using at least one computer hardware processor, the following can be done, namely: The data processing system receives a request to assign a value to a first attribute within a first data entity instance of a first data entity, The first data entity includes a plurality of attributes, including the first attribute and the second attribute. The first data entity is associated with at least one validation rule, the at least one validation rule includes a first validation rule associated with the first attribute, the first validation rule specifies a first condition for the first attribute that depends on the second attribute. Receiving and Identifying one or more valid values ​​for the first attribute using the first validation rule, Using the first condition for the first attribute, generate a query for one or more valid values, This includes executing the generated query to obtain one or more valid values ​​for the first attribute, Identifying, Assigning a value to the first attribute in the first data entity instance according to an input indicating a selection of at least one of the one or more valid values ​​for the first attribute, including assigning the selected at least one valid value to the first attribute. A method that includes performing [something].

2. Using the first condition for the first attribute that depends on the second attribute, generating the query for one or more valid values ​​for the first attribute is: Identifying the current value assigned to the second attribute within the first data entity instance, The query is generated using the current value of the second attribute in the first data entity instance, The method according to claim 1, including the method described in claim 1.

3. The current value assigned to the second attribute in the first data entity instance is an instance of the second data entity, and generating the query based on the current value assigned to the second attribute of the first data entity is: Accessing at least one attribute from the second data entity, The query is generated based on the at least one attribute value from the instance of the second data entity, The method according to claim 2, including the method described in claim 2.

4. The at least one validation rule includes a plurality of validation rules associated with each attribute of the first data entity, Identifying the first validation rule among the plurality of validation rules based on the relationship between the first validation rule and the first attribute. The method according to claim 1, further comprising:

5. The first validation rule includes a second condition for the first attribute, and generates a query for the one or more valid values. The first part of the query is generated based on the first condition for the first attribute, The second part of the query is generated based on the second condition for the first attribute, The method according to claim 1, including the method described in claim 1.

6. Using the first condition described above to generate the query for the one or more valid values ​​is, Converting the first condition for the first attribute into a query search condition, The aforementioned query search conditions are incorporated into the query, The method according to claim 1, including the method described in claim 1.

7. The method according to claim 1, wherein assigning the value to the first attribute in the first data entity instance includes assigning an instance of a second data entity to the first attribute in the first data entity instance.

8. The method according to claim 7, wherein generating the query for the one or more valid values ​​using the first condition for the first attribute includes generating a query for instances of the second data entity, and executing the generated query to obtain the one or more valid values ​​for the first attribute includes executing the generated query for a subset of data consisting of instances of the second data entity.

9. The method according to claim 1, wherein the first attribute indicates an owner, access security level, data source, or data format associated with the first data entity instance.

10. The method according to claim 1, wherein the first data entity instance stores information about a software application or dataset as attribute values ​​in the first data entity instance.

11. The method according to claim 10, wherein the first attribute indicates a data source or data format that will be used by the software application when attempting to invoke a certain function of the software application, and the one or more valid values ​​are suitable for invoking the function of the software application.

12. The method according to claim 10, wherein the first attribute indicates an access security level associated with the dataset which will be used when attempting to provide access to the dataset, and the one or more valid values ​​are one or more access security levels which provide access to the dataset.

13. To send to a client device the instruction for one or more valid values ​​for the first attribute, to be displayed within a graphical user interface (GUI), The client device receives the input through the GUI indicating the selection of at least one of the one or more valid values ​​for the first attribute, The method according to claim 1, further comprising:

14. The method according to claim 1, wherein identifying the one or more valid values ​​for the first attribute includes identifying one or more instances of a second data entity as the one or more valid values ​​for the first attribute.

15. The first validation rule includes a second condition for the first attribute, Identifying one or more valid values ​​using the first validation rule described above means that the query can be performed as follows: The first query search condition is generated using the first condition for the first attribute, To generate a second query search condition using the second condition for the first attribute. The method according to claim 1, further comprising generating by

16. Using the first validation rule of the war chronicle, identify one or more invalid values ​​for the aforementioned first attribute, To prevent the transmission of one or more invalid values, The method according to claim 1, further comprising:

17. A system for performing valid data allocation in a data processing system configured to process data updated by user devices and / or computer processes, wherein the data processing system is a system for storing the data using data entities and instances thereof, At least one computer hardware processor, At least one non-temporary computer-readable storage medium for storing an assignment validation module, wherein the assignment validation module includes a rule selection component, a query generation component, and a query execution component. Includes, The at least one computer hardware processor executes the assignment validation module as follows: The assignment validation module receives a request to assign a value to the first attribute of the first data entity instance of the first data entity, The first data entity includes a plurality of attributes, including the first attribute and the second attribute. The first data entity is associated with at least one validation rule that must be met for an attribute value in an instance of the first data entity to be valid, the at least one validation rule includes a first validation rule associated with the first attribute, and the first validation rule specifies a first condition for the first attribute that depends on the second attribute. Receiving and Identifying one or more valid values ​​for the first attribute using the rule selection component and the first validation rule, Using the query generation component, generate a query for one or more valid values ​​that uses the first condition for the first attribute, This includes using the query execution component to execute the generated query and obtain one or more valid values ​​for the first attribute, Identifying, Assigning a value to the first attribute of the first data entity instance in accordance with an input indicating a selection of at least one of the one or more valid values ​​for the first attribute, comprising assigning the selected one or more valid values ​​to the first attribute, Assign A system programmed to perform a certain action.

18. The data processing system stores data using data entities and instances thereof in at least one non-temporary computer-readable storage medium which stores instructions causing the at least one computer hardware processor to perform a method of performing a data allocation valid in data processing configured to process data updated by user devices and / or computer processes, and the method is The data processing system receives a request to assign a value to a first attribute within a first data entity instance of a first data entity, The first data entity includes a plurality of attributes, including the first attribute and the second attribute. The first data entity is associated with at least one validation rule that must be met for an attribute value in an instance of the first data entity to be valid, the at least one validation rule includes a first validation rule associated with the first attribute, and the first validation rule expresses a first condition for the first attribute that depends on the second attribute. Receiving and Identifying one or more valid values ​​for the first attribute using the first validation rule, Using the first condition for the first attribute, generate a query for one or more valid values, Execute the generated query to obtain one or more valid values ​​for the first attribute, Including identification, Assigning a value to the first attribute in the first data entity instance according to an input indicating a selection of at least one of the one or more valid values ​​for the first attribute, including assigning the selected at least one valid value to the first attribute; A non-temporary computer-readable memory field containing at least one such field.

Images