Database fault self-recovery method and system based on frequent item set optimization

Abstract

The invention provides a database fault self-healing method and system based on frequent item set optimization, and provides a self-healing mechanism based on hierarchical optimization and a particle swarm optimization algorithm in order to overcome the defect that an existing fault self-healing system lacks fault priority ranking and deep fault correlation analysis. Through hierarchical optimization of the core target and the auxiliary target, the system can dynamically sort according to the fault severity and the self-healing effect, key faults are preferentially processed, and the self-healing efficiency is improved. Meanwhile, frequent item set mining and a particle swarm optimization algorithm are introduced, potential relevance between alarms is deeply mined, a fault root cause recognition and repair strategy is optimized, processing only aiming at presentation alarms is avoided, and the repair effect of the system on complex faults is improved. According to the method, intelligent scheduling of the self-healing task and dynamic adjustment of the global optimal solution are realized, and the reliability and adaptability of the fault self-healing system are improved.

Description

Technical Field

[0001] The present invention relates to a database fault self-healing method and system based on frequent item set optimization, and belongs to the field of database intelligent operation and maintenance. Background Art

[0002] As the scale of data becomes larger and larger, the pressure on database operation and maintenance gradually increases. The existing traditional operation and maintenance methods mainly rely on manual fault diagnosis and processing. After the system alarm occurs, the operation and maintenance personnel need to manually analyze the alarm information, find the root cause of the fault, and formulate corresponding solutions. This manual intervention mode is not only time-consuming, but also easily affected by subjective judgment, resulting in inefficient fault handling, and may even delay the resolution of key issues, affecting system stability and business continuity.

[0003] The emergence of intelligent operation and maintenance systems has largely solved the above problems. Fault self-healing technology is a key link in intelligent operation and maintenance systems. Fault self-healing provides solutions to database system alarms through automated processes such as automatic detection, diagnosis, and fault handling, reducing the system's dependence on manual work, speeding up fault recovery, and improving the accuracy of fault handling. The fault self-healing system can quickly diagnose the fault after the alarm is triggered, and perform repair operations according to the preset self-healing strategy, realizing the full process automation from fault detection to repair, significantly improving the overall operation and maintenance efficiency. However, the existing fault self-healing system still faces some challenges when facing complex and diverse fault scenarios, including:

[0004] 1. Most existing fault self-healing systems rely on preset self-healing rules, which are usually formulated based on the experience of operation and maintenance experts. However, when multiple alarms occur in the system, the existing self-healing system lacks an effective fault priority sorting mechanism and cannot reasonably allocate processing priorities according to the severity of the fault and the impact on the system. Minor faults and serious faults will cause system maintenance congestion, delay the repair time of key faults, and thus reduce the overall self-healing efficiency of the system.

[0005] 2. The fault self-healing system can accurately identify faults and take targeted repair measures. At present, the system usually only processes the superficial alarms, ignoring the deeper fault correlation behind the alarms, and cannot effectively infer the root cause of the superficial faults. This limitation makes it difficult for the fault self-healing system to achieve the best repair effect when dealing with complex faults, increasing the possibility of repeated faults.

[0006] Therefore, how to optimize the fault self-healing system and improve its fault identification capability and processing efficiency has become an urgent problem to be solved in the current intelligent operation and maintenance field. BRIEF DESCRIPTION OF THE DRAWINGS

[0007] Figure 1 This is the flow chart of the fault self-healing system.

[0008] Figure 2 Flowchart of the frequent itemset mining algorithm. Summary of the invention

[0009] In order to solve the technical problems existing in the prior art, the present invention proposes a database fault self-healing method based on frequent item set optimization for the system fault detected by the anomaly detection system, and the method comprises the following steps:

[0010] (1) Associate candidate faults, by analyzing the correlation of abnormal indicators, revealing the correlation between all abnormal monitoring indicators;

[0011] (2) Formulate self-healing rules. Formulate fault self-healing rules based on alarm items and alarm item association rules;

[0012] (3) Feedback the self-healing results and record the processing results, including the person who processed the fault, the processing method, the processing time, and the processing status. After the fault processing is completed, the completion degree of the fault processing should be evaluated and the processing strategy should be fed back to the formulation of self-healing rules;

[0013] Among them, the frequent item set mining algorithm is used to associate candidate faults, and the candidate item sets of association relationships between all monitoring items are generated and sorted. In the subsequent self-healing operation, the fault self-healing of all alarms will be completed in sequence according to the priority order of the fault item set.

[0014] Furthermore, the frequent itemset mining algorithm includes:

[0015] 1.1 Generate candidate item sets. The system extracts possible frequent item sets from the data set and generates initial candidate item sets.

[0016] 1.2 Filter frequent item sets and identify item sets that contribute more to restoring system stability during the system self-healing process from candidate fault item sets;

[0017] 1.3 Optimize the sorting of frequent itemsets, use the particle swarm optimization algorithm to sort the itemsets according to their self-healing effects, and the self-healing system sorts the degree of system recovery according to the priority level;

[0018] 1.4 Iterate the frequent itemsets, repeat steps 1.2 and 1.3 until the expected number of iterations is reached or the fitness no longer changes significantly, and output the global best position gbest. According to the optimized sorting scheme, the system processes the frequent itemsets one by one according to the priority and performs the corresponding self-healing operation;

[0019] Furthermore, step 1.3 includes the following steps:

[0020] 1.3.1 Calculation Among them, k∈[1,l] is the particle dimension index; l∈[1,m] is the dividing point, defining the front and back parts of the particle dimension; m is the total number of particle dimensions; t and t+1 are the time steps of the current iteration and the next iteration respectively; are the velocity and new velocity of the i-th particle in the first l dimensions respectively; is the current position of the particle in the first l dimensions; ω is the inertia weight; c 1k ,c 2k As the learning factor, adjust the particle to its best position pbest ik and the global best position gbest k The degree of movement; r 1k ,r 2k is a random number;

[0021] 1.3.2 Calculation in, and are the initial velocity and new velocity of the ith particle in the last ml dimensions respectively; is the current position of the particle in the last ml dimensions;

[0022] 1.3.3 Calculate the next position x of the particle based on the velocities in the first l dimensions and the last ml dimensions i (t+1)=x i (t)+v i (t+1), where

[0023] Based on the above method, the present invention further proposes a database fault self-healing system based on frequent item set optimization, which includes:

[0024] (1) Candidate fault association module, which reveals the association between all abnormal monitoring indicators through correlation analysis of abnormal indicators;

[0025] (2) Self-healing rule formulation module, which formulates fault self-healing rules based on alarm items and alarm item association rules;

[0026] (3) Self-healing result feedback module, which records the processing results, including the person who processed the fault, the processing method, the processing time, and the processing status. After the fault processing is completed, the completion degree of the fault processing should be evaluated and the processing strategy should be fed back to the self-healing rule formulation module;

[0027] Among them, the candidate fault association module adopts the frequent item set mining algorithm to generate the candidate item sets of association relationships between all monitoring items and sort them. In the subsequent self-healing operation, the fault self-healing of all alarms will be completed in sequence according to the priority order of the fault item sets.

[0028] Furthermore, the frequent itemset mining algorithm includes:

[0029] 1.1 Generate candidate item sets. The system extracts possible frequent item sets from the data set and generates initial candidate item sets.

[0030] 1.2 Filter frequent item sets and identify item sets that contribute more to restoring system stability during the system self-healing process from candidate fault item sets;

[0031] 1.3 Optimize the sorting of frequent itemsets, use the particle swarm optimization algorithm to sort the itemsets according to their self-healing effects, and the self-healing system sorts the degree of system recovery according to the priority level;

[0032] 1.4 Iterate the frequent itemsets, repeat steps 1.2 and 1.3 until the expected number of iterations is reached or the fitness no longer changes significantly, and output the global best position gbest. According to the optimized sorting scheme, the system processes the frequent itemsets one by one according to the priority and performs the corresponding self-healing operation;

[0033] Furthermore, step 1.3 includes the following steps:

[0034] 1.3.1 Calculation Among them, k∈[1,l] is the particle dimension index; l∈[1,m] is the dividing point, defining the front and back parts of the particle dimension; m is the total number of particle dimensions; t and t+1 are the time steps of the current iteration and the next iteration respectively; are the velocity and new velocity of the i-th particle in the first l dimensions respectively; is the current position of the particle in the first l dimensions; ω is the inertia weight; c 1k ,c 2k As the learning factor, adjust the particle to its best position pbest ik and the global best position gbest k The degree of movement; r 1k ,r 2k is a random number;

[0035] 1.3.2 Calculation in, and are the initial velocity and new velocity of the ith particle in the last ml dimensions respectively; is the current position of the particle in the last ml dimensions.

[0036] 1.3.3 Calculate the next position x of the particle based on the velocities in the first l dimensions and the last ml dimensions i (t+1)=x i (t)+v i(t+1), where

[0037] In view of the defects of the existing fault self-healing system that lacks fault priority sorting and in-depth fault correlation analysis, the present invention proposes a self-healing mechanism based on hierarchical optimization and particle swarm optimization algorithm. Through the hierarchical optimization of core goals and auxiliary goals, the system can dynamically sort according to the severity of faults and self-healing effects, give priority to critical faults, and improve self-healing efficiency. At the same time, frequent item set mining and particle swarm optimization algorithms are introduced to deeply explore the potential correlation between alarms, optimize the identification and repair strategies of the root causes of faults, avoid only processing superficial alarms, and improve the system's repair effect on complex faults. This method realizes the intelligent scheduling of self-healing tasks and the dynamic adjustment of the global optimal solution, improving the reliability and adaptability of the fault self-healing system. DETAILED DESCRIPTION

[0038] Example 1

[0039] In the existing field of intelligent operation and maintenance of databases, the alarm item anomaly detection method has been gradually improved and matured. However, when a system alarm occurs, a large number of operation and maintenance personnel are required to find the cause of the fault and provide a solution. This method slows down the efficiency of the intelligent operation and maintenance system and is difficult to meet the requirements of efficient and stable operation. In order to solve this problem, the fault self-healing system came into being. The fault self-healing system automatically detects and handles faults, reduces manual intervention, greatly improves the speed and accuracy of alarm processing, and can perform diagnosis and recovery operations in time after the alarm is triggered, thereby improving the overall operation and maintenance efficiency and ensuring the stability and high availability of the system. The proposed fault self-healing system contains the following modules, see for details Figure 1 .

[0040] (1) Candidate fault association module

[0041] First, the candidate fault association module reveals the correlation between all abnormal monitoring indicators through correlation analysis of abnormal indicators. In the anomaly detection system, an abnormal indicator may be triggered by other indicators. Constructing candidate fault modes based on the mutual influence relationship of these indicators helps to infer more load fault scenarios and discover the root causes behind the superficial faults. This inference capability can guide the system to take more effective recovery measures and improve the efficiency of fault self-healing.

[0042] Specifically, the candidate fault association module uses a frequent item set mining algorithm to generate candidate item sets of association relationships between all monitoring items and sort them. In the subsequent self-healing operation, the fault self-healing of all alarms will be completed in sequence according to the priority order of the fault item sets. The frequent item set mining algorithm process is as follows: Figure 2 shown.

[0043] 1) Candidate item set generation

[0044] The system extracts possible frequent item sets from the data set and generates initial candidate item sets. The candidate item sets calculate the support of each item set by scanning the database, subject to the condition of meeting the minimum support threshold. For item sets that do not meet the threshold, the system will prune to avoid redundant calculations.

[0045] 2) Frequent item set screening

[0046] In the self-healing system, the goal of frequent item set screening is to identify those item sets that contribute more to restoring system stability during the system self-healing process from the candidate fault item sets. Through historical data analysis, the system can find frequently occurring fault types, evaluate the self-healing effects of these faults, and screen out key item sets that can significantly improve system recovery efficiency.

[0047] 3) Optimize the sorting of frequent itemsets

[0048] Furthermore, the present invention introduces the particle swarm optimization algorithm to utilize its optimization ability when screening frequent item sets, sorting the item sets according to their self-healing effects, and the priority level of the self-healing system will be sorted according to the degree of system recovery. The specific process is as follows:

[0049] Particle initialization: Each frequent item set is regarded as a particle. The position of each particle represents the priority of the item set in the sorting, and the speed represents the strength of adjusting the sorting.

[0050] Fitness function: The fitness function is used to evaluate the self-healing effect of frequent itemsets. The indicators of the fitness function include self-healing effect score, support frequency, and execution priority. The self-healing effect score comprehensively considers the repair success rate, repair time, and system stability.

[0051] Particle velocity update: The velocity of each particle is updated based on the current position, the individual best position (pbest), and the global best position (gbest).

[0052] Aiming at the conflict problem in multi-objective optimization, the present invention introduces a hierarchical optimization strategy, which divides the objective k into a core objective and an auxiliary objective. In the fault self-healing system, fault severity, system stability and self-healing effect are taken as core objectives, and resource consumption, optimization of self-healing task sequence and redundancy check are taken as auxiliary objectives. In the initial stage, only the core objective is optimized to find a set of candidate solutions, specifically Based on the candidate solution, an auxiliary objective is introduced and optimized twice:

[0053] Among them, t and t+1 represent the time steps of the current iteration and the next iteration respectively;

[0054] are the velocity and new velocity of the i-th particle in the first l dimensions respectively;

[0055] is the current position of the particle in the first l dimensions;

[0056] and are the initial velocity and new velocity of the ith particle in the last ml dimensions respectively;

[0057] is the current position of the particle in the last ml dimensions;

[0058] ω represents the inertia weight, which controls the influence of the particle's current velocity;

[0059] c 1k ,c 2k Represents the learning factor, which adjusts the particle to its best position pbest ik and the global best position gbest k the degree of movement;

[0060] r 1k ,r 2k Represents a random number, which increases the randomness of particle exploration.

[0061] Location Updates:

[0062] Update the particle position (sorting scheme) to x according to the new speed i (t+1)=x i (t)+v i (t+1), where Since the position represents the sorting scheme, the order needs to be adjusted through operations such as exchange and insertion during the update process.

[0063] 4) Frequent Itemset Iteration

[0064] Next, repeat the iteration and update until the expected number of iterations is reached or the fitness no longer changes significantly, and output the global best position gbest, that is, the optimized frequent item set priority ranking. According to the optimized ranking scheme, the system processes the frequent item sets one by one according to the priority and performs the corresponding self-healing operation.

[0065] (2) Self-healing rule making module

[0066] In the self-healing rule formulation module, fault self-healing rules are formulated for alarm items and alarm item association rules. Among them, self-healing rules include support from expert prior knowledge bases, fault diagnosis cases, etc., and built-in common operation and maintenance tasks are matched with corresponding alarm items. Users can also customize extended fault rules as needed and flexibly configure and enable them. The fault self-healing strategy is divided into two types: fully automatic self-healing and semi-automatic self-healing. Fully automatic self-healing includes alarm notification, automatic triggering of preset disposal, and notification of disposal results; semi-automatic self-healing includes alarm triggering, recommended alarm disposal actions, and manually triggered disposal. Operation and maintenance experts can manually trigger disposal according to the alarm content and recommended disposal actions, and can modify and improve disposal actions based on their own experience. The improved disposal actions will be fed back to the system to optimize the recommended disposal actions.

[0067] (3) Self-healing result feedback module

[0068] The processing results are recorded in the self-healing result feedback module, including the person who processed, the processing method, the processing time and the processing status. The processing status is divided into completed, failover and uncompleted. After the fault processing is completed, the completion of the fault processing should be evaluated. If the abnormal alarm value is restored and no new alarm is generated, it is marked as completed; if the current abnormal alarm value is restored but a new alarm item abnormality is generated and cannot be resolved by the self-healing rule, a rollback is triggered to restore to the original system state, and other self-healing solutions are considered and the self-healing rules are improved; finally, if the abnormal alarm value does not return to the normal threshold range, the processing strategy must also be modified, and the modified processing strategy should be fed back to the self-healing rule module.

[0069] Example 2

[0070] This system is suitable for large database server operation and maintenance scenarios. Large database servers use anomaly detection algorithms to detect abnormalities in various database monitoring items. Assume that the current database has an abnormal increase in database response time. The intelligent operation and maintenance system monitors various database performance indicators and detects multiple abnormal alarm items, including low buffer read rate, CPU utilization surge, query execution time timeout, etc. At this time, the fault self-healing system will automatically start and execute the following steps:

[0071] (1) Candidate fault association module:

[0072] By analyzing the historical data of database performance monitoring, the system extracts some possibly related abnormal alarm item sets. In this embodiment, it is assumed that the alarm items that appear include:

[0073] Buffer read efficiency is low

[0074] High CPU utilization

[0075] Query execution time timeout

[0076] Disk I / O wait time is too long

[0077] Step 1: Candidate item set generation

[0078] These alarm items are used to generate candidate item sets through the frequent item set mining algorithm. Assuming that the minimum support threshold we set is 0.15, the system generates the following candidate item sets by scanning the monitoring data and calculating the support:

[0079] {Buffer read rate is low, query execution time has timed out} S1 = 0.3

[0080] {CPU utilization is high, query execution time has timed out} S2 = 0.25

[0081] {Disk I / O waiting time is too long, query execution time has timed out} S3 = 0.28

[0082] {Buffer read rate is low, CPU utilization is high} S4 = 0.22

[0083] {Disk I / O waiting time is too long, CPU utilization is high} S5 = 0.18

[0084] Among them, S1~S5 represent the support degree.

[0085] Step 2: Frequent itemsets screening

[0086] Based on historical fault processing data, the system conducts a preliminary evaluation of the self-healing effect of each item set. The self-healing effect score defined here is based on the following criteria:

[0087] Fault repair success rate

[0088] Time required for repair

[0089] Stability after system recovery

[0090] Assume that the self-healing effect is scored as follows:

[0091] {Buffer read rate is low, query execution time has timed out} H1 = 0.7

[0092] {CPU utilization is high, query execution time has timed out} H2 = 0.65

[0093] {Disk I / O waiting time is too long, query execution time has timed out} H3 = 0.6

[0094] {Buffer read rate is low, CPU utilization is high} H4 = 0.5

[0095] {Disk I / O waiting time is too long, CPU utilization is high} H5 = 0.55

[0096] Among them, H1~H5 are the self-healing effect scores.

[0097] Step 3: Optimize the ranking of frequent itemsets

[0098] Next, the particle swarm optimization algorithm is used to sort these frequent item sets. Assume that the initial particle swarm is as follows, and the initial position and speed of the particle represent the priority of the item set in the sorting:

[0099] Particle 1 ({low buffer read rate, query execution timeout}) P1 = 0.8, V1 = 0.1

[0100] Particle 2 ({CPU utilization is high, query execution time has timed out}) P2 = 0.6, V2 = 0.05

[0101] Particle 3 ({Disk I / O waiting time is too long, query execution time has timed out}) P3 = 0.7, V3 = 0.008

[0102] Particle 4 ({low buffer read rate, high CPU utilization}) P4 = 0.5, V4 = 0.02

[0103] Particle 5 ({Disk I / O waiting time is too long, CPU utilization is high}) P5 = 0.4, V5 = 0.04

[0104] Among them, P1~P5 represent position, V1~V5 represent speed

[0105] Assume that the initial execution priorities of the five particles are 0.8, 0.6, 0.7, 0.5, and 0.4, respectively, and the weight coefficients of the self-healing effect score, support frequency, and execution priority are 0.5, 0.3, and 0.2, respectively. Then, the fitness function is calculated as follows:

[0106] Particle 1: F1 = 0.5 × 0.7 + 0.3 × 0.3 + 0.2 × 0.8 = 0.35 + 0.09 + 0.16 = 0.6

[0107] Particle 2: F2 = 0.5 × 0.65 + 0.3 × 0.25 + 0.2 × 0.6 = 0.325 + 0.075 + 0.12 = 0.52

[0108] Particle 3: F3 = 0.5 × 0.6 + 0.3 × 0.28 + 0.2 × 0.7 = 0.3 + 0.084 + 0.14 = 0.524

[0109] Particle 4: F4 = 0.5 × 0.5 + 0.3 × 0.22 + 0.2 × 0.5 = 0.25 + 0.066 + 0.1 = 0.416

[0110] ·Particle 5: F5=0.5×0.55+0.3×0.18+0.2×0.4=0.275+0.054+0.08=0.409

[0111] Next, the velocity and position are updated using the particle swarm optimization formula:

[0112] v1(t+1)=0.5·0.1+1.5·0.6·(0.8-0.8)+2.0·0.7·(0.85-0.8)

[0113] =0.05+0+0.07=0.12

[0114] x1(t+1)=0.8+0.12=0.92

[0115] Through iteration, particles gradually approach the optimal sorting position, and the final global best solution is gbest = 0.92.

[0116] The final ranking results of frequent itemsets are as follows:

[0117] {Buffer read rate is low, query execution time has timed out}

[0118] {Disk I / O wait time is too long, query execution time timeout}

[0119] ·{CPU utilization is high, query execution time has timed out}

[0120] {Buffer read rate is low, CPU utilization is high}

[0121] {Disk I / O wait time is too long, CPU utilization is high}

[0122] Finally, the system will search for solutions in the fault rules according to the sorting results. For the high-priority item set of "low buffer read rate" and "query execution time timeout", the system will first automatically perform the following operations:

[0123] Increased the shared buffer size of the database from 2GB to 4GB.

[0124] Optimize query plans and adjust SQL execution order.

[0125] Monitor disk I / O and restart the database instance when necessary to free up I / O resources.

[0126] Assume that during this process, the buffer read rate is successfully improved to a normal value and the query timeout problem is significantly improved. The system marks the fault handling as completed.

[0127] The units, devices or modules described in the above embodiments can be implemented by computer chips or entities, or by products with certain functions. For the convenience of description, the above devices are described separately by functions divided into various modules. Of course, when implementing this application, the functions of each module can be implemented in the same or more software and / or hardware, or the modules that implement the same function can be implemented by a combination of multiple sub-modules or sub-units. The device embodiments described above are only schematic. For example, the division of the units is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the coupling or direct coupling or communication connection between each other shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0128] Those skilled in the art also know that, in addition to implementing the controller in a purely computer-readable program code, the controller can be made to implement the same function in the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers by logically programming the method steps. Therefore, such a controller can be considered as a hardware component, and the devices for implementing various functions included therein can also be considered as structures within the hardware component. Or even, the devices for implementing various functions can be considered as both software modules for implementing the method and structures within the hardware component.

[0129] The present application may be described in the general context of computer-executable instructions executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, classes, etc. that perform specific tasks or implement specific abstract data types. The present application may also be practiced in distributed computing environments where tasks are performed by remote processing devices connected through a communication network. In a distributed computing environment, program modules may be located in local and remote computer storage media, including storage devices.

[0130] It can be known from the description of the above implementation methods that those skilled in the art can clearly understand that the present application can be implemented by means of software plus a necessary general hardware platform. Based on such an understanding, the technical solution of the present application can be essentially or partly contributed to the prior art in the form of a software product, which can be stored in a storage medium such as ROM / RAM, a magnetic disk, an optical disk, etc., and includes several instructions for enabling a computer device (which can be a personal computer, a mobile terminal, a server, or a network device, etc.) to execute the methods described in the various embodiments of the present application or certain parts of the embodiments.

[0131] The various embodiments in this specification are described in a progressive manner, and the same or similar parts between the various embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. The present application can be used in many general or special computer system environments or configurations. For example: personal computers, server computers, handheld devices or portable devices, tablet devices, multi-processor systems, microprocessor-based systems, set-top boxes, programmable electronic devices, network PCs, minicomputers, mainframe computers, distributed computing environments including any of the above systems or devices, etc.

[0132] The specific embodiments described above further illustrate the purpose, technical solutions and beneficial effects of the present application. It should be understood that the above description is only a specific embodiment of the present application and is not intended to limit the scope of protection of the present application. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present application should be included in the scope of protection of the present application.

Claims

1. A database fault self-healing method based on frequent item set optimization, the method comprising the following steps: (1) Associate candidate faults, by analyzing the correlation of abnormal indicators, revealing the correlation between all abnormal monitoring indicators; (2) Formulate self-healing rules. Formulate fault self-healing rules based on alarm items and alarm item association rules; (3) Feedback the self-healing results and record the processing results, including the person who processed the fault, the processing method, the processing time, and the processing status. After the fault processing is completed, the completion degree of the fault processing should be evaluated and the processing strategy should be fed back to the formulation of self-healing rules; The feature is that a frequent item set mining algorithm is used when associating candidate faults, and candidate item sets of association relationships between all monitoring items are generated and sorted. In subsequent self-healing operations, the fault self-healing of all alarms will be completed in sequence according to the priority order of the fault item sets.

2. A database fault self-healing method based on frequent itemset optimization as claimed in claim 1, characterized in that: The frequent itemset mining algorithm includes: 1.1 Generate candidate item sets. The system extracts possible frequent item sets from the data set and generates initial candidate item sets. 1.2 Filter frequent item sets and identify item sets that contribute more to restoring system stability during the system self-healing process from candidate fault item sets; 1.3 Optimize the sorting of frequent itemsets, use the particle swarm optimization algorithm to sort the itemsets according to their self-healing effects, and the self-healing system sorts the degree of system recovery according to the priority level; 1.4 Iterate the frequent itemsets, repeat steps 1.2 and 1.3 until the expected number of iterations is reached or the fitness no longer changes significantly, and output the global best position gbest. According to the optimized sorting scheme, the system processes the frequent itemsets one by one according to priority and performs corresponding self-healing operations.

3. A database fault self-healing method based on frequent itemset optimization as claimed in claim 2, characterized in that: Step 1.3 includes the following steps: 1.3.1 Calculation Among them, k∈[1,l] is the particle dimension index; l∈[1,m] is the dividing point, defining the front and back parts of the particle dimension; m is the total number of particle dimensions; t and t+1 are the time steps of the current iteration and the next iteration respectively; are the velocity and new velocity of the i-th particle in the first l dimensions respectively; is the current position of the particle in the first l dimensions; ω is the inertia weight; c 1k ,c 2k To learn the factor, adjust the particle to its best position pbest ik and the global best position gbest k The degree of movement; r 1k ,r 2k is a random number; 1.3.2 Calculation in, and are the initial velocity and new velocity of the ith particle in the last ml dimensions respectively; is the current position of the particle in the last ml dimensions; 1.3.3 Calculate the next position x of the particle based on the velocities in the first l dimensions and the last ml dimensions i (t+1)=x i (t)+v i (t+1), where 4. A database fault self-healing system based on frequent item set optimization, the system comprising: (1) Candidate fault association module, which reveals the association between all abnormal monitoring indicators through correlation analysis of abnormal indicators; (2) Self-healing rule formulation module, which formulates fault self-healing rules based on alarm items and alarm item association rules; (3) Self-healing result feedback module, which records the processing results, including the person who processed the fault, the processing method, the processing time, and the processing status. After the fault processing is completed, the completion degree of the fault processing should be evaluated and the processing strategy should be fed back to the self-healing rule formulation module; The feature is that the candidate fault association module adopts a frequent item set mining algorithm to generate candidate item sets of association relationships between all monitoring items and then sort them. In the subsequent self-healing operation, the fault self-healing of all alarms will be completed in sequence according to the priority order of the fault item sets.

5. A database fault self-healing system based on frequent itemset optimization as claimed in claim 4, characterized in that: The frequent itemset mining algorithm includes: 1.1 Generate candidate item sets. The system extracts possible frequent item sets from the data set and generates initial candidate item sets. 1.2 Filter frequent item sets and identify item sets that contribute more to restoring system stability during the system self-healing process from candidate fault item sets; 1.3 Optimize the sorting of frequent itemsets, use the particle swarm optimization algorithm to sort the itemsets according to their self-healing effects, and the self-healing system sorts the degree of system recovery according to the priority level; 1.4 Iterate the frequent itemsets, repeat steps 1.2 and 1.3 until the expected number of iterations is reached or the fitness no longer changes significantly, and output the global best position gbest. According to the optimized sorting scheme, the system processes the frequent itemsets one by one according to priority and performs corresponding self-healing operations.

6. A database fault self-healing system based on frequent itemset optimization as claimed in claim 5, characterized in that: Step 1.3 includes the following steps: 1.3.1 Calculation Among them, k∈[1,l] is the particle dimension index; l∈[1,m] is the dividing point, defining the front and back parts of the particle dimension; m is the total number of particle dimensions; t and t+1 are the time steps of the current iteration and the next iteration respectively; are the velocity and new velocity of the i-th particle in the first l dimensions respectively; is the current position of the particle in the first l dimensions; ω is the inertia weight; c 1k ,c 2k To learn the factor, adjust the particle to its best position pbest ik and the global best position gbest k The degree of movement; r 1k ,r 2k is a random number; 1.3.2 Calculation in, and are the initial velocity and new velocity of the ith particle in the last ml dimensions respectively; is the current position of the particle in the last ml dimensions. According to the speed of the first l dimensions and the last ml dimensions, calculate the next position x of the particle i (t+1)=x i (t)+v i (t+1), where

Images