Method and system for automatically extracting and cleaning code change data

Abstract

The invention relates to the field of software development and management, in particular to an automatic extraction and cleaning method for code change data, which comprises the following steps of: selecting a version control platform to carry out code management and version control, and monitoring the code change condition by the version control platform; when the code is changed, extracting data of the code change; formatting the data; performing data cleaning on the formatted data; storing and exporting the cleaned data; according to the method, extraction, data cleaning and data export are performed into a CI / CD assembly line, data extraction, data formatting, data cleaning and data export processes are automatically executed when codes are submitted or requests are merged each time, a report is generated or an automatic test is triggered, data of code change in a version control platform can be efficiently extracted, and the efficiency of code change in the version control platform is improved. According to the method, the data are automatically formatted into standard structured data, the data are screened and cleaned based on a self-defined rule, and finally a report is generated or automatic testing is performed, so that the code management efficiency is improved.

Description

Technical Field

[0001] This invention relates to the field of software development and management, and in particular to a method and system for automatically extracting and cleaning code change data. Background Technology

[0002] In existing technologies, mainstream version control platforms such as Git and SVN are widely used for code management and version control in software development projects. These systems provide basic functions such as code commits, logging, and difference comparison, helping developers track code changes and collaborate. Meanwhile, some automation tools integrate automated monitoring and report generation capabilities for code repositories, such as Jenkins, GitLab CI, and GitHub Actions.

[0003] While existing version control platforms and automation tools can manage code changes, they generally suffer from the following drawbacks:

[0004] Data format disorder: The change data extracted from the version control platform has an inconsistent structure and often contains a lot of redundant information, making it difficult to apply directly to automated processes or analysis tasks.

[0005] Lack of automated cleanup: Existing systems lack the ability to automatically clean and filter code change data. Developers need to manually process a large number of invalid change records, which is both time-consuming and error-prone.

[0006] Difficulty in integrated analysis: Existing tools cannot intelligently extract code changes of specific business modules, nor can they conduct in-depth analysis of the code development of specific functions, which affects development efficiency and quality.

[0007] Complex configuration: Many automation tools lack ease of use when configuring complex change filtering or report generation, requiring developers to manually write a lot of scripts and configurations, which increases the cost of system maintenance. Summary of the Invention

[0008] To overcome the problems of chaotic data format, lack of automated data cleaning, difficulty in integration and analysis, and complex configuration that occur in the process of managing code using version control platforms and automation tools in the existing technology, the purpose of this invention is to provide an automatic extraction and cleaning method and system for code change data. It can efficiently extract code change data from version control platforms, automatically format it into standard structured data, filter and clean the data based on custom rules, and finally generate reports or automated tests, thereby improving code management efficiency.

[0009] This invention is implemented using the following scheme:

[0010] An automatic method for extracting and cleaning code change data, the steps of which are as follows:

[0011] Step 1: Select a version control platform for code management and version control. The version control platform can monitor code changes.

[0012] Step 2: When the code changes, extract the data related to the code changes;

[0013] Step 3: Format the data;

[0014] Step 4: Perform data cleaning on the formatted data;

[0015] Step 5: Store and export the cleaned data;

[0016] Step 6: Integrate steps 2-5 into the CI / CD pipeline to automatically execute the data extraction, data formatting, data cleaning, and data export processes with each code commit or merge request, and generate reports or trigger automated tests.

[0017] Furthermore, step 2 specifically involves:

[0018] Step 2.1: Select the extraction method, including extracting data by time range, extracting data by submission range, and extracting data by tag or version number; the data extraction by time range extracts the changed data within a specific time period by specifying the start and end times; the data extraction by submission range obtains the changed data between specific versions by specifying the start and end submission hash values;

[0019] Step 2.2: Extract the commit log and record the information for each commit. Use the `git log` or `svn log` command to obtain the commit information.

[0020] Step 2.3: Extract the file change list. Use the `git diff --name-status` command or the `svn diff --summarize` command to get the list of files changed in each commit, and record the file paths and change status.

[0021] Step 2.4: Extract code diff data. Use the `git diff` or `svn diff` command to extract the diff data for specific lines of code. The diff data includes newly added, deleted, or modified data.

[0022] Furthermore, step 3 is further specified as follows:

[0023] Step 3.1: Define the data structure. The extracted data will be transformed into a standardized data structure that can extract code difference data.

[0024] Step 3.2: Parse the commit logs, extract key information using predefined parsing rules or regular expressions, and transform it into unified structured data;

[0025] Step 3.3: Analyze the code difference data. Further analyze the extracted code difference data, break down the changed code by file and line, and record the specific change type.

[0026] Step 3.4: Provide multi-format support, allowing formatted data to be stored in multiple formats.

[0027] Furthermore, step 4 is further specified as follows:

[0028] Step 4.1: Define custom data cleaning rules, including filtering by file type, filtering by function, filtering by time range or submitter, and filtering by specific submitter;

[0029] Step 4.2: Eliminate redundant information, automatically identify and eliminate invalid change records or noisy information, and retain only the data after changes that are actually relevant to the business.

[0030] Step 4.3: Data verification and cleaning. The extracted data is verified for format and consistency. If errors or anomalies are found, they will be automatically repaired or the user will be prompted to make manual adjustments.

[0031] Furthermore, step 5 specifically involves: exporting and cleaning the data, which supports multiple data export formats, or storing it directly in a relational database or NoSQL database, and automatically generating a report containing detailed change information, which is then categorized and organized according to business needs for code review or compliance checks.

[0032] An automatic extraction and cleaning system for code change data, the system comprising a control platform management module, a data extraction module, a data formatting module, a data cleaning module, a data storage and output module, and an automation integration module;

[0033] The control platform management module is used to select a version control platform for code management and version control, and the version control platform can monitor code changes.

[0034] The data extraction module is used to extract data related to code changes when code changes occur.

[0035] The data formatting module is used to format data;

[0036] The data cleaning module is used to clean the formatted data;

[0037] The data storage output module is used to store and export the cleaned data;

[0038] The automated integration module integrates the data extraction module, data formatting module, data cleaning module, and data storage and output module into the CI / CD pipeline. During each code commit or merge request, it automatically executes the data extraction, data formatting, data cleaning, and data export processes, and generates reports or triggers automated tests.

[0039] Furthermore, the data extraction module specifically includes:

[0040] The extraction method can be selected, including extracting data by time range, extracting data by submission range, and extracting data by tag or version number; the data extraction by time range extracts the data changed within a specific time period by specifying a start and end time; the data extraction by submission range obtains the data changed between specific versions by specifying the start and end submission hash values;

[0041] Extract the commit log, record information for each commit, and obtain commit information using the `git log` or `svn log` command;

[0042] Extract the file change list. Use the `git diff --name-status` or `svn diff --summarize` command to get the list of files changed in each commit, and record the file paths and change status.

[0043] Extract code diff data. Use the `git diff` or `svn diff` command to extract diff data for specific lines of code. Difference data includes added, deleted, or modified data.

[0044] Furthermore, the data formatting module specifically includes:

[0045] Define the data structure; the extracted data will be transformed into a standardized data structure, which can extract code difference data.

[0046] Parse the commit logs, extract key information using predefined parsing rules or regular expressions, and transform it into unified structured data;

[0047] Parse the code difference data, further analyze the extracted code difference data, break down the changed code by file and line, and record the specific change type;

[0048] It provides support for multiple formats, allowing formatted data to be stored in various formats.

[0049] Furthermore, the data cleaning module specifically includes:

[0050] Custom data cleaning rules include filtering by file type, filtering by function, filtering by time range or submitter, and filtering by specific submitter;

[0051] Remove redundant information, automatically identify and remove invalid change records or noisy information, and retain only the data after changes that are actually relevant to the business.

[0052] Data validation and cleaning: The extracted changed data is validated for format and consistency. If errors or anomalies are found, the system will automatically repair them or prompt the user to make manual adjustments.

[0053] Furthermore, the data storage output module specifically includes: the exported and cleaned data supports multiple data export formats, or can be directly stored in a relational database or NoSQL database, and automatically generates a report containing detailed change information, which is classified and organized according to business needs for code review or compliance checks.

[0054] The beneficial effects of this invention are as follows:

[0055] This invention provides an automatic method and system for extracting and cleaning code change data. By using code change data extraction, formatting, and cleaning technology based on a version control platform, it achieves automated data processing. This invention can efficiently and intelligently extract code change records from a version control system, automatically format them into standard structured data, and filter and clean the data based on custom rules. Finally, the processed change data is exported in a format that can be used for code review, automated testing, or continuous integration. Attached Figure Description

[0056] Figure 1 This is a flowchart of the method of the present invention;

[0057] Figure 2 This is a structural block diagram of the system of the present invention. Detailed Implementation

[0058] The invention will now be further described with reference to the accompanying drawings.

[0059] See Figure 1 An automatic extraction and cleaning method for code change data, the steps of which are as follows:

[0060] Step 1: Select a version control platform for code management and version control. The version control platform can monitor code changes.

[0061] Step 2: When the code changes, extract the data related to the code changes;

[0062] Step 3: Format the data;

[0063] Step 4: Perform data cleaning on the formatted data;

[0064] Step 5: Store and export the cleaned data;

[0065] Step 6: Integrate steps 2-5 into the CI / CD pipeline to automatically execute the data extraction, data formatting, data cleaning, and data export processes with each code commit or merge request, and generate reports or trigger automated tests.

[0066] The present invention will be further described below with reference to a specific embodiment:

[0067] An automatic method for extracting and cleaning code change data, the method comprising the following steps:

[0068] Step 1: Choose a version control platform for code management and version control;

[0069] Step 1.1: Choose a version control platform: Based on the version control platform used by the development team (such as Git or SVN), choose a suitable connection method. You can interact with local code or software via APIs (such as GitHub API, GitLab API) or command-line tools (such as Git command-line tools, SVN command-line tools).

[0070] Step 1.2: Set connection parameters:

[0071] Project path: Sets the local or remote path to the code repository. For example, in Git, this can be the absolute path to the local working directory or the URL of the remote repository.

[0072] Authentication: Authentication is performed using a username / password, SSH key, or OAuth token, depending on the local software configuration. For example, when using Git, an SSH key can be used to authenticate to connect to a remote repository.

[0073] Configure branch: Determine the branch to operate on. You can specify the default development branch (such as master or main) through parameters, or you can dynamically set a specific branch to extract relevant data.

[0074] Step 1.3: Check connection validity:

[0075] Execute a connection test command locally (such as `git ls-remote` or `svn info`) to verify a successful connection to the version control platform. If the connection fails, provide a detailed error report to help users troubleshoot the problem.

[0076] Step 1.4: Initialize the project context:

[0077] Initialize necessary project context information, such as the current branch name and remote repository address. This step provides context information support for subsequent code change extraction and processing.

[0078] Step 2: When the code changes, extract the data related to the code changes;

[0079] Step 2.1: Select the extraction method, including extracting data by time range, extracting data by commit range, and extracting data by tag or version number; the extraction by time range is achieved by specifying a start and end time (e.g., git log --since=).<start_date> --until=<end_date> Extracting data that has changed within a specific time period; the extraction of data by commit range is achieved by specifying the start and end commit hashes (such as git log).<start_commit> .<end_commit> The method retrieves data on changes between specific versions; the method for extracting data by tag or version number retrieves code changes for specific versions (e.g., git log v1.0..v2.0) by tag or version number.

[0080] Step 2.2: Extract the commit log and record the information of each commit. Use the `git log` or `svn log` command to obtain the commit information and extract the hash value, committer, commit time, commit message, etc. of each commit.

[0081] Example command: `git log --pretty=format:"%H|%an|%ad|%s"` extracts the hash, author, commit date, and commit message of the commit.

[0082] Step 2.3: Extract the file change list. Use the `git diff --name-status` command or the `svn diff --summarize` command to get the list of files changed in each commit, and record the file paths and change status, such as added, modified, and deleted.

[0083] Step 2.4: Extract code diff data. Use the `git diff` or `svn diff` command to extract the diff data for specific lines of code. The diff data includes newly added, deleted, or modified data, or it can be newly added, deleted, or modified lines.

[0084] Step 3: Format the data;

[0085] Step 3.1: Define the data structure. The extracted data will be transformed into a standardized data structure that can extract code difference data.

[0086] The extracted data will be transformed into a standardized data structure (such as a dictionary, table, or JSON format). Data items include: the hash value of the commit, the committer, the commit time, the commit message, a list of changed files (including filename, path, and status), and code difference data (grouped by file, recording the modification details of specific lines).

[0087] Data structure examples

[0088]

[0089]

[0090]

[0091] Step 3.2: Parse the commit log, using predefined parsing rules or regular expressions to extract key information and transform it into unified structured data; for example, parse information such as the committer name and date.

[0092] Step 3.3: Analyze the code difference data. Further analyze the extracted code difference data, break down the changed code by file and line, and record the specific change type (addition, deletion, or modification).

[0093] Step 3.4: Provide multi-format support, allowing formatted data to be stored in various formats, including dictionaries, lists, JSON, CSV, etc., to facilitate subsequent processing and analysis under different needs.

[0094] Step 4: Data cleaning;

[0095] Step 4.1: Define custom data cleaning rules, including filtering by file type, filtering by function, filtering by time range or submitter, and filtering by specific submitter;

[0096] Filter by file type: For example, keep only .java, .py code files and remove other file types (such as images and configuration files).

[0097] Example of a rule:

[0098] {

[0099] "file_types":["java","py","cpp"]

[0100] }

[0101] Filter by function: Filter code changes for a specified module or function based on file path or naming convention (e.g., src / main / java / com / company / module / ).

[0102] Example of a rule:

[0103] {

[0104] "module_paths":["src / moduleX / ","src / moduleY / "]

[0105] }

[0106] Filter by time range or submitter: such as filtering changes within a specific date range or changes submitted by a specific developer.

[0107] Example of a rule:

[0108]

[0109] Specific committer filtering rules: Filter commit data based on the committer's name or username. This rule allows you to focus only on code changes made by a specific developer.

[0110] Step 4.2: Eliminate redundant information. Automatically identify and eliminate invalid change records or noisy information (such as large-scale code formatting changes, comment modifications, etc.), and only retain the data after the code changes that are actually related to the business.

[0111] Step 4.3: Data verification and cleaning. Perform format and consistency verification on the extracted data (modified data) to ensure that all data items conform to the expected structure and content. If errors or anomalies are found, they will be automatically repaired or the user will be prompted to make manual adjustments.

[0112] Step 5: Data storage and export;

[0113] Step 5.1: Data supports multiple export formats (such as JSON or CSV files) or can be directly stored in a relational or NoSQL database for historical tracing, analysis, or use by third-party tools; JSON format export: suitable for API integration or subsequent automated analysis. CSV format export: suitable for data report generation or data migration operations.

[0114] Step 5.2: Automatically generate a report containing detailed change information, categorize and organize it according to business needs, and use it for code review or compliance checks. The report can be updated as needed with information such as file-level changes and differences in lines of code.

[0115] Step 6: Automated integration;

[0116] Step 6.1: Integrate steps 2-5 into the CI / CD pipeline to automatically execute the data extraction, data formatting, data cleaning, and data export processes with each code commit or merge request, and generate reports or trigger automated tests.

[0117] CI / CD pipelines refer to the process of connecting and coding every step of the entire ecosystem from development to deployment through pipelines, making the development process more efficient and faster through automated pipelines.

[0118] Step 6.2: Set up an automated triggering mechanism to automatically trigger the corresponding process based on different events, such as automatically starting data extraction and cleaning operations when committing on a specific branch, approving merge requests, or releasing a version;

[0119] Step 6.3: Automated Testing and Review. The cleaned data can be used in an automated testing framework to trigger corresponding unit tests, integration tests, or security checks. Furthermore, code reviewers can also use the reports generated by this invention to conduct code reviews.

[0120] Step 6.4: Exception Handling and Logging: Log each step in the automated process, including the extracted change data, the application results of the cleaning rules, and the status of the export operation. If an exception occurs in a certain step, the process will be automatically stopped and an error log will be generated for developers to troubleshoot.

[0121] See Figure 2 The automatic extraction and cleaning system for code change data includes a control platform management module, a data extraction module, a data formatting module, a data cleaning module, a data storage and output module, and an automation integration module.

[0122] The control platform management module is used to select a version control platform for code management and version control, and the version control platform can monitor code changes.

[0123] The data extraction module is used to extract data after code changes.

[0124] The data formatting module is used to format data;

[0125] The data cleaning module is used to clean the formatted data;

[0126] The data storage output module is used to store and export the cleaned data;

[0127] The automated integration module integrates the data extraction module, data formatting module, data cleaning module, and data storage and output module into the CI / CD pipeline. During each code commit or merge request, it automatically executes the data extraction, data formatting, data cleaning, and data export processes, and generates reports or triggers automated tests.

[0128] In a specific embodiment of the present invention, the data extraction module specifically comprises:

[0129] The extraction method can be selected, including extracting data by time range, extracting data by submission range, and extracting data by tag or version number; the data extraction by time range extracts the data changed within a specific time period by specifying a start and end time; the data extraction by submission range obtains the data changed between specific versions by specifying the start and end submission hash values;

[0130] Extract the commit log, record information for each commit, and obtain commit information using the `git log` or `svn log` command;

[0131] Extract the file change list. Use the `git diff --name-status` or `svn diff --summarize` command to get the list of files changed in each commit, and record the file paths and change status.

[0132] Extract code diff data using the `git diff` or `svn diff` command to extract diff data for specific lines of code, including added, deleted, or modified data.

[0133] In a specific embodiment of the present invention, the data formatting module specifically comprises:

[0134] Define the data structure; the extracted data will be transformed into a standardized data structure, which can extract code difference data.

[0135] Parse the commit logs, extract key information using predefined parsing rules or regular expressions, and transform it into unified structured data;

[0136] Parse the code difference data, further analyze the extracted code difference data, break down the changed code by file and line, and record the specific change type;

[0137] It provides support for multiple formats, allowing formatted data to be stored in various formats.

[0138] In a specific embodiment of the present invention, the data cleaning module specifically comprises:

[0139] Custom data cleaning rules include filtering by file type, filtering by function, filtering by time range or submitter, and filtering by specific submitter;

[0140] Redundant information is removed; invalid change records or noisy information are automatically identified and removed, and only code changes relevant to actual business operations are retained.

[0141] Data validation and cleaning: The extracted changed data is validated for format and consistency. If errors or anomalies are found, the system will automatically repair them or prompt the user to make manual adjustments.

[0142] In a specific embodiment of the present invention, the data storage output module specifically includes: the exported and cleaned data supports multiple data export formats, or is directly stored in a relational database or NoSQL database, and automatically generates a report containing detailed change information, which is classified and organized according to business needs for code review or compliance checks.

[0143] This invention has the following specific application scenarios:

[0144] 1. Quality assurance in software development projects:

[0145] Full Automation: For projects that require frequent releases, this system can achieve full automation of testing, from code submission to test execution, automatically generating unit tests and data, significantly improving testing efficiency and coverage.

[0146] Rapid feedback: Through intelligent analysis and automatically generated test cases, the development team can quickly obtain feedback, promptly identify and fix problems, and improve software quality.

[0147] 2. Financial and High-Security System Testing:

[0148] Blockchain authentication: In fields such as finance where there are high security requirements for test results, blockchain technology is used to record test results, ensuring the authenticity and immutability of the testing process and enhancing the credibility and compliance of the system.

[0149] Compliance audit: Financial systems can use blockchain records for compliance audits to ensure that test results meet industry standards and regulatory requirements.

[0150] 3. Cross-service integration testing for microservice architecture projects:

[0151] Intelligent integration testing: The system can automatically analyze the dependencies between microservices, generate cross-service integration test cases, and ensure interface compatibility and data flow accuracy between services.

[0152] Dynamic testing: The system automatically adjusts the testing strategy based on changes and integration between services to ensure that tests cover all relevant services and interfaces.

[0153] 4. Behavior-driven development scenario:

[0154] Natural Language Testing: Natural language test scenarios generated using BDD technology make test cases easier to understand and maintain, and are suitable for collaboration between business personnel and developers.

[0155] Readability and Communication: BDD format test cases can improve communication efficiency among team members, especially in scenarios where requirements are unclear or complex, and help to clarify requirements and test objectives.

[0156] The above description is only a preferred embodiment of the present invention. All equivalent changes and modifications made within the scope of the claims of the present invention should be included in the scope of the present invention.

Claims

1. An automatic method for extracting and cleaning code change data, including a version control platform, characterized in that: The method steps are as follows: Step 1: Select a version control platform for code management and version control. The version control platform can monitor code changes. Step 2: When the code changes, extract the data related to the code changes; Step 3: Format the data; Step 4: Perform data cleaning on the formatted data; Step 5: Store and export the cleaned data; Step 6: Integrate steps 2-5 into the CI / CD pipeline to automatically execute the data extraction, data formatting, data cleaning, and data export processes with each code commit or merge request, and generate reports or trigger automated tests.

2. The method for automatically extracting and cleaning code change data according to claim 1, characterized in that, Step 2 is as follows: Step 2.1: Select the extraction method, including extracting data by time range, extracting data by submission range, and extracting data by tag or version number; the data extraction by time range extracts the changed data within a specific time period by specifying the start and end times; the data extraction by submission range obtains the changed data between specific versions by specifying the start and end submission hash values; Step 2.2: Extract the commit log and record the information for each commit. Use the `git log` or `svn log` command to obtain the commit information. Step 2.3: Extract the file change list. Use the `git diff --name-status` command or the `svn diff --summarize` command to get the list of files changed in each commit, and record the file paths and change status. Step 2.4: Extract code diff data. Use the `git diff` or `svn diff` command to extract the diff data for specific lines of code. The diff data includes newly added, deleted, or modified data.

3. The method for automatically extracting and cleaning code change data according to claim 1, characterized in that, Step 3 is further specified as follows: Step 3.1: Define the data structure. The extracted data will be transformed into a standardized data structure that can extract code difference data. Step 3.2: Parse the commit logs, extract key information using predefined parsing rules or regular expressions, and transform it into unified structured data; Step 3.3: Analyze the code difference data. Further analyze the extracted code difference data, break down the changed code by file and line, and record the specific change type. Step 3.4: Provide multi-format support, allowing formatted data to be stored in multiple formats.

4. The method for automatically extracting and cleaning code change data according to claim 1, characterized in that, Step 4 is further specified as follows: Step 4.1: Define custom data cleaning rules, including filtering by file type, filtering by function, filtering by time range or submitter, and filtering by specific submitter; Step 4.2: Eliminate redundant information, automatically identify and eliminate invalid change records or noisy information, and retain only the data after changes that are actually relevant to the business. Step 4.3: Data verification and cleaning. The extracted data is verified for format and consistency. If errors or anomalies are found, they will be automatically repaired or the user will be prompted to make manual adjustments.

5. The method for automatically extracting and cleaning code change data according to claim 1, characterized in that, Step 5 further specifies that: the exported and cleaned data supports multiple data export formats, or can be directly stored in a relational database or NoSQL database, and automatically generates a report containing detailed change information, which is classified and organized according to business needs for code review or compliance checks.

6. An automatic extraction and cleaning system for code change data, characterized in that, The system includes a control platform management module, a data extraction module, a data formatting module, a data cleaning module, a data storage and output module, and an automation integration module. The control platform management module is used to select a version control platform for code management and version control, and the version control platform can monitor code changes. The data extraction module is used to extract data related to code changes when code changes occur. The data formatting module is used to format data; The data cleaning module is used to clean the formatted data; The data storage output module is used to store and export the cleaned data; The automated integration module integrates the data extraction module, data formatting module, data cleaning module, and data storage and output module into the CI / CD pipeline. During each code commit or merge request, it automatically executes the data extraction, data formatting, data cleaning, and data export processes, and generates reports or triggers automated tests.

7. The automatic extraction and cleaning system for code change data according to claim 6, characterized in that, The data extraction module specifically includes: The extraction method can be selected, including extracting data by time range, extracting data by submission range, and extracting data by tag or version number; the data extraction by time range extracts the data changed within a specific time period by specifying a start and end time; the data extraction by submission range obtains the data changed between specific versions by specifying the start and end submission hash values; Extract the commit log, record information for each commit, and obtain commit information using the `git log` or `svn log` command; Extract the file change list. Use the `git diff --name-status` or `svn diff --summarize` command to get the list of files changed in each commit, and record the file paths and change status. Extract code diff data. Use the `git diff` or `svn diff` command to extract diff data for specific lines of code. Difference data includes added, deleted, or modified data.

8. The automatic extraction and cleaning system for code change data according to claim 6, characterized in that, The data formatting module specifically includes: Define the data structure; the extracted data will be transformed into a standardized data structure, which can extract code difference data. Parse the commit logs, extract key information using predefined parsing rules or regular expressions, and transform it into unified structured data; Parse the code difference data, further analyze the extracted code difference data, break down the changed code by file and line, and record the specific change type; It provides support for multiple formats, allowing formatted data to be stored in various formats.

9. The automatic extraction and cleaning system for code change data according to claim 6, characterized in that, The data cleaning module specifically includes: Custom data cleaning rules include filtering by file type, filtering by function, filtering by time range or submitter, and filtering by specific submitter; Remove redundant information, automatically identify and remove invalid change records or noisy information, and retain only the data after changes that are actually relevant to the business. Data validation and cleaning: The extracted changed data is validated for format and consistency. If errors or anomalies are found, the system will automatically repair them or prompt the user to make manual adjustments.

10. The automatic extraction and cleaning system for code change data according to claim 6, characterized in that, The data storage output module specifically supports multiple data export formats for the cleaned data, or can be directly stored in a relational database or NoSQL database, and automatically generates a report containing detailed change information, which is classified and organized according to business needs for code review or compliance checks.

Images