Offshore wind plant heterogeneous data lake snapshot integration method supporting dynamic backtracking

Abstract

The invention provides an offshore wind power plant heterogeneous data lake snapshot integration method supporting dynamic backtracking, and aims to solve the problems of high operation and maintenance cost, inconsistent mass real-time data access and low historical backtracking efficiency caused by the fact that an existing Lambda architecture needs to maintain double computing engines. And constructing an incremental snapshot chain to support efficient data version backtracking. Specifically, the method comprises the following steps: designing a dynamic snapshot generation module based on time window division, and converting real-time streaming data into traceable continuous snapshot segments; a multi-version concurrency control engine is developed, and ACID transaction overhead is reduced through column type differential storage; meanwhile, a dynamic metadata sensing layer is established, a backward compatible mapping rule is automatically generated when a data mode is changed, and continuous and stable operation of a calculation engine is guaranteed; according to the method, the operation and maintenance complexity of the offshore wind power plant data lake is remarkably reduced, efficient integration of heterogeneous data and accurate backtracking of historical states are realized, and the data availability of fan fault diagnosis is effectively improved.

Description

TECHNICAL FIELD

[0001] The present application relates to a dynamic backtracking offshore wind farm heterogeneous data lake snapshot integration for realizing efficient fusion, version control and accurate backtracking of historical state of real-time and offline data of offshore wind farms. BACKGROUND

[0002] During the operation of offshore wind farms, high-frequency monitoring stream data is continuously generated, including SCADA, condition monitoring and vibration sensors, and other multi-source heterogeneous information. At the same time, offline batch processing data such as ship inspection and unmanned aerial vehicle shooting need to be periodically accessed. The traditional Lambda architecture maintains two links of stream processing engine and batch processing engine in parallel to try to meet the needs of real-time computing and offline analysis of two scenes. However, this architecture exposes some prominent problems in the practice of offshore wind farms, such as high operation and maintenance cost, difficulty in ensuring consistency of real-time and offline data, and low efficiency of historical backtracking.

[0003] Firstly, the double-engine parallel deployment, monitoring, upgrading and troubleshooting workload is doubled, and the operation and maintenance personnel need to master two sets of technology stacks. Secondly, the stream and batch links are written independently, which is easy to cause the same index to be inconsistent in the two links, which interferes with the fault diagnosis of the wind turbine. Thirdly, when the historical state needs to be reviewed, the traditional solution can only run TB-level original logs, and the batch task takes several hours, which cannot meet the rapid diagnosis needs within the short downtime window of the wind turbine. Finally, the format of the heterogeneous data sources of offshore wind farms is quite different, and the Schema changes frequently. The existing lake warehouse solution lacks optimization for high-concurrency sensors and periodic offline supplement recording scenarios, and cannot realize accurate backtracking within seconds while ensuring ACID. Therefore, a method is needed to unify stream and batch storage, reduce operation and maintenance complexity, and support dynamic Schema evolution and efficient historical backtracking of heterogeneous data lake snapshot integration method to significantly improve the data availability and operation and maintenance efficiency of wind turbine fault diagnosis of offshore wind farms. SUMMARY

[0004] This invention addresses the problems of high maintenance costs, inconsistent access to massive real-time data, and low efficiency of historical backtracking caused by the need to maintain dual computing engines in existing Lambda architectures. It proposes a snapshot integration method for heterogeneous data lakes in offshore wind farms that supports dynamic backtracking. This method achieves unified storage of streaming and batch data through a snapshot isolation mechanism and constructs an incremental snapshot chain to support efficient data version backtracking. Specifically, a dynamic snapshot generation module based on time window partitioning is designed to transform real-time streaming data into traceable continuous snapshot fragments; a multi-version concurrency control engine is developed, reducing ACID transaction overhead through columnar differential storage; and a dynamic metadata awareness layer is established to automatically generate backward-compatible mapping rules when data patterns change, ensuring the continuous and stable operation of the computing engine. This invention significantly reduces the operational complexity of offshore wind farm data lakes, achieves efficient integration of heterogeneous data and accurate backtracking of historical states, and effectively improves the data availability for wind turbine fault diagnosis.

[0005] The present invention provides a snapshot integration method for heterogeneous data lakes of offshore wind farms that supports dynamic backtracking, comprising the following steps:

[0006] S1: Receives real-time monitoring data streams and offline survey data from offshore wind farms via a distributed message queue. It then calls a dynamic metadata parser to automatically extract data source format features. Based on the feature matching results, it activates the corresponding data mode adapter to generate a unified data object. Specifically, it receives real-time monitoring data streams and offline survey data from offshore wind farms via a distributed message queue, defining the real-time data stream as D... stream ={d1,d2,...,d n}, where d i This represents a single real-time monitoring record; the offline dataset is D. batch ={D1,D2,...,D m}, D j This represents a single batch file, which uses a dynamic metadata parser to extract data source format features and construct a feature vector. f type Identify the data source type, f size f represents the data size. schema Describe the data structure, activate the corresponding data pattern adapter based on the feature matching result, and the matching logic is as follows:

[0007]

[0008] Where K is the set of adapters, Let ||·|| be the preset feature vector of the k-th adapter, and ||·|| be the Euclidean distance calculation. The adapter transforms heterogeneous data into a unified data object UO = {schema, payload, timestamp}, where schema describes the data structure, payload stores the actual data content, and timestamp records the timestamp when the data is generated.

[0009] S2: Divide continuous time windows according to data timestamps, and trigger a snapshot generation event when each window is closed, converting the data in the window into independent snapshot fragments according to the columnar storage structure;

[0010] S3: Generate a unique version identifier for the current snapshot fragment, establish a bidirectional version pointer based on the storage path of the previous snapshot, and merge the differences in the columnar storage files to form an incremental snapshot chain;

[0011] S4: Receive the historical status query request submitted by the user, parse the target time range parameter in the request, and locate the set of continuous snapshot segments that meet the time range along the incremental snapshot chain;

[0012] S5: Load the columnar storage file of the target snapshot fragment set, filter version conflict data through the multi-version concurrency control engine, and output a consistent historical state view after sorting by time dimension;

[0013] S6: Monitor data source structure change events, record schema change logs in new snapshots, and dynamically rewrite historical snapshot query statements based on backward compatibility rules.

[0014] According to a specific implementation of an embodiment of the present invention, the specific steps of S2 are as follows:

[0015] Based on the timestamp field of the Unified Data Object (UO), the data stream is divided into a continuous sequence of time windows; the time window length parameter Δt is defined, and the k-th time window is represented as:

[0016] W k =[t base +(k-1)·Δt,t base +k·Δt)

[0017] Among them, t base The base timestamp is k, and the window index is k. When the system time is t... current Satisfying t current ≥t base When +k·Δt, the window close event E is triggered. close In E close In the event, the collection window W k All elements satisfying UO.timestamp∈W k A unified object that constitutes a dataset Through columnar storage conversion engine Convert to snapshot fragment S k Its storage structure satisfies:

[0018]

[0019] Where Γ is a preset columnar storage template, Φ is a transformation function that maps the dataset to a columnar storage file, and each S k Stored separately as a Parquet file; the file path includes the window index k and the close timestamp.

[0020] According to a specific implementation of an embodiment of the present invention, the specific steps of S3 are as follows:

[0021] Based on the snapshot fragment sequence {S1,S2,...,S... n Construct an incremental storage structure for the currently generated snapshot fragment S. k A unique version identifier is assigned, and its generation rules satisfy the following:

[0022] V k =H(S) k-1 .V||hash(S k ))

[0023] Where H is the cryptographic hash function, S k-1 .V represents the predecessor snapshot version number, || represents the bit string concatenation operation, hash(S k A version pointer association mechanism is established by using the hash digest of the current snapshot fragment content and defining a forward pointer P. f and backward pointer P b :

[0024] S k →P f (S k ) = NULL

[0025] S k →P b (S k ) = V k-1

[0026] S k-1 →P f (S K-1 ) = V k

[0027] Here, → indicates a pointer assignment operation, NULL indicates the end of the chain, and the current snapshot fragment S is calculated. k Compared to the previous version S k-1 Columnar differences:

[0028] Δk =Ψ(S k ,S k-1 )

[0029] Where Ψ is the difference calculation function, Δ k To store the difference packets, only the changed data is stored, forming an incremental snapshot chain. Each node contains a version identifier, difference data, and a pointer triplet.

[0030] According to a specific implementation of an embodiment of the present invention, the specific steps of S4 are as follows:

[0031] When the target time point t is received query When a backtracking request is made, a version chain backtracking operation is performed. First, the target window index is calculated:

[0032]

[0033] Among them, t base The base timestamp is Δt, where Δt is the fixed window length. This represents the floor function, based on index k. target Locating snapshot fragments and its version number Establish a backtracking transaction Where V current This indicates the latest snapshot version number. Indicates the target version number. Represents the set of backtracking paths, using a bidirectional pointer P. f and P b Construct version jump path:

[0034]

[0035] V min =min(V current V target )

[0036] V max =max(V current V target )

[0037] Among them, V current V represents the latest snapshot version number. min V indicates the lowest version. max This indicates the highest version. This represents the set of backtracking paths, where path nodes are verified for connectivity via pointers.

[0038] V i →P f =V i+1

[0039] Among them, P f This indicates a forward pointer; if the path is not continuous, it returns error code ε. chain Apply version locks during transaction execution:

[0040]

[0041] Where Λ(V) represents the version lock, This represents the set of backtracking paths, and the locking mechanism ensures the backtracking path... The version involved cannot be modified during the transaction; output target snapshot reference:

[0042]

[0043] Where path(·) is the physical storage path extraction function, V target Indicates the target version number. Indicates a snapshot fragment. This indicates a reference to the target snapshot.

[0044] According to a specific implementation of an embodiment of the present invention, the specific steps of S5 are as follows:

[0045] Reference to the target snapshot based on the output of the backtracking transaction and incremental snapshot chain Perform multi-version data reconstruction and merge the starting point version V. base For the closest to target version V target Full benchmark snapshot:

[0046] V base =max{V j |V j ≤V target ∧β(V j )=true}

[0047] Where β is the baseline snapshot determination function, when V j For a complete snapshot, β(V) j If ) = true, calculate the increment sequence to be applied:

[0048] Ω={Δ k |V base <Δ k ≤V target}

[0049] Where, Δ k To store the difference packets, V base V represents the base snapshot version number. target Indicates the target version number, m is the version index, and constructs the fusion operator.

[0050]

[0051] Among them, S base Represents baseline snapshot data, Δ base+1 Δ target Indicates a specific version incremental package. The incremental application operator is mathematically defined as follows:

[0052]

[0053] Where S represents the input data state, Δ represents a single incremental packet, and Γ is the columnar storage template. For columnar data merging operators, Γ -1 The storage format deserialization function performs memory-optimized fusion and loads the baseline snapshot S. base To columnar memory buffer Sequential application of incremental packages:

[0054]

[0055]

[0056] Where Γ is the columnar storage template, Ω represents the set of incremental packages to be applied, and the final target time point t is generated. query Complete data view Its storage format satisfies:

[0057]

[0058] Where, Φ -1 This is the inverse operation of the transformation function Φ.

[0059] According to a specific implementation of an embodiment of the present invention, the specific steps of S6 are as follows:

[0060] Data view V generated based on multi-version fusion target To ensure data consistency, define a data integrity verification function χ:

[0061]

[0062] Where H is the cryptographic hash function, Φ is the row-column transformation function, and V target For the target version number; when When this occurs, the anomaly recovery mechanism is triggered, and a recovery path matrix is ​​constructed:

[0063]

[0064] Where, δ i =||Vtarget -V i || represents the Manhattan distance, ρ(Vi) is the baseline snapshot path extraction function, and p is the number of candidate baseline snapshots; the optimal recovery source V is selected. recover :

[0065]

[0066] Where, δ i This represents the Manhattan distance of the version, where λ is the weighting factor for the full snapshot. It is an indicator function, when β(V) i If ) = true, set the value to 0; otherwise, set the value to 1 and perform incremental replay.

[0067]

[0068] in, For the fusion operator, V recover Indicates the optimal recovery source. Indicates restoring the baseline snapshot, Δ j This indicates an incremental difference packet; after replay, double verification is performed.

[0069]

[0070] Where ζ represents the recovery verification result, ∧ represents the logical AND operation, χ represents the data integrity verification function, and t query This represents the query request time point, where τ is the metadata extraction function. If ζ = true, update the final output; otherwise, return error code ε. integrity Record the recovery trajectory

[0071]

[0072] Where Ω is the set of incremental packets, ζ represents the recovery verification result, and ← represents the log append operation. Attached Figure Description

[0073] Figure 1 This is a flowchart of the method;

[0074] Figure 2 This is the architecture diagram of this method. Detailed Implementation

[0075] To facilitate understanding and implementation of the present invention by those skilled in the art, the present invention will be further described in detail below with reference to examples and accompanying drawings.

[0076] As attached Figure 1 and attached Figure 2 As shown, a snapshot integration method for heterogeneous data lakes of offshore wind farms that supports dynamic backtracking includes the following steps:

[0077] Step 1: Receive real-time monitoring data streams and offline survey data from offshore wind farms via a distributed message queue. Invoke a dynamic metadata parser to automatically extract data source format features. Based on the feature matching results, activate the corresponding data mode adapter to generate a unified data object. Specifically, receive real-time monitoring data streams and offline survey data from offshore wind farms via a distributed message queue, defining the real-time data stream as D... stream ={d1,d2,...,d n}, where d i This represents a single real-time monitoring record; the offline dataset is D. batch ={D1,D2,...,D m}, D j This represents a single batch file, which uses a dynamic metadata parser to extract data source format features and construct a feature vector. f type Identify the data source type, f size f represents the data size. schema Describe the data structure, activate the corresponding data pattern adapter based on the feature matching result, and the matching logic is as follows:

[0078]

[0079] Where K is the set of adapters, Let ||·|| be the preset feature vector of the k-th adapter, and ||·|| be the Euclidean distance calculation. The adapter transforms heterogeneous data into a unified data object UO = {schema, payload, timestamp}, where schema describes the data structure, payload stores the actual data content, and timestamp records the timestamp when the data is generated.

[0080] Step 2: Divide the data into continuous time windows based on the data timestamps, and trigger a snapshot generation event when each window is closed, converting the data within the window into independent snapshot fragments according to the columnar storage structure;

[0081] Based on the timestamp field of the Unified Data Object (UO), the data stream is divided into a continuous sequence of time windows; the time window length parameter Δt is defined, and the k-th time window is represented as:

[0082] W k =[t base +(k-1)·Δt,t base +k·Δt)

[0083] Among them, t base The base timestamp is k, and the window index is k. When the system time is t... current Satisfying tcurrent ≥t base When +k·Δt, the window close event E is triggered. close In E close In the event, the collection window W k All elements satisfying UO.timestamp∈W k A unified object that constitutes a dataset Through columnar storage conversion engine Convert to snapshot fragment S k Its storage structure satisfies:

[0084]

[0085] Where Γ is a preset columnar storage template, Φ is a transformation function that maps the dataset to a columnar storage file, and each S k Stored separately as a Parquet file; the file path includes the window index k and the close timestamp.

[0086] Step 3: Generate a unique version identifier for the current snapshot fragment, establish a bidirectional version pointer based on the storage path of the previous snapshot, and merge the differences in the columnar storage files to form an incremental snapshot chain;

[0087] Based on the snapshot fragment sequence {S1,S2,...,S... n Construct an incremental storage structure for the currently generated snapshot fragment S. k A unique version identifier is assigned, and its generation rules satisfy the following:

[0088] V k =H(S) k-1 .V||hash(S k ))

[0089] Where H is the cryptographic hash function, S k-1 .V represents the predecessor snapshot version number, || represents the bit string concatenation operation, hash(S k A version pointer association mechanism is established by using the hash digest of the current snapshot fragment content and defining a forward pointer P. f and backward pointer P b :

[0090] S k →P f (S k ) = NULL

[0091] S k →P b (S k ) = V k-1

[0092] Sk-1 →P f (S k-1 ) = V k

[0093] Here, → indicates a pointer assignment operation, NULL indicates the end of the chain, and the current snapshot fragment S is calculated. k Compared to the previous version S k-1 Columnar differences:

[0094] Δ k =Ψ(S k ,S k-1 )

[0095] Where Ψ is the difference calculation function, Δ k To store the difference packets, only the changed data is stored, forming an incremental snapshot chain. Each node contains a version identifier, difference data, and a pointer triplet;

[0096] Step 4: Receive the historical status query request submitted by the user, parse the target time range parameter in the request, and locate the set of continuous snapshot segments that meet the time range along the incremental snapshot chain;

[0097] When the target time point t is received query When a backtracking request is made, a version chain backtracking operation is performed. First, the target window index is calculated:

[0098]

[0099] Among them, t base The base timestamp is Δt, where Δt is the fixed window length. This represents the floor function, based on index k. target Locating snapshot fragments and its version number Establish a backtracking transaction Where V current This indicates the latest snapshot version number. Indicates the target version number. Represents the set of backtracking paths, using a bidirectional pointer P. f and P b Construct version jump path:

[0100]

[0101] V min =min(V current V target )

[0102] V max =max(V current Vtarget )

[0103] Among them, V current V represents the latest snapshot version number. min V indicates the lowest version. max This indicates the highest version. This represents the set of backtracking paths, where path nodes are verified for connectivity via pointers.

[0104] V i →P f =V i+1

[0105] Among them, P f This indicates a forward pointer; if the path is not continuous, it returns error code ε. chain Apply version locks during transaction execution:

[0106]

[0107] Where Λ(V) represents the version lock, This represents the set of backtracking paths, and the locking mechanism ensures the backtracking path... The version involved cannot be modified during the transaction; output target snapshot reference:

[0108]

[0109] Where path(·) is the physical storage path extraction function, V target Indicates the target version number. Indicates a snapshot fragment. Indicates a reference to the target snapshot;

[0110] Step 5: Load the columnar storage file of the target snapshot fragment set, filter version conflict data through the multi-version concurrency control engine, and output a consistent historical state view after sorting by time dimension:

[0111] Reference to the target snapshot based on the output of the backtracking transaction and incremental snapshot chain Perform multi-version data reconstruction and merge the starting point version V. base For the closest to target version V target Full benchmark snapshot:

[0112] V base =max{V j |V j ≤V target ∧β(V j )=true}

[0113] Where β is the baseline snapshot determination function, when V j For a complete snapshot, β(V)j If ) = true, calculate the increment sequence to be applied:

[0114] Ω={Δ k |V base <Δ k ≤V target}

[0115] Where, Δ k To store the difference packets, V base V represents the base snapshot version number. target Indicates the target version number, m is the version index, and constructs the fusion operator.

[0116]

[0117] Among them, S base Represents baseline snapshot data, Δ base+1 Δ target Indicates a specific version incremental package. The incremental application operator is mathematically defined as follows:

[0118]

[0119] Where S represents the input data state, Δ represents a single incremental packet, and Γ is the columnar storage template. For columnar data merging operators, Γ -1 The storage format deserialization function performs memory-optimized fusion and loads the baseline snapshot S. base To columnar memory buffer Sequential application of incremental packages:

[0120]

[0121] Where Γ is the columnar storage template, Ω represents the set of incremental packages to be applied, and the final target time point t is generated. query Complete data view Its storage format satisfies:

[0122]

[0123] Where, Φ -1 This is the inverse operation of the transformation function Φ;

[0124] Step 6: Monitor data source structure change events, record schema change logs in new snapshots, and dynamically rewrite historical snapshot query statements based on backward compatibility rules.

[0125] Data view V generated based on multi-version fusion target To ensure data consistency, define a data integrity verification function χ:

[0126]

[0127] Where H is the cryptographic hash function, Φ is the row-column transformation function, and V target For the target version number; when When this occurs, the anomaly recovery mechanism is triggered, and a recovery path matrix is ​​constructed:

[0128]

[0129] Where, δ i =||V target -V i || represents the Manhattan distance, ρ(V) i ) represents the baseline snapshot path extraction function, and p represents the number of candidate baseline snapshots; the optimal recovery source V is selected. recover :

[0130]

[0131] Where, δ i This represents the Manhattan distance of the version, where λ is the weighting factor for the full snapshot. It is an indicator function, when β(V) i If ) = true, set the value to 0; otherwise, set the value to 1 and perform incremental replay.

[0132]

[0133] Where F is the fusion operator, V recover SV represents the optimal recovery source. recover Indicates restoring the baseline snapshot, Δ j This indicates an incremental difference packet; after replay, double verification is performed.

[0134]

[0135] Where ζ represents the recovery verification result, ∧ represents the logical AND operation, χ represents the data integrity verification function, and t query This represents the query request time point, where τ is the metadata extraction function. If ζ = true, update the final output; otherwise, return error code ε. integrity Record the recovery trajectory

[0136]

[0137] Where Ω is the set of incremental packets, ζ represents the recovery verification result, and ← represents the log append operation.

Claims

1. A snapshot integration method for heterogeneous data lakes of offshore wind farms supporting dynamic backtracking, characterized in that... Includes the following steps: S1: Receives real-time monitoring data streams and offline survey data from offshore wind farms via a distributed message queue. It then calls a dynamic metadata parser to automatically extract data source format features. Based on the feature matching results, it activates the corresponding data mode adapter to generate a unified data object. Specifically, it receives real-time monitoring data streams and offline survey data from offshore wind farms via a distributed message queue, defining the real-time data stream as D... stream ={d1,d2,...,d n }, where d i This represents a single real-time monitoring record; the offline dataset is D. batch ={D1,D2,...,D m }, D j This represents a single batch file, which uses a dynamic metadata parser to extract data source format features and construct a feature vector. f type Identify the data source type, f size f represents the data size. schema Describe the data structure, activate the corresponding data pattern adapter based on the feature matching result, and the matching logic is as follows: Where K is the set of adapters, Let ||·|| be the preset feature vector of the k-th adapter, and ||·|| be the Euclidean distance calculation. The adapter transforms heterogeneous data into a unified data object UO = {schema, payload, timestamp}, where schema describes the data structure, payload stores the actual data content, and timestamp records the timestamp when the data is generated. S2: Divide continuous time windows according to data timestamps, and trigger a snapshot generation event when each window is closed, converting the data in the window into independent snapshot fragments according to the columnar storage structure; S3: Generate a unique version identifier for the current snapshot fragment, establish a bidirectional version pointer based on the storage path of the previous snapshot, and merge the differences in the columnar storage files to form an incremental snapshot chain; S4: Receive the historical status query request submitted by the user, parse the target time range parameter in the request, and locate the set of continuous snapshot segments that meet the time range along the incremental snapshot chain; S5: Load the columnar storage file of the target snapshot fragment set, filter version conflict data through the multi-version concurrency control engine, and output a consistent historical state view after sorting by time dimension; S6: Monitor data source structure change events, record schema change logs in new snapshots, and dynamically rewrite historical snapshot query statements based on backward compatibility rules.

2. The method for integrating snapshots of heterogeneous data lakes of offshore wind farms supporting dynamic backtracking as described in claim 1, characterized in that... The specific method for step S2 is as follows: Based on the timestamp field of the Unified Data Object (UO), the data stream is divided into a continuous sequence of time windows; the time window length parameter Δt is defined, and the k-th time window is represented as: W k =[t base +(k-1)·Δt,t base +k·Δt) Among them, t base The base timestamp is k, and the window index is k. When the system time is t... current Satisfying t current ≥t base When +k·Δt, the window close event E is triggered. close In E close In the event, the collection window W k All elements satisfying UO.timestamp∈W k A unified object that constitutes a dataset Through columnar storage conversion engine Convert to snapshot fragment S k Its storage structure satisfies: Where Γ is a preset columnar storage template, Φ is a transformation function that maps the dataset to a columnar storage file, and each S k Stored separately as a Parquet file; the file path includes the window index k and the close timestamp.

3. The method for integrating snapshots of heterogeneous data lakes of offshore wind farms supporting dynamic backtracking as described in claim 1, characterized in that... The specific method in step S3 is as follows: Based on the snapshot fragment sequence {S1,S2,...,S... n Construct an incremental storage structure for the currently generated snapshot fragment S. k A unique version identifier is assigned, and its generation rules satisfy the following: V k =H(S k-1 .V||hash(S k )) Where H is the cryptographic hash function, S k-1 .V represents the predecessor snapshot version number, || represents the bit string concatenation operation, hash(S k A version pointer association mechanism is established by using the hash digest of the current snapshot fragment content and defining a forward pointer P. f and backward pointer P b : S k →P f (S k )=NULL S k →P b (S k )=V k-1 S k-1 →P f (S k-1 )=V k Here, → indicates a pointer assignment operation, NULL indicates the end of the chain, and the current snapshot fragment S is calculated. k Compared to the previous version S k-1 Columnar differences: D k =Ψ(S k ,S k-1 ) Where Ψ is the difference calculation function, Δ k To store the difference packets, only the changed data is stored, forming an incremental snapshot chain. Each node contains a version identifier, difference data, and a pointer triplet.

4. The method for integrating snapshots of heterogeneous data lakes of offshore wind farms supporting dynamic backtracking as described in claim 1, characterized in that... The specific steps in step S4 are as follows: When the target time point t is received query When a backtracking request is made, a version chain backtracking operation is performed. First, the target window index is calculated: Among them, t base The base timestamp is Δt, where Δt is the fixed window length. This represents the floor function, based on index k. target Locating snapshot fragments and its version number Establish a backtracking transaction Where V current This indicates the latest snapshot version number. Indicates the target version number. Represents the set of backtracking paths, using a bidirectional pointer P. f and P b Construct version jump path: V min =min(V current ,V target ) V max =max(V current ,V target ) Among them, V current V represents the latest snapshot version number. min V indicates the lowest version. max This indicates the highest version. This represents the set of backtracking paths, where path nodes are verified for connectivity via pointers. V i →P f =V i+1 Among them, P f This indicates a forward pointer; if the path is not continuous, it returns error code ε. chain Apply version locks during transaction execution: Where Λ(V) represents the version lock, This represents the set of backtracking paths, and the locking mechanism ensures the backtracking path... The version involved cannot be modified during the transaction; output target snapshot reference: Where path(·) is the physical storage path extraction function, V target Indicates the target version number. Indicates a snapshot fragment. This indicates a reference to the target snapshot.

5. The method for integrating snapshots of heterogeneous data lakes of offshore wind farms supporting dynamic backtracking as described in claim 1, characterized in that... The specific steps in step S5 are as follows: Reference to the target snapshot based on the output of the backtracking transaction and incremental snapshot chain Perform multi-version data reconstruction and merge the starting point version V. base For the closest to target version V target Full benchmark snapshot: V base =max{V j ∣V j ≤V target ∧β(V j )=true} in, β is the baseline snapshot determination function, when V j For a complete snapshot, β(V) j If ) = true, calculate the increment sequence to be applied: Ω={D k ∣V base <D k ≤V target } Where, Δ k To store the difference packets, V base V represents the base snapshot version number. target Indicates the target version number, m is the version index, and constructs the fusion operator. Among them, S base Represents baseline snapshot data, Δ base+1 Δ target Indicates a specific version incremental package. The incremental application operator is mathematically defined as follows: Where S represents the input data state, Δ represents a single incremental packet, and Γ is the columnar storage template. For columnar data merging operators, Γ -1 The storage format deserialization function performs memory-optimized fusion and loads the baseline snapshot S. base To columnar memory buffer Apply incremental packages sequentially: Where Γ is the columnar storage template, Ω represents the set of incremental packages to be applied, and the final target time point t is generated. query Complete data view Its storage format satisfies: Where, Φ -1 This is the inverse operation of the transformation function Φ.

6. The method for integrating snapshots of heterogeneous data lakes of offshore wind farms supporting dynamic backtracking as described in claim 1, characterized in that... The specific steps in step S6 are as follows: Data view V generated based on multi-version fusion target To ensure data consistency, define a data integrity verification function χ: Where H is the cryptographic hash function, Φ is the row-column transformation function, and V target For the target version number; when When this occurs, the anomaly recovery mechanism is triggered, and a recovery path matrix is ​​constructed: Where, δ i =||V target -V i || represents the Manhattan distance, ρ(V) i ) represents the baseline snapshot path extraction function, and p represents the number of candidate baseline snapshots; the optimal recovery source V is selected. recover : Where, δ i This represents the Manhattan distance of the version, where λ is the weighting factor for the full snapshot. It is an indicator function, when β(V) i If ) = true, set the value to 0; otherwise, set the value to 1 and perform incremental replay. in, For the fusion operator, V recover Indicates the optimal recovery source. Indicates restoring the baseline snapshot, Δ j This indicates an incremental difference packet; after replay, double verification is performed. Where ζ represents the recovery verification result, ∧ represents the logical AND operation, χ represents the data integrity verification function, and t query This represents the query request time point, where τ is the metadata extraction function. If ζ = true, update the final output; otherwise, return error code ε. integrity Record the recovery trajectory Where Ω is the set of incremental packets, ζ represents the recovery verification result, and ← represents the log append operation.

Images