Data auditing method and device and computer program product

Abstract

The invention discloses a data auditing method and device and a computer program product, and relates to the technical field of data auditing. The data auditing method comprises the steps of obtaining to-be-audited data; analyzing the pre-configured relational expression information, and determining auditing information; determining an auditing task based on a demand and the auditing information; and performing auditing processing on the to-be-audited data based on the auditing task to obtain an auditing result. The problem that data auditing in related technologies limits the effectiveness of overall data auditing and the expansibility of a system is at least solved.

Description

Technical Field

[0001] This application relates to the field of data auditing technology, and in particular to a data auditing method, apparatus and computer program product. Background Technology

[0002] Data auditing is a systematic process of checking and correcting data errors to ensure data quality, consistency, and integrity. It is widely used in data governance, risk control, and other fields.

[0003] Currently, data auditing mainly relies on automation, but existing technologies suffer from structural complexity, code redundancy, and difficult-to-understand function logic. Audit control tables can only audit single attributes and cannot reflect the constraints between database tables, thus limiting the effectiveness of overall data auditing and the scalability of the system. Summary of the Invention

[0004] This application provides a data auditing method, apparatus, and computer program product to at least solve the problem that data auditing in related technologies limits the effectiveness of overall data auditing and the scalability of the system.

[0005] In a first aspect, embodiments of this application provide a data auditing method, including: Obtain the data to be audited; Parse the pre-configured relational information to determine the audit information; Based on the requirements and the audit information, the audit tasks are determined; Based on the audit task, the data to be audited is processed to obtain the audit results.

[0006] Secondly, embodiments of this application provide a data auditing device, including: The acquisition module is used to acquire the data to be audited. The parsing module is used to parse pre-configured relational information to determine audit information; The determination module is used to determine the audit task based on the requirements and the audit information; The audit module is used to perform audit processing on the data to be audited based on the audit task, and obtain the audit result.

[0007] Thirdly, embodiments of this application provide a computer program product, the computer program product including a computer program stored on a non-transitory computer-readable storage medium, the computer program including program instructions, which, when executed by a computer, implement the steps of the method described in the first aspect.

[0008] In this embodiment, the data to be audited is first obtained; then, the pre-configured relational information is parsed to determine the audit information; next, based on the requirements and audit information, the audit task is determined; finally, based on the audit task, the data to be audited is processed to obtain the audit result. This embodiment, by configuring relational expressions and tasks and implementing relational auditing according to user needs, frees the client from directly creating specific objects, allowing them to simply use the objects, thus improving its scalability and maintainability. Attached Figure Description

[0009] The accompanying drawings, which are included to provide a further understanding of this application and form part of this application, illustrate exemplary embodiments and are used to explain this application, but do not constitute an undue limitation of this application. In the drawings: Figure 1 This is a flowchart of the data auditing method provided in the embodiments of this application; Figure 2 This is a flowchart illustrating the relational management process provided in an embodiment of this application; Figure 3 This is a schematic diagram of the data auditing device provided in the embodiments of this application; Figure 4 This is a schematic diagram of the structure of the electronic device provided in the embodiments of this application. Detailed Implementation

[0010] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0011] The terms "first," "second," etc., used in the specification and claims of this application are used to distinguish similar objects and not to describe a specific order or sequence. It should be understood that such use of data can be interchanged where appropriate so that embodiments of this application can be implemented in orders other than those illustrated or described herein. Furthermore, in the specification and claims, "and / or" indicates at least one of the connected objects, and the character " / " generally indicates that the preceding and following objects are in an "or" relationship.

[0012] Data auditing in related technologies utilizes data audit control tables to process the data to be audited. Its audit granularity is limited to a specific attribute of a database table, allowing auditing only for each attribute individually and failing to reflect the overall constraints between database tables. During data synchronization from a data source address to a data target address, a portion of the data sent by the data source address and a portion of the data received by the data target address are acquired according to a preset ratio. Based on data volume matching rules, the sent and received data are matched to obtain a matching result. Finally, a data sampling audit algorithm is used to sample and audit the sent and received data to obtain the audit result. This structure is complex and reduces the system's scalability and maintainability. By building a knowledge base to store the company's financial and audit policies and regulations, standard templates for various economic transactions in financial activities, and problem cases found during audits, it is convenient for departmental financial personnel to access these resources in real time during daily economic transactions. This allows them to find standard templates for standardized operations, and the problem cases help them to focus on relevant issues and proactively avoid them. However, this approach involves complex function logic, making the functions themselves difficult to understand, and it does not reflect the constraints between data entities at the business level.

[0013] To address the shortcomings of current data auditing methods, which only audit individual attributes and fail to reflect the overall constraints between database tables, resulting in complex structures, reduced system scalability and maintainability, and complex and difficult-to-understand function logic, this application establishes an information model and data model based on relational expressions. It designs methods for writing and reading XML parsing, standardizing the audit relational expressions in XML, making the auditing method more universal. The application also restructures audit task management and audit result display, improving scalability and maintainability. Furthermore, it proposes an improved data acquisition and analysis model based on heterogeneous data sources, enhancing the scalability, maintainability, and comprehensibility of data analysis.

[0014] The following is in conjunction with the appendix Figures 1 to 4 This application provides a detailed description of a data auditing method, apparatus, and computer program product through specific embodiments and application scenarios.

[0015] like Figure 1 The diagram shown is a flowchart of a data auditing method provided in an embodiment of this application. Figure 1 As shown, the data auditing method may include the contents shown in S101 to S104.

[0016] In S101, obtain the data to be audited.

[0017] Among them, the data to be audited can be collected through a data collection model, and the data collection model can adopt a data collection and analysis mode.

[0018] In one example, the data acquisition process can be as follows: First, CollectionTime creates a DataCollectionFactory instance; second, DataCollectionFactory calls the FileParser's fileReader() method to read file information; DataCollectionFactory performs corresponding data collection based on the read file information and stores the collected information in a file; then, DataCollectionFactory creates a DataAdapterFactory instance; DataCollectionFactory calls the FileParser's fileReader() method to read the result file information; finally, DataCollectionFactory stores the read information in the target data source according to the target format.

[0019] In S102, the pre-configured relational information is parsed to determine the audit information.

[0020] Among them, relational expressions are used to describe the logical relationships between data.

[0021] In S103, audit tasks are determined based on requirements and audit information.

[0022] Among them, demand refers to the actual needs of users, i.e., business personnel, that is, how to audit the data to be audited, such as auditing call detail records in the data to be audited.

[0023] In S104, based on the audit task, the audit data to be audited is processed to obtain the audit results.

[0024] In this embodiment, the data to be audited is first obtained; then, the pre-configured relational information is parsed to determine the audit information; next, based on the requirements and audit information, the audit task is determined; finally, based on the audit task, the data to be audited is processed to obtain the audit result. This embodiment, by configuring relational expressions and tasks and implementing relational auditing according to user needs, frees the client from directly creating specific objects, allowing them to simply use the objects, thus improving its scalability and maintainability.

[0025] In one example, the definition and configuration process of relations can be described in a relational management model, such as... Figure 2 As shown.

[0026] First, user configuration: Business personnel (i.e., users) submit relational expressions to the audit system. The relational expressions are in text form to users. For example, if a user submits the relational expression "Batch of call detail records = Number of valid call detail records + Number of erroneous call detail records", the system scans the relational expression text, records the relational expression text, and finds the data entity names from the relational expression text. Users specify the tuple description information of the data entities, and the system records this configuration information.

[0027] Secondly, relational information storage can record the relational information configured by the user, as well as the detailed information of the data entity tuples it contains, according to the characteristic data model.

[0028] During this process, relational information can be adjusted. That is, the data auditing method can also include: adjusting relational information, including adding, deleting and modifying relations.

[0029] The addition of relational relationships can include storing relational information in a database. The process is as follows: The user calls the Balance() method of Balance to create a Balance instance, which returns a value upon successful creation; the user calls the set() method of Balance to set basic relational information, including relation number, relation name, content, explanation information, script information, creator, etc.; the user calls the BalanceManage() method of BalanceManage to create a BalanceManage instance; the BalanceManage instance calls the DbMgr() method of DbMgr to create a DbMgr instance for connecting to the database; the user calls the createBalance() method of BalanceManage to add the Balance instance created above into the database; BalanceManage calls the free() method to release the DbMgr instance; BalanceManage returns the success or failure information of the database operation to the user through the result variable.

[0030] Relation deletion can include removing unwanted relations from the database. The specific process is as follows: The user calls the BalanceManage() method to create a BalanceManage instance; the BalanceManage instance calls the DbMgr() method to create a DbMgr instance for connecting to the database; the user calls the BalanceManage() method to search for all relations in the database and calls the Balance() method to create a Balance instance to display to the user; the user selects the Balance information to be deleted and removes the relation information from the database by calling the BalanceManage() method; BalanceManage calls the free() method to release the DbMgr instance; BalanceManage returns the success or failure information of the database operation to the user through the result variable.

[0031] Relational modification can include modifying existing relations in the database. The specific process is as follows: The user calls the `BalanceManage()` method of `BalanceManage` to create a `BalanceManage` instance; the `BalanceManage` instance calls the `DbMgr()` method of `DbMgr` to create a `DbMgr` instance, which is used to connect to the database; the user calls the `searchBalance()` method of `BalanceManage` to find all relations in the database, and then calls the `Balance()` method of `Balance` to create a `Balance` instance to display to the user; the user selects the `Balance` information to modify and calls the `set()` method of `Balance` to reset the relation information. Modifiable relation information includes relation name, content, explanation information, script information, and modifier. The user calls the `modifyBalance()` method of `BalanceManage` to update the relation information; `BalanceManage` calls the `free()` method to release the `DbMgr` instance; `BalanceManage` returns the success or failure information of the database operation to the user through the `result` variable.

[0032] Next, write parsing, that is, the system parses the relational information it records and its corresponding data entity configuration information, extracts the audit information, including relation symbols, relational functions, operation order, data entity configuration information, etc., and automatically generates XML format files for relational instances according to specific schema specifications. XML is a standardized data description format, which can realize standardized sharing of audit information within and between systems.

[0033] In one example, parsing pre-configured relational information to determine audit information may include: parsing the data entity configuration information in the pre-configured relational information, extracting audit information, which includes at least relation symbols, relation functions, operation order, and data entity configuration information; and converting the audit information into an XML format file.

[0034] The detailed algorithm process for parsing is as follows: Instantiate an XML document object `Document doc = Document.Factory.newInstance()`; create a relational element object `Balance balance = doc.addNewbalance()`; extract the relation symbols from the relational text and set the relation symbols for the relational object `balance.setRelation()`; parse the expression on the left side of the relation symbol; parse the expression on the right side of the relation symbol. In one instance, parsing the data entity configuration information in the pre-configured relational information to extract audit information may include: obtaining the relation symbols from the relational text; parsing the expressions on the left and right sides of the relation symbols respectively to obtain the audit information.

[0035] In one example, the steps for parsing an expression are as follows: Create an empty queue to store operator characters or data entity name strings; create an empty stack to store objects of type ExpressionType; convert the expression from an infix expression of relational text to a prefix expression, and while forming the prefix expression, enqueue each element of the prefix expression in turn. The elements in the queue may include relational function operators and data entity names; create an expression object ExpressionType exp = new ExpressionType(), and push exp onto the stack.

[0036] In one example, an expression object `ExpressionType exp = stack.pop()` is popped from the stack; an element is removed from the queue, and if the element type is an operator, the operation function symbol of the expression object `exp` is set to that operator `exp.setOperation()`; a sub-expression `ExpressionType expB = exp.addNewExpression()` is created for the right side of the operator on the `exp` object; `expB` is pushed onto the stack; a sub-expression `ExpressionType expA = exp.addNewExpression()` is created for the left side of the operator on the `exp` object; `expA` is pushed onto the stack. If the dequeued element is not an operator, it must be a data entity name. In this case, a new data entity object `DataelementType dataelement = exp.addNewDataelement()` is added to the expression object `exp`; the configuration information of the data entity object is set using `Dataelement.setDataelement()`.

[0037] Then, the system automatically reads the XML file, parses out the audit information, and obtains a relational instance. This information forms the basis for the actual audit of the data.

[0038] In one example, determining the audit task based on requirements and audit information may include: obtaining an XML format file; parsing the audit information in the XML format file to obtain relational text; determining the basic information of the audit task based on requirements, which includes at least the task name, task number, relational text contained in the task, and task start time; selecting the target relational text based on the basic information of the audit task; and determining the audit task based on the target relational text and the basic information.

[0039] The detailed algorithm process for parsing is as follows: Obtain a reference to the document object from the XML file: `Document doc = Document.Factory.parse(xmlFile)`; Obtain the relational object `BalanceType balance = doc.getBalance()`; Extract the relational text from the `Balance` object: `balance.getRelation()`; Obtain the left expression of the relational object: `exp = balance.getExpressionArray`. The expression `exp` is parsed to obtain the expression text, along with detailed tuple descriptions of each data entity. The expression text is then transformed from a prefix expression to an infix expression. Finally, the right expression of the relational object, `exp = balance.getExpressionArray`, is obtained. The expression exp is parsed to obtain the expression text, and detailed tuple descriptions of each data entity are also parsed out. The expression text is transformed from a prefix expression to an infix expression. The infix text of the left expression, the relation symbol, and the infix text of the right relation are concatenated to obtain the relation text.

[0040] Furthermore, parsing the audit information in the XML format file to obtain relational text can include: obtaining relational objects from the XML format file; obtaining relation symbol text based on the relational objects; obtaining the left and right expressions of the relational objects based on the relation symbol text; parsing the left and right expressions to obtain left expression text and right expression text; and concatenating the left expression text, relation symbol text, and right expression text to obtain the relational text.

[0041] The parsing method for the left and right expressions is as follows: Create an empty queue to store the prefix expression text, including metaoperation symbols and data entity names; create an empty stack to store objects of type ExpressionTyp in XML; push the expression exp onto the stack; pop the expression object ExpressionType exp from the stack; if (exp.getExpressionArray().size=0), then retrieve the child element of the expression object exp, whose type must be data entity DataelementType; DataelementType dataelement=exp.getDataelement(); retrieve the entity name of the data entity String name=datalement.getName(); add the data entity name string to the queue queue.add(name); read the detailed tuple description information of the data entity dataelement.getDetail(). Otherwise, read the operator text of the expression object exp: String operation = exp.getOperation(); add the text to the queue: queue.add(operation); create a new right sub-expression object of exp: ExpertiseType expB = exp.getExpressionArray(1), and push expB onto the stack; create a new left sub-expression object of exp: ExpertiseType expB = exp.getExpressionArray(0), and push expB onto the stack.

[0042] Finally, relational information is used, namely, generating audit scripts and sharing audit information based on the audit information obtained from reading and parsing.

[0043] In one possible implementation of this application, the data auditing method may further include: managing auditing tasks, including task customization, task modification, and task deletion.

[0044] Task customization involves configuring basic task information such as task name, task number, relational expressions, and start time, and storing this information in the corresponding database table. Task deletion refers to removing a task from the system when it is no longer needed. Tasks cannot be deleted while in an active state. After deletion, all previously executed results of the task should also be removed from the database. Task modification involves altering the basic state of a specified task. Modification requires setting the task state to invalid, then restoring it to active after modification. Furthermore, tasks cannot be modified while in an executing state.

[0045] In one example, the task customization process is as follows: The user calls the `TaskManage()` method of `TaskManage` to create a `TaskManage` instance; the `TaskManage` instance calls the `DbMgr()` method of `DbMgr` to create a `DbMgr` instance for connecting to the database; the user calls the `createTask()` method of `TaskManage` to create a `Task` instance, the specific type of which is either `ScheduleTask` (scheduled task) or `InstanceTask` (instance task); the user calls the `set()` method of `Task` to set properties for the `Task` instance; the user calls the `getBalanceInfoFromDb()` method of `TaskManage` to read existing relational information from the database and displays it to the user; the user selects the required relation and calls the `TaskBalance()` method of `TaskBalance` to create a `TaskBalance` instance; the user calls the `set()` method of `TaskBalance` to configure the selected relational information into the `TaskBalance` instance, including the city information where the relation runs, whether there is a billing period, etc.; the user calls the `set()` method of `Task` to continue configuring the `Task`'s properties; this is used to call `TaskManage()`. The `taskInfoToDb()` method of `TaskManage` adds basic task information to the database; users call the `taskBalanceToDb()`, `taskBalanceStateToDb()`, `taskCityState()`, and `taskStateToDb()` methods of `TaskManage` to store relational information, relational state information, city state information, and task state information related to the task into the corresponding information tables in the database; users call the `createJob()` method of `TaskManage` to create the stored procedure required for task scheduling and the parameter information required for execution; users call the `executeJob()` method of `TaskManage` to execute the created task; `TaskManage` calls the `free()` method to release the `DbMgr` instance.

[0046] In one example, the task deletion process is as follows: The user selects the task to be deleted and calls the `Task()` method of `Task` to create an instance; the user calls the `TaskManage()` method of `TaskManage` to create a `TaskManage` instance; the `TaskManage` instance calls the `DbMgr()` method of `DbMgr` to create a `DbMgr` instance for connecting to the database; the user calls the `isValid()` method of `TaskManage` to read the task's status information from the database and determine the task's status; only tasks in an invalid state can be deleted; the user calls the `hasResult()` method of `TaskManage` to determine if the task has a corresponding audit result; if not, it can be deleted directly; if so, the result should also be deleted; the user calls the `deleteTask()` method of `TaskManage` to delete the relevant information of the selected task from the database, including basic task information, relational information included in the task, task status information, task relational status information, and task location status information; the user calls the `deleteResult()` method of `TaskManage` to delete the result information generated by the task from the database; `TaskManage` calls the `free()` method to release the `DbMgr` instance.

[0047] In one example, the task modification process is as follows: The user selects the task to be modified and calls the `Task()` method of `Task` to create an instance; the user calls the `TaskManage()` method of `TaskManage` to create a `TaskManage` instance; the `TaskManage` instance calls the `DbMgr()` method of `DbMgr` to create a `DbMgr` instance for connecting to the database; the user calls the `get()` method of `TaskManage` to read the task's status information from the database and determines whether the task is in an executing state. If it is, it cannot be modified; the user calls the `setEnvalid()` method of `TaskManage` to set the task status to invalid; the user calls the `modifyTask()` method of `TaskBalance` to modify the task's relevant information; after modification, the user calls the `setValid()` method of `TaskManage` to set the task status back to valid; `TaskManage` calls the `free()` method to release the `DbMgr` instance.

[0048] In one possible implementation of this application, the data auditing method may further include: displaying the audit results.

[0049] The results display function presents the audit results to the user, and its main function is to query the results.

[0050] In one example, the result display process is as follows: The user enters information such as the task number and task execution time to be queried on the page; the user calls the `create()` method of `ResultFactory` to create a `ResultFactory` instance; the `Result` instance calls the `DbMgr()` method of `DbMgr` to create a `DbMgr` instance for connecting to the database; the `Result` instance calls its own `querySummaryResult()` method to read the summary result information from the database and displays this information to the user; the user selects a record in the summary information and obtains the task number, city number, and task start time using the `get()` method; the `Result` instance calls its own `queryDetailResult()` method to read the detailed result information of the corresponding summary record from the database and displays this information to the user; the `Result` instance calls the `free()` method to release the `DbMgr` instance.

[0051] This application's embodiments are based on relational programming, designing methods for writing and reading XML parsing, achieving XML standardization of audit relational programming, and making the audit methods more universal. Furthermore, the audit task management and audit result display have been refactored, designing a parent class `Task` to manage common functionalities of instant tasks `InstanceTask` and scheduled tasks `ScheduleTask`, eliminating code duplication between instant and scheduled tasks. The `TaskManage` class is responsible for creating concrete instances of the `Task` class, `ScheduleTask` objects, and `InstanceTask` objects, thus freeing the client from directly creating concrete objects and allowing them to simply use the objects, improving its extensibility and maintainability.

[0052] like Figure 3 The diagram shown is a schematic representation of a data auditing device provided in an embodiment of this application. Figure 3 As shown, the data auditing device may include: an acquisition module 301, a parsing module 302, a determination module 303, and an auditing module 304.

[0053] The module includes an acquisition module 301 for acquiring data to be audited; a parsing module 302 for parsing pre-configured relational information to determine audit information; a determination module 303 for determining audit tasks based on requirements and the audit information; and an audit module 304 for performing audit processing on the data to be audited based on the audit tasks to obtain audit results.

[0054] In this embodiment, the acquisition module 301 first acquires the data to be audited; the parsing module 302 parses the pre-configured relational information to determine the audit information; then, the determination module 303 determines the audit task based on the requirements and the audit information; finally, the audit module 304 performs audit processing on the data to be audited based on the audit task to obtain the audit result. This embodiment, by configuring relational expressions and tasks and implementing relational auditing according to user needs, frees the client from directly creating specific objects, allowing them to simply use the objects, thus improving its scalability and maintainability.

[0055] In one possible implementation of this application, the parsing module 302 is used to: parse the data entity configuration information in the pre-configured relational information, extract audit information, the audit information including at least relation symbols, relation functions, operation order, and data entity configuration information; and convert the audit information into an XML format file.

[0056] In one possible implementation of this application, the parsing module 302 is used to: obtain relation symbols in relational text; and parse the expressions on the left and right sides of the relation symbols respectively to obtain audit information.

[0057] In one possible implementation of this application, the determining module 303 is configured to: obtain an XML format file; parse the audit information in the XML format file to obtain relational text; determine the basic information of the audit task based on the requirements, wherein the basic information includes at least the task name, task number, relational text contained in the task, and task start time; select a target relational text based on the basic information of the audit task; and determine the audit task based on the target relational text and the basic information.

[0058] In one possible implementation of this application, the determining module 303 is configured to: obtain a relational object from the XML format file; obtain relation symbol text based on the relational object; obtain the left expression and right expression of the relational object based on the relation symbol text; parse the left expression and the right expression to obtain left expression text and right expression text; and concatenate the left expression text, the relation symbol text, and the right expression text to obtain relational text.

[0059] In one possible embodiment of this application, the data auditing device may further include an adjustment module.

[0060] The adjustment module is used to adjust the relation information, including adding, deleting, and modifying relations.

[0061] In one possible implementation of this application, the data auditing device may further include a management module.

[0062] The management module is used to manage the audit tasks, including task customization, task modification, and task deletion.

[0063] In one possible implementation of this application, the data auditing device may further include a display module.

[0064] The display module is used to display the audit results.

[0065] The data auditing device in this application already has the functionality of... Figures 1 to 2 The method embodiments shown are described in detail. Therefore, for any parts not covered in detail in this embodiment, please refer to the relevant descriptions in the foregoing embodiments, which will not be repeated here.

[0066] like Figure 4 As shown, this application embodiment also provides an electronic device 400, including a processor 401, a memory 402, and a program or instructions stored in the memory 402 and executable on the processor 401. When the program or instructions are executed by the processor 401, they implement the various processes of the above-described data audit processing method embodiment and achieve the same technical effect. To avoid repetition, they will not be described again here.

[0067] Optionally, embodiments of this application also provide a computer-readable storage medium storing a computer program. When executed by a processor, this computer program implements the various processes of the above-described data auditing method embodiments and achieves the same technical effects. To avoid repetition, it will not be described again here. The computer-readable storage medium may be a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, etc.

[0068] Optionally, this application embodiment also provides a computer program product, which includes a computer program stored on a non-transitory computer-readable storage medium. The computer program includes program instructions, which, when executed by a computer, implement the various processes of the above-described data auditing method embodiment and achieve the same technical effect. To avoid repetition, they will not be described again here.

[0069] It should be noted that, in this document, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or system that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or system. Unless otherwise specified, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or system that includes that element.

[0070] Through the above description of the embodiments, those skilled in the art can clearly understand that the methods of the above embodiments can be implemented by means of software plus necessary general-purpose hardware platforms. Of course, they can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, can be embodied in the form of a software product. This computer software product is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk) and includes several instructions to cause a terminal (which may be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in the various embodiments of this application.

[0071] The embodiments of this application have been described above with reference to the accompanying drawings. However, this application is not limited to the specific embodiments described above. The specific embodiments described above are merely illustrative and not restrictive. Those skilled in the art can make many other forms under the guidance of this application without departing from the spirit and scope of the claims, and all of these forms are within the protection scope of this application.

Claims

1. A data auditing method, characterized by, include: Obtain the data to be audited; Parse the pre-configured relational information to determine the audit information; Based on the requirements and the audit information, the audit tasks are determined; Based on the audit task, the data to be audited is processed to obtain the audit results.

2. The method according to claim 1, characterized in that, The step of parsing the pre-configured relational information to determine the audit information includes: Parse the data entity configuration information in the pre-configured relational information to extract audit information, which includes at least relation symbols, relation functions, operation order, and data entity configuration information. The audit information is converted into an XML format file.

3. The method according to claim 2, characterized in that, The step of parsing the data entity configuration information in the pre-configured relational information and extracting audit information includes: Retrieve relation symbols from relational text; The expressions on the left and right sides of the relation symbol are parsed to obtain audit information.

4. The method according to claim 1, characterized in that, The process of determining audit tasks based on requirements and audit information includes: Obtain XML format files; Parse the audit information in the XML format file to obtain relational text; Based on the requirements, determine the basic information of the audit task. The basic information includes at least the task name, task number, the relational expression contained in the task, and the task start time. Based on the basic information of the audit task, select the target relational text; Based on the target relational text and the basic information, the audit task is determined.

5. The method according to claim 4, characterized in that, The process of parsing the audit information in the XML format file to obtain relational text includes: Obtain the relational object from the XML format file; Based on the relational object, obtain the relational symbol text; Based on the relational symbol text, the left and right expressions of the relational object are obtained; The left expression and the right expression are parsed to obtain the left expression text and the right expression text; The left expression text, the relation symbol text, and the right expression text are concatenated to obtain the relation text.

6. The method according to claim 1, characterized in that, The method further includes: The relational information is adjusted, including adding, deleting, and modifying relations.

7. The method according to claim 1, characterized in that, The method further includes: The audit tasks are managed, including task customization, task modification, and task deletion.

8. The method according to claim 1, characterized in that, The method further includes: The audit results will be displayed.

9. A data auditing device, characterized in that, include: The acquisition module is used to acquire the data to be audited. The parsing module is used to parse pre-configured relational information to determine audit information; The determination module is used to determine the audit task based on the requirements and the audit information; The audit module is used to perform audit processing on the data to be audited based on the audit task, and obtain the audit result.

10. A computer program product, characterized in that, The computer program product includes a computer program stored on a non-transitory computer-readable storage medium, the computer program including program instructions that, when executed by a computer, implement the steps of the method as described in any one of claims 1 to 8.

Images