Database test result intelligent evaluation system based on big data

Abstract

The invention relates to the technical field of database test and performance evaluation, and discloses a database test result intelligent evaluation system based on big data, which comprises a data acquisition module, an intelligent analysis module, a scene adaptation module, an evaluation decision module and a display storage module. Executing double-flow parallel acquisition of multi-source heterogeneous data by the system, and aligning a performance index and a static execution plan by using a nearest neighbor maintenance strategy; constructing a fuzzy physical topological mask matrix by analyzing operator dependency and a state during operation, and generating a causal atlas by combining statistical association strength; a variational auto-encoder is used to identify a current service scene type to dynamically adjust an analysis strategy, and a root cause probability of an abnormal index is calculated based on a causal atlas. According to the method, by fusing physical topology prior and statistical causal inference, the problems of single test data dimension and difficulty in causal relationship identification are solved, and high-precision evaluation and adaptive tuning of database performance are realized.

Description

Technical Field

[0001] This invention relates to the field of database testing and performance evaluation technology, specifically to an intelligent evaluation system for database test results based on big data. Background Technology

[0002] As database system architectures evolve towards distributed and cloud-native architectures, the data generated by database testing exhibits characteristics of massive volume, multidimensionality, and heterogeneity. When performing performance evaluations and stress tests on database instances, it is typically necessary to concurrently process high-frequency resource performance metrics, discrete SQL execution logs, and complex execution plan data.

[0003] Existing database testing and evaluation techniques largely rely on statistical anomaly detection algorithms or preset static thresholds. These methods are typically limited to monitoring single-dimensional indicators or can only calculate the numerical linear correlation between indicators. However, given the complex logical dependencies and resource competition relationships between operators within a database, numerical correlations alone are insufficient to characterize the true causal logic. Lacking awareness of the database's internal execution logic and runtime resource topology, existing technologies struggle to accurately isolate the root causes of performance anomalies and their consequent cascading effects. They are easily influenced by external interference variables, leading to the establishment of erroneous causal connections and a high false positive rate in evaluation results.

[0004] Furthermore, the business scenarios supported by databases exhibit dynamic fluctuations, with different business load types showing significant differences in resource consumption patterns and performance. Existing evaluation systems often employ fixed strategy parameters or general models, lacking the ability to dynamically identify and adaptively match the characteristics of the current business scenario. When the characteristics of the test load drift or change, the fixed evaluation logic cannot be adjusted in a timely manner, making it difficult to accurately reflect the true performance bottlenecks of the database in specific scenarios and limiting the reference value of test results in guiding system optimization. Summary of the Invention

[0005] To address the shortcomings of existing technologies, this invention provides an intelligent evaluation system for database test results based on big data. This system solves the technical problem that existing database test evaluation technologies lack the ability to perceive the internal physical topology of the database and adapt to business scenarios, making it difficult to accurately distinguish between the root causes of performance anomalies and pseudo-causal connections under complex load environments.

[0006] To achieve the above objectives, the present invention provides the following technical solution:

[0007] This invention provides an intelligent evaluation system for database test results based on big data.

[0008] The system includes a data acquisition module configured to execute a dual-stream parallel acquisition strategy. For continuously changing performance metric sequences, this module performs high-frequency time-series acquisition; for discrete-triggered structured query language commands, the module captures the execution logic and calls the database kernel interpretation interface to obtain the static execution plan tree, synchronously reading the runtime global state counter. This module maintains an independent acquisition thread pool and shares the system clock source, using a timestamp alignment strategy to map the discrete static execution plan and runtime global state counter onto the timeline of the performance metric sequence, thereby outputting a raw dataset containing performance metrics, execution plans, runtime states, and configuration parameters.

[0009] The intelligent analysis module parses operator dependencies in the static execution plan and constructs a fuzzy physical topology mask matrix based on runtime state data. The construction process includes: establishing an operator resource affinity benchmark library and mapping operator nodes to initial resource affinity vectors; calculating the rate of change of the runtime global state counter within the sampling period and normalizing the rate of change to a resource calibration coefficient based on a pre-set abnormal behavior mapping table. When the state counter undergoes a sudden change, the initial resource affinity vector corresponding to the SQL instruction is nonlinearly corrected using the resource calibration coefficient to generate a dynamic resource feature matrix, and then the connection weights from load-type indicators to resource-type indicators are calculated. The system then weights and fuses the generated fuzzy physical topology mask matrix with the statistical correlation strength between indicators to generate a causal graph.

[0010] The scenario adaptation module extracts resource statistical features of performance metrics, load logic features of static execution plans, and historical topology propagation features, assembling them into an original state vector. This module utilizes a variational autoencoder network to map the high-dimensional original state vector to a low-dimensional latent space, performing exponentially weighted moving average processing and density-based clustering analysis on the mean vector. The module calculates the Euclidean distance and matching confidence between the current scenario vector and the centroids of historical scenario clusters to identify the current business scenario type, and retrieves the corresponding strategy parameter mapping template from a pre-built strategy library to dynamically adjust the computational logic of the intelligent analysis module. Furthermore, this module uses a nonlinear control law based on error feedback to calculate the parameter adjustment magnitude and, combined with physical boundary constraints obtained through hardware telemetry, generates verified atomic execution instructions.

[0011] This invention provides an intelligent evaluation system for database test results based on big data. It has the following beneficial effects:

[0012] 1. This invention constructs a fuzzy physical topology mask matrix, combining the operator logic of the static execution plan with the runtime state, thus overcoming the limitation of single statistical correlation in representing causal relationships. The system uses this matrix as a constraint to eliminate spurious causal connections caused by external variable interference, thereby accurately locating the root cause of performance anomalies in multidimensional indicators and improving the accuracy and interpretability of evaluation results under complex load environments.

[0013] 2. This invention achieves adaptive evaluation and security tuning based on business scenario identification. By identifying current load characteristics and dynamically matching evaluation strategies through algorithms, it solves the problem that fixed strategies cannot adapt to business load drift. Simultaneously, combined with physical boundary constraint verification and a stability risk assessment model, the system can automatically perform rollback when parameter adjustments trigger hard constraints, effectively ensuring operational stability while improving database performance.

[0014] 3. This invention employs a dual-stream parallel acquisition and time alignment strategy to achieve synchronous correlation between high-frequency performance metrics and discrete SQL execution logic, solving the problem of inconsistent analysis of heterogeneous data. Combined with an attention-based metadata feature fusion method, the system can effectively aggregate query context and system configuration features, further enhancing the model's ability to represent complex internal database operating states. Attached Figure Description

[0015] Figure 1 This is a schematic diagram of the system architecture of the present invention;

[0016] Figure 2 This is a schematic diagram of the method flow of the present invention;

[0017] Figure 3 This is a performance trend comparison chart of the present invention;

[0018] Figure 4 This is a comparison chart of the accuracy of root cause analysis under different fault scenarios of the present invention.

[0019] The module includes: 110, data acquisition module; 120, intelligent analysis module; 130, scene adaptation module; 140, evaluation and decision-making module; and 150, display and storage module. Detailed Implementation

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

[0021] See attached document Figure 1This invention provides an intelligent evaluation system for database test results based on big data, comprising: a data acquisition module 110, an intelligent analysis module 120, a scenario adaptation module 130, an evaluation decision module 140, and a display and storage module 150. The modules communicate with each other via a system bus or a standard data interface.

[0022] The data acquisition module 110 is configured to establish a connection with the database instance under test and execute a parallel acquisition task of multi-source heterogeneous data. The data acquisition module 110 includes a high-frequency time-series acquisition unit and an execution logic acquisition unit. The high-frequency time-series acquisition unit is used to acquire database runtime performance indicators at a preset sampling frequency. These performance indicators include throughput, response time, CPU utilization, memory page scan rate, and disk I / O rate. The execution logic acquisition unit is used to capture high-frequency structured query language statements within the test window, call the database kernel interpretation interface to obtain the static execution plan tree, synchronously read the database's internal global state counters, and output a raw dataset containing the performance indicator sequence, static execution plan, and runtime state data.

[0023] The intelligent analysis module 120 is connected to the data acquisition module 110, receiving the raw dataset and performing computational processing. The intelligent analysis module 120 is configured to perform signal denoising, standardized resampling, physical topology construction, statistical causal inference, and multi-dimensional feature fusion operations. Internally, the intelligent analysis module 120 integrates physical topology constraint logic, parses operator dependencies in the static execution plan, dynamically calibrates operator resource consumption characteristics using a global state counter, and generates a fuzzy physical topology mask matrix. The intelligent analysis module 120 calculates the statistical correlation strength between indicators and weightedly fuses the statistical correlation strength with the fuzzy physical topology mask matrix, outputting a final causal graph that excludes false causal relationships.

[0024] The scenario adaptation module 130 is connected to both the data acquisition module 110 and the intelligent analysis module 120. The scenario adaptation module 130 is configured to extract the test data load feature vector and use a density clustering algorithm to identify the current business scenario type. Based on the identification results, the scenario adaptation module 130 retrieves the corresponding parameter configuration file from a pre-set strategy library and dynamically loads the resource affinity vector baseline value, algorithm adjustment coefficient, and threshold parameters into the intelligent analysis module 120, adjusting the calculation logic of the intelligent analysis module 120.

[0025] The assessment and decision-making module 140 is connected to the intelligent analysis module 120 and receives the final causal graph. The assessment and decision-making module 140 is configured to calculate the root cause probability, impact range, and risk level of abnormal indicators based on the topological structure of the causal graph, and generate structured assessment result data.

[0026] The display storage module 150 is connected to the evaluation decision module 140 and the intelligent analysis module 120. The display storage module 150 is configured to persistently store the evaluation result data and causal graph, display the evaluation conclusions through a human-computer interaction interface, and support users to provide feedback and corrections to the evaluation parameters.

[0027] See attached document Figure 2 This invention provides an intelligent evaluation method for database test results based on big data, comprising the following steps:

[0028] First, the system initiates the data acquisition module 110 to execute a parallel acquisition task, simultaneously acquiring time-series performance indicator streams reflecting the database resource consumption status, as well as static execution plans and dynamic state counters reflecting the internal execution paths of the database within the same time window. Next, the intelligent analysis module 120 preprocesses the time-series performance indicator streams, using a discrete wavelet transform algorithm to separate high-frequency noise components in the signal, a median filtering algorithm to smooth the discrete input and output indicator data, and a linear interpolation algorithm to align heterogeneous frequency indicator data to a unified time axis, generating a standardized feature vector sequence. Subsequently, the intelligent analysis module 120 constructs a fuzzy physical topology mask matrix, parses the operators in the static execution plan and maps them to initial resource affinity vectors, reads the dynamic state counters, and when a discrepancy is detected between the runtime state and the static plan, corrects the resource affinity vector using the numerical deviation of the dynamic state counter. Based on the corrected resource affinity vector and the dependencies between operators, it calculates the physical correlation weights between indicators. Further, the intelligent analysis module 120 processes the standardized feature vector sequence... The system performs statistical analysis, dividing the time series into high-load and low-load groups based on the distribution of intervention variable values. It calculates the mean difference and variance ratio of each indicator under different groups, and derives the initial statistical causal strength value by combining dynamic lag window time series constraints. Then, the intelligent analysis module 120 performs multi-dimensional fusion calculation, extracting metadata features from database objects and calculating metadata association factors through a neural network model. It then calculates the statistical causal strength value, physical association weights in the fuzzy physical topology mask matrix, and metadata association factors according to a preset fusion model, generating the final causal association strength matrix and constructing a directed weighted causal graph. Simultaneously, the scenario adaptation module 130 monitors the input data feature distribution. When a change in the test scenario is detected, it determines the new scenario category through clustering matching and updates the resource mapping rules and fusion calculation parameters used in the intelligent analysis module 120. Finally, the evaluation and decision module 140 traverses the critical path based on the causal graph, identifies the root cause nodes leading to performance bottlenecks, calculates the comprehensive risk score for this test, and outputs the final test evaluation report through the display and storage module 150.

[0029] The data acquisition module 110 employs a dual-stream parallel acquisition strategy that decouples time-series metrics from execution logic. Given the difference between the high-frequency, continuous nature of performance metrics and the low-frequency, discrete nature of execution plans, to avoid metric sampling jitter caused by I / O blocking during single-threaded acquisition of the execution plan, the system constructs two independent data channels to maintain timestamp indexes separately, and uses zero-order hold logic to achieve time-domain alignment.

[0030] During the initialization phase, the data acquisition module 110 establishes transmission links between the database and the operating system, and configures a time-triggered timing acquisition thread pool and an event-polling logical capture thread pool, both sharing a nanosecond-level clock source. The module follows the Nyquist theorem and dynamically adjusts the sampling frequency based on the number of CPU cores, periodically reading indicator data to construct the original feature vector of each moment, while explicitly defining the composite indicators:

[0031] ;

[0032] In the formula: This represents the number of queries per second and the number of transactions per second. This represents the normalized CPU utilization, with values ​​ranging from 1 to 2. ; This indicates the memory stress index; This indicates disk I / O throughput utilization; This indicates the network card bandwidth utilization rate. Indicates the strength of the lock contention.

[0033] The execution logic and runtime state flow are collected in parallel with high-frequency data acquisition to obtain static structure and dynamic correction information for building the physical topology. First, the query summary table is monitored to filter SQL samples with the highest execution frequency (Top-10 to Top-50) or response times exceeding the P99 baseline by 1.5 times. Second, the interpretation interface is called to obtain the static execution plan, which includes operator type, object, and estimated row count. Finally, instance-level global state counters are read synchronously within the same window to correct static prediction deviations.

[0034] ;

[0035] In the formula: This represents the disk sort counter; This represents the disk temporary table counter; Indicates a range connection counter; This represents the full table scan counter. Finally, data buffering and alignment are performed. The data acquisition module 110 writes the generated high-frequency continuous sequence and low-frequency discrete events into the circular buffer respectively. The system uses a nearest neighbor hold strategy to process heterogeneous frequency data: for any given time... performance indicators Related distance time Recent timestamp The execution plan and state counter are used to map discrete logic states into background constraint signals on a continuous time axis.

[0036] The intelligent analysis module 120 receives the raw dataset output by the data acquisition module 110. Since different indicators in the raw dataset originate from different acquisition probes, issues such as misaligned timestamps, inconsistent sampling frequencies, and environmental noise interference exist. The intelligent analysis module 120 performs the following processing steps:

[0037] The system performs signal characteristic classification and processing logic decentralization. To avoid a single denoising algorithm destroying the physical characteristics of different types of indicators, the system first classifies the indicators based on their physical attributes. The system divides the input indicator set into a continuous state indicator set. With discrete event indicator set . It includes metrics that have long-term correlation and continuous fluctuation characteristics, such as CPU utilization and memory usage. It includes metrics with bursty and sparse characteristics, such as disk read / write operations per second, network packet count, and lock wait count.

[0038] Perform multi-scale adaptive denoising based on discrete wavelet transform. For Continuous index sequence By utilizing the localization properties of wavelet transform in the time-frequency domain, the true variations (low frequencies) in a signal are separated from random noise (high frequencies). Specifically, this includes:

[0039] Multi-scale decomposition. The Daubechies wavelet system is selected as the basis function for the signal. conduct Layer decomposition. In the first layer... In layer decomposition, the approximation coefficients are calculated. With detail coefficient :

[0040] ;

[0041] ;

[0042] In the formula: Represents the time index of a discrete signal; This represents the input discrete-time sequence signal; Indicates the scale (hierarchy) index of wavelet decomposition; The shift factor represents the wavelet transform. ; express .

[0043] Noise intensity estimation and threshold calculation. To adapt to noise levels under different loads, this embodiment does not use a fixed threshold, but instead employs a robust estimation method based on the first-level detail coefficients to calculate the noise standard deviation. This estimation method utilizes the absolute deviation of the median, which can effectively resist the interference of abrupt changes in the signal itself on noise estimation.

[0044] ;

[0045] Based on this, calculate the general threshold. :

[0046] ;

[0047] In the formula: This represents the estimated noise standard deviation; This represents the sequence of detail coefficients obtained from the first level of decomposition; This indicates the median operation; This represents the proportionality constant between the absolute median and the standard deviation under a normal distribution; Indicates the noise reduction threshold; This represents the total number of sample points within the current time window.

[0048] Soft threshold quantization and reconstruction. Detail coefficients at each layer. A soft thresholding function is used to filter out noise while maintaining signal continuity, avoiding the pseudo-Gibbs phenomenon caused by hard thresholding. The corrected detail coefficients... The calculation is as follows:

[0049] ;

[0050] In the formula: This represents the detail coefficients after soft thresholding. Represents the original detail coefficients; This represents the general threshold obtained from the aforementioned calculation; Representing the sign function. Utilizing approximation coefficients and processed detail coefficients. Perform inverse discrete wavelet transform to output a denoised continuous index sequence. Perform median filtering based on a sliding window. For Discrete index sequence in Median filtering is used to eliminate transient pulse interference caused by probe blockage or network jitter. For time intervals... The sampling points are set to a filter window length of 10 ... The window length is set to an odd number, depending on the sampling frequency. This embodiment sets This ensures that transient spikes are filtered out without losing the true characteristics of short transaction flows. The filtered output value. for:

[0051] ;

[0052] In the formula: Indicates time Filtered discrete index values; Indicates time The original collected values; Indicates the length of the filter window (odd number); Denotes the shift factor of the wavelet transform, satisfying .

[0053] Perform time-domain alignment and linear resampling. Due to hardware interrupt delays, the actual acquisition time... There is a deviation from the theoretical timeline. The intelligent analysis module 120 constructs a unified timeline. The time interval is set to For any processed index sequence The numerical values ​​at the standard time point were calculated using a linear interpolation algorithm. :

[0054] ;

[0055] In the formula: Indicates at the standard time point The interpolation result at the location; , They represent the immediate neighbors in the original sequence. Previous sampling point and the next sampling point The index values; , The next nearest neighbors in the original sequence The two sampling times. If If the packet loss exceeds a preset threshold, the point is marked as a missing value and no interpolation is performed to avoid introducing spurious data. Z-score standardization is then executed. To eliminate the influence of different physical dimensions on the weights of subsequent matrix operations, the system performs Z-score standardization on the feature vector sequence. Implementing standardization:

[0056] ;

[0057] In the formula: Indicates the first Each indicator at time The standardized Z-Score value; Indicates the first The arithmetic mean of each indicator over the entire current testing period; Indicates the first Standard deviation of each indicator; This represents a smoothing factor to prevent division by zero errors.

[0058] The intelligent analysis module 120 implements a resource affinity vector mapping mechanism. The physical principle of this mechanism lies in building a bridge connecting the logical execution domain and the physical resource domain. Database monitoring metrics are continuous numerical signals, while SQL execution plans are discrete tree structures. To incorporate both into a unified mathematical model for calculation, discrete operator nodes must be mapped to continuous numerical vectors, allowing the SQL execution cost to participate in subsequent causal matrix operations in a linear algebraic form. The specific execution steps are as follows:

[0059] Construct an operator resource affinity benchmark library. The system loads a pre-built benchmark library into memory. This step first defines the dimensional mapping relationship of the resource space, dividing physical resources into basic dimensions and establishing the following index mapping: Dimension 0 corresponds to computing resources, Dimension 1 corresponds to memory resources, Dimension 2 corresponds to storage input / output, and Dimension 3 corresponds to network transmission. (Benchmark library) Stores standard operator types To the baseline resource affinity vector The mapping. A four-dimensional nonnegative vector:

[0060] ;

[0061] In the formula: Represents the baseline resource affinity vector of the standard operator; These represent the resource consumption weights for the four dimensions of computation, memory, storage input / output, and network transmission, respectively, with values ​​ranging from [0,1].

[0062] The static execution plan tree is parsed and node features are extracted. The intelligent analysis module 120 parses the previously output static execution plan tree. For each node in the tree... Extract the following feature parameters: operator type Estimated number of scan lines Data width .

[0063] Calculate the initial affinity vector for each node. For each node... The system according to Retrieval reference vector and utilize the scaling factor After making corrections, the initial affinity vector is obtained. :

[0064] ;

[0065] Where: scaling factor This is used to quantify the nonlinear amplification effect of data size on resource consumption intensity. The calculation formula is as follows:

[0066] ;

[0067] In the formula: Represents a node The initial affinity vector; Represents a node The baseline resource affinity vector for the corresponding operator type; Represents a node The estimated number of scan rows; Represents a node Data width; This represents the normalization reference constant, which takes the value of the total number of bytes in the largest table in the current database instance or a default constant. .

[0068] Generate the resource feature matrix of the execution unit. To subsequently construct the physical topology mask for the entire system, the system needs to calculate the comprehensive resource requirements of all active SQL queries within the current time window. For the... For high-frequency SQL statements, the system traverses the set of all operator nodes in its execution plan tree. Calculate the resource dimension of this SQL. Cumulative affinity :

[0069] ;

[0070] In the formula: Indicates the first SQL-like statements in the first Cumulative affinity across resource dimensions; Indicates the first The set of all operator nodes in the SQL statement execution plan tree; Represents a node In the Initial affinity components across each resource dimension. After calculation, each type of SQL is transformed into a feature vector. This serves as the basic input for subsequent dynamic calibration and mask construction.

[0071] The intelligent analysis module 120 performs runtime state feedback calibration. To avoid the high-performance overhead of enabling SQL-level tracing, the system utilizes a low-cost kernel global state counter as an alternative. By capturing counter mutation signals and combining them with static execution plan indexes, the system accurately attributes global resource overflows to local SQL queries with corresponding characteristics, thereby dynamically correcting static estimation biases without zero intrusion.

[0072] Dynamic counter differential and rate calculation. The intelligent analysis module 120 receives the previously acquired global state counter set. Since the acquired counter is a monotonically increasing cumulative value, the system first calculates its rate of change within the current sampling period. Let time... The counter reading is The reading at the previous time step was The sampling interval is Then calculate the first-order difference rate. :

[0073] ;

[0074] In the formula: Indicates counter At any moment The rate of change; Indicates counter At any moment The cumulative reading; Indicates counter In the previous moment The cumulative reading; Indicates the sampling time interval.

[0075] Construct a resource dimension mapping table for abnormal behavior. The system pre-configures one such abnormal behavior mapping table. This mapping table is used to establish a causal relationship between kernel counters and physical resource dimensions. Essentially, it's a knowledge graph representation of database kernel principles, containing counter identifiers. Features of correlation operators and dimensions of affected resources Calculate the resource consumption calibration coefficient. For each counter entry in the mapping table... The system calculates resource calibration coefficients. This coefficient is used to normalize the absolute rate of the counter. The correction strength for the interval. The calculation formula uses the Sigmoid saturation function:

[0076] ;

[0077] In the formula: This is expressed as a normalized sensitivity factor. To ensure that the calibration coefficients are decoupled from hardware performance, The calculations incorporate hardware benchmark parameters:

[0078] ;

[0079] In the formula: Indicates counter At any moment The resource calibration coefficient, with a value range of [0,1]; This represents the rate of change of the counter obtained from the aforementioned calculation; This represents the saturation threshold coefficient, with a value of 0.05. This indicates the maximum physical read / write speeds per second for the server's storage device.

[0080] Perform dynamic adjustments to the affinity vector. The intelligent analysis module 120 iterates through the static feature vectors of all active SQL categories within the current time window. For each type of SQL The system checks whether its static execution plan contains the associated operator features defined in the mapping table. If the match is successful, and the global counter displays an error at this time ( If the affinity value of the SQL statement is not specified, then a non-linear gain correction is applied to the corresponding resource dimension:

[0081] ;

[0082] In the formula: This is the corrected dynamic affinity value; This represents the static cumulative affinity value before correction; Represents a set Medium counter The calibration coefficient; For all pointers to resource dimensions The set of exception counters; This is a dynamic reliability factor used to control the magnitude of runtime feedback correction to the static estimate. This embodiment sets... The typical value is 0.8. The term, as a damping factor, ensures It always monotonically approximates but never exceeds 1.0, maintaining the normalization property of the vector space. The output is the calibrated feature matrix. The system generates a dynamic resource feature matrix. The non-zero elements in this matrix explicitly indicate which SQL statements are the root cause of specific resource spikes at the current moment, providing a weighted basis calibrated with measured data for the subsequent construction of fuzzy physical topology masks.

[0083] The intelligent analysis module 120 executes the process of constructing a fuzzy physical topology mask. The physical principle of this process lies in injecting prior knowledge from the database domain into the causal inference algorithm to constrain the search space and eliminate spurious correlations. In purely data-driven causal discovery algorithms, statistical correlations are often misjudged as causal relationships due to confounding factors. This embodiment constructs a continuous-value mask matrix to quantify the probability of physical causal paths between different indicators, thereby masking physically uninterpretable connections in subsequent graphical model learning. The specific execution steps are as follows: Initialize the topology skeleton and matrix structure. The system initializes a matrix with dimension [missing information] in memory. fuzzy mask matrix ,in This represents the total number of monitored metrics. Matrix elements. Indicators For indicators Prior probability weights that have a direct impact. Calculate load-resource mapping weights. For the connection from load metrics to resource metrics, the system utilizes the dynamic resource feature matrix output in Section 3.2. Calculate path weights. The system calculates the fuzzy connection strength. This calculation process essentially aggregates the operator-level resource characteristics of all currently active SQL queries into system-level load characteristics:

[0084] ;

[0085] In the formula: Indicates from load metrics To resource indicators (Corresponding resource dimensions) Fuzzy connection weights; The set of active SQL categories within the current time window; For the first The frequency of SQL-like operations within the current window; For the first SQL-like for the first Dimensional resources (corresponding indicators) The dynamic affinity of ) To prevent the removal of the zero constant.

[0086] Calculate resource interaction weights. For interaction paths within the resource layer, the system dynamically assigns weights based on the state of the global anomaly counter. These paths typically correspond to resource overflow conversion effects. The system extracts counter calibration coefficients. Calculate the interaction weights:

[0087] ;

[0088] In the formula: Indicates from resource indicators To resource indicators Interaction weights; Indicates counter Resource calibration coefficient; Representation of resources To resources The set of exception counters that have undergone transformation; This represents the signal amplification gain; the value used in this embodiment is... .because The maximum value is 1. The function of this coefficient is to set the corresponding causal path weight to 1.0 when a clear overflow signal is detected, thus forcibly enabling the edge.

[0089] Calculate the resource performance saturation weights. (This applies to resource indicators.) Pointing performance indicators The system calculates weights based on the saturation principle in queuing theory for the path. It's important to note that the input for this step... The raw absolute utilization data must be used, not the standardized Z-score data, because the physical bottleneck depends on the absolute resource utilization level. System build saturation weights. :

[0090] ;

[0091] In the formula: Indicates from resource indicators To performance indicators Saturation weight; Representing resources The original average utilization rate within the current window; Indicates the queuing inflection point threshold; This represents the activation slope, with a value of 10. The output is the fuzzy physical topology mask. After the above calculations, the system generates the final fuzzy mask matrix. This matrix is ​​input as a priori constraint into the causal structure learning algorithm. In the subsequent generational search process, the algorithm will only... Search along the path, and The magnitude of the value will be used as the Bayesian prior probability to influence the judgment score of the causal edge, thereby ensuring that the generated root cause topology graph conforms to the objective physical laws of the database.

[0092] The intelligent analysis module 120 executes the grouping intervention logic for time series data. This logic is based on the principle of invariant causal prediction. In complex database systems, statistical correlations between indicators are often misleading due to unobservable confounding factors. However, true physical causal relationships should maintain structural stability under different external environments. Therefore, this step automatically identifies natural transitions in the system's operating state through algorithms and models them as soft intervention experiments, thus providing a data foundation for subsequent spurious correlation removal. The specific execution steps are as follows: Multidimensional time series change point detection. The intelligent analysis module 120 receives standardized multidimensional time series data. The system employs an offline change point detection mechanism based on the PELT algorithm to identify time discontinuities where the system's statistical characteristics drift. The system constructs an objective function. The set of change points is determined by minimizing the objective function. :

[0093] ;

[0094] In the formula: Let represent the negative log-likelihood cost function based on the assumption of a multivariate Gaussian distribution. For a segment of length , The calculation formula is as follows:

[0095] ;

[0096] In the formula: Let be the determinant of the empirical covariance matrix of the data within this segment. For data dimensions; To prevent overfitting, a penalty term is dynamically calculated based on an improved Bayesian information criterion.

[0097] ;

[0098] In the formula: Represents the time set of the point of change; Indicates the number of variable points; Indicates the first Data subsequences within a time segment; Indicates the current segment Length (number of sample points); This represents the empirical covariance matrix of the data within the current segment; The determinant of the covariance matrix; Indicates the dimension of the data; This represents the total number of sample points in the entire time series.

[0099] coefficient This corresponds to the number of independent parameters in a multivariate Gaussian distribution. The PELT algorithm utilizes dynamic programming principles and employs an inequality pruning strategy to achieve linear time complexity. The global optimal solution of the above objective function is obtained internally, and the continuous time axis is divided into a series of discrete segments with local stationarity. .

[0100] State-space clustering and environment label generation. Since different time periods may correspond to the same system loading pattern, the system needs to group time segments with similar features into the same interference environment. The system calculates the feature center vector and covariance matrix for each time segment. To prevent matrix non-invertibility due to multicollinearity, the system first performs Tikhonov regularization:

[0101] ;

[0102] In the formula: To prevent the elimination of the zero constant, the symmetric KL divergence is then used to measure the distribution distance between the two segments. :

[0103] ;

[0104] In the formula: Represents the trace of a matrix; Each represents a segment and The regularized covariance matrix; Each represents a segment and The mean vector of the feature centers; Indicates the data dimension.

[0105] The intelligent analysis module 120 acquires the intervention augmentation dataset. and fuzzy physical topology mask Next, the quantitative calculation of causal strength is performed. The physical principle of this process lies in orthogonally verifying domain knowledge and data statistics. Traditional causal discovery algorithms face the curse of dimensionality in high-dimensional spaces and are easily affected by pure numerical noise. This embodiment employs a dual verification mechanism that combines physical masking to guide the search space with invariance principle verification of connection strength. The mask is used to reduce the search space and protect physically reasonable weak signals, while invariance verification is used to eliminate spurious causal relationships that are only coincidentally related under specific loads. The specific execution steps are as follows:

[0106] Perform a mask-guided conditional independence test. The system utilizes fuzzy physical topology masks. The PC-Stable algorithm is initialized and pruned. The system only considers the prior probabilities in the mask matrix. node pairs Initial undirected edges are established between the fully connected graphs, thus sparsifying the graph into a physics-constrained skeleton graph. For each edge in the skeleton graph, the system performs a conditional independence test. The null hypothesis is assumed. For variables and Given a set of conditions The components are mutually independent. The system calculates the partial correlation coefficient. And the Fisher Z-transform was used to calculate the statistic. :

[0107] ;

[0108] In the formula: Representing variables and Given a set of conditions The partial correlation coefficient under the condition; Indicates the number of samples; The size of the condition set. To incorporate domain prior knowledge, this embodiment employs a dynamic significance threshold strategy. In statistical testing, the significance level... This determines the ease or difficulty of rejecting the null hypothesis. The system uses mask weights. Dynamic calculation of significance level :

[0109] ;

[0110] In the formula: Indicators and The dynamic significance level of the connection determination between them; Indicates the basic significance level; Indicates the noise reduction threshold; Indicators in fuzzy physical topology masks For indicators The prior weights. The physical meaning of this formula is: when the physical mask is displayed... and There is a strong possibility of physical connection ( When the system reaches a significance level, This improvement expands the rejection region, making edges that would otherwise be judged as independent due to weak signals more likely to be judged as correlated and retained. This mechanism effectively solves the problem of broken real physical paths caused by sampling noise. ( If the function is the inverse cumulative distribution function of the standard normal distribution, then the null hypothesis of independence is rejected, and the connection edge is retained.

[0111] Causal orientation and invariance verification. The system first uses unshielded collision structure rules to partially orient the skeleton graph. Then, for each directed edge to be verified... Using intervention variables generated in the preceding step Invariance verification is performed. To overcome the multicollinearity problem commonly found among database indicators, the system uses a ridge regression model for parameter estimation. The system categorizes data according to intervention variables. Divided into Each subset, in each environment subset Train the model:

[0112] ;

[0113] In the formula: Indicates environment Next target node Observed values; Indicates environment Potential parent node Observed values; Represents a node The set of adjacent nodes; Indicates environment Down right The regression coefficients; Indicates environment Other control variables The regression coefficients; The remainder represents the regression residual. The system calculates the invariance score for this connection. The formula is as follows:

[0114] ;

[0115] In the formula: Indicates the regression coefficient sequence in Variance under different environments; Indicates the regression coefficient sequence in The mean value under various environments; This represents the smoothing constant. This score measures the robustness of the causal mechanism: if... If it is a true physical cause and effect, then regardless of whether the system is in an idle or high-load environment, its unit influence coefficient will be... It should remain relatively stable at this time. Conversely, if the correlation between the two is merely spurious, their coefficients will fluctuate drastically with environmental changes, leading to... .

[0116] Generate the final causality strength matrix. The system calculates the weighted adjacency matrix of the final directed graph. The matrix elements integrate effect magnitude, statistical robustness, and physical probability.

[0117] ;

[0118] In the formula: Indicators For indicators The final causal relationship strength; This represents the absolute value of the mean of the regression coefficients (effect magnitude). Indicates the invariance score (statistical robustness); This represents the physical mask weights (physical probabilities). Finally, the system processes the matrix... Perform sparsity cleaning, The element is set to 0 in this embodiment. The output matrix This is the root cause analysis topology diagram that has undergone both physical and statistical verification.

[0119] The intelligent analysis module 120 executes metadata feature extraction and neural network processing logic. This step aims to resolve the contradiction between the discrete symbolic nature of database metadata and the continuous input requirements of neural networks. In the database, SQL template IDs, error codes, etc., are unordered categorical variables. Directly using integer encoding will introduce incorrect ordinal relationships, while using One-Hot encoding will lead to the curse of dimensionality and make it impossible to measure the similarity between entities. This embodiment uses entity embedding technology to map discrete symbols into low-dimensional dense vectors, making the Euclidean distance between SQL statements with similar performance characteristics or related error codes closer in the vector space. The specific execution steps are as follows:

[0120] Construct a discrete metadata index dictionary. The system cleans the collected metadata stream. For each discrete feature domain, the system constructs an independent vocabulary. The main discrete feature domains and their processing logic are as follows: SQL template domain: Extract parameterized SQL text summaries, retain the top-N most frequently executed templates to construct a dictionary, and uniformly map the remaining low-frequency templates to... <unk>Identifiers. Waiting event field: Creates a full dictionary of standard wait events defined by the database kernel. Configuration state field: Maps enumerated configuration parameters to IDs. The system maintains multiple independent lookup tables to ensure ID space isolation between different fields.

[0121] Distributed feature embedding is performed. For each discrete feature input within a time window, the system uses an embedding layer to transform it into a dense vector. Let the vocabulary size of a certain feature domain be... Embedding dimension is For the first in this domain Entity Index Its embedding vector The calculation is as follows:

[0122] ;

[0123] In the formula: Indicates the first Embedding vectors of discrete entities; Represents a learnable embedding matrix; Indicates the first The index value of each entity.

[0124] Joint feature aggregation based on attention mechanism. Since the number of active SQL statements changes dynamically within a sampling window, it cannot directly adapt to the fixed-length input of a fully connected layer. The system employs a self-attention convergence layer to compress the variable-length vector set into a fixed-length context vector.

[0125] The system calculates the aggregate vector. :

[0126] ;

[0127] ;

[0128] ;

[0129] In the formula: Indicates the first Attention score for each feature; Represents a trainable context query vector; This represents the weight matrix and bias vector of the attention mapping layer; Indicates the first Normalized attention weights for each feature; This represents the context vector after weighted aggregation; This indicates the number of features within the current window. It should be noted that... It is not an external input, but a randomly initialized and trainable model parameter. It represents the global attention preferences learned by the model, used to automatically identify which SQL features are more critical in the current decision task.

[0130] Nonlinear cross-fusion of multi-domain features. The system cross-interacts the aggregated SQL load features with system configuration features: to capture the nonlinear combination effect that triggers anomalies only under specific loads and configurations, and to address the issue of inconsistent dimensions among different feature sources, the system introduces a bilinear projection layer. First, the projection matrix is ​​used to map features from different dimensions to the same textual dimension. Then execute the Hadamard product:

[0131] ;

[0132] In the formula: This represents the feature vector after cross-fusion; Indicates metadata load characteristics; This represents the system configuration feature vector; , This represents the dimension-aligned projection matrix; Represents the bias vector; This represents the linear rectification activation function. : Represents an element-wise multiplication operation. Physically, this operation is equivalent to performing a logical AND operation in a continuous vector space. The cross-linked feature is activated only when both feature vectors have high activation values ​​in their corresponding dimensions, thus accurately capturing the strong coupling pattern between load and configuration. The processed result serves as the final metadata fusion feature. Output.

[0133] The evaluation and decision module 140 performs a two-layer topological constraint fusion calculation. The physical principle of this step is based on the first-order approximation theory of spectral graph convolutional networks. In complex database systems, faults often do not occur in isolation but propagate along specific physical connections or logical dependencies. This embodiment constructs a heterogeneous graph model, using an adjacency matrix to define the energy flow channels of the system. Graph convolution operators aggregate local anomaly features scattered across nodes into a global fault mode, thereby using network structure information to resolve the ambiguity of single-node features. The specific execution steps are as follows:

[0134] Construct a heterogeneous node feature matrix. Initialize the node features in the system's graph model. For each monitoring indicator node in the system... (common (number of nodes), its initial feature vector It is composed of time-series statistical features and global metadata features:

[0135] ;

[0136] In the formula: Represents a node The initial input feature vector; Represents a node The time-series statistical feature vector; Represents the global metadata fusion vector; , This represents the weight matrix and bias of the projection layer; This represents a vector concatenation operation. This projection operation maps the system-level global context to the local feature space of each node through a broadcast mechanism, enabling the node features to have environmental awareness.

[0137] A two-layer topological adjacency matrix is ​​synthesized. The system constructs a weighted adjacency matrix that integrates physical priors and statistical observations. To eliminate physical masks The system first addresses the dimensional differences between the matrices. Perform maximum-minimum normalization to map its element values ​​to the [0,1] interval. Then, calculate the fusion matrix using the following formula:

[0138] ;

[0139] In the formula: Represents the elements of the merged adjacency matrix; Indicates the physical mask weights; Indicates statistical causal weights; This indicates a normalization operation; This represents the prior confidence coefficient; This is represented as the Kronecker function. After construction, the system... Perform renormalization to prevent numerical instability of features during multi-level propagation:

[0140] ;

[0141] Perform graph convolution feature propagation. The system utilizes the normalized adjacency matrix. Multi-layer graph convolution operations are performed on node features. This embodiment uses a two-layer graph convolutional network to capture fault associations within a two-hop range. The layer-by-layer propagation formula is as follows:

[0142] ;

[0143] In the formula: This represents the renormalized adjacency matrix; This represents the degree matrix after adding self-loops; This represents the fused adjacency matrix obtained from the aforementioned calculation; Indicates the first The node feature matrix of the layer; Indicates the first The trainable weight matrix of the layer; This represents a non-linear activation function.

[0144] Calculate the root cause probability distribution. This is based on the final node features that aggregate information from the entire graph. (here) The system uses a fully connected layer to calculate the probability score that each node is the root cause.

[0145] ;

[0146] In the formula: This represents the root cause probability distribution vector of all nodes; This represents the output feature matrix of the last layer of the graph convolutional network; , This represents the weights and biases of the output layer; This represents the normalized exponential function. The system is based on... All indicators are sorted in descending order of their numerical values, and the top indicators with a cumulative probability sum of 0.9 are selected. One node, or directly select the Top-3 nodes as the recommended root cause set.

[0147] The scene adaptation module 130 is responsible for compressing high-dimensional heterogeneous runtime data into low-dimensional dense feature vectors. Through multimodal feature assembly and variational autoencoder mapping, the system constructs a unified latent space representing load similarity. Specific assembly steps include: extracting resource statistical features that retain high-variance activity indicators; introducing metadata fusion vectors as load semantic features; and performing global max pooling on the node matrix output by graph convolution to extract topology propagation features.

[0148] ;

[0149] In the formula: The first eigenvector represents the topological eigenvector. One component; The graph convolution output matrix represents the first... The node eigenvalues ​​of dimension; This represents the total number of nodes (indicators) in the graph. Finally, the system performs the stitching operation: .

[0150] Latent space mapping based on variational autoencoders. Due to The latent space is typically high-dimensional (>500 dimensions) and exhibits non-linear correlation, making direct clustering ineffective. The system utilizes a variational autoencoder (VAE) to map it to a low-dimensional latent space. The VAE network structure and computational logic are as follows: Encoder: Maps the input to the mean and log-variance of the latent distribution using a multilayer perceptron. .

[0151] ;

[0152] ;

[0153] In the formula: Represents the hidden layer feature vector; This represents the original scene state vector after assembly. , This represents the weights and biases of the first layer of the encoder; The vector representing the mean of the potential distribution; Represents the variance vector of the potential distribution; , , , These represent the linear layer parameters that generate the mean and variance. Reparameterized sampling: To make the random sampling process differentiable, the system introduces auxiliary noise variables. Calculate the latent vector :

[0154] ;

[0155] In the formula: This represents the latent space vector obtained from sampling; It indicates that it follows a standard normal distribution. Auxiliary noise variables; This indicates element-wise multiplication. This embodiment sets... Dimensions Loss function construction: the objective function for model training. Includes reconstruction error and KL divergence regularization term:

[0156] ;

[0157] In the formula: This represents the reconstructed output of the decoder; Represents the KL divergence decoupling coefficient; The dimension representing the potential space; , Let the mean vector and variance vector represent the first and second values, respectively. Each component.

[0158] Temporal smoothing and scene vector generation. To eliminate scene recognition jumps caused by instantaneous load fluctuations, the system performs time-series smoothing on the mean vector output by the encoder. Execute the index-weighted moving average.

[0159] ;

[0160] In the formula: Indicates time The encoded mean vector output by VAE; This is represented as a smoothing factor, and in this embodiment, it is set to 0.2. Indicates time The smoothed scene feature vector, which possesses smoothness and local continuity, ensures the stability of subsequent clustering algorithms over time.

[0161] The scene adaptation module 130 executes density-based clustering analysis and online matching logic. This step is based on the manifold assumption, which states that effective data points in a high-dimensional state space are usually distributed near a low-dimensional manifold. Using the DBSCAN algorithm, the system can automatically discover the natural distribution structure of sample points in the latent space, grouping system states with similar geometric distances into the same scene cluster. The specific execution is as follows:

[0162] Maintain a historical scene sample library. The system maintains a fixed-size library in memory. (sliding window buffer) This buffer is used to store historical scene vectors and their associated policy execution effects. The sample tuples in the buffer are defined as follows:

[0163] ;

[0164] In the formula: For a moment Scene feature vectors; This is the policy ID issued at that moment (corresponding to a specific set of parameter configurations); The system scores the performance gains after strategy execution. This is based on the rate of change in throughput over a period of time (e.g., 30 seconds) before and after strategy execution. and the rate of change of response time (RT) Calculate this value:

[0165] ;

[0166] In the formula: This indicates the performance benefit score after the strategy is executed; , These represent the throughput before and after the strategy is executed, respectively. , These represent the response time before and after the strategy is executed, respectively. , This is represented by a weighting coefficient, which is set to 0.5 in this embodiment. The formula shows that the higher the TPS increase and the greater the RT decrease, the higher the policy score.

[0167] Perform asynchronous incremental DBSCAN clustering. To ensure the real-time performance of the online service, the system periodically (every other time) runs in a background thread. Clustering is performed on the buffer data (in seconds). For any sample point... The system calculates its - The number of neighbors within the neighborhood. If the number exceeds... ,but These are marked as core points. The clustering output is... Scene clusters And the set of noise points. For each valid cluster The system performs the following operations: Calculate the centroid:

[0168] ;

[0169] In the formula: Indicates the first The centroid vector of a scene cluster; Cluster The number of samples in the sample; This represents a scene vector sample within a cluster. Optimal strategy: Iterate through all strategy IDs associated with samples within the cluster and calculate the average return for each strategy. The strategy with the highest value is selected as the "standard strategy" for this scenario. Online scene similarity matching. When real-time scene vectors... During generation, the system calculates that it is the centroid of all known fields. The Euclidean distance.

[0170] ;

[0171] In the formula: This represents the distance between the current scene vector and the nearest cluster centroid; Represents the current real-time scene vector; This represents the centroid vector of a known cluster.

[0172] Let the corresponding nearest cluster index be The system determines the current state's affiliation based on distance: if... If the current scenario is determined to be unknown or an outlier state, the system will not match any historical strategies and will switch to the default safe mode or exploration mode. Determine if the current scene is a known scene. Then proceed to the subsequent confidence assessment.

[0173] Strategy retrieval and parameter conservatism correction. The system retrieves the scenario. Standard strategy To prevent the over-application of aggressive strategies at scene edges, the system calculates the matching confidence score. :

[0174] ;

[0175] In the formula: This represents the cluster neighborhood radius. The system sets a confidence threshold. .like Directly issue the strategy Complete parameter configuration. If... Execution parameter conservative adjustment. Assumption strategy. Includes a numerical parameter to be adjusted. and default security parameters The system calculates the actual parameters to be sent based on the confidence level. :

[0176] ;

[0177] ;

[0178] In the formula: This indicates the final parameter value sent. Indicates the interpolation coefficients; Indicates the confidence threshold; This indicates the target parameter value recommended by the strategy; This represents the default safety parameter value. The formula utilizes coefficients. A linear interpolation is performed between the target optimized value and the default safe value. As the confidence level decreases, the issued parameters will smoothly degenerate to the default configuration, thus ensuring the safe operation of the system while leveraging historical experience.

[0179] The scenario adaptation module 130 executes the dynamic mapping logic of the strategy parameters. This step aims to solve the adaptation problem between the static strategy template and the dynamic system baseline. Parameter adjustment in a database system is essentially a feedback control process. This embodiment transforms the high-level optimization strategy into a specific control objective and, combined with the real-time observed state of the current system, uses a nonlinear control law to calculate specific parameter values ​​adapted to the current load level, thereby achieving personalized dynamic instantiation of the strategy. The specific execution is as follows:

[0180] Policy template retrieval and parsing. Based on the policy ID determined in previous steps, the system extracts parameter mapping templates from the policy rule base. The mapping template uses a key-value pair structure to define the configuration items involved in the strategy and their calculation patterns.

[0181] Parameter instantiation based on nonlinear control laws. For parameters marked as dynamic modes, the system reads the current system state. Calculate the target parameter value Taking the thread concurrency parameter as an example, the system employs a nonlinear proportional control algorithm based on error feedback. Subsequently, the adjusted target value is calculated using the following control law formula:

[0182] ;

[0183] ;

[0184] In the formula: Indicates the control adjustment range; Indicates the target setpoint; This represents the observed value of the current reference indicator; Indicates the error sensitivity index; This represents the calculated target parameter value; Indicates the baseline value of the parameter; Indicates the adjustment gain coefficient; This is the error sensitivity index.

[0185] Security boundary pruning based on hardware introspection. The system calculates... Perform multi-dimensional constraint verification to ensure that the distributed configuration does not exceed physical hardware limitations. During the system startup phase, the physical boundaries are obtained through hardware introspection mechanisms, and a constraint set is constructed. For a single parameter The system is based on its physical upper limit. and lower limit Execute truncation:

[0186] ;

[0187] For memory parameter groups with coupling relationships (such as buffer pools, log buffers, and sorting buffers), the system performs a joint capacity check. If the cumulative value of all memory parameters exceeds the safe limit of physical memory, proportional compression is performed.

[0188]

[0189] , ;

[0190] In the formula: Indicates the proportional compression factor; Indicates the memory safety threshold; This indicates the total physical memory capacity of the server; This represents the safe value of each memory parameter after individual boundary trimming. Atomic instruction generation and delivery.

[0191] The evaluation decision module 140 executes the construction and calculation logic of the three-dimensional evaluation model. This step is based on the principle of multi-objective optimization and aims to quantify the overall net benefit after the evaluation strategy is implemented. In database tuning, an improvement in a single performance indicator is often accompanied by the risk of increased resource consumption or decreased stability. This embodiment constructs an orthogonal evaluation space consisting of performance benefits, stability risks, and resource costs. By comparing time window data before and after the strategy takes effect, a normalized scalar score is calculated. The specific execution steps are as follows:

[0192] Computational performance gain dimension score The official definition of the iron strategy takes effect at the time when... Set two time windows: reference tightness. and evaluation window .in, The window duration (300 seconds in this example) A buffer period (30 seconds in this example) is provided to avoid system jitter during parameter switching. To eliminate the impact of transient spikes in the monitoring data on the mean, the system performs outlier filtering based on interquartile range on the throughput and response time series within the two windows: retaining data points within the range. The mean TPS and RT are calculated based on the filtered data, and a performance score is calculated.

[0193] ;

[0194] In the formula: This indicates a performance-based score. , Indicates the weighting coefficient; , These represent the average throughput of the evaluation window and the baseline window, respectively. , These represent the average response times of the evaluation window and the baseline window, respectively. This represents the numerical truncation function. It is used to calculate the stability risk dimension score. This dimension is used to penalize strategies that, while improving mean performance, exacerbate system response jitter. The system calculates the standard deviation and mean of the response time series within the evaluation window. The coefficient of variation was obtained. The stability score is calculated using the following formula:

[0195] ;

[0196] In the formula: The coefficient of variation represents the response time within the evaluation window; Indicates the stability threshold; This is represented as the penalty slope, which is set to 5.0 in this example. This parameter means that once the volatility exceeds the threshold, the score will decay rapidly. The score resets to zero when it reaches 0.4. The resource cost dimension score is calculated. This dimension is used to evaluate whether performance improvements comply with the energy efficiency ratio principle, that is, whether unit resource consumption generates more business value. The system defines the energy efficiency ratio. The ratio of throughput to resource utilization:

[0197] ;

[0198] In the formula: Average CPU utilization To smooth out errors and prevent division by zero, the resource cost score is calculated as follows:

[0199] ;

[0200] In the formula: Indicates the energy efficiency ratio; This represents the average CPU utilization. Indicates the magnification factor; Represents throughput. Generates a multi-dimensional comprehensive decision score. The system first checks whether any hard constraint violations have been triggered within the evaluation window. (Hard constraint set) This includes: the presence of deadlock or memory overflow keywords in the database error log; and master-slave replication delays exceeding a safe threshold (e.g., 5 seconds).

[0201] The number of active connections reached 95%. The overall score is calculated as follows:

[0202] ;

[0203] ;

[0204] In the formula: This indicates the final overall decision score; This represents the original weighted score; , , Indicates the weight of each dimension; This represents the set of hard constraints. If... If the value is 0.1, the system determines that the policy is effective in the current scenario and retains the configuration; otherwise, the system will trigger a rollback operation to restore the parameter snapshot before the policy took effect.

[0205] The display storage module 150 further executes visualization rendering and natural language generation logic. This step aims to address the bandwidth mismatch between the underlying high-frequency monitoring data and the cognitive capabilities of operations and maintenance personnel. Through feature-preserving downsampling and structured text generation techniques, the system transforms abstract mathematical evaluation results into visualized trend graphs and readable decision reports, and provides a manual intervention interface to correct long-term algorithmic biases. The specific execution steps are as follows:

[0206] Adaptive feature downsampling of time-series data. Because the monitoring data generated by the preceding modules has a high sampling rate, direct full rendering on the client side would lead to sluggish graphical interface response and memory overflow. To reduce the data volume while preserving the data's morphological characteristics, the system does not use uniform sampling or average sampling, but instead employs the maximum triangle three-bucket algorithm. Assume the original data sequence is... The target display point count is The algorithm divides the original sequence into... There are three equal-length buckets. For each data point within the current bucket, the algorithm finds a point... This makes the selected points from the previous bucket... ,point And the average point of the next bucket The triangle formed has the largest area. The formula for calculating the area is as follows:

[0207] ;

[0208] In the formula: , These represent the timestamp coordinates of the data points and the numerical coordinates of the metrics, respectively. These refer to the selected point of the previous bucket, the candidate point of the current bucket, and the average point of the next bucket, respectively. The algorithm ensures that even with a compression rate exceeding 95%, the instantaneous jitter and load fluctuation trends of the database can still be accurately preserved in the visualization chart. The system overlays vertical marker lines on the rendered time series diagram, and the time coordinates of these marker lines correspond to the issuance times of atomic instructions in the strategy issuance step. This allows for a direct comparison of the states before and after the strategic intervention.

[0209] The system uses state mapping-based template-filling logic to generate natural language reports. These reports are based on root cause categories and overall scores. The sign of the symbol is used to retrieve the template from a preset mapping table: when When the template is successfully invoked, enter the name and improvement rate of the indicator with the largest change in the window; when When the rollback template is invoked, the hard constraints that trigger the rollback should be specified. The generated text is encapsulated as a JSON object. -0.5, the system marks the message severity level as Warning and highlights it in the foreground.

[0210] Interactive signal processing and strategy weight adjustment. The system provides two operation controls, positive confirmation and negative rejection, in the visual report interface to receive external feedback signals from operations and maintenance experts. When user feedback is received... At that time, the system located the current scene cluster. The following strategy Recommendation weight Perform online correction. The correction algorithm employs a linear update rule with boundary constraints:

[0211] ;

[0212] ;

[0213] In the formula: This indicates the revised strategy recommendation weights; This represents the learning rate based on human feedback. Indicates user feedback signals; Represents the absolute value of the overall score; This represents a numerical truncation function. For data communication in the Web front-end, this embodiment uses the WebSocket full-duplex communication protocol to achieve real-time push. The specific connection establishment and message parsing process are well-known technologies in the field and will not be described in detail here. The database self-healing and optimization system provided in this embodiment can be deployed on a separate physical server, run as a cloud service in a virtualized computing resource pool, or deployed in a sidecar mode on the same physical host machine sharing the kernel space with the target database instance to achieve efficient monitoring with zero copying.

[0214] To verify the effectiveness of the intelligent evaluation system for database test results based on big data (hereinafter referred to as "this system") provided in this embodiment of the invention in practical technical applications, this embodiment constructed a standardized hardware testing environment and selected an industry-standard database performance benchmark test model for comparative experiments.

[0215] Experimental environment configuration:

[0216] Hardware platform: The test server uses a standard x86 architecture, configured with a 48-core CPU, 256GB DDR4 memory, and a 3.2TB NVMe solid-state storage array. The network environment is a 10 Gigabit local area network.

[0217] Software environment: The object under test is an open-source relational database management system, and the operating system is an enterprise-level Linux distribution.

[0218] Comparison Groups: Baseline Control Group: Maintains default parameter configurations after database installation, without additional intervention. Rule Optimization Group: Applies static threshold scripts written based on expert experience. Traditional Model Group: Uses a random forest regression model that does not include the physical topology masking technology of this invention for parameter recommendation and anomaly detection. This Example Group: Enables the data acquisition module 110, intelligent analysis module 120 (including causal graph construction), and scene adaptation module 130 of this invention.

[0219] Performance optimization effect verification (see appendix) Figure 3 The experiment uses the TPC-C (Online Transaction Processing Benchmark) model to simulate high-concurrency write load, setting up 1000 warehouses and running continuously for 120 minutes.

[0220] Throughput Trend Analysis (see Appendix) Figure 3 a): In the initial stage of test startup, this embodiment group quickly identifies the current IO-intensive write load characteristics through the scenario adaptation module 130 and issues optimized parameters for the log flushing strategy. For example... Figure 3 As shown in Figure a, the transaction throughput per second (TPS) of this embodiment group rapidly climbed and stabilized around the 10th minute, with a final stable value of approximately 18,500 TPS. In contrast, the baseline control group maintained a lower level (approximately 6,000 TPS). Due to the lack of causal constraints, the traditional model group exhibited a significant oscillation and trial-and-error process in the early stages, resulting in a slower convergence speed.

[0221] Response delay stability analysis (see appendix) Figure 3 b): such as Figure 3 As shown in b, regarding the P99 long-tail latency (99% of request response time), this embodiment group successfully suppressed the latency below the 50ms threshold specified in the Service Level Agreement by precisely controlling lock contention and memory swapping rate. In contrast, although the traditional model group showed an improvement in average performance, it failed to properly handle the physical causality of resource contention, resulting in frequent spikes and fluctuations in the latency curve.

[0222] Root cause analysis accuracy verification (see appendix) Figure 4 To verify the diagnostic accuracy of the evaluation decision module 140, four typical faults were injected into the controlled environment during the experiment: CPU saturation (computation-intensive SQL), IO bottleneck (log disk bandwidth exhaustion), memory overflow risk (complex join queries), and deadlock contention.

[0223] Accuracy statistics: Figure 4 The Top-3 root cause recommendation accuracy of different systems under the above failure scenarios is shown.

[0224] Data Comparison: In single-fault scenarios (such as CPU saturation), the differences between the groups are not significant. However, in complex "cascading fault" scenarios (i.e., connection accumulation due to IO blocking, which in turn leads to lock waiting), traditional model groups can often only identify superficial indicators (lock waiting), with accuracy dropping to 55%; while the group in this embodiment, by using fuzzy physical topology masks, can trace back to the underlying IO configuration problem along the causal path, maintaining an accuracy of over 92.5%.

[0225] Experimental conclusions: Experimental data show that, by introducing physical topological constraints and causal inference mechanisms, the embodiments of the present invention have faster convergence speed, higher performance gains, and more accurate fault location capabilities than traditional methods when processing high-dimensional, heterogeneous database test data.

[0226] Supplementary description of the attached diagram: Figure 3 This is a performance trend comparison chart between the embodiments of the present invention and existing technologies under TPC-C load; where (a) subplot shows the change curve of transactions per second over time, and (b) subplot shows the change curve of 99th percentile response time over time. (See attached chart.) Figure 4 This is a bar chart comparing the root cause localization accuracy of the embodiments of the present invention with that of existing technologies under different fault injection scenarios.< / unk>

Claims

1. A database test result intelligent evaluation system based on big data, characterized in that, include: The data acquisition module (110) is used to collect the raw dataset of the database instance under test. The raw dataset includes a sequence of performance indicators, a static execution plan, runtime state data and database configuration parameters. The runtime state data includes a runtime global state counter and database wait events. The intelligent analysis module (120) is used to construct a fuzzy physical topology mask matrix using the static execution plan and the runtime state data, and generate a causal graph by combining the statistical correlation strength between indicators; The scenario adaptation module (130) is used to identify the current business scenario type and call the corresponding parameter mapping template to adjust the calculation logic of the intelligent analysis module (120) and the test strategy of the database instance under test; The evaluation decision module (140) is used to calculate the root cause probability of the abnormal indicators based on the causal graph and generate structured evaluation result data. The display storage module (150) is used to display the structured evaluation result data and to correct the strategy recommendation weights of the scene adaptation module (130) in response to user feedback.

2. The intelligent evaluation system for database test results based on big data according to claim 1, characterized in that, The data acquisition module (110) includes a high-frequency timing acquisition unit and an execution logic acquisition unit, and executes a dual-stream parallel acquisition strategy for multi-source heterogeneous data; The high-frequency time-series acquisition unit is used to acquire the performance index sequence that exhibits continuous fluctuation characteristics according to a preset sampling frequency; The execution logic acquisition unit is used to capture high-frequency structured query language statements that present discrete event characteristics, call the database kernel interpretation interface to obtain the corresponding static execution plan, and synchronously read the runtime global state counter contained in the runtime state data; The data acquisition module (110) maintains two independent acquisition thread pools, corresponding to the high-frequency timing acquisition unit and the execution logic acquisition unit, respectively. The two share the system clock source and use the nearest neighbor hold strategy to map the discrete static execution plan and the runtime global state counter to the time axis of the performance index sequence.

3. The intelligent evaluation system for database test results based on big data according to claim 2, characterized in that, When constructing the fuzzy physical topology mask matrix, the intelligent analysis module (120) parses the operator dependencies in the static execution plan and performs the following operations: Construct an operator resource affinity benchmark library and map the operator nodes in the static execution plan to initial resource affinity vectors; Calculate the rate of change of the runtime global state counter contained in the runtime state data within the sampling period, and normalize the rate of change into a resource calibration coefficient based on a preset abnormal behavior mapping table. When a sudden change is detected in the runtime global state counter, the initial resource affinity vector of the structured query language statement corresponding to the static execution plan is nonlinearly adjusted using the resource calibration coefficient to generate a dynamic resource feature matrix; Identify the load category index and resource category index in the performance index sequence, calculate the connection weight from the load category index to the resource category index based on the dynamic resource feature matrix, and generate the fuzzy physical topology mask matrix.

4. The intelligent evaluation system for database test results based on big data according to claim 3, characterized in that, The intelligent analysis module (120) is used to perform quantitative calculations of causal strength, specifically including: The multidimensional time series data consisting of the performance index sequence and the runtime global state counter is subjected to standardization processing and change point detection. The multidimensional time series data is divided into discrete segments with local stationarity and clustered to generate intervention variables that reflect different operating environments. Using the fuzzy physical topology mask matrix as a priori constraint, the connection paths between indices are initialized and pruned. Perform conditional independence tests on the preserved connection paths, divide the data into multiple subsets using the intervention variables, and train a regression model on each subset; The degree of fluctuation of the regression coefficients of the regression model among different subsets is calculated as an invariance score. False causal connections in which the regression coefficients fluctuate with the change of the intervention variable are eliminated, and the final causal association strength matrix is ​​generated.

5. The intelligent evaluation system for database test results based on big data according to claim 1, characterized in that, The intelligent analysis module (120) is used to extract metadata features of database objects based on the static execution plan and the database configuration parameters, specifically including: Construct a discrete metadata index dictionary, and map the structured query language template extracted based on the static execution plan and the wait events in the runtime state data to entity indexes; The entity index is transformed into a dense embedding vector using a learnable embedding matrix; A convergence layer based on a self-attention mechanism is used to calculate the attention score of each dense embedding vector, and the variable-length dense embedding vector set is weighted and aggregated into a fixed-length context vector; The context vector is cross-fused with the system configuration feature vector derived from the database configuration parameters using a bilinear projection layer to generate metadata fusion features.

6. The intelligent evaluation system for database test results based on big data according to claim 1, characterized in that, The scenario adaptation module (130) identifies the current business scenario type specifically by including: Assemble an original state vector comprising resource statistical features extracted from the performance index sequence, load semantic features extracted from the static execution plan, and topology propagation features extracted from the graph model output by the evaluation decision module (140) in the historical evaluation period; The high-dimensional original state vector is mapped to the mean vector and variance vector of the low-dimensional latent space using a variational autoencoder network, and an exponentially weighted moving average is applied to the mean vector. Density-based clustering analysis is performed on the processed mean vector to calculate the Euclidean distance between the current scene vector and the centroids of historical scene clusters. If the Euclidean distance is less than a preset threshold, the match is considered successful, and the match confidence is calculated based on the Euclidean distance.

7. The intelligent evaluation system for database test results based on big data according to claim 5, characterized in that, The evaluation and decision module (140) is used to construct a two-layer topological constraint fusion model, specifically including: The statistical features of the performance index sequence output by the intelligent analysis module (120) are concatenated with the metadata fusion features to serve as the initial node features of the graph model. The adjacency matrix of the causal graph generated by the intelligent analysis module (120) is normalized and then combined with the weights of the fuzzy physical topology mask matrix to synthesize a fused adjacency matrix. Feature propagation and aggregation are performed on the topology defined by the fused adjacency matrix using a graph convolutional network. A fully connected layer is used to calculate the probability score of each node as a root cause, and the structured evaluation result data is generated based on the probability score.

8. The intelligent evaluation system for database test results based on big data according to claim 1, characterized in that, The scenario adaptation module (130) is used to perform dynamic mapping of strategy parameters, specifically including: Based on the retrieved parameter mapping template, read the current system state observation value; The adjustment range of the parameters is calculated using a nonlinear control law formula based on error feedback. The adjustment range changes nonlinearly with the error of the system state deviating from the target setpoint defined in the parameter mapping template. Physical boundary constraints are obtained through hardware introspection, and upper and lower limit truncation and joint capacity verification are performed on the calculated target parameter values ​​to generate atomic execution instructions that are sent to the database kernel.

9. The intelligent evaluation system for database test results based on big data according to claim 1, characterized in that, The performance indicator sequence includes at least throughput, response time, and resource utilization data. The evaluation decision module (140) is used to construct a three-dimensional evaluation model and calculate a comprehensive decision score based on the performance indicator sequence within the evaluation window after the strategy takes effect. Performance gain score is calculated based on the rate of change of the throughput and the response time after outlier filtering. Calculate the stability risk dimension score: The score is calculated based on the coefficient of variation of the response time sequence. When the coefficient of variation exceeds the stability threshold, the score is calculated according to the slope decay method. Resource cost dimension score: calculated based on the rate of change of the ratio of throughput to resource utilization rate; If a hard constraint is triggered within the evaluation window, the overall decision score is set to a negative value and a rollback recommendation signal is generated.

10. The intelligent evaluation system for database test results based on big data according to claim 9, characterized in that, The display storage module (150) is specifically used to perform the following operations: The maximum triangle triple-bucket algorithm is used to downsample the performance index sequence, retaining the extreme values ​​and inflection point features of the data and compressing the number of data points for visualization rendering. Receive user feedback signals on the evaluation conclusions, and adjust the strategy recommendation weights for the current business scenario type online based on the positive or negative type of the feedback signals and the current comprehensive decision score.

Images