Data integration, stacked drag-and-drop visualization execution methods, devices, equipment, and media

Abstract

This disclosure presents embodiments of a data integration stacked drag-and-drop visualization execution method, apparatus, device, and medium. One specific implementation of the method includes: generating a stacked component template library; displaying the stacked component template library on a visualization canvas; converting stacked drag-and-drop operations into an initial stacked blueprint; obtaining an initial verification result; performing the following cleaning steps: obtaining a cleaned initial stacked blueprint; obtaining a complete stacked blueprint; obtaining the verification result; and performing the following steps: generating an executable execution topology; and executing the execution topology. This implementation improves configuration efficiency and execution stability in data integration stacked drag-and-drop visualization execution tasks.

Description

Technical Field

[0001] The embodiments disclosed herein relate to the field of computer technology, and more specifically to a data integration stacked drag-and-drop visualization execution method, apparatus, device, and medium. Background Technology

[0002] A stacked drag-and-drop visual execution method for data integration can improve the configuration accuracy and execution stability of data integration tasks. Currently, when performing data integration tasks visually, the common approach is to achieve data integration or service orchestration through a graphical canvas, connector components, and connection line components, and then parse the drag-and-drop results into executable scripts, configuration files, or task topologies.

[0003] However, in practice, it has been found that when using the above methods to visualize and perform data integration tasks, the following technical problems often arise: When data integration or service orchestration is achieved through graphical canvases, connector components, and connection line components, and components are dragged and dropped, and the dragged component results are parsed into executable scripts, configuration files, or task topologies through automatic configuration file generation, only the connection of the dragged components is considered, without taking into account the hierarchical semantics of the dragged components. This results in poor stacked semantic modeling capabilities for data integration processing layers, an inability to clean and verify dragged results, and consequently, low accuracy of the dragged components. Consequently, the stability of the dragged results converted into backend executable topologies is poor, and the configuration time is long when performing data integration stacked drag-and-drop visualization execution tasks based on dragged components with low accuracy.

[0004] The information disclosed in this background section is only intended to enhance the understanding of the background of the inventive concept, and therefore may contain information that does not constitute prior art known to those skilled in the art. Summary of the Invention

[0005] The summary portion of this disclosure is intended to provide a brief overview of the concepts, which will be described in detail in the detailed description portion. This summary portion is not intended to identify key or essential features of the claimed technical solutions, nor is it intended to limit the scope of the claimed technical solutions.

[0006] Some embodiments of this disclosure provide a data integration stacked drag-and-drop visualization execution method, apparatus, electronic device, and computer-readable medium to address one or more of the technical problems mentioned in the background section above.

[0007] In a first aspect, some embodiments of this disclosure provide a data integration stacked drag-and-drop visualization execution method, the method comprising: generating a stacked component template library based on a preset set of stacked component groups; displaying the stacked component template library on a visualization canvas; in response to detecting a target user's stacked drag-and-drop operation on stacked components in the displayed stacked component template library, converting the stacked drag-and-drop operation into an initial stacked blueprint; performing a verification process on the initial stacked blueprint to obtain an initial verification result; in response to the initial verification result indicating verification failure, performing the following cleaning steps: performing a cleaning process on the initial stacked blueprint to obtain a cleaned initial stacked blueprint; in response to detecting a target user's selection operation on a candidate method confirmation control displayed on the visualization canvas, determining the cleaned initial stacked blueprint as a complete stacked blueprint; performing a verification process on the complete stacked blueprint to obtain a verification result; in response to the verification result indicating verification success, performing the following steps: generating an executable execution topology based on the complete stacked blueprint; in response to detecting a target user's selection operation on a release confirmation control displayed on the visualization canvas, executing the execution topology.

[0008] Secondly, some embodiments of this disclosure provide a data integration stacked drag-and-drop visualization execution apparatus, the apparatus comprising: a generation unit configured to generate a stacked component template library according to a preset set of stacked component groups; a display unit configured to display the stacked component template library on a visualization canvas; a conversion unit configured to convert the stacked drag-and-drop operation into an initial stacked blueprint in response to detecting a target user's stacked drag-and-drop operation on stacked components in the displayed stacked component template library; a first verification unit configured to perform verification processing on the initial stacked blueprint to obtain an initial verification processing result; and a first execution unit configured to execute a method in response to the initial verification processing result indicating verification failure. The cleaning steps are as follows: The initial stacked blueprint is cleaned to obtain a cleaned initial stacked blueprint; in response to detecting the target user's selection operation on the candidate method confirmation control displayed in the visualization canvas, the cleaned initial stacked blueprint is determined as a complete stacked blueprint; a second verification unit is configured to verify the complete stacked blueprint to obtain a verification result; a second execution unit is configured to, in response to the verification result indicating successful verification, execute the following steps: Based on the complete stacked blueprint, an executable execution topology is generated; in response to detecting the target user's selection operation on the release confirmation control displayed in the visualization canvas, the execution topology is executed.

[0009] Thirdly, some embodiments of this disclosure provide an electronic device, including: one or more processors; and a storage device having one or more programs stored thereon, wherein when the one or more programs are executed by the one or more processors, the one or more processors implement the method described in any implementation of the first aspect above.

[0010] Fourthly, some embodiments of this disclosure provide a computer-readable medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the method described in any of the implementations of the first or second aspect.

[0011] The above embodiments of this disclosure have the following beneficial effects: A data integration stacked drag-and-drop visualization execution method according to some embodiments of this disclosure improves the stacked semantic modeling capability during data integration stacked drag-and-drop visualization execution tasks, thereby shortening configuration time, improving the stability of the executable topology, and ultimately improving the stability of task execution performance. Specifically, the reason for the long configuration time and low execution stability during data integration stacked drag-and-drop visualization execution tasks is that when data integration or service orchestration is achieved through a graphical canvas, connector components, and connection line components, and components are dragged and dropped, and the dragged component results are parsed into executable scripts, configuration files, or task topologies through automatic configuration file generation, only the connection of the dragged components is considered, without taking into account the hierarchical semantics corresponding to the dragged components. This results in poor stacked semantic modeling capability at the data integration processing level, inability to clean and verify the dragged results, and consequently, low accuracy of the dragged components. This leads to poor stability in converting the dragged results into the backend executable topology, and long configuration time when performing data integration stacked drag-and-drop visualization execution tasks based on dragged components with low accuracy. Based on this, the data integration stacked drag-and-drop visualization execution method of some embodiments of this disclosure first generates a stacked component template library according to a preset set of stacked component groups. This allows the generation of a stacked component template library for target users to select stacked components to perform data integration tasks. Then, the stacked component template library is displayed on a visualization canvas. This allows the target user to select components from the displayed stacked component template library. Subsequently, in response to detecting a stacked drag-and-drop operation by the target user on stacked components in the displayed stacked component template library, the stacked drag-and-drop operation is converted into an initial stacked blueprint. This yields an initial stacked blueprint, providing the user with a visually editable, verifiable, and deployable architectural blueprint as a starting point for low-code development. Subsequently, the initial stacked blueprint is validated to obtain an initial validation result. This initial validation result ensures the initial stacked blueprint has basic feasibility. Then, in response to the initial validation result indicating validation failure, the following cleaning steps are performed: First, the initial stacked blueprint is cleaned to obtain a cleaned initial stacked blueprint. This yields a cleaned initial stack blueprint, used to eliminate redundancy, conflicts, or invalid configurations, providing the infrastructure for subsequent interactive editing. Then, in response to detecting a user's selection action on the candidate method confirmation control displayed in the visualization canvas, the cleaned initial stack blueprint is identified as the complete stack blueprint. This complete stack blueprint provides the user with a visually editable, validated, and deployable architecture blueprint. Subsequently, the complete stack blueprint undergoes validation processing, resulting in a validation result. This validation result ensures the complete stack blueprint possesses basic feasibility.Subsequently, in response to the successful verification result, the following steps are executed: First, an executable execution topology is generated based on the complete stacking blueprint. This allows for the generation of an executable execution topology that constrains the scheduling of components according to the correct dependencies and order at runtime. Then, in response to detecting the target user's selection operation on the release confirmation control displayed in the visualization canvas, the execution topology is executed. This allows the data integration task to be executed based on the execution topology. Because data integration or service orchestration is not achieved through graphical canvases, connector components, and connecting wire components, and drag-and-drop results are not parsed into executable scripts, configuration files, or task topologies, but rather through a pre-defined set of stacked component groups, a stacked component template library is generated. This allows for the acquisition of the hierarchical semantics of drag-and-drop components, thereby improving the stacked semantic modeling capability of the data integration processing hierarchy. Furthermore, the complete stacking blueprint is obtained through a cleansing method for the generation engine and verification processing, resulting in the stable generation of executable execution topologies. This improves task configuration efficiency and the stability of task execution performance, and reduces the configuration time when performing data integration stacked drag-and-drop visualization execution tasks using drag-and-drop components. Attached Figure Description

[0012] The above and other features, advantages, and aspects of the embodiments of this disclosure will become more apparent from the accompanying drawings and the following detailed description. Throughout the drawings, the same or similar reference numerals denote the same or similar elements. It should be understood that the drawings are schematic, and elements are not necessarily drawn to scale.

[0013] Figure 1 This is a flowchart of some embodiments of the data integration stacked drag-and-drop visualization execution method according to this disclosure; Figure 2 This is a structural schematic diagram of some embodiments of the data integration stacked drag-and-drop visualization execution device according to this disclosure; Figure 3 This is a schematic diagram of the structure of an electronic device suitable for implementing some embodiments of the present disclosure. Detailed Implementation

[0014] Embodiments of this disclosure will now be described in more detail with reference to the accompanying drawings. While some embodiments of this disclosure are shown in the drawings, it should be understood that this disclosure can be implemented in various forms and should not be construed as limited to the embodiments set forth herein. Rather, these embodiments are provided to provide a more thorough and complete understanding of this disclosure. It should be understood that the accompanying drawings and embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of protection of this disclosure.

[0015] It should also be noted that, for ease of description, only the parts relevant to the invention are shown in the accompanying drawings. Unless otherwise specified, the embodiments and features described in this disclosure can be combined with each other.

[0016] It should be noted that the concepts of "first" and "second" mentioned in this disclosure are used only to distinguish different devices, modules or units, and are not used to limit the order of functions performed by these devices, modules or units or their interdependencies.

[0017] It should be noted that the terms "a" and "a plurality of" used in this disclosure are illustrative rather than restrictive, and those skilled in the art should understand that, unless otherwise expressly indicated in the context, they should be understood as "one or more".

[0018] The names of messages or information exchanged between multiple devices in the embodiments of this disclosure are for illustrative purposes only and are not intended to limit the scope of such messages or information.

[0019] This disclosure will now be described in detail with reference to the accompanying drawings and embodiments.

[0020] Figure 1 A flow 100 of some embodiments of a data integration stacked drag-and-drop visualization execution method according to this disclosure is shown. This data integration stacked drag-and-drop visualization execution method includes the following steps: Step 101: Generate a stacked component template library based on the preset stacked component group set.

[0021] In some embodiments, the execution entity (e.g., a computing device) of the data integration stacked drag-and-drop visualization execution method can generate a stacked component template library based on a preset set of stacked component groups. The preset set of stacked component groups can be a collection of pre-defined preset stacked component groups. These preset stacked component groups can be collections of components of the same type, including components of the same type. For example, the components can be programmable components for user-visualized operation, configuration, and preview. The stacking method of the preset stacked component groups included in the preset set can be scroll stacking, grid stacking, or vertical stacking. The preset set of stacked component groups can be displayed on a visualization canvas. This visualization canvas can represent a graphical user interface for performing data integration tasks. Here, the component types of each component included in the aforementioned preset stacked component group are not specifically limited. For example, a component type can be a component for data processing or a component for component verification. A component for data processing can be a data cleaning component, which can remove duplicates and fill in null values. A component for component verification can be a quality verification component, which can verify the integrity and uniqueness of a component. The integrity verification indicates whether the connection between the stacked component and other components is correct. The uniqueness verification indicates whether the preset stacked component is used only once in the data integration task. Here, the type of the preset stacked component is not specifically set and can be set according to requirements. For example, the preset stacked component can be a component used to start the task. Here, the task type of the aforementioned data integration task is not limited and can be set according to actual needs. For example, the task type of the data integration task can be a batch processing task. In practice, the aforementioned execution entity can set an initially empty stacked component template library. The aforementioned stacked component template library can represent a pre-defined set for storing stacked components. Then, each stacking component included in the above-mentioned preset stacking component group set is stored in the above-mentioned initially empty stacking component template library.

[0022] In addressing the technical problems mentioned above, and considering the application scenario—peak marketing periods on e-commerce platforms—a second technical problem often arises: When using graphical canvases, connector components, and connecting wires for service orchestration during peak e-commerce marketing periods, users need to manually locate and correctly connect components from the graphical canvas. This process is cumbersome, has a high error rate, and consequently leads to low marketing efficiency, long configuration times, and low stability on the e-commerce platform. Given the following requirements for this application scenario: user-driven natural language processing, intelligent component combination, and high demands for efficient service orchestration configuration and stability, we have decided to adopt the following solution: Optionally, after step 101, the aforementioned executing entity may, in response to receiving the user semantic requirement text input by the target user, parse the user semantic requirement text to obtain a semantic parsing result, wherein the semantic parsing result can characterize the parsed user semantic requirement text. The semantic parsing result includes data integration requirements and task orchestration requirements. The target user can be any user with data integration task operation permissions. The user semantic requirement text can characterize the text describing the task objective by the target user in natural language. For example, the task objective could be: extract new data from the order table of the production system at 8:00 AM every day and clean up invalid orders, and recheck the order table at 10:00 AM every day to see if there are any orders that need to be cleaned up. The data integration requirement can characterize the requirements for the data source set to achieve the task objective. For example, the data integration requirement could be "extracting new data requirement and cleaning data requirement (e.g., extracting new data from the order table of the production system and cleaning up invalid orders)". The task orchestration requirement can characterize the task flow requirements set to achieve the task objective. For example, the task flow requirements at least include the task execution order. The task execution order can be "executed in chronological order (e.g., first, extract new data at 8:00 AM daily and clean up invalid orders, then recheck the order table at 10:00 AM daily for any orders that need to be cleaned up)." In practice, the aforementioned execution entity can use a pre-trained language model to parse and process the aforementioned user semantic requirement text to obtain data integration requirements and task orchestration requirements. For example, the aforementioned pre-trained language model can be BERT. The aforementioned pre-trained language model can be trained through the following steps: obtain a training sample set, in which the training samples include sample text recording the sample user semantic requirement text and the standard semantic parsing results corresponding to the sample text, wherein the aforementioned standard semantic parsing results at least include standard data integration requirements and standard task orchestration requirements; use the sample text of the training samples in the aforementioned training sample set as input, and use the standard semantic parsing results corresponding to the input sample text as the expected output to train the BERT model, obtaining the trained BERT model as the pre-trained language model.

[0023] Then, using the aforementioned stacked component template library, the data integration requirements are matched to obtain the corresponding stacked components. In practice, the executing entity can determine the corresponding preset integration requirement relationships from a set of preset integration requirement relationships. Then, the stacked components in the stacked component template library corresponding to each determined preset integration requirement relationship are identified as the stacked components corresponding to the data integration requirements, resulting in the various stacked components. The preset integration requirement relationships in the aforementioned set of preset integration requirement relationships can characterize the correspondence between data integration requirements and stacked components. For example, a preset integration requirement relationship could be: "Data integration requirement: data cleaning requirement, stacked component: component used to process data."

[0024] Subsequently, the aforementioned task orchestration requirements are matched using a pre-defined orchestration task library to obtain corresponding task orchestration components. This pre-defined orchestration task library represents a pre-set collection for storing pre-built components containing various corresponding task flow requirements. For example, components in the pre-defined orchestration task library can be components used for execution in chronological order. In practice, the executing entity can determine the corresponding pre-defined orchestration requirement relationships from the pre-defined orchestration requirement correspondence set. Then, the task orchestration components in the pre-defined orchestration task library corresponding to each determined pre-defined orchestration requirement correspondence are identified as the task orchestration components corresponding to the aforementioned task orchestration requirements, resulting in various task orchestration components. The pre-defined orchestration requirement correspondence relationships in the pre-defined orchestration requirement correspondence set represent the correspondence between task orchestration requirements and task orchestration components. For example, the pre-defined orchestration requirement correspondence relationship can be: "Task orchestration requirement: Execution in chronological order; Task orchestration component: Component used for execution in chronological order."

[0025] Subsequently, according to the preset component combination method, the stacked components and task orchestration components corresponding to the aforementioned data integration requirements are subjected to combination verification processing to obtain a candidate set of successfully verified component combinations. The preset component combination method represents the way the stacked components and task orchestration components are combined and verified using a preset verification algorithm. The component combinations in the candidate set of successfully verified component combinations represent the stacked components and task orchestration components that satisfy the preset component combination method. In practice, for each stacked component corresponding to the aforementioned data integration requirements, the execution entity can input the stacked component and each task orchestration component into the preset verification algorithm. In response to successful verification, the component combination consisting of the stacked components and task orchestration components that satisfy the preset component combination method is added to the candidate set of component combinations, thus obtaining a candidate set of successfully verified component combinations. For example, the preset verification algorithm can be the CSP (Constraint Satisfaction Problem) algorithm.

[0026] Then, feature extraction processing is performed on the historical result feedback data to obtain a historical success case feature library. This historical result feedback data can represent each successfully executed data integration task in history. The historical success case feature library can represent a knowledge base composed of feature vectors extracted from each data integration task included in the historical result feedback data. For example, the extracted features may include: component combination methods, performance indicators, and user feedback tags. The component combination methods can be the correspondence between stacked components and task orchestration components. The performance indicators can be the CPU utilization and memory utilization of executing the data integration task. The user feedback tags can represent the statements by which users evaluate the executed data integration task. In practice, the executing entity can use principal component analysis (PCA) to perform feature extraction processing on each data integration task included in the historical result feedback data, obtaining the extracted feature vector corresponding to each data integration task as the historical success case feature library.

[0027] Subsequently, based on the aforementioned historical successful case feature library, the similarity score between each component combination in the aforementioned successfully verified component combination candidate set and the aforementioned historical successful case feature library is determined, resulting in various similarity scores. These similarity scores characterize the degree of matching between the component combination and the feature vector of each data integration task in the aforementioned historical successful case feature library. For example, the similarity score can be a value greater than or equal to 0 and less than or equal to 1. In practice, for each component combination in the aforementioned successfully verified component combination candidate set, firstly, the aforementioned execution entity can use the Multi-Hot algorithm to vectorize the component combination to obtain the corresponding feature vector. Then, the cosine similarity is used to determine the similarity score between the aforementioned feature vector and each feature vector in the historical successful case feature library.

[0028] Subsequently, based on the aforementioned similarity scores, a weighted scoring process is applied to each component combination in the successfully verified candidate set, resulting in a scored candidate set of component combinations. Each scored component combination in this set represents a component combination with a score obtained after quantitative evaluation. In practice, firstly, the following steps are performed on each component combination in the successfully verified candidate set: the similarity score corresponding to the component combination and a preset auxiliary indicator are weighted and fused to obtain a score for the corresponding component combination. The preset auxiliary indicator can be the number of times the component combination has been historically invoked. Then, based on the obtained scores for each component combination, the component combinations in the successfully verified candidate set are sorted in descending order, resulting in the sorted successfully verified candidate set of component combinations, which is then used as the scored candidate set of component combinations.

[0029] Then, the component combination with the highest score in the candidate set of scored component combinations is selected as the optimal component combination, resulting in the stacked component mapping result. This stacked component mapping result characterizes the mapping relationship between the stacked components and orchestration components included in the optimal component combination. In practice, the mapping relationship between the stacked components and orchestration components included in the optimal component combination can be determined as the stacked component mapping result using a column field mapping matching algorithm.

[0030] Finally, based on the preset layout and the mapping results of the stacked components, an initial stacking blueprint is generated in the visualization canvas. The preset layout can be vertical stacking or horizontal arrangement. This initial stacking blueprint represents the initial process blueprint composed of the stacked components, used to express the execution flow of the data integration task. In practice, the executing entity can input the preset layout and the mapping results of the stacked components into a preset layout algorithm to generate the initial stacking blueprint in the visualization canvas. For example, the preset layout algorithm can be a linear layout.

[0031] The above-described technical solution, as an inventive point of this disclosure, solves technical problem two: "leading to low marketing efficiency, long configuration time, and low stability in e-commerce platforms." The reasons for this are as follows: When using a graphical canvas, connector components, and connecting wire components for service orchestration during peak marketing periods on e-commerce platforms, users need to manually find components from the graphical canvas and connect them correctly. This process is cumbersome and has a high error rate, resulting in low marketing efficiency, long configuration time, and low stability. To improve marketing efficiency, reduce configuration time, and enhance configuration stability, this disclosure identifies user needs by parsing their semantic requirement text. Then, based on a historical success case library, it recommends the optimal component combination for the user's needs, instead of using a graphical canvas, connector components, and connecting wire components for service orchestration during peak marketing periods on e-commerce platforms. Therefore, this improves marketing efficiency, reduces configuration time, and enhances configuration stability.

[0032] Step 102: Display the stacked component template library on the visualization canvas.

[0033] In some embodiments, the aforementioned execution entity may display the aforementioned stacked component template library on a visualization canvas.

[0034] Step 103: In response to detecting a stacked drag operation by the target user on stacked components in the displayed stacked component template library, the stacked drag operation is converted into an initial stacked blueprint.

[0035] In some embodiments, in response to detecting a target user's drag-and-drop operation on stacked components in the displayed stacked component template library, the execution entity can convert the drag-and-drop operation into an initial stacking blueprint. The drag-and-drop operation can be a single drag-and-drop operation performed by the target user on the visualization canvas, or a simultaneous drag-and-drop operation performed by the target user and other target users on the visualization canvas. It should be noted that multiple target users can simultaneously perform drag-and-drop operations on stacked components in the stacked component template library.

[0036] In addressing the technical problems mentioned above, and considering the application scenario—peak marketing periods on e-commerce platforms—the following technical problem often arises: When using graphical canvases, connector components, and connecting wire components for service orchestration during peak marketing periods on e-commerce platforms, if multiple users move existing components almost simultaneously (e.g., components for product carousels, coupon pop-ups, and countdown timers), the system may be unable to determine the order of operations, leading to component misalignment, loss of product-related data, and confusion of product information. This results in significant losses for the e-commerce platform, low configuration efficiency in service orchestration, and poor platform stability. Considering the following requirements for this application scenario: secure collaborative editing by multiple users, and high demands for configuration efficiency and stability in service orchestration, we have decided to adopt the following solution: In some optional implementations of certain embodiments, in response to detecting a target user's stacked drag operation on stacked components in the displayed stacked component template library, the aforementioned execution entity can convert the stacked drag operation into an initial stacked blueprint through the following steps: The first step involves generating operation data packets corresponding to the stacked drag-and-drop operation in response to the detection that the stacked drag-and-drop operation meets a preset concurrent drag-and-drop condition. Each operation data packet can correspond one-to-one with a user executing the stacked drag-and-drop operation in parallel. The operation data packets can include, but are not limited to, at least one of the following: a site identifier and an execution timestamp. The site identifier can represent a label for the user corresponding to the stacked drag-and-drop operation, used to distinguish different users. The execution timestamp can represent the time point in time when the stacked drag-and-drop operation occurs. The preset concurrent drag-and-drop condition can be that the number of users executing the stacked drag-and-drop operation within a preset time window is greater than or equal to a preset target number. For example, the preset time window can be within 5 seconds. The preset target number can be 2. In practice, the executing entity can determine the execution timestamp and the user's site identifier corresponding to each target user executing the stacked drag-and-drop operation as operation data packets to obtain each operation data packet.

[0037] The second step is to sort the aforementioned operation data packets to obtain an initial operation data packet sequence. This initial operation data packet sequence can be the operation data packets sorted chronologically according to their execution timestamps. In practice, the executing entity can sort the operation data packets chronologically according to the execution timestamps included in each operation data packet to obtain the sorted operation data packets as the initial operation data packet sequence.

[0038] The third step involves performing conflict detection processing on each operation data packet in the initial operation data packet sequence to obtain conflict detection result information. This conflict detection result information characterizes whether the execution order of the stacked drag-and-drop operations corresponding to each initial operation data packet in the initial operation data packet sequence conflicts, whether the dragged positions conflict simultaneously, and the specific details of the conflict. These specific details can be the cause of the conflict in the stacked drag-and-drop operations, used as input to the operation conversion algorithm to correct the operation data packets. For example, the conflict type label can be a timing conflict. In practice, the execution entity can perform the following detection processing on each initial operation data packet in the initial operation data packet sequence: First, timing conflict detection can be performed on the initial operation data packets using vector clocks to obtain structured timing conflict detection results. These timing conflict detection results can indicate whether there is a conflict in the execution order of the stacked drag-and-drop operations corresponding to the initial operation data packets and the specific details of the conflict. For example, the timing conflict detection result can indicate that a conflict exists, and the specific details of the conflict are that the timing relationship between the stacked component corresponding to the stacked drag-and-drop operation and the stacked component corresponding to an adjacent stacked drag-and-drop operation conflicts. Then, positional conflict detection can be performed on the above operation data packets using an interval tree method to obtain structured positional conflict detection results. These results can specify whether there is a conflict in the positions where the stacked drag operations corresponding to the initial operation data packets are dragged simultaneously, and the specific details of the conflict. For example, the result could be that a conflict exists, and the specific details are that at least two users simultaneously dragged the data packets to different positions. Finally, the positional conflict detection results and the temporal conflict detection results are combined to form the conflict detection result information.

[0039] Fourth, based on the operation conversion algorithm, the aforementioned site identifiers, and the aforementioned conflict detection results, each operation data packet in the initial operation data packet sequence is corrected to obtain a corrected initial operation data packet sequence as the final operation data packet sequence. The operation conversion algorithm can be an OT algorithm. The final operation data packet sequence can be the corrected initial operation data packet sequence, used to generate the initial stacking blueprint. In practice, the execution entity inputs the site identifier and specific conflict details corresponding to each operation data packet into the operation conversion algorithm for correction processing, and outputs the corrected initial operation data packet sequence as the final operation data packet sequence.

[0040] The fifth step involves generating an updated initial stack blueprint based on the aforementioned final operation data packet sequence. In practice, the executing entity can use a deterministic replay algorithm to determine each stack component corresponding to the final operation data packet sequence as the initial stack blueprint.

[0041] The above-described technical solution, as an inventive point of this disclosure, solves technical problem three: "leading to severe losses for e-commerce platforms, low configuration efficiency of service orchestration, and poor platform stability." The reasons for these problems are as follows: When using graphical canvases, connector components, and connecting wire components for service orchestration during peak marketing scenarios on e-commerce platforms, if multiple users move existing components almost simultaneously—such as components for product carousels, coupon pop-ups, and countdown timers—the system may be unable to determine the order of operations, resulting in component misalignment, loss of product-related data, and confusion of product information. This, in turn, leads to severe losses for e-commerce platforms, low configuration efficiency of service orchestration, and poor platform stability. To reduce losses on e-commerce platforms, improve the configuration efficiency of service orchestration, and enhance task stability, this disclosure uses concurrency detection to identify multi-user operations to obtain operation data packets. Then, it sorts the multi-user operations based on the execution timestamps in the operation data packets. Finally, it obtains the final concurrent operation result through conflict detection and automatic correction. This approach, instead of using a simple graphical canvas, connector components, and connecting wire components for service orchestration during peak marketing scenarios on e-commerce platforms, can reduce losses on e-commerce platforms, improve the configuration efficiency of service orchestration, and enhance task stability.

[0042] Optionally, after step 103, firstly, in response to detecting the target user's selection operation on the recommended insertion control displayed in the visualization canvas, the executing entity may also generate a recommended stacked component package based on the stacked component template library. The recommended insertion control can be a control used by the target user to determine whether to insert a recommended stacked component. The recommended stacked component package can represent the stacked components with the highest similarity recommended to the target user. Here, the specific method of selection is not limited; for example, it can be used to select the recommended insertion control displayed in the visualization canvas by clicking, swiping, or dragging.

[0043] In some optional implementations of certain embodiments, in response to detecting the target user's selection operation on the recommended insertion control displayed in the visualization canvas, the execution entity can generate a recommended stacked component package based on the stacked component template library through the following steps: The first step involves determining, in response to the existence of stacking components in the aforementioned stacking component template library that satisfy the recall constraints, that stacking component in the aforementioned stacking component template library that satisfies the recall constraints as an initial candidate component set. The recall constraints can be that the purpose of a stacking component in the stacking component template library is the same as the purpose of a stacking component that historically performed a data integration task, and that the data format of the stacking component is the same as the data format of each stacking component in the aforementioned initial stacking blueprint. The data format can characterize the data format of each stacking component in the aforementioned initial stacking blueprint. For example, the data format can be JSON.

[0044] The second step is to determine the recommended score for each initial candidate component in the aforementioned initial candidate component set, thus obtaining a recommended score set. Each recommended score in this set represents the matching degree between the initial candidate component and the current data integration task. For example, the recommended score could be 0.2. In practice, the executing entity can use a preset field compatibility mapping table to determine whether the field types of the initial candidate components and the current data integration task are compatible. This preset field compatibility mapping table represents the correspondence between the field types of stacked components in the stacked component template library and adjacent stacked components in the current data integration task. For example, the preset field compatibility mapping table could be: "Stacked component: sql_001, Field type: INT, Adjacent stacked component: sql_002, Field type: BIGINT, Compatibility: Yes". Then, a preset interface compatibility mapping table can be used to determine whether the interfaces of the stacked components in the stacked component template library and the interfaces of the stacked components in the current data integration task are compatible. This preset interface compatibility mapping table represents the correspondence between the stacked components in the stacked component template library and adjacent stacked components in the current data integration task. For example, the preset interface compatibility mapping table can be: "Stacked component: sql_001, Supported input protocol: JDBC, Supported output protocol: Kafka, then adjacent stacked component: sql_002, Supported input protocol: Kafka, Supported output protocol: Kafka, Compatibility: Yes". Subsequently, in response to determining that the above initial candidate component is compatible with the field type of the current data integration task but incompatible with the interface, or in response to determining that the above initial candidate component is incompatible with the field type of the current data integration task but compatible with the interface, the first value is determined as the structure matching degree. In response to determining that the above initial candidate component is compatible with the field type of the current data integration task and compatible with the interface, the second value is determined as the structure matching degree. In response to determining that the above initial candidate component is incompatible with the field type of the current data integration task and incompatible with the interface, the third value is determined as the structure matching degree. The above first value is 0.5. The above second value is 1. The above first value is 0. Then, using cosine similarity, the similarity between the above initial candidate component and the current data integration task is determined as the scene similarity. Subsequently, the ratio between the number of times the initial candidate component was invoked in similar contexts and the total number of similar contexts is determined as the historical reuse frequency. The similar contexts can be data integration tasks of the same type as the current data integration task. Here, the task type of the data integration task is not limited and can be set according to actual needs; for example, the task type of the data integration task can be ETL. Then, the ratio between the number of historical successful executions of the corresponding initial candidate component and the total number of historical executions is determined as the historical success rate.The aforementioned historical execution count can be the total number of times the initial candidate component was executed. Next, the ratio between the resource consumption of the initial candidate component and a preset resource consumption is determined as the target ratio. The resource consumption can be CPU utilization and memory utilization. The specific value of the preset resource consumption is not limited and can be set according to actual needs. Next, the aforementioned structural matching degree, scene similarity, historical reuse frequency, historical success rate, and target ratio are input into a preset weight formula to obtain the recommended score for each initial candidate component. As an example, the preset weight formula can be: Recommended Score = Structural Matching Degree × Weight a + Scene Similarity × Weight b + Historical Reuse Frequency × Weight c + Historical Success Rate × Weight d - Target Ratio × Weight e. The weights a, b, c, d, and e can be set by the user according to actual needs; no specific limitations are imposed here. Finally, the obtained recommended scores are determined as a set of recommended scores.

[0045] The third step involves sorting the initial candidate components in the initial candidate component set according to the aforementioned recommended score set, resulting in a recommended stacked component package. In practice, the executing entity can sort the initial candidate components in the initial candidate component set in descending order according to the aforementioned recommended score set, obtaining the sorted initial candidate components as the recommended stacked component package.

[0046] The fourth step is to add the recommended stacking component package to the initial stacking blueprint to obtain the modified initial stacking blueprint.

[0047] Step 104: Perform verification processing on the initial stacked blueprint to obtain the initial verification processing result.

[0048] In some embodiments, the execution entity may perform verification processing on the initial stacking blueprint to obtain an initial verification result. This initial verification result indicates whether the initial stacking blueprint verification was successful or failed. In practice, for each stacking component in the initial stacking blueprint: First, the compatibility between the stacking component and its adjacent stacking components can be determined using the preset interface compatibility mapping table. Then, the compatibility of field types between the stacking component and its adjacent stacking components can be determined using the preset field compatibility mapping table. Finally, the permission mapping table can be used to determine whether the target user has permission to use the stacking component. This preset permission mapping table represents the correspondence between the target user and the stacking components with usage permissions in the stacking component template library. For example, the preset permission mapping table could be: "Target User: admin1, Stacking Component: sql_001". Subsequently, in response to determining that the stacking component and its associated stacking components are compatible, that the field types of the stacking component and its adjacent stacking components are compatible, and that the target user has access to the stacking components that include the aforementioned stacking component, a successful verification is determined as the first target verification result. In response to determining that the stacking component and its associated stacking components are incompatible, that the field types of the stacking component and its associated stacking components are incompatible, or that the target user has access to the stacking components that do not include the aforementioned stacking component, a failed verification is determined as the first target verification result. Finally, in response to determining that all obtained first target verification results indicate successful verification, a successful verification is determined as the initial verification processing result. In response to determining that among the obtained first target verification results there is a target verification result indicating a failed verification, a failed verification is determined as the initial verification processing result.

[0049] Optionally, after step 104, in response to the initial verification process result indicating successful verification, the execution entity may also determine the initial stack blueprint as a complete stack blueprint.

[0050] Step 105: In response to the initial verification processing result indicating verification failure, the following cleaning steps are performed: Step 1051: Clean the initial stacked blueprint to obtain the cleaned initial stacked blueprint.

[0051] In some embodiments, the execution entity can perform cleaning processing on the initial stack blueprint to obtain a cleaned initial stack blueprint. In practice, the execution entity can input the initial stack blueprint into a cleaning method generation engine to obtain a cleaned initial stack blueprint. The specific type of the cleaning method generation engine is not limited and can be set according to actual needs. For example, the cleaning method generation engine can be the CLAIRE engine.

[0052] Step 1052: In response to detecting that the target user has performed a selection operation on the candidate method confirmation control displayed in the visualization canvas, the cleaned initial stacked blueprint is determined as the complete stacked blueprint.

[0053] In some embodiments, the execution entity may, in response to detecting a selection operation by the target user on the candidate method confirmation control displayed on the visualization canvas, determine the cleaned initial stacking blueprint as a complete stacking blueprint. The candidate method confirmation control may be a control used to allow the target user to confirm the cleaned initial stacking blueprint.

[0054] Step 106: Perform verification processing on the complete stacked blueprint to obtain the verification processing result.

[0055] In some embodiments, the execution entity may perform verification processing on the complete stack blueprint to obtain a verification result. The verification result can indicate whether the verification of the complete stack blueprint was successful or failed. In practice, for each stack component in the complete stack blueprint: First, the compatibility between the stack component and its adjacent stack components can be determined using the preset interface compatibility mapping table. Then, the compatibility of field types between the stack component and its adjacent stack components can be verified using the preset field compatibility mapping table. Next, the permission mapping table can be used to determine whether the target user has permission to use the stack component. Finally, in response to determining that the stack component is compatible with its adjacent stack components, that its field types are compatible, and that the target user has permission to use the stack component, a successful verification is determined as the second target verification result. In response to the determination that the aforementioned stacking component is incompatible with its adjacent stacking component, that the field types of the aforementioned stacking component are incompatible with its adjacent stacking component, or that the target user does not have permission to use the aforementioned stacking component, a verification failure is determined as the second target verification result. Finally, in response to the determination that all obtained second target verification results indicate successful verification, a successful verification is determined as the verification processing result. In response to the determination that among the obtained second target verification results there is a second target verification result indicating verification failure, a verification failure is determined as the verification processing result.

[0056] Step 107: In response to the verification processing result indicating successful verification, perform the following steps: Step 1071: Generate an executable execution topology based on the complete stack blueprint.

[0057] In some embodiments, the execution entity can generate an executable execution topology based on the complete stack blueprint described above. This execution topology can characterize the topological structure used to perform the data integration task. For example, the topology can be a directed acyclic graph.

[0058] In some optional implementations of certain embodiments, the aforementioned execution entity can generate an executable execution topology based on the aforementioned complete stacking blueprint through the following steps: The first step is to parse the complete stacked blueprint to obtain topology nodes. These topology nodes represent the nodes used to construct the execution topology. In practice, the execution entity can use the Kahn algorithm to parse the complete stacked blueprint and obtain the topology nodes.

[0059] The second step is to determine the set of topological edges based on the aforementioned topological nodes and the complete stacking blueprint. Each topological edge in this set represents the connection between any two topological nodes in the complete stacking blueprint. In practice, the execution entity can use a DAG scheduling algorithm to resolve the topological edges between every two adjacent stacking components in the complete stacking blueprint, obtaining each topological edge as a set.

[0060] The third step involves encapsulating the preset tenant methods corresponding to the complete stacking blueprint to obtain tenant method objects. These preset tenant methods represent the various stacking components available to each target user during the execution of the data integration task, achieving multi-tenant isolation. This multi-tenant isolation can manifest as providing different stacking components for different target users. The tenant method object is the encapsulated preset tenant method. In practice, the execution entity can use the Template Method Pattern to encapsulate the preset tenant methods corresponding to the complete stacking blueprint, obtaining executable tenant method objects.

[0061] The fourth step is to attach the aforementioned tenant method object to each topological edge in the aforementioned topological edge set, thereby obtaining an executable execution topology. In practice, the aforementioned execution entity can attach the aforementioned tenant method object to the aforementioned topological edge to obtain an executable execution topology.

[0062] Optionally, after step 1071, the execution entity may first obtain result feedback data information of the execution topology. This result feedback data information may characterize the component CPU utilization, memory utilization, and component execution time consumed during the execution of the execution topology. The component execution time may be the total execution time of the execution topology. The component CPU utilization may be the CPU utilization during the execution of the execution topology. The memory utilization may be the memory utilization during the execution of the execution topology.

[0063] Then, based on the feedback data from the above results, each recommended score in the above recommended score set is updated to obtain the updated recommended score set as the recommended score set.

[0064] In some optional implementations of certain embodiments, the execution entity may update each recommended score in the recommended score set by updating the data information fed back by the results through the following steps, thereby obtaining the updated recommended score set as the recommended score set.

[0065] The first step is to construct a component performance profile based on the feedback data from the above results. This component performance profile can be a portrait of the execution time, CPU utilization, and memory utilization of each stacked component during the execution of the above execution topology. In practice, the above execution entity can be constructed using principal component analysis based on the feedback data from the above results.

[0066] The second step involves determining the component stress coefficient for each stacked component used in the execution topology based on the aforementioned component performance profile, thus obtaining a component stress coefficient group. The component stress coefficients in this group characterize the stress coefficients of the stacked components used when executing the execution topology. In practice, the execution entity can use a Min-Max normalization algorithm to normalize the execution time, CPU utilization, and memory utilization of the stacked components corresponding to the aforementioned component performance profile, obtaining standardized values. Then, the standardized values ​​are summed using preset weights to obtain the component stress coefficient corresponding to the stacked components. For example, the preset weights could be: 0.3 for CPU utilization, 0.2 for memory utilization, and 0.25 for execution time. Finally, the obtained component stress coefficients are defined as a component stress coefficient group.

[0067] The third step involves updating each recommended score in the aforementioned recommended score set based on the component pressure coefficient group. The updated recommended score set is then used as the final recommended score set. In practice, the executing entity can input the recommended scores and the corresponding component pressure coefficients from the component pressure coefficient group as weighting factors into a weighted correction algorithm to perform a weighted update of the recommended scores, resulting in the updated recommended scores as the final recommended score set.

[0068] Step 1072: In response to detecting a selection operation by the target user on the publish confirmation control displayed in the visualization canvas, execute the execution topology.

[0069] In some embodiments, the execution entity may execute the execution topology in response to detecting a selection operation by the target user on a publish confirmation control displayed in the visualization canvas. The publish confirmation control can be a control used by the target user to confirm the execution of the execution topology. In practice, the execution entity may execute the execution topology using the Kahn algorithm.

[0070] The above embodiments of this disclosure have the following beneficial effects: A data integration stacked drag-and-drop visualization execution method according to some embodiments of this disclosure improves the stacked semantic modeling capability during data integration stacked drag-and-drop visualization execution tasks, thereby shortening configuration time, improving the stability of the executable topology, and ultimately improving the stability of task execution performance. Specifically, the reason for the long configuration time and low execution stability during data integration stacked drag-and-drop visualization execution tasks is that when data integration or service orchestration is achieved through a graphical canvas, connector components, and connection line components, and components are dragged and dropped, and the dragged component results are parsed into executable scripts, configuration files, or task topologies through automatic configuration file generation, only the connection of the dragged components is considered, without taking into account the hierarchical semantics corresponding to the dragged components. This results in poor stacked semantic modeling capability at the data integration processing level, inability to clean and verify the dragged results, and consequently, low accuracy of the dragged components. This leads to poor stability in converting the dragged results into the backend executable topology, and long configuration time when performing data integration stacked drag-and-drop visualization execution tasks based on dragged components with low accuracy. Based on this, the data integration stacked drag-and-drop visualization execution method of some embodiments of this disclosure first generates a stacked component template library according to a preset set of stacked component groups. This allows the generation of a stacked component template library for target users to select stacked components to perform data integration tasks. Then, the stacked component template library is displayed on a visualization canvas. This allows the target user to select components from the displayed stacked component template library. Subsequently, in response to detecting a stacked drag-and-drop operation by the target user on stacked components in the displayed stacked component template library, the stacked drag-and-drop operation is converted into an initial stacked blueprint. This yields an initial stacked blueprint, providing the user with a visually editable, verifiable, and deployable architectural blueprint as a starting point for low-code development. Subsequently, the initial stacked blueprint is validated to obtain an initial validation result. This initial validation result ensures the initial stacked blueprint has basic feasibility. Then, in response to the initial validation result indicating validation failure, the following cleaning steps are performed: First, the initial stacked blueprint is cleaned to obtain a cleaned initial stacked blueprint. This yields a cleaned initial stack blueprint, used to eliminate redundancy, conflicts, or invalid configurations, providing the infrastructure for subsequent interactive editing. Then, in response to detecting a user's selection action on the candidate method confirmation control displayed in the visualization canvas, the cleaned initial stack blueprint is identified as the complete stack blueprint. This complete stack blueprint provides the user with a visually editable, validated, and deployable architecture blueprint. Subsequently, the complete stack blueprint undergoes validation processing, resulting in a validation result. This validation result ensures the complete stack blueprint possesses basic feasibility.Subsequently, in response to the successful verification result, the following steps are executed: First, an executable execution topology is generated based on the complete stacking blueprint. This allows for the generation of an executable execution topology that constrains the scheduling of components according to the correct dependencies and order at runtime. Then, in response to detecting the target user's selection operation on the release confirmation control displayed in the visualization canvas, the execution topology is executed. This allows the data integration task to be executed based on the execution topology. Because data integration or service orchestration is not achieved through graphical canvases, connector components, and connecting wire components, and drag-and-drop results are not parsed into executable scripts, configuration files, or task topologies, but rather through a pre-defined set of stacked component groups, a stacked component template library is generated. This allows for the acquisition of the hierarchical semantics of drag-and-drop components, thereby improving the stacked semantic modeling capability of the data integration processing hierarchy. Furthermore, the complete stacking blueprint is obtained through a cleansing method for the generation engine and verification processing, resulting in the stable generation of executable execution topologies. This improves task configuration efficiency and the stability of task execution performance, and reduces the configuration time when performing data integration stacked drag-and-drop visualization execution tasks using drag-and-drop components.

[0071] Further reference Figure 2 As an implementation of the methods shown in the above figures, this disclosure provides some embodiments of a data integration stacked drag-and-drop visualization execution device, these device embodiments being similar to... Figure 1 Corresponding to the method embodiments shown, the device can be specifically applied to various electronic devices.

[0072] like Figure 2As shown, a data integration stacked drag-and-drop visualization execution device 200 in some embodiments includes: a generation unit 201, a display unit 202, a conversion unit 203, a first verification unit 204, a first execution unit 205, a second verification unit 206, and a second execution unit 207. The generation unit 201 is configured to generate a stacked component template library based on a preset set of stacked component groups; the display unit 202 is configured to display the stacked component template library on a visualization canvas; the conversion unit 203 is configured to convert the stacked drag-and-drop operation into an initial stacked blueprint in response to detecting a target user's stacked drag-and-drop operation on stacked components in the displayed stacked component template library; the first verification unit 204 is configured to perform verification processing on the initial stacked blueprint to obtain an initial verification processing result; and the first execution unit 205 is configured to perform the following cleaning steps in response to the initial verification processing result indicating verification failure: [The text abruptly ends here, so the translation stops.] The image is cleaned to obtain a cleaned initial stacked blueprint; in response to detecting the target user's selection operation on the candidate method confirmation control displayed in the visualization canvas, the cleaned initial stacked blueprint is determined as a complete stacked blueprint; the second verification unit 206 is configured to perform verification processing on the complete stacked blueprint to obtain a verification processing result; the second execution unit 207 is configured to, in response to the verification processing result indicating successful verification, execute the following steps: generate an executable execution topology based on the complete stacked blueprint; in response to detecting the target user's selection operation on the release confirmation control displayed in the visualization canvas, execute the execution topology.

[0073] It is understandable that the units described in the data integration stacked drag-and-drop visualization execution device 200 and the reference Figure 1 The steps in the described method correspond to each other. Therefore, the operations, features, and beneficial effects described above for the method also apply to the data integration stacked drag-and-drop visualization execution device 200 and the units contained therein, and will not be repeated here.

[0074] The following is for reference. Figure 3 It shows a schematic diagram of the structure of an electronic device 300 (e.g., a computing device) suitable for implementing some embodiments of the present disclosure. Figure 3 The electronic device shown is merely an example and should not be construed as limiting the functionality and scope of the embodiments of this disclosure.

[0075] like Figure 3As shown, the electronic device 300 may include a processing unit 301 (e.g., a central processing unit, a graphics processor, etc.), which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 302 or a program loaded from a storage device 308 into a random access memory (RAM) 303. The RAM 303 also stores various programs and data required for the operation of the electronic device 300. The processing unit 301, ROM 302, and RAM 303 are interconnected via a bus 304. An input / output (I / O) interface 305 is also connected to the bus 304.

[0076] Typically, the following devices can be connected to I / O interface 305: input devices 306 including, for example, touchscreens, touchpads, keyboards, mice, cameras, microphones, accelerometers, gyroscopes, etc.; output devices 307 including, for example, liquid crystal displays (LCDs), speakers, vibrators, etc.; storage devices 308 including, for example, magnetic tapes, hard disks, etc.; and communication devices 309. Communication device 309 allows electronic device 300 to communicate wirelessly or wiredly with other devices to exchange data. Although Figure 3 An electronic device 300 with various devices is shown; however, it should be understood that it is not required to implement or possess all of the devices shown. More or fewer devices may be implemented or possessed alternatively. Figure 3 Each box shown can represent a device or multiple devices as needed.

[0077] In particular, according to some embodiments of this disclosure, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, some embodiments of this disclosure include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication device 309, or installed from storage device 308, or installed from ROM 302. When the computer program is executed by processing device 301, it performs the functions defined in the methods of some embodiments of this disclosure.

[0078] It should be noted that, in some embodiments of this disclosure, the computer-readable medium may be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium may be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In some embodiments of this disclosure, a computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In some embodiments of this disclosure, a computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals may take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. A computer-readable signal medium can be any computer-readable medium other than a computer-readable storage medium, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to: wires, optical fibers, RF (radio frequency), etc., or any suitable combination thereof.

[0079] In some implementations, clients and servers can communicate using any currently known or future-developed network protocol such as HTTP (Hypertext Transfer Protocol) and can interconnect with digital data communication (e.g., communication networks) of any form or medium. Examples of communication networks include local area networks (“LANs”), wide area networks (“WANs”), the Internet (e.g., the Internet of Things), and peer-to-peer networks (e.g., ad hoc peer-to-peer networks), as well as any currently known or future-developed networks.

[0080] The aforementioned computer-readable medium may be included in the aforementioned electronic device; or it may exist independently and not assembled into the electronic device. The aforementioned computer-readable medium carries one or more programs. When the electronic device executes the aforementioned one or more programs, the electronic device causes the following: it generates a stacked component template library based on a preset set of stacked component groups; it displays the stacked component template library on a visualization canvas; in response to detecting a target user's stacked drag operation on stacked components in the displayed stacked component template library, it converts the stacked drag operation into an initial stacked blueprint; it performs a verification process on the initial stacked blueprint to obtain an initial verification result; in response to the initial verification result indicating verification failure, it performs the following cleaning steps: it performs a cleaning process on the initial stacked blueprint to obtain a cleaned initial stacked blueprint; in response to detecting a target user's selection operation on a candidate method confirmation control displayed on the visualization canvas, it determines the cleaned initial stacked blueprint as a complete stacked blueprint; it performs a verification process on the complete stacked blueprint to obtain a verification result; in response to the verification result indicating successful verification, it performs the following steps: it generates an executable execution topology based on the complete stacked blueprint; in response to detecting a target user's selection operation on a release confirmation control displayed on the visualization canvas, it executes the execution topology.

[0081] Computer program code for performing operations of some embodiments of this disclosure can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, and conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a local area network (LAN) or a wide area network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0082] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0083] The units described in some embodiments of this disclosure can be implemented in software or hardware. The described units can also be located in a processor, and for example, can be described as: a generation unit, a conversion unit, a first verification unit, a cleaning unit, a second verification unit, and an execution unit. The names of these units do not necessarily limit the unit itself; for example, a generation unit can also be described as "a unit that generates a stacked component template library based on a preset set of stacked component groups."

[0084] The functions described above in this document can be performed at least in part by one or more hardware logic components. For example, exemplary types of hardware logic components that can be used, without limitation, include: field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), system-on-a-chip (SoCs), complex programmable logic devices (CPLDs), and so on.

[0085] The above description is merely a selection of preferred embodiments of this disclosure and an explanation of the technical principles employed. Those skilled in the art should understand that the scope of the invention involved in the embodiments of this disclosure is not limited to technical solutions formed by specific combinations of the above-described technical features, but should also cover other technical solutions formed by arbitrary combinations of the above-described technical features or their equivalents without departing from the above-described inventive concept. For example, technical solutions formed by substituting the above-described features with (but not limited to) technical features with similar functions disclosed in the embodiments of this disclosure.

Claims

1. A data integration stacked drag-and-drop visualization execution method, comprising: Generate a stacked component template library based on a preset set of stacked component groups; Display the stacked component template library on a visualization canvas; In response to detecting a target user's stacked drag operation on stacked components in the displayed stacked component template library, the stacked drag operation is converted into an initial stacked blueprint; The initial stacking blueprint is verified to obtain the initial verification result; In response to the initial verification result indicating verification failure, the following cleaning steps are performed: The initial stacked blueprint is cleaned to obtain a cleaned initial stacked blueprint; In response to detecting that the target user has selected a candidate method confirmation control displayed in the visualization canvas, the cleaned initial stacked blueprint is determined as the complete stacked blueprint; The complete stacked blueprint is verified to obtain the verification result; In response to the verification processing result indicating successful verification, the following steps are executed: Based on the complete stack blueprint, generate an executable execution topology; In response to detecting that the target user has made a selection operation on the publish confirmation control displayed in the visualization canvas, the execution topology is executed.

2. The method according to claim 1, wherein, After performing verification processing on the initial stacked blueprint to obtain the initial verification result, the method further includes: In response to the initial verification process result indicating successful verification, the initial stack blueprint is determined as a complete stack blueprint.

3. The method according to claim 1, wherein, The step of generating an executable execution topology based on the complete stack blueprint includes: The complete stacked blueprint is parsed to obtain topology nodes; Based on the topology nodes and the complete stacking blueprint, determine the set of topology edges; The preset tenant method corresponding to the complete stack blueprint is encapsulated to obtain a tenant method object; The tenant method object is attached to each topological edge in the topological edge set to obtain an executable execution topology.

4. The method according to claim 1, wherein, After converting the stacked drag operation into an initial stacked blueprint in response to detecting a target user's stacked drag operation on stacked components in the displayed stacked component template library, the method further includes: In response to detecting that the target user has selected a recommended insertion control displayed on the visualization canvas, a recommended stacked component package is generated based on the stacked component template library; Add the recommended stacking component package to the initial stacking blueprint to obtain the modified initial stacking blueprint, which will then serve as the initial stacking blueprint.

5. The method according to claim 4, wherein, The step of generating a recommended stacked component package based on the stacked component template library includes: In response to determining that there are stack components in the stack component template library that satisfy the recall constraints, each stack component in the stack component template library that satisfies the recall constraints is determined as an initial candidate component set; Determine the recommended score for each initial candidate component in the initial candidate component set to obtain a set of recommended scores; Based on the recommended score set, the initial candidate components in the initial candidate component set are sorted to obtain a recommended stacked component package.

6. The method according to claim 5, wherein, After generating an executable execution topology based on the complete stack blueprint, the method further includes: Obtain the result feedback data information of the execution topology; Based on the feedback data, each recommended score in the recommended score set is updated to obtain the updated recommended score set.

7. The method according to claim 6, wherein, The step of updating each recommendation score in the recommendation score set based on the feedback data information to obtain the updated recommendation score set includes: Based on the feedback data, construct a component performance profile; Based on the component performance profile, the component stress coefficient of each stacked component used by the execution topology is determined to obtain the component stress coefficient group; Based on the component pressure coefficient group, each recommended score in the recommended score set is updated to obtain the updated recommended score set as the recommended score set.

8. A data integration stacked drag-and-drop visualization execution device, comprising: The generation unit is configured to generate a stacked component template library based on a preset set of stacked component groups; The display unit is configured to display the stacked component template library onto a visualization canvas; The conversion unit is configured to convert the stacking drag operation into an initial stacking blueprint in response to detecting a target user's stacking drag operation on stacked components in the displayed stacking component template library; The first verification unit is configured to perform verification processing on the initial stacking blueprint to obtain the initial verification processing result. The first execution unit is configured to perform the following cleaning steps in response to the initial verification processing result indicating verification failure: clean the initial stack blueprint to obtain a cleaned initial stack blueprint. In response to detecting that the target user has selected a candidate method confirmation control displayed in the visualization canvas, the cleaned initial stacked blueprint is determined as the complete stacked blueprint; The second verification unit is configured to perform verification processing on the complete stacked blueprint to obtain the verification processing result. The second execution unit is configured to, in response to the verification processing result indicating successful verification, perform the following steps: generate an executable execution topology based on the complete stack blueprint; and execute the execution topology in response to detecting the target user's selection operation on the release confirmation control displayed in the visualization canvas.

9. An electronic device, comprising: One or more processors; Storage device, on which one or more programs are stored, When the one or more programs are executed by the one or more processors, the one or more processors implement the method as described in any one of claims 1-7.

10. A computer-readable medium having a computer program stored thereon, wherein, When the computer program is executed by a processor, it implements the method as described in any one of claims 1-7.

Images